include/CountedReference.h

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