ACE/ace/Value_Ptr.h

   1 // -*- C++ -*-
   2
   3 //==========================================================================
   4 /**
   5  *  @file Value_Ptr.h
   6  *
   7  *  Value_Ptr implementation based on code in Herb Sutter's book "More
   8  *  Exceptional C++".
   9  *
  10  *  @author Ossama Othman <ossama@dre.vanderbilt.edu>
  11  */
  12 //==========================================================================
  13
  14 #ifndef ACE_VALUE_PTR_H
  15 #define ACE_VALUE_PTR_H
  16
  17 #include /**/ "ace/config-lite.h"
  18
  19 #include <algorithm>
  20
  21 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  22
  23 namespace ACE
  24 {
  25   /**
  26    * @struct VP_traits
  27    *
  28    * @brief @c Value_Ptr traits template structure.
  29    *
  30    * The @c Value_Ptr template class delegates some operations to this
  31    * template traits structure.
  32    *
  33    * Specialize this trait template if cloning through copy
  34    * construction is not sufficient.  For example, to avoid slicing
  35    * when copying an object through a base class pointer, one can
  36    * implement a virtual "clone" method that can be used to
  37    * polymorphically invoke the appropriate cloning operation(s).
  38    * That virtual method would then be invoked by the @c VP_traits\<\>
  39    * specialization.
  40    */
  41   template <typename T>
  42   struct VP_traits
  43   {
  44     /// Copy the given object.
  45     static T * clone (T const * p) { return new T (*p); }
  46   };
  47
  48   /**
  49    * @class Value_Ptr
  50    *
  51    * @brief Smart pointer implementation designed for use as a class
  52    *        member.
  53    *
  54    * Using a @c std::auto_ptr\<\> as a class member is sometimes
  55    * problematic since ownership of memory is transferred when copying
  56    * such members.  This @c Value_Ptr class is explicitly designed to
  57    * avoid such problems by performing copies of the underlying object
  58    * rather than transfer ownership.  This, for example, allows it to
  59    * be readily used as a member in classes placed inside STL
  60    * containers.
  61    *
  62    * @see Item 31 in "More Exceptional C++" by Herb Sutter.
  63    */
  64   template <typename T>
  65   class Value_Ptr
  66   {
  67   public:
  68     /// Constructor.
  69     explicit Value_Ptr (T * p = 0) : p_ (p) {}
  70
  71     /// Destructor.
  72     ~Value_Ptr () { delete this->p_; }
  73
  74     /// Deference operator.
  75     T & operator* () const { return *this->p_; }
  76
  77     /// Pointer operator.
  78     T * operator-> () const { return this->p_; }
  79
  80     /// Non-throwing swap operation used to make assignment strongly
  81     /// exception-safe.
  82     /**
  83      * @note As implemented, the swap operation may not work correctly
  84      *       for @c auto_ptr\<\>s, but why would one use an @c
  85      *       auto_ptr\<\> as the template argument for this particular
  86      *       template class!?
  87      */
  88     void swap (Value_Ptr & other) { std::swap (this->p_, other.p_); }
  89
  90     /// Copy constructor.
  91     Value_Ptr (Value_Ptr const & other)
  92       : p_ (create_from (other.p_)) { }
  93
  94     /// Assignment operator.
  95     Value_Ptr & operator= (Value_Ptr const & other)
  96     {
  97       // Strongly exception-safe.
  98       Value_Ptr temp (other);
  99       this->swap (temp);
 100       return *this;
 101     }
 102
 103     /// Converting copy constructor.
 104     template <typename U>
 105     Value_Ptr (Value_Ptr<U> const & other)
 106       : p_ (create_from (other.p_)) { }
 107
 108     /// Converting assignment operator.
 109     template <typename U>
 110     Value_Ptr & operator= (Value_Ptr<U> const & other)
 111     {
 112       // Strongly exception-safe.
 113       Value_Ptr temp (other);
 114       this->swap (temp);
 115       return *this;
 116     }
 117
 118   private:
 119     /// Copying method invoked when copy constructing.
 120     template <typename U>
 121     T * create_from (U const * p) const
 122     {
 123       return p ? VP_traits<U>::clone (p) : 0;
 124     }
 125
 126   private:
 127     template <typename U> friend class Value_Ptr;
 128
 129     /// Object owned by this @c Value_Ptr.
 130     T * p_;
 131   };
 132 }
 133
 134 ACE_END_VERSIONED_NAMESPACE_DECL
 135
 136 #endif  /* ACE_VALUE_PTR_H */