Servant_Var.inl
Go to the documentation of this file.
00001 // -*- C++ -*- 00002 // 00003 // $Id: Servant_Var.inl 88803 2010-02-02 11:13:27Z vzykov $ 00004 00005 #include <algorithm> 00006 00007 TAO_BEGIN_VERSIONED_NAMESPACE_DECL 00008 00009 template <class T> 00010 ACE_INLINE T * 00011 TAO::Utils::Servant_Var<T>::_duplicate (T * p) 00012 { 00013 if (p != 0) 00014 { 00015 p->_add_ref (); 00016 } 00017 00018 return p; 00019 } 00020 00021 template <class T> 00022 ACE_INLINE void 00023 TAO::Utils::Servant_Var<T>::swap (Servant_Var<T> & rhs) throw () 00024 { 00025 std::swap (this->ptr_, rhs.ptr_); 00026 } 00027 00028 template <class T> 00029 ACE_INLINE TAO::Utils::Servant_Var<T>::Servant_Var (T * p) 00030 : ptr_ (p) 00031 { 00032 } 00033 00034 // If _add_ref throws, this object will not be completely constructed 00035 // so the destructor will not be called. 00036 template <class T> 00037 ACE_INLINE TAO::Utils::Servant_Var<T>::Servant_Var (Servant_Var<T> const & rhs) 00038 : ptr_ (Servant_Var<T>::_duplicate(rhs.ptr_)) 00039 { 00040 } 00041 00042 template <class T> 00043 ACE_INLINE TAO::Utils::Servant_Var<T> & 00044 TAO::Utils::Servant_Var<T>::operator= (Servant_Var<T> const & rhs) 00045 { 00046 TAO::Utils::Servant_Var<T> tmp (rhs); 00047 this->swap (tmp); 00048 return *this; 00049 } 00050 00051 template <class T> 00052 ACE_INLINE typename TAO::Utils::Servant_Var<T> & 00053 TAO::Utils::Servant_Var<T>::operator= (T * p) 00054 { 00055 if (this->ptr_ != p) 00056 { 00057 // This constructor doesn't increase the reference count so we 00058 // we must check for self-assignment. Otherwise the reference 00059 // count would be prematurely decremented upon exiting this 00060 // scope. 00061 TAO::Utils::Servant_Var<T> tmp (p); 00062 this->swap (tmp); 00063 } 00064 00065 return *this; 00066 } 00067 00068 template <class T> ACE_INLINE 00069 TAO::Utils::Servant_Var<T>::~Servant_Var (void) throw () 00070 { 00071 if (ptr_ != 0) 00072 { 00073 ptr_->_remove_ref (); 00074 } 00075 } 00076 00077 #if !defined(ACE_LACKS_MEMBER_TEMPLATES) 00078 template <class T> template <class Y> 00079 ACE_INLINE TAO::Utils::Servant_Var<T>::Servant_Var (Y * p) 00080 : ptr_ (p) 00081 { 00082 } 00083 00084 template <class T> template <class Y> 00085 ACE_INLINE TAO::Utils::Servant_Var<T>::Servant_Var (Servant_Var<Y> const & rhs) 00086 : ptr_ (Servant_Var<T>::_duplicate (rhs.in ())) 00087 { 00088 } 00089 00090 template <class T> template <class Y> 00091 ACE_INLINE typename TAO::Utils::Servant_Var<T> & 00092 TAO::Utils::Servant_Var<T>:: 00093 operator=(Servant_Var<Y> const & rhs) 00094 { 00095 TAO::Utils::Servant_Var<T> tmp (rhs); 00096 this->swap (tmp); 00097 return *this; 00098 } 00099 00100 template <class T> template <class Y> 00101 ACE_INLINE typename TAO::Utils::Servant_Var<T> & 00102 TAO::Utils::Servant_Var<T>::operator= (Y * p) 00103 { 00104 if (this->ptr_ != p) 00105 { 00106 // This constructor doesn't increase the reference count so we 00107 // we must check for self-assignment. Otherwise the reference 00108 // count would be prematurely decremented upon exiting this 00109 // scope. 00110 TAO::Utils::Servant_Var<T> tmp (p); 00111 this->swap (tmp); 00112 } 00113 00114 return *this; 00115 } 00116 #endif /* ACE_LACKS_MEMBER_TEMPLATES */ 00117 00118 template <class T> 00119 ACE_INLINE T const * 00120 TAO::Utils::Servant_Var<T>::operator->() const 00121 { 00122 return ptr_; 00123 } 00124 00125 template <class T> 00126 ACE_INLINE T * 00127 TAO::Utils::Servant_Var<T>::operator->() 00128 { 00129 return ptr_; 00130 } 00131 00132 template <class T> 00133 ACE_INLINE T const & TAO::Utils::Servant_Var<T>::operator*() const 00134 { 00135 return *ptr_; 00136 } 00137 00138 template <class T> 00139 ACE_INLINE T & TAO::Utils::Servant_Var<T>::operator*() 00140 { 00141 return *ptr_; 00142 } 00143 00144 template <class T> 00145 ACE_INLINE TAO::Utils::Servant_Var<T>::operator void const * () const 00146 { 00147 return ptr_; 00148 } 00149 00150 template <class T> 00151 ACE_INLINE T * 00152 TAO::Utils::Servant_Var<T>::in (void) const 00153 { 00154 return ptr_; 00155 } 00156 00157 template <class T> 00158 ACE_INLINE T *& 00159 TAO::Utils::Servant_Var<T>::inout (void) 00160 { 00161 return ptr_; 00162 } 00163 00164 template <class T> 00165 ACE_INLINE T *& 00166 TAO::Utils::Servant_Var<T>::out (void) 00167 { 00168 TAO::Utils::Servant_Var<T> tmp; 00169 this->swap (tmp); 00170 return ptr_; 00171 } 00172 00173 template <class T> 00174 ACE_INLINE T * 00175 TAO::Utils::Servant_Var<T>::_retn (void) 00176 { 00177 T * rval = ptr_; 00178 ptr_ = 0; 00179 return rval; 00180 } 00181 00182 #if !defined (ACE_LACKS_MEMBER_TEMPLATES) 00183 template <class X, class Y> 00184 ACE_INLINE bool 00185 operator== (typename TAO::Utils::Servant_Var<X> const & x, 00186 typename TAO::Utils::Servant_Var<Y> const & y) 00187 { 00188 return x.in () == y.in (); 00189 } 00190 00191 template <class X, class Y> 00192 ACE_INLINE bool 00193 operator!= (typename TAO::Utils::Servant_Var<X> const & x, 00194 typename TAO::Utils::Servant_Var<Y> const & y) 00195 { 00196 return x.in () != y.in (); 00197 } 00198 #endif /* ! ACE_LACKS_MEMBER_TEMPLATES */ 00199 00200 TAO_END_VERSIONED_NAMESPACE_DECL
