ACE/ace/Auto_Ptr.inl

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