TAO/tao/VarOut_T.inl

   1 // -*- C++ -*-
   2 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
   3
   4 template<typename T>
   5 ACE_INLINE
   6 TAO_Var_Base_T<T>::TAO_Var_Base_T ()
   7   : ptr_ (nullptr)
   8 {}
   9
  10 template<typename T>
  11 ACE_INLINE
  12 TAO_Var_Base_T<T>::TAO_Var_Base_T (T * p)
  13   : ptr_ (p)
  14 {}
  15
  16 template<typename T>
  17 ACE_INLINE
  18 TAO_Var_Base_T<T>::~TAO_Var_Base_T ()
  19 {
  20   delete this->ptr_;
  21 }
  22
  23 template<typename T>
  24 ACE_INLINE
  25 const T *
  26 TAO_Var_Base_T<T>::operator-> () const
  27 {
  28   return this->ptr_;
  29 }
  30
  31 template<typename T>
  32 ACE_INLINE
  33 T *
  34 TAO_Var_Base_T<T>::operator-> ()
  35 {
  36   return this->ptr_;
  37 }
  38
  39 template<typename T>
  40 ACE_INLINE
  41 const T &
  42 TAO_Var_Base_T<T>::in () const
  43 {
  44   return *this->ptr_;
  45 }
  46
  47 template<typename T>
  48 ACE_INLINE
  49 T &
  50 TAO_Var_Base_T<T>::inout ()
  51 {
  52   return *this->ptr_;
  53 }
  54
  55 template<typename T>
  56 ACE_INLINE
  57 T *
  58 TAO_Var_Base_T<T>::ptr () const
  59 {
  60   return this->ptr_;
  61 }
  62
  63 template<typename T>
  64 ACE_INLINE
  65 TAO_Var_Base_T<T>::operator T *& ()
  66 {
  67   return this->ptr_;
  68 }
  69
  70 // *************************************************************
  71
  72 template<typename T>
  73 ACE_INLINE
  74 TAO_Fixed_Var_T<T>::TAO_Fixed_Var_T ()
  75 {}
  76
  77 template<typename T>
  78 ACE_INLINE
  79 TAO_Fixed_Var_T<T>::TAO_Fixed_Var_T (T * p)
  80   : TAO_Var_Base_T<T> (p)
  81 {}
  82
  83 template<typename T>
  84 ACE_INLINE
  85 TAO_Fixed_Var_T<T>::TAO_Fixed_Var_T (const TAO_Fixed_Var_T<T> & p)
  86   : TAO_Var_Base_T<T> (p)
  87 {}
  88
  89 // Fixed-size types only.
  90 template<typename T>
  91 ACE_INLINE
  92 TAO_Fixed_Var_T<T>::TAO_Fixed_Var_T (const T & p)
  93 {
  94   ACE_NEW (this->ptr_,
  95            T (p));
  96 }
  97
  98 template<typename T>
  99 ACE_INLINE
 100 TAO_Fixed_Var_T<T> &
 101 TAO_Fixed_Var_T<T>::operator= (T * p)
 102 {
 103   delete this->ptr_;
 104   this->ptr_ = p;
 105   return *this;
 106 }
 107
 108 template<typename T>
 109 ACE_INLINE
 110 TAO_Fixed_Var_T<T>::operator const T & () const
 111 {
 112   return *this->ptr_;
 113 }
 114
 115 template<typename T>
 116 ACE_INLINE
 117 TAO_Fixed_Var_T<T>::operator T & ()
 118 {
 119   // Use plain new, using the ACE_NEW macros will mean we dereference a
 120   // nil pointer and crash which is more bad then plain new which could
 121   // lead to a bad_alloc exception
 122   if (!this->ptr_)
 123   {
 124     this->ptr_ = new T;
 125   }
 126
 127   return *this->ptr_;
 128 }
 129
 130 template<typename T>
 131 ACE_INLINE
 132 TAO_Fixed_Var_T<T>::operator T & () const
 133 {
 134   return *this->ptr_;
 135 }
 136
 137 // Mapping for fixed size.
 138 template<typename T>
 139 ACE_INLINE
 140 T &
 141 TAO_Fixed_Var_T<T>::out ()
 142 {
 143   // Use plain new, using the ACE_NEW macros will mean we dereference a
 144   // nil pointer and crash which is more bad then plain new which could
 145   // lead to a bad_alloc exception
 146   if (!this->ptr_)
 147   {
 148     this->ptr_ = new T;
 149   }
 150
 151   return *this->ptr_;
 152 }
 153
 154 template<typename T>
 155 ACE_INLINE
 156 T
 157 TAO_Fixed_Var_T<T>::_retn ()
 158 {
 159   return *this->ptr_;
 160 }
 161
 162 // *************************************************************
 163
 164 template<typename T>
 165 ACE_INLINE
 166 TAO_Var_Var_T<T>::TAO_Var_Var_T ()
 167 {}
 168
 169 template<typename T>
 170 ACE_INLINE
 171 TAO_Var_Var_T<T>::TAO_Var_Var_T (T * p)
 172   : TAO_Var_Base_T<T> (p)
 173 {}
 174
 175 template<typename T>
 176 ACE_INLINE
 177 TAO_Var_Var_T<T>::TAO_Var_Var_T (const TAO_Var_Var_T<T> & p)
 178   : TAO_Var_Base_T<T> (p)
 179 {}
 180
 181 template<typename T>
 182 ACE_INLINE
 183 TAO_Var_Var_T<T> &
 184 TAO_Var_Var_T<T>::operator= (T * p)
 185 {
 186   delete this->ptr_;
 187   this->ptr_ = p;
 188   return *this;
 189 }
 190
 191 template<typename T>
 192 ACE_INLINE
 193 TAO_Var_Var_T<T>::operator const T & () const
 194 {
 195   return *this->ptr_;
 196 }
 197
 198 template<typename T>
 199 ACE_INLINE
 200 TAO_Var_Var_T<T>::operator T & ()
 201 {
 202   return *this->ptr_;
 203 }
 204
 205 template<typename T>
 206 ACE_INLINE
 207 TAO_Var_Var_T<T>::operator T & () const
 208 {
 209   return *this->ptr_;
 210 }
 211
 212 // Mapping for variable size.
 213 template<typename T>
 214 ACE_INLINE
 215 T *&
 216 TAO_Var_Var_T<T>::out ()
 217 {
 218   delete this->ptr_;
 219   this->ptr_ = nullptr;
 220   return this->ptr_;
 221 }
 222
 223 template<typename T>
 224 ACE_INLINE
 225 T *
 226 TAO_Var_Var_T<T>::_retn ()
 227 {
 228   T * tmp = this->ptr_;
 229   this->ptr_ = nullptr;
 230   return tmp;
 231 }
 232
 233 // *************************************************************
 234
 235 template<typename T>
 236 ACE_INLINE
 237 TAO_Out_T<T>::TAO_Out_T (T *& p)
 238   : ptr_ (p)
 239 {
 240   this->ptr_ = nullptr;
 241 }
 242
 243 template<typename T>
 244 ACE_INLINE
 245 TAO_Out_T<T>::TAO_Out_T (T_var & p)
 246   : ptr_ (p.out ())
 247 {
 248   delete this->ptr_;
 249   this->ptr_ = nullptr;
 250 }
 251
 252 template<typename T>
 253 ACE_INLINE
 254 TAO_Out_T<T>::TAO_Out_T (const TAO_Out_T<T> & p)
 255   : ptr_ (p.ptr_)
 256 {}
 257
 258 template<typename T>
 259 ACE_INLINE
 260 TAO_Out_T<T> &
 261 TAO_Out_T<T>::operator= (const TAO_Out_T<T> & p)
 262 {
 263   this->ptr_ = p.ptr_;
 264   return *this;
 265 }
 266
 267 template<typename T>
 268 ACE_INLINE
 269 TAO_Out_T<T> &
 270 TAO_Out_T<T>::operator= (T * p)
 271 {
 272   this->ptr_ = p;
 273   return *this;
 274 }
 275
 276 template<typename T>
 277 ACE_INLINE
 278 TAO_Out_T<T>::operator T *& ()
 279 {
 280   return this->ptr_;
 281 }
 282
 283 template<typename T>
 284 ACE_INLINE
 285 T *&
 286 TAO_Out_T<T>::ptr ()
 287 {
 288   return this->ptr_;
 289 }
 290
 291 template<typename T>
 292 ACE_INLINE
 293 T *
 294 TAO_Out_T<T>::operator-> ()
 295 {
 296   return this->ptr_;
 297 }
 298
 299 TAO_END_VERSIONED_NAMESPACE_DECL