ACE/ace/Auto_Ptr.inl

   1 // -*- C++ -*-
   2 #include "ace/Global_Macros.h"
   3
   4 #if !defined (ACE_HAS_CPP17)
   5
   6 #if defined (ACE_HAS_ALLOC_HOOKS)
   7 # include "ace/Malloc_Base.h"
   8 #endif /* ACE_HAS_ALLOC_HOOKS */
   9
  10 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  11
  12 template<class X> ACE_INLINE void
  13 ACE_Auto_Basic_Ptr<X>::dump () const
  14 {
  15 #if defined (ACE_HAS_DUMP)
  16   ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::dump");
  17 #endif /* ACE_HAS_DUMP */
  18 }
  19
  20 template<class X> ACE_INLINE void
  21 ACE_Auto_Basic_Array_Ptr<X>::dump () const
  22 {
  23 #if defined (ACE_HAS_DUMP)
  24   ACE_TRACE ("ACE_Auto_Basic_Array_Ptr<X>::dump");
  25 #endif /* ACE_HAS_DUMP */
  26 }
  27
  28 template<class X> ACE_INLINE
  29 ACE_Auto_Basic_Ptr<X>::ACE_Auto_Basic_Ptr (ACE_Auto_Basic_Ptr<X> &rhs)
  30   : p_ (rhs.release ())
  31 {
  32   ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::ACE_Auto_Basic_Ptr");
  33 }
  34
  35 template<class X> ACE_INLINE X *
  36 ACE_Auto_Basic_Ptr<X>::get () const
  37 {
  38   ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::get");
  39   return this->p_;
  40 }
  41
  42 template<class X> ACE_INLINE X *
  43 ACE_Auto_Basic_Ptr<X>::release ()
  44 {
  45   ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::release");
  46   X *old = this->p_;
  47   this->p_ = nullptr;
  48   return old;
  49 }
  50
  51 template<class X> ACE_INLINE void
  52 ACE_Auto_Basic_Ptr<X>::reset (X *p)
  53 {
  54   ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::reset");
  55   if (this->get () != p)
  56     delete this->get ();
  57   this->p_ = p;
  58 }
  59
  60 template<class X> ACE_INLINE ACE_Auto_Basic_Ptr<X> &
  61 ACE_Auto_Basic_Ptr<X>::operator= (ACE_Auto_Basic_Ptr<X> &rhs)
  62 {
  63   ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::operator=");
  64   if (this != &rhs)
  65     {
  66       this->reset (rhs.release ());
  67     }
  68   return *this;
  69 }
  70
  71 template<class X> ACE_INLINE
  72 ACE_Auto_Basic_Ptr<X>::~ACE_Auto_Basic_Ptr ()
  73 {
  74   ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::~ACE_Auto_Basic_Ptr");
  75   delete this->get ();
  76 }
  77
  78 template<class X> ACE_INLINE X &
  79 ACE_Auto_Basic_Ptr<X>::operator *() const
  80 {
  81   ACE_TRACE ("ACE_Auto_Basic_Ptr<X>::operator *()");
  82   return *this->get ();
  83 }
  84
  85 #if defined (ACE_LACKS_AUTO_PTR)
  86 template<class X> ACE_INLINE X *
  87 auto_ptr<X>::operator-> () const
  88 {
  89   ACE_TRACE ("auto_ptr<X>::operator->");
  90   return this->get ();
  91 }
  92 #endif /* ACE_LACKS_AUTO_PTR */
  93
  94 template<class X> ACE_INLINE X *
  95 ACE_Auto_Ptr<X>::operator-> () const
  96 {
  97   ACE_TRACE ("ACE_Auto_Ptr<X>::operator->");
  98   return this->get ();
  99 }
 100
 101 template<class X> ACE_INLINE X *
 102 ACE_Auto_Basic_Array_Ptr<X>::get () const
 103 {
 104   ACE_TRACE ("ACE_Auto_Basic_Array_Ptr<X>::get");
 105   return this->p_;
 106 }
 107
 108 template<class X> ACE_INLINE X *
 109 ACE_Auto_Basic_Array_Ptr<X>::release ()
 110 {
 111   ACE_TRACE ("ACE_Auto_Basic_Array_Ptr<X>::release");
 112   X *old = this->p_;
 113   this->p_ = 0;
 114   return old;
 115 }
 116
 117 template<class X> ACE_INLINE void
 118 ACE_Auto_Basic_Array_Ptr<X>::reset (X *p)
 119 {
 120   ACE_TRACE ("ACE_Auto_Basic_Array_Ptr<X>::reset");
 121   if (this->get () != p)
 122 #if defined (ACE_HAS_ALLOC_HOOKS)
 123     ACE_Allocator::instance()->free(this->get ());
 124 #else
 125     delete [] this->get ();
 126 #endif /* ACE_HAS_ALLOC_HOOKS */
 127
 128   this->p_ = p;
 129 }
 130
 131 template<class X> ACE_INLINE
 132 ACE_Auto_Basic_Array_Ptr<X>::ACE_Auto_Basic_Array_Ptr (ACE_Auto_Basic_Array_Ptr<X> &rhs)
 133   : p_ (rhs.release ())
 134 {
 135   ACE_TRACE ("ACE_Auto_Basic_Array_Ptr<X>::ACE_Auto_Basic_Array_Ptr");
 136 }
 137
 138 template<class X> ACE_INLINE ACE_Auto_Basic_Array_Ptr<X> &
 139 ACE_Auto_Basic_Array_Ptr<X>::operator= (ACE_Auto_Basic_Array_Ptr<X> &rhs)
 140 {
 141   ACE_TRACE ("ACE_Auto_Basic_Array_Ptr<X>::operator=");
 142   if (this != &rhs)
 143     {
 144       this->reset (rhs.release ());
 145     }
 146   return *this;
 147 }
 148
 149 template<class X> ACE_INLINE
 150 ACE_Auto_Basic_Array_Ptr<X>::~ACE_Auto_Basic_Array_Ptr ()
 151 {
 152   ACE_TRACE ("ACE_Auto_Basic_Array_Ptr<X>::~ACE_Auto_Basic_Array_Ptr");
 153 #if defined (ACE_HAS_ALLOC_HOOKS)
 154   ACE_Allocator::instance()->free(this->get ());
 155 #else
 156   delete [] this->get ();
 157 #endif /* ACE_HAS_ALLOC_HOOKS */
 158 }
 159
 160 template<class X> ACE_INLINE X &
 161 ACE_Auto_Basic_Array_Ptr<X>::operator *() const
 162 {
 163   return *this->get ();
 164 }
 165
 166 template<class X> ACE_INLINE X &
 167 ACE_Auto_Basic_Array_Ptr<X>::operator[](int i) const
 168 {
 169   X *array = this->get ();
 170   return array[i];
 171 }
 172
 173 template<class X> ACE_INLINE X *
 174 ACE_Auto_Array_Ptr<X>::operator->() const
 175 {
 176   return this->get ();
 177 }
 178
 179 ACE_END_VERSIONED_NAMESPACE_DECL
 180
 181 #endif /* ACE_HAS_CPP17 */