src/Resource/smart_ptr.h

   1 #ifndef SMART_PTR_H
   2 #define SMART_PTR_H
   3
   4 /**
   5  * @file smart_ptr.h
   6  * This file contains the SmartPtr definition.
   7  *
   8  * Based on CONFIG_USE_BOOST_POINTERS we can alternate using a custom SmartPtr class and boost::shared_ptr.
   9  * Currently we use boost::shared_ptr since the custom pointer doesn't provide static_cast.
  10  *
  11  * @see SmartPtr
  12  */
  13
  14 #if 0
  15         /** Statement is only executed because debug mode is enabled. */
  16         #define DEB(x) x
  17 #else
  18         /** Statement is not executed because debug mode is disabled. */
  19         #define DEB(x)
  20 #endif
  21 #if 0
  22         /** Statement is only executed because debug mode is enabled. */
  23         #define DEB2(x) x
  24 #else
  25         /** Statement is not executed because debug mode is disabled. */
  26         #define DEB2(x)
  27 #endif
  28
  29 /** When defined this enables the use of boost::shared_pointer instead of a homebrow SmartPtr. */
  30 #define CONFIG_USE_BOOST_POINTERS
  31 #ifdef CONFIG_USE_BOOST_POINTERS
  32
  33 #include <boost/shared_ptr.hpp>
  34 #include <boost/enable_shared_from_this.hpp>
  35
  36 /** Define SmartPtr as the type to use for smart pointers. */
  37 #define SmartPtr boost::shared_ptr
  38
  39 /** Define boost::checked_delete as the method used to delete objects. */
  40 #define SmartPtrDelete(target)  void boost::checked_delete<target>(target* x);
  41
  42 #else
  43
  44 /** Define SmartPtr as the class that will be used to delete objects. */
  45 #define SmartPtrDelete(target)  class SmartPtr<target>
  46
  47 /**
  48  * The reference counting class
  49  */
  50 class SmartPtrCount
  51 {
  52         int m_refCount;
  53
  54 public:
  55         /**
  56          * Construct a reference counting class for row pointer data
  57          * \param data pointer
  58          */
  59         SmartPtrCount()
  60                 : m_refCount( 1 )
  61         {
  62                 DEB( printf("SmartPtrCount ctor...\n"));
  63         }
  64
  65         /**
  66          * Destructor
  67          */
  68         virtual ~SmartPtrCount()
  69         {
  70                 DEB( printf("SmartPtrCount dtor...\n"));
  71         }
  72
  73         /**
  74          * Increase reference counting by 1
  75          */
  76         void IncRef() { m_refCount ++ ; }
  77
  78         /**
  79          * Decrease reference counting by 1
  80          */
  81         void DecRef() { m_refCount -- ; }
  82         /**
  83          * Return the current reference counting
  84          * \return current reference counting
  85          */
  86         int  GetRefCount() { return m_refCount; }
  87 };
  88
  89 /**
  90  * A smart pointer class that provides a reference counting and auto delete memory.
  91  *
  92  * This class is similar to std::auto_ptr, with 2 exceptions:
  93  * - This class uses reference counting
  94  * - We dont provide a release() function (because of the reference counting)
  95  * It is recommended to use this class instead of using raw pointer wherever possible.
  96  *
  97  * \note smart pointer to NULL is valid.
  98  */
  99 template <class T>
 100 class SmartPtr
 101 {
 102         T* m_data;
 103         SmartPtrCount* m_ref;
 104
 105 public:
 106         /**
 107          * Construct smart pointer from ptr
 108          * \param ptr pointer
 109          */
 110         SmartPtr(T* ptr)
 111         {
 112                 DEB( printf("SmartPtr T* ctor...\n"));
 113                 // create a fresh copy
 114                 CreateFresh( ptr );
 115         }
 116
 117         /**
 118          * Default constructor
 119          */
 120         SmartPtr()
 121                 : m_data(NULL)
 122         {
 123                 DEB( printf("SmartPtr ctor...\n"));
 124                 m_ref = new SmartPtrCount();
 125         }
 126
 127         /**
 128          * Copy constructor
 129          * \param rhs right hand side
 130          */
 131         SmartPtr(const SmartPtr& rhs)
 132                 : m_data(NULL),
 133                 m_ref(NULL)
 134         {
 135                 DEB( printf("SmartPtr SmartPtr ctor...\n"));
 136                 *this = rhs;
 137         }
 138
 139         template<class Y>
 140         SmartPtr(SmartPtr<Y> const& rhs)
 141                 : m_data(rhs.m_data),
 142                 m_ref(rhs.m_ref)
 143         {
 144                 DEB( printf("SmartPtr SmartPtr<Y> ctor...\n"));
 145                 m_ref->IncRef();
 146         }
 147
 148         /**
 149          * Assignment operator
 150          * \param rhs right hand side
 151          * \return reference to this
 152          */
 153         SmartPtr& operator=(const SmartPtr& rhs)
 154         {
 155                 DEB2( printf("SmartPtr = operator...\n"));
 156
 157                 // increase the reference count
 158                 if( m_ref == rhs.m_ref )
 159                 {
 160                         DEB2( printf("m_ref = rhs.m_ref\n") );
 161                         return *this;
 162                 }
 163
 164                 // Delete previous reference
 165                 DeleteRefCount();
 166
 167                 // TODO: What to do here?
 168                 if( !rhs.m_ref )
 169                 {
 170                         DEB2( printf("!rhs.m_ref\n") );
 171                         return *this;
 172                 }
 173
 174                 DEB2( printf("no returns so far\n") );
 175
 176                 m_data = rhs.m_data;
 177                 m_ref = rhs.m_ref;
 178                 m_ref->IncRef();
 179                 return *this;
 180         }
 181
 182         /**
 183          * Destructor
 184          */
 185         virtual ~SmartPtr()
 186         {
 187                 DEB( printf("SmartPtr dtor...\n"));
 188                 DeleteRefCount();
 189         }
 190
 191         /**
 192          * Replace the current pointer with ptr
 193          * if the current ptr is not NULL, it will be freed (reference counting free) before assingning the new ptr
 194          * \param ptr new pointer
 195          */
 196         void reset(T* ptr = 0)
 197         {
 198                 DeleteRefCount();
 199                 CreateFresh( ptr );
 200         }
 201
 202         /**
 203          * Return pointer the row data pointer
 204          * \return pointer to the row data pointer
 205          */
 206         T* get() const
 207         {
 208                 return m_data;
 209         }
 210
 211         /**
 212          * Overload the '->' operator
 213          * \return pointer to the row data pointer
 214          */
 215         T* operator->() const
 216         {
 217                 return m_data;
 218         }
 219
 220         /**
 221          * Dereference operator
 222          * \return dereference the row data
 223          */
 224         T& operator*() const
 225         {
 226                 return *(m_data);
 227         }
 228
 229         /**
 230          * Test for NULL operator
 231          * \return true if the internal row data or the reference counting class are NULL false otherwise
 232          */
 233         bool operator!() const
 234         {
 235                 return (!m_ref || !m_data);
 236         }
 237
 238         /**
 239          * test for bool operation
 240          * \return true of the internal raw data exist and it is not null
 241          */
 242         operator bool() const
 243         {
 244                 return m_ref && m_data;
 245         }
 246
 247         void print() const
 248         {
 249                 printf("%d: %p (%p)\n", m_ref->GetRefCount(), m_data, this);
 250         }
 251
 252 private:
 253         void DeleteRefCount()
 254         {
 255                 DEB2( printf("DeleteRefCount()\n") );
 256                 // decrease the ref count (or delete pointer if it is 1)
 257                 if( m_ref )
 258                 {
 259                         DEB2( printf("m_ref\n") );
 260                         if( m_ref->GetRefCount() <= 1 )
 261                         {
 262                                 DEB2( printf("m_ref->GetRefCount() <= 1\n") );
 263                                 delete m_ref;
 264                                 m_ref = NULL;
 265                                 delete m_data;
 266                                 m_data = NULL;
 267                         }
 268                         else
 269                         {
 270                                 DEB2( printf("m_ref->GetRefCount() = %d\n", m_ref->GetRefCount()) );
 271                                 m_ref->DecRef();
 272                         }
 273                 }
 274                 else
 275                 {
 276                         DEB2( printf("!m_ref\n") );
 277                 }
 278         };
 279
 280         void CreateFresh(T* ptr)
 281         {
 282                 m_ref = new SmartPtrCount();
 283                 m_data = ptr;
 284         }
 285
 286         template<class Y> friend class SmartPtr;
 287 };
 288
 289 #endif // CONFIG_USE_BOOST_POINTERS
 290 #endif // SMART_PTR_H