TAO/tao/Intrusive_Ref_Count_Handle_T.inl

   1 // -*- C++ -*-
   2 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
   3
   4 template <typename T>
   5 ACE_INLINE
   6 TAO_Intrusive_Ref_Count_Handle<T>::TAO_Intrusive_Ref_Count_Handle (void)
   7   : ptr_(0)
   8 {
   9 }
  10
  11
  12 template <typename T>
  13 ACE_INLINE
  14 TAO_Intrusive_Ref_Count_Handle<T>::TAO_Intrusive_Ref_Count_Handle (
  15   T*   p,
  16   bool take_ownership)
  17   : ptr_(p)
  18 {
  19   if (!take_ownership)
  20     {
  21       this->claim ();
  22     }
  23 }
  24
  25
  26 template <typename T>
  27 ACE_INLINE
  28 TAO_Intrusive_Ref_Count_Handle<T>::TAO_Intrusive_Ref_Count_Handle (
  29   const TAO_Intrusive_Ref_Count_Handle<T>& b)
  30   : ptr_(b.ptr_)
  31 {
  32   this->claim();
  33 }
  34
  35
  36 template <typename T>
  37 ACE_INLINE
  38 TAO_Intrusive_Ref_Count_Handle<T>::~TAO_Intrusive_Ref_Count_Handle()
  39 {
  40   this->drop();
  41 }
  42
  43
  44 template <typename T>
  45 ACE_INLINE
  46 TAO_Intrusive_Ref_Count_Handle<T>&
  47 TAO_Intrusive_Ref_Count_Handle<T>::operator=(T* p)
  48 {
  49   TAO_Intrusive_Ref_Count_Handle<T> tmp (p);
  50   return this->operator= (tmp);
  51 }
  52
  53
  54 template <typename T>
  55 ACE_INLINE
  56 TAO_Intrusive_Ref_Count_Handle<T>&
  57 TAO_Intrusive_Ref_Count_Handle<T>::operator=
  58                                  (const TAO_Intrusive_Ref_Count_Handle<T>& b)
  59 {
  60   // Strongly exception-safe assignment through the usual copy and
  61   // swap technique.
  62
  63   TAO_Intrusive_Ref_Count_Handle<T> tmp (b);
  64
  65   T * old_ptr = this->ptr_;
  66   this->ptr_ = tmp.ptr_;
  67   tmp.ptr_ = old_ptr;
  68
  69   return *this;
  70 }
  71
  72
  73 template <typename T>
  74 ACE_INLINE
  75 T*
  76 TAO_Intrusive_Ref_Count_Handle<T>::operator->() const
  77 {
  78   return this->ptr_;
  79 }
  80
  81
  82 template <typename T>
  83 ACE_INLINE
  84 bool
  85 TAO_Intrusive_Ref_Count_Handle<T>::is_nil() const
  86 {
  87   return this->ptr_ == 0;
  88 }
  89
  90
  91 template <typename T>
  92 ACE_INLINE
  93 T*
  94 TAO_Intrusive_Ref_Count_Handle<T>::in() const
  95 {
  96   return this->ptr_;
  97 }
  98
  99
 100 template <typename T>
 101 ACE_INLINE
 102 T*&
 103 TAO_Intrusive_Ref_Count_Handle<T>::inout()
 104 {
 105   return this->ptr_;
 106 }
 107
 108
 109 template <typename T>
 110 ACE_INLINE
 111 T*&
 112 TAO_Intrusive_Ref_Count_Handle<T>::out()
 113 {
 114   this->drop();
 115   return this->ptr_;
 116 }
 117
 118
 119 template <typename T>
 120 ACE_INLINE
 121 T*
 122 TAO_Intrusive_Ref_Count_Handle<T>::_retn()
 123 {
 124   T* retval = this->ptr_;
 125   this->ptr_ = 0;
 126   return retval;
 127 }
 128
 129
 130 template <typename T>
 131 ACE_INLINE
 132 bool
 133 TAO_Intrusive_Ref_Count_Handle<T>::operator== (const TAO_Intrusive_Ref_Count_Handle& h) const
 134 {
 135   return this->ptr_ == h.in();
 136 }
 137
 138
 139 template <typename T>
 140 ACE_INLINE
 141 void
 142 TAO_Intrusive_Ref_Count_Handle<T>::claim()
 143 {
 144   if (this->ptr_ != 0)
 145     {
 146       this->ptr_->_add_ref();
 147     }
 148 }
 149
 150
 151 template <typename T>
 152 ACE_INLINE
 153 void
 154 TAO_Intrusive_Ref_Count_Handle<T>::drop()
 155 {
 156   if (this->ptr_ != 0)
 157     {
 158       this->ptr_->_remove_ref();
 159       this->ptr_ = 0;
 160     }
 161 }
 162
 163 TAO_END_VERSIONED_NAMESPACE_DECL