include/CountedReference.h

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