ACE/ace/Intrusive_Auto_Ptr.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Intrusive_Auto_Ptr.h
   6  *
   7  *  @author Iliyan Jeliazkov <iliyan@ociweb.com>
   8  *
   9  *  @note Modeled on http://www.boost.org/boost/intrusive_ptr.hpp
  10  */
  11 //=============================================================================
  12
  13 #ifndef ACE_INTRUSIVE_AUTO_PTR_H
  14 #define ACE_INTRUSIVE_AUTO_PTR_H
  15
  16 #include /**/ "ace/pre.h"
  17
  18 #include "ace/Atomic_Op.h"
  19
  20 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  21 # pragma once
  22 #endif /* ACE_LACKS_PRAGMA_ONCE */
  23
  24 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  25
  26 // Forward decl.
  27 template <class X> class ACE_Intrusive_Auto_Ptr;
  28
  29 /**
  30  * @class ACE_Intrusive_Auto_Ptr
  31  *
  32  * @brief This class implements support for a reference counted
  33  * auto_ptr. It assumes reference counting abilities of the
  34  * parameterizing class.
  35  *
  36  * Assigning or copying instances of an ACE_Intrusive_Auto_Ptr will
  37  * automatically increment the reference count. When the last instance
  38  * that references a ACE_Intrusive_Auto_Ptr instance is destroyed or
  39  * overwritten, it will invoke delete on its underlying pointer.
  40  *
  41  * The ACE_Intrusive_Auto_Ptr works by maintaining a reference to a
  42  * separate representation object, ACE_Intrusive_Auto_Ptr_Rep. That
  43  * separate representation object contains the reference count and the
  44  * actual pointer value.
  45  */
  46 template <class X>
  47 class ACE_Intrusive_Auto_Ptr
  48 {
  49 protected:
  50   /// Used to define a proper boolean conversion for "if (sp) ..."
  51   static void unspecified_bool(ACE_Intrusive_Auto_Ptr<X>***){}
  52   typedef void (*unspecified_bool_type)(ACE_Intrusive_Auto_Ptr<X>***);
  53
  54 public:
  55   /// Enables "if (sp) ..."
  56   operator unspecified_bool_type() const
  57     {
  58         return rep_ == 0 ? 0: unspecified_bool;
  59     }
  60
  61   /// Constructor that initializes an ACE_Intrusive_Auto_Ptr to
  62   /// the specified pointer value.
  63   ACE_Intrusive_Auto_Ptr (X *p = 0, bool addref = true);
  64
  65   /// Copy constructor binds the new ACE_Intrusive_Auto_Ptr to the
  66   /// representation object referenced by @a r.
  67   /// An ACE_Intrusive_Auto_Ptr_Rep is created if necessary.
  68   ACE_Intrusive_Auto_Ptr (const ACE_Intrusive_Auto_Ptr<X> &r);
  69
  70   // Derived class copy ctor
  71   template<class U> ACE_Intrusive_Auto_Ptr(const ACE_Intrusive_Auto_Ptr<U> & rhs);
  72
  73   /// Destructor. Releases the reference to the underlying representation.
  74   /// If the release of that reference causes its reference count to reach 0,
  75   /// the representation object will also be destroyed.
  76   virtual ~ACE_Intrusive_Auto_Ptr ();
  77
  78   /// Assignment operator that binds the current object and @a r to the same
  79   /// ACE_Intrusive_Auto_Ptr_Rep. An ACE_Intrusive_Auto_Ptr_Rep
  80   /// is created if necessary.
  81   void operator = (const ACE_Intrusive_Auto_Ptr<X> &r);
  82
  83   /// Redirection operator
  84   X *operator-> () const;
  85
  86   /// Accessor method.
  87   X &operator *() const;
  88
  89   /// Releases the reference to the underlying representation object.
  90   /// @retval The pointer value prior to releasing it.
  91   X *release ();
  92
  93   /// Releases the current pointer value and then sets a new
  94   /// pointer value specified by @a p.
  95   void reset (X *p = 0);
  96
  97   /// Get the pointer value.
  98   X *get () const;
  99
 100    /// Get the reference count value.
 101   long count () const;
 102
 103   /// Declare the dynamic allocation hooks.
 104   ACE_ALLOC_HOOK_DECLARE;
 105
 106 protected:
 107   /// Protect operations on the ACE_Intrusive_Auto_Ptr.
 108   X *rep_;
 109 };
 110
 111   /// Equality operator that returns @c true if both
 112   /// ACE_Intrusive_Auto_Ptr objects point to the same underlying
 113   /// representation. It does not compare the actual pointers.
 114   /**
 115    * @note It also returns @c true if both objects have just been
 116    *       instantiated and not used yet.
 117    */
 118 template<class T, class U>
 119 bool operator==(ACE_Intrusive_Auto_Ptr<T> const & a, ACE_Intrusive_Auto_Ptr<U> const & b);
 120
 121 /// Inequality operator, which is the opposite of equality.
 122 template<class T, class U>
 123 bool operator!=(ACE_Intrusive_Auto_Ptr<T> const & a, ACE_Intrusive_Auto_Ptr<U> const & b);
 124
 125 template<class T, class U>
 126 bool operator==(ACE_Intrusive_Auto_Ptr<T> const & a, U * b);
 127
 128 template<class T, class U>
 129 bool operator!=(ACE_Intrusive_Auto_Ptr<T> & a, U * b);
 130
 131 template<class T, class U>
 132 bool operator==(T * a, ACE_Intrusive_Auto_Ptr<U> const & b);
 133
 134 template<class T, class U>
 135 bool operator!=(T * a, ACE_Intrusive_Auto_Ptr<U> const & b);
 136
 137 ACE_END_VERSIONED_NAMESPACE_DECL
 138
 139 #if defined (__ACE_INLINE__)
 140 #include "ace/Intrusive_Auto_Ptr.inl"
 141 #endif /* __ACE_INLINE __ */
 142
 143 #include "ace/Intrusive_Auto_Ptr.cpp"
 144
 145 #include /**/ "ace/post.h"
 146
 147 #endif /* ACE_INTRUSIVE_AUTO_PTR_H */