ACE/ace/Refcounted_Auto_Ptr.inl

   1 // -*- C++ -*-
   2 #include "ace/Guard_T.h"
   3 #include "ace/Log_Category.h"
   4
   5 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   6
   7 template <class X, class ACE_LOCK> inline long
   8 ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::count () const
   9 {
  10   return this->ref_count_.value();
  11 }
  12
  13 template <class X, class ACE_LOCK> inline long
  14 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::count () const
  15 {
  16   return this->rep_->count ();
  17 }
  18
  19 template <class X, class ACE_LOCK> inline bool
  20 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::null () const
  21 {
  22   return (this->rep_ == 0 || this->rep_->get () == 0);
  23 }
  24
  25 template <class X, class ACE_LOCK> inline ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK> *
  26 ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::internal_create (X *p)
  27 {
  28   ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK> *temp = 0;
  29   ACE_NEW_RETURN (temp,
  30                   (ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>) (p),
  31                   0);
  32   return temp;
  33 }
  34
  35 template <class X, class ACE_LOCK> inline ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK> *
  36 ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::create (X *p)
  37 {
  38   // Yes set ref count to zero.
  39   ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK> *temp = internal_create (p);
  40   if (!temp)
  41     throw std::bad_alloc ();
  42    return temp;
  43 }
  44
  45 template <class X, class ACE_LOCK> inline ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK> *
  46 ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::attach (ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>*& rep)
  47 {
  48   if (rep == 0)
  49     return 0;
  50
  51   ++rep->ref_count_;
  52
  53   return rep;
  54 }
  55
  56 template <class X, class ACE_LOCK> inline void
  57 ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::detach (ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>*& rep)
  58 {
  59   if (rep == 0)
  60     return;
  61
  62   if (rep->ref_count_-- == 0)
  63     delete rep;
  64 }
  65
  66 template <class X, class ACE_LOCK> inline
  67 ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::ACE_Refcounted_Auto_Ptr_Rep (X *p)
  68   : ptr_ (p),
  69     ref_count_ (0)
  70 {
  71 }
  72
  73 template <class X, class ACE_LOCK> inline
  74 ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::~ACE_Refcounted_Auto_Ptr_Rep ()
  75 {
  76 }
  77
  78 template <class X, class ACE_LOCK> inline X *
  79 ACE_Refcounted_Auto_Ptr_Rep<X, ACE_LOCK>::get () const
  80 {
  81   return this->ptr_.get ();
  82 }
  83
  84 template <class X, class ACE_LOCK> inline
  85 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::ACE_Refcounted_Auto_Ptr (X *p)
  86   : rep_ (AUTO_REFCOUNTED_PTR_REP::create (p))
  87 {
  88 }
  89
  90 template <class X, class ACE_LOCK> inline
  91 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::ACE_Refcounted_Auto_Ptr (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &r)
  92   : rep_ (AUTO_REFCOUNTED_PTR_REP::attach (((ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &) r).rep_))
  93 {
  94 }
  95
  96 template <class X, class ACE_LOCK> inline bool
  97 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator== (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &r) const
  98 {
  99   return r.rep_ == this->rep_;
 100 }
 101
 102 template <class X, class ACE_LOCK> inline bool
 103 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator!= (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &r) const
 104 {
 105   return r.rep_ != this->rep_;
 106 }
 107
 108 template <class X, class ACE_LOCK> inline X *
 109 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator-> () const
 110 {
 111     return this->rep_->get();
 112 }
 113
 114 template<class X, class ACE_LOCK> inline X &
 115 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator *() const
 116 {
 117   return *this->rep_->get ();
 118 }
 119
 120 template<class X, class ACE_LOCK> inline bool
 121 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator !() const
 122 {
 123   return this->rep_->get () == 0;
 124 }
 125
 126 template<class X, class ACE_LOCK> inline
 127 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator unspecified_bool_type () const
 128 {
 129   return this->rep_->get () != 0 ? unspecified_bool : 0;
 130 }
 131
 132 template <class X, class ACE_LOCK> inline X*
 133 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::get () const
 134 {
 135   // We return the ACE_Future_rep.
 136   return this->rep_->get ();
 137 }
 138
 139 template<class X, class ACE_LOCK> inline X *
 140 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::release ()
 141 {
 142   X *p = this->get ();
 143   AUTO_REFCOUNTED_PTR_REP::detach (this->rep_);
 144   this->rep_ = 0;
 145   return p;
 146 }
 147
 148 template<class X, class ACE_LOCK> inline void
 149 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::reset (X *p)
 150 {
 151   // Avoid deleting the underlying auto_ptr if assigning the same actual
 152   // pointer value.
 153   if (this->get () == p)
 154     return;
 155
 156   AUTO_REFCOUNTED_PTR_REP *old_rep = this->rep_;
 157   if ((this->rep_ = AUTO_REFCOUNTED_PTR_REP::create (p)) != 0)
 158     AUTO_REFCOUNTED_PTR_REP::detach (old_rep);
 159   else
 160     this->rep_ = old_rep;
 161   return;
 162 }
 163
 164 template <class X, class ACE_LOCK> inline void
 165 ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator = (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &rhs)
 166 {
 167   //  bind <this> to the same <ACE_Refcounted_Auto_Ptr_Rep> as <r>.
 168   AUTO_REFCOUNTED_PTR_REP *old_rep = this->rep_;
 169   if (rhs.rep_ != 0)
 170     {
 171       this->rep_ = AUTO_REFCOUNTED_PTR_REP::attach
 172         (const_cast<ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>& > (rhs).rep_);
 173       if (this->rep_ != 0)
 174         AUTO_REFCOUNTED_PTR_REP::detach (old_rep);
 175     }
 176   else    // Assign a 0 rep to this
 177     {
 178       AUTO_REFCOUNTED_PTR_REP::detach (old_rep);
 179       this->rep_ = 0;
 180     }
 181 }
 182
 183 ACE_END_VERSIONED_NAMESPACE_DECL