RefCount.h

/* This file is Copyright 2000-2008 Meyer Sound Laboratories Inc.  See the included LICENSE.txt file for details. */ 

#ifndef MuscleRefCount_h 
#define MuscleRefCount_h 

#include "util/ObjectPool.h" 
#include "system/AtomicCounter.h"

BEGIN_NAMESPACE(muscle);

class RefCountable;

class RefCountable
{
public:
   RefCountable() : _manager(NULL) {/* empty */}

   RefCountable(const RefCountable &) : _manager(NULL) {/* empty */}

   virtual ~RefCountable() {/* empty */}

   inline RefCountable &operator=(const RefCountable &) {return *this;}

   inline void IncrementRefCount() const {_refCount.AtomicIncrement();}

   inline bool DecrementRefCount() const {return _refCount.AtomicDecrement();}

   void SetManager(AbstractObjectManager * manager) {_manager = manager;}

   AbstractObjectManager * GetManager() const {return _manager;}
   
   uint32 GetRefCount() const {return _refCount.GetCount();}

private:
   mutable AtomicCounter _refCount;
   AbstractObjectManager * _manager;
};

template <class Item> class Ref;  // forward reference

typedef Ref<RefCountable> GenericRef;

template <class Item> class Ref
{
public:
   typedef ObjectPool<Item> ItemPool;        
   Ref() : _item(NULL), _doRefCount(true) {/* empty */}

   Ref(Item * item, bool doRefCount = true) : _item(item), _doRefCount(doRefCount) {RefItem();} 

   Ref(const Ref & copyMe) : _item(NULL), _doRefCount(true) {*this = copyMe;}

   Ref(const GenericRef & ref, bool junk) : _item(NULL), _doRefCount(true) {(void) junk; (void) SetFromGeneric(ref);}

   ~Ref() {UnrefItem();}

   void SetRef(Item * item, bool doRefCount = true)
   {
      if (item == _item)
      {
         if (doRefCount != _doRefCount)
         {
            if (doRefCount)
            {
               // We weren't ref-counting before, but the user wants us to start
               _doRefCount = true;
               RefItem();
            }
            else 
            {
               // We were ref-counting before, but the user wants us to drop it
               UnrefItem();
               _doRefCount = false;
            } 
         }
      }
      else
      {
         // switch items
         UnrefItem();
          _item       = item;
          _doRefCount = doRefCount;
         RefItem();
      }
   }

   inline Ref &operator=(const Ref & rhs) {if (this != &rhs) SetRef(rhs._item, rhs._doRefCount); return *this;}

   bool operator ==(const Ref &rhs) const {return _item == rhs._item;}
 
   bool operator !=(const Ref &rhs) const {return _item != rhs._item;}
 
   Item * GetItemPointer() const {return _item;}

   Item * CheckedGetItemPointer() const {return this ? _item : NULL;}

   Item * operator()() const {return _item;}

   void Reset() {UnrefItem();}

   void Neutralize() {if ((_doRefCount)&&(_item)) (void) _item->DecrementRefCount(); _item = NULL;}

   void SwapContents(Ref & swapWith)
   {
      muscleSwap(_item,       swapWith._item); 
      muscleSwap(_doRefCount, swapWith._doRefCount);
   }

   bool IsRefCounting() const {return _doRefCount;}

   GenericRef GetGeneric() const {return GenericRef(_item, _doRefCount);}

   status_t SetFromGeneric(const GenericRef & genericRef)
   {
      RefCountable * genericItem = genericRef();
      if (genericItem)
      {
         Item * typedItem = dynamic_cast<Item *>(genericItem);
         if (typedItem == NULL) return B_ERROR;
         SetRef(typedItem, genericRef.IsRefCounting());
      }
      else Reset();

      return B_NO_ERROR;
   }

   inline void SetFromGenericUnchecked(const GenericRef & genericRef)
   {
      SetRef(static_cast<Item *>(genericRef()), genericRef.IsRefCounting());
   }

   bool IsRefPrivate() const
   {
      return ((_item == NULL)||((_doRefCount)&&(_item->GetRefCount() == 1)));
   }

   status_t EnsureRefIsPrivate()
   {
      if (IsRefPrivate() == false)
      {
         AbstractObjectManager * m = _item->GetManager();
         Item * newItem = m ? static_cast<Item *>(m->ObtainObjectGeneric()) : newnothrow Item;
         if (newItem) 
         {
            *newItem = *_item;
            SetRef(newItem);
         }
         else 
         { 
            WARN_OUT_OF_MEMORY;
            return B_ERROR;
         }
      }
      return B_NO_ERROR;
   }

   uint32 HashCode() const {return (uint32)((unsigned long)_item);}  // double-cast for AMD64

private:
   void RefItem() {if ((_doRefCount)&&(_item)) _item->IncrementRefCount();}
   void UnrefItem()
   {
      if (_item)
      {
         if ((_doRefCount)&&(_item->DecrementRefCount()))
         {
            AbstractObjectManager * m = _item->GetManager();
            if (m) m->RecycleObject(_item);
              else delete _item;
         }
         _item = NULL;
      }
   }
   
   Item * _item; 
   bool _doRefCount;
};

// VC++6 and ealier can't handle partial template specialization, so don't let it see this
// To compile using them, you'll have to write an explicit HashFunctor.  Sucks, eh?
// At least you can use the DECLARE_HASHTABLE_KEY_CLASS macro to make it quicker for you.
#ifndef MUSCLE_USING_OLD_MICROSOFT_COMPILER
template <class T> class HashFunctor;
template <class Item> class HashFunctor<Ref<Item> >
{
public:
   uint32 operator()(const Ref<Item> & ref) const {return ref.HashCode();}
};
template <class Item> class HashFunctor<const Ref<Item> * >
{
public:
   uint32 operator()(const Ref<Item> * ref) const {return ref->HashCode();}
};
#endif

END_NAMESPACE(muscle);

#endif

---