dep/ACE_wrappers/ace/Intrusive_Auto_Ptr.inl

   1 // -*- C++ -*-
   2 //
   3 // $Id: Intrusive_Auto_Ptr.inl 81219 2008-04-02 20:23:32Z iliyan $
   4
   5 #include "ace/Guard_T.h"
   6 #include "ace/Log_Msg.h"
   7
   8 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   9
  10 template <class X> ACE_INLINE
  11 ACE_Intrusive_Auto_Ptr<X>::ACE_Intrusive_Auto_Ptr (X *p, bool addref)
  12   : rep_ (p)
  13 {
  14   if (rep_ != 0  && addref)
  15     X::intrusive_add_ref (rep_);
  16 }
  17
  18 template <class X> ACE_INLINE
  19 ACE_Intrusive_Auto_Ptr<X>::ACE_Intrusive_Auto_Ptr (const ACE_Intrusive_Auto_Ptr<X> &r)
  20   : rep_ (r.rep_)
  21 {
  22   if (rep_ != 0)
  23     X::intrusive_add_ref (rep_);
  24 }
  25
  26 template <class X> ACE_INLINE X *
  27 ACE_Intrusive_Auto_Ptr<X>::operator-> (void) const
  28 {
  29     return this->rep_;
  30 }
  31
  32 template<class X> ACE_INLINE X &
  33 ACE_Intrusive_Auto_Ptr<X>::operator *() const
  34 {
  35   return *this->rep_;
  36 }
  37
  38 template <class X> ACE_INLINE X*
  39 ACE_Intrusive_Auto_Ptr<X>::get (void) const
  40 {
  41   // We return the ACE_Future_rep.
  42   return this->rep_;
  43 }
  44
  45 template<class X> ACE_INLINE X *
  46 ACE_Intrusive_Auto_Ptr<X>::release (void)
  47 {
  48   X *p = this->rep_;
  49   if (this->rep_ != 0)
  50     X::intrusive_remove_ref (this->rep_);
  51
  52   this->rep_ = 0;
  53   return p;
  54 }
  55
  56 template<class X> ACE_INLINE void
  57 ACE_Intrusive_Auto_Ptr<X>::reset (X *p)
  58 {
  59   // Avoid deleting the underlying auto_ptr if assigning the same actual
  60   // pointer value.
  61   if (this->rep_ == p)
  62     return;
  63
  64   X *old_rep = this->rep_;
  65   this->rep_ = p;
  66
  67   if (this->rep_ != 0)
  68     X::intrusive_add_ref (this->rep_);
  69
  70   if (old_rep != 0)
  71     X::intrusive_remove_ref (old_rep);
  72
  73   return;
  74 }
  75
  76 template <class X> ACE_INLINE void
  77 ACE_Intrusive_Auto_Ptr<X>::operator = (const ACE_Intrusive_Auto_Ptr<X> &rhs)
  78 {
  79   // do nothing when aliasing
  80   if (this->rep_ == rhs.rep_)
  81     return;
  82
  83   // assign a zero
  84   if (rhs.rep_  == 0)
  85     {
  86       X::intrusive_remove_ref (rhs.rep_);
  87       this->rep_ = 0;
  88       return;
  89     }
  90
  91   //  bind <this> to the same <ACE_Intrusive_Auto_Ptr_Rep> as <rhs>.
  92   X *old_rep = this->rep_;
  93   this->rep_ = rhs.rep_;
  94   X::intrusive_add_ref (this->rep_);
  95   X::intrusive_remove_ref (old_rep);
  96 }
  97
  98 // Copy derived class constructor
  99 template<class X> template <class U> ACE_INLINE
 100 ACE_Intrusive_Auto_Ptr<X>::ACE_Intrusive_Auto_Ptr (const ACE_Intrusive_Auto_Ptr<U> & rhs)
 101 {
 102   // note implicit cast from U* to T* so illegal copy will generate a
 103   // compiler warning here
 104   this->rep_ = rhs.operator-> ();
 105   X::intrusive_add_ref(this->rep_);
 106 }
 107
 108   /// Equality operator that returns @c true if both
 109   /// ACE_Intrusive_Auto_Ptr objects point to the same underlying
 110   /// representation. It does not compare the actual pointers.
 111   /**
 112    * @note It also returns @c true if both objects have just been
 113    *       instantiated and not used yet.
 114    */
 115 template<class T, class U> ACE_INLINE bool operator==(ACE_Intrusive_Auto_Ptr<T> const & a, ACE_Intrusive_Auto_Ptr<U> const & b)
 116 {
 117     return a.get() == b.get();
 118 }
 119
 120   /// Inequality operator, which is the opposite of equality.
 121   template<class T, class U> ACE_INLINE bool operator!=(ACE_Intrusive_Auto_Ptr<T> const & a, ACE_Intrusive_Auto_Ptr<U> const & b)
 122 {
 123     return a.get() != b.get();
 124 }
 125
 126     template<class T, class U> ACE_INLINE bool operator==(ACE_Intrusive_Auto_Ptr<T> const & a, U * b)
 127 {
 128     return a.get() == b;
 129 }
 130
 131       template<class T, class U> ACE_INLINE bool operator!=(ACE_Intrusive_Auto_Ptr<T> & a, U * b)
 132 {
 133     return a.get() != b;
 134 }
 135
 136         template<class T, class U> ACE_INLINE bool operator==(T * a, ACE_Intrusive_Auto_Ptr<U> const & b)
 137 {
 138     return a == b.get();
 139 }
 140
 141           template<class T, class U> ACE_INLINE bool operator!=(T * a, ACE_Intrusive_Auto_Ptr<U> const & b)
 142 {
 143     return a != b.get();
 144 }
 145
 146
 147 ACE_END_VERSIONED_NAMESPACE_DECL