cpp/include/Ice/Handle.h

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #ifndef ICE_HANDLE_H
  11 #define ICE_HANDLE_H
  12
  13 #include <IceUtil/Handle.h>
  14 #include <Ice/Config.h>
  15
  16 //
  17 // We include ProxyHandle.h here to make sure that the Ice::ProxyHandle
  18 // template is defined before any definition of upCast().
  19 //
  20 // See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=25495 for information
  21 // on why this is necessary.
  22 //
  23 #include <Ice/ProxyHandle.h>
  24
  25 //
  26 // "Handle" or "smart pointer" template for classes derived from
  27 // IceInternal::GCShared, IceUtil::Shared, or IceUtil::SimpleShared.
  28 //
  29 // In constrast to IceUtil::Handle, IceInternal::Handle<T> can be used
  30 // for a type T that has been declared but not defined. The only
  31 // requirement is a declaration of the following function:
  32 //
  33 // namespace IceInternal
  34 // {
  35 //     X* upCast(T*);
  36 // }
  37 //
  38 // Where X is (or derives from) IceUtil::Shared or IceUtil::SimpleShared.
  39 //
  40
  41 namespace IceInternal
  42 {
  43
  44 template<typename T>
  45 class Handle : public ::IceUtil::HandleBase<T>
  46 {
  47 public:
  48
  49 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600)
  50     //
  51     // C++Builder 2009 does not allow setting Ptr to 0.
  52     //
  53     Handle(int p)
  54     {
  55         assert(p == 0);
  56         this->_ptr = 0;
  57     }
  58 #endif
  59
  60     Handle(T* p = 0)
  61     {
  62         this->_ptr = p;
  63
  64         if(this->_ptr)
  65         {
  66             upCast(this->_ptr)->__incRef();
  67         }
  68     }
  69
  70     template<typename Y>
  71     Handle(const Handle<Y>& r)
  72     {
  73         this->_ptr = r._ptr;
  74
  75         if(this->_ptr)
  76         {
  77             upCast(this->_ptr)->__incRef();
  78         }
  79     }
  80
  81     template<typename Y>
  82     Handle(const ::IceUtil::Handle<Y>& r)
  83     {
  84         this->_ptr = r._ptr;
  85
  86         if(this->_ptr)
  87         {
  88             upCast(this->_ptr)->__incRef();
  89         }
  90     }
  91
  92     Handle(const Handle& r)
  93     {
  94         this->_ptr = r._ptr;
  95
  96         if(this->_ptr)
  97         {
  98             upCast(this->_ptr)->__incRef();
  99         }
 100     }
 101
 102     ~Handle()
 103     {
 104         if(this->_ptr)
 105         {
 106             upCast(this->_ptr)->__decRef();
 107         }
 108     }
 109
 110     Handle& operator=(T* p)
 111     {
 112         if(this->_ptr != p)
 113         {
 114             if(p)
 115             {
 116                 upCast(p)->__incRef();
 117             }
 118
 119             T* ptr = this->_ptr;
 120             this->_ptr = p;
 121
 122             if(ptr)
 123             {
 124                 upCast(ptr)->__decRef();
 125             }
 126         }
 127         return *this;
 128     }
 129
 130     template<typename Y>
 131     Handle& operator=(const Handle<Y>& r)
 132     {
 133         if(this->_ptr != r._ptr)
 134         {
 135             if(r._ptr)
 136             {
 137                 upCast(r._ptr)->__incRef();
 138             }
 139
 140             T* ptr = this->_ptr;
 141             this->_ptr = r._ptr;
 142
 143             if(ptr)
 144             {
 145                 upCast(ptr)->__decRef();
 146             }
 147         }
 148         return *this;
 149     }
 150
 151     template<typename Y>
 152     Handle& operator=(const ::IceUtil::Handle<Y>& r)
 153     {
 154         if(this->_ptr != r._ptr)
 155         {
 156             if(r._ptr)
 157             {
 158                 upCast(r._ptr)->__incRef();
 159             }
 160
 161             T* ptr = this->_ptr;
 162             this->_ptr = r._ptr;
 163
 164             if(ptr)
 165             {
 166                 upCast(ptr)->__decRef();
 167             }
 168         }
 169         return *this;
 170     }
 171
 172     Handle& operator=(const Handle& r)
 173     {
 174         if(this->_ptr != r._ptr)
 175         {
 176             if(r._ptr)
 177             {
 178                 upCast(r._ptr)->__incRef();
 179             }
 180
 181             T* ptr = this->_ptr;
 182             this->_ptr = r._ptr;
 183
 184             if(ptr)
 185             {
 186                 upCast(ptr)->__decRef();
 187             }
 188         }
 189         return *this;
 190     }
 191
 192     template<class Y>
 193     static Handle dynamicCast(const ::IceUtil::HandleBase<Y>& r)
 194     {
 195 #ifdef __BCPLUSPLUS__
 196         return Handle<T>(dynamic_cast<T*>(r._ptr));
 197 #else
 198         return Handle(dynamic_cast<T*>(r._ptr));
 199 #endif
 200     }
 201
 202     template<class Y>
 203     static Handle dynamicCast(Y* p)
 204     {
 205 #ifdef __BCPLUSPLUS__
 206         return Handle<T>(dynamic_cast<T*>(p));
 207 #else
 208         return Handle(dynamic_cast<T*>(p));
 209 #endif
 210     }
 211
 212     void __clearHandleUnsafe()
 213     {
 214         this->_ptr = 0;
 215     }
 216 };
 217
 218 }
 219
 220 #endif