geo/CountedReference.h

   1 /***************************************************************************
   2  *   This file is part of Tecorrec.                                        *
   3  *   Copyright 2008 James Hogan <james@albanarts.com>                      *
   4  *                                                                         *
   5  *   Tecorrec is free software: you can redistribute it and/or modify      *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation, either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   Tecorrec is distributed in the hope that it will be useful,           *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with Tecorrec.  If not, write to the Free Software Foundation,  *
  17  *   Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   *
  18  ***************************************************************************/
  19
  20 #ifndef _COUNTED_REFERENCE_H_
  21 #define _COUNTED_REFERENCE_H_
  22
  23 /**
  24  * @file util/CountedReference.h
  25  * @brief Counted reference templates.
  26  * @author James Hogan <james@albanarts.com>
  27  */
  28
  29 #include <algorithm>
  30
  31 /// Base class for reference counting
  32 class ReferenceCounted
  33 {
  34   public:
  35
  36     /*
  37       Constructors + destructor
  38     */
  39
  40     /// Default constructor
  41     ReferenceCounted()
  42     : referenceCount(0u)
  43     {
  44     }
  45
  46     /// Destructor.
  47     virtual ~ReferenceCounted()
  48     {
  49     }
  50
  51     /*
  52       Reference counting functions
  53     */
  54
  55     /// Increment the reference count.
  56     unsigned int incRefCount()
  57     {
  58       return ++referenceCount;
  59     }
  60
  61     /// Decrement the reference count.
  62     unsigned int decRefCount()
  63     {
  64       return --referenceCount;
  65     }
  66
  67     /// Get the number of references.
  68     unsigned int getRefCount() const
  69     {
  70       return referenceCount;
  71     }
  72
  73   private:
  74
  75     /*
  76       Variables
  77     */
  78
  79     /// Number of references
  80     unsigned int referenceCount;
  81 };
  82
  83 /// Base class for virtual reference counting.
  84 /**
  85  * Use this as a virtual base class during multiple inheritance.
  86  * Its quite simply an interface allowing the derived class to implement its
  87  * own reference counting.
  88  */
  89 class ReferenceCountedAbstract
  90 {
  91   public:
  92
  93     /*
  94       Constructors + destructor
  95     */
  96
  97     /// Destructor.
  98     virtual ~ReferenceCountedAbstract()
  99     {
 100     }
 101
 102     /*
 103       Reference counting functions
 104     */
 105
 106     /// Increment the reference count.
 107     virtual void incRefCount() = 0;
 108
 109     /// Decrement the reference count.
 110     virtual void decRefCount() = 0;
 111
 112     /// Get the number of references.
 113     virtual unsigned int getRefCount() const = 0;
 114 };
 115
 116 /// Base class for virtual reference counting.
 117 /**
 118  * Use this as a virtual base class during multiple inheritance.
 119  * It implements a basic reference counter.
 120  * @param autoDelete Whether to delete when reference reaches zero.
 121  */
 122 template <bool autoDelete>
 123 class ReferenceCountedVirtual : public virtual ReferenceCountedAbstract
 124 {
 125   public:
 126
 127     /*
 128      * Reference counting functions from ReferenceCountedAbstract
 129      */
 130
 131     /// Increment the reference count.
 132     virtual void incRefCount()
 133     {
 134       ++_referenceCount;
 135     }
 136
 137     /// Decrement the reference count.
 138     virtual void decRefCount()
 139     {
 140       --_referenceCount;
 141       if ( autoDelete && _referenceCount == 0 )
 142       {
 143         delete this;
 144       }
 145     }
 146
 147     /// Get the number of references.
 148     virtual unsigned int getRefCount() const
 149     {
 150       return _referenceCount;
 151     }
 152
 153   private:
 154
 155     /*
 156      * Variables
 157      */
 158
 159     /// Reference count
 160     unsigned int _referenceCount;
 161 };
 162
 163 /// Interface to reference counting.
 164 template <typename T>
 165 struct Referencer
 166 {
 167   /// Unique key type.
 168   typedef T* Key;
 169
 170   /// Increment the reference count for @p object.
 171   static void incRefCount(T* object)
 172   {
 173     object->incRefCount();
 174   }
 175
 176   /// Decrement the reference count for @p object and delete if zero.
 177   static void decRefCount(T* object)
 178   {
 179     if ( 0u == object->decRefCount() )
 180     {
 181       delete object;
 182     }
 183   }
 184
 185   /// Get the number of references to @p object.
 186   static unsigned int getRefCount(const T* object)
 187   {
 188     return object->getRefCount();
 189   }
 190
 191   /// Get the unique key for @p object.
 192   static const Key& getKey(const T* object)
 193   {
 194     return object;
 195   }
 196 };
 197
 198 /// Interface to reference counting.
 199 template <typename T>
 200 struct ReferencerSimple
 201 {
 202   /// Unique key type.
 203   typedef T* Key;
 204
 205   /// Increment the reference count for @p object.
 206   static void incRefCount(T* object)
 207   {
 208     object->incRefCount();
 209   }
 210
 211   /// Decrement the reference count for @p object.
 212   static void decRefCount(T* object)
 213   {
 214     object->decRefCount();
 215   }
 216
 217   /// Get the number of references to @p object.
 218   static unsigned int getRefCount(const T* object)
 219   {
 220     return object->getRefCount();
 221   }
 222
 223   /// Get the unique key for @p object.
 224   static const Key& getKey(const T* object)
 225   {
 226     return object;
 227   }
 228 };
 229
 230 // By default use T::DefaultReferencer
 231 template <typename T>
 232 struct DefaultReferencer
 233 {
 234   typedef typename T::DefaultReferencer Type;
 235 };
 236 // Expands to the default referencer for type T
 237 #define DEFAULT_REFERENCER_TYPE(T) \
 238   ::DefaultReferencer< T >::Type
 239
 240 // Override default referencer
 241 #define DEFAULT_REFERENCER(T,R) \
 242   template <> \
 243   struct DefaultReferencer< T > \
 244   { \
 245     typedef R Type; \
 246   }
 247 // Inherit the default referencer of another class
 248 #define INHERIT_DEFAULT_REFERENCER(T,P) \
 249   template <> \
 250   struct DefaultReferencer< T > \
 251   { \
 252     typedef DEFAULT_REFERENCER_TYPE(P) Type; \
 253   }
 254
 255 /// A reference to a counted object.
 256 template <typename T, typename REF = typename DEFAULT_REFERENCER_TYPE(T) >
 257 class Reference
 258 {
 259   public:
 260
 261     /*
 262       Types
 263     */
 264
 265     /// Object type.
 266     typedef T Object;
 267
 268     /// Referencer structure.
 269     typedef REF Referencer;
 270
 271     /*
 272       Constructors + destructor
 273     */
 274
 275     /// Default/Primary constructor.
 276     Reference(Object* newObject = 0)
 277     : object(newObject)
 278     {
 279       if ( newObject )
 280       {
 281         REF::incRefCount(newObject);
 282       }
 283     }
 284
 285     /// Copy constructor.
 286     Reference(const Reference& ref)
 287     : object((Object*)ref)
 288     {
 289       if ( object )
 290       {
 291         Referencer::incRefCount(object);
 292       }
 293     }
 294
 295     /// Conversion constructor.
 296     template <typename U, typename REF2>
 297     Reference(const Reference<U,REF2>& ref)
 298     : object((T*)ref)
 299     {
 300       if ( object )
 301       {
 302         Referencer::incRefCount(object);
 303       }
 304     }
 305
 306     /// Destructor.
 307     ~Reference()
 308     {
 309       if ( object )
 310       {
 311         Referencer::decRefCount(object);
 312       }
 313     }
 314
 315
 316     /*
 317       Object management / efficiency
 318     */
 319
 320     /// Swap with another object references.
 321     void swap(Reference& other)
 322     {
 323       std::swap(object, other.object);
 324     }
 325
 326     /// Get the number of references to this object.
 327     /**
 328      * @return 0 if nothing is referenced
 329      */
 330     unsigned int getRefCount() const
 331     {
 332       if ( object )
 333       {
 334         return Referencer::getRefCount(object);
 335       }
 336       else
 337       {
 338         return 0;
 339       }
 340     }
 341
 342
 343     /*
 344       Modification operators
 345     */
 346
 347     /// Assignment to object.
 348     Reference & operator = (Object* newObject)
 349     {
 350       if ( object != newObject )
 351       {
 352         if ( object )
 353         {
 354           Referencer::decRefCount(object);
 355         }
 356         object = newObject;
 357         if ( newObject )
 358         {
 359           Referencer::incRefCount(newObject);
 360         }
 361       }
 362       return *this;
 363     }
 364
 365     /// Assignment to reference.
 366     Reference & operator = (const Reference<T,REF>& newObject)
 367     {
 368       if ( object != (Object*)newObject )
 369       {
 370         if ( object )
 371         {
 372           Referencer::decRefCount(object);
 373         }
 374         object = (Object*)newObject;
 375         if ( object )
 376         {
 377           Referencer::incRefCount(object);
 378         }
 379       }
 380       return *this;
 381     }
 382
 383     /// Assignment to reference.
 384     template <typename REF2>
 385     Reference & operator = (const Reference<T,REF2>& newObject)
 386     {
 387       if ( object != (Object*)newObject )
 388       {
 389         if ( object )
 390         {
 391           Referencer::decRefCount(object);
 392         }
 393         object = (Object*)newObject;
 394         if ( object )
 395         {
 396           Referencer::incRefCount(object);
 397         }
 398       }
 399       return *this;
 400     }
 401
 402     /*
 403       Access operators
 404     */
 405
 406     /// Cast to Object*.
 407     operator Object* () const
 408     {
 409       return object;
 410     }
 411
 412     /// Dereference.
 413     Object* operator -> () const
 414     {
 415       return object;
 416     }
 417
 418     /*
 419      * Casting
 420      */
 421
 422     /// Dynamic cast.
 423     template <typename U>
 424     friend U dynamicCast(const Reference& ref)
 425     {
 426       return dynamic_cast<U>(ref.object);
 427     }
 428
 429   protected:
 430
 431     /*
 432       Variables
 433     */
 434
 435     /// Pointer to the object.
 436     Object* object;
 437 };
 438
 439 namespace std
 440 {
 441   /*
 442     std::swap specialisations
 443   */
 444   template <typename T, typename REF>
 445   void swap(Reference<T,REF>& a, Reference<T,REF>& b)
 446   {
 447     a.swap(b);
 448   }
 449 };
 450
 451 #endif // _COUNTED_REFERENCE_H_