referencecounted.h

/***************************************************************************
                          referencecounted.h  -  description
                             -------------------
    begin                : Sat Aug 2 2003
    copyright            : (C) 2003 by Jacques Gasselin de Richebourg
    email                : jacquesgasselin@hotmail.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Lesser General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef REFERENCECOUNTED_H
#define REFERENCECOUNTED_H


#include <map>
#include <iostream>
#include <string>

#include "glassert.h"


class ReferenceCounted
{
   int count;
   //if count == 0 it should be deleted
   
   public:

   ReferenceCounted():count(0){}
   ReferenceCounted( const ReferenceCounted& ):count(0){}

   virtual ~ReferenceCounted(){}

   inline void ref() { ++count; }
   inline ReferenceCounted* unref()
   {
      --count;
      if(count < 1)
      {  delete this; return NULL; }
      return this;
   }

   inline int getCount() { return count; }
};

template <class T>
class IRCPointer
{
public:
   ReferenceCounted* rc;

   IRCPointer()
   :rc(NULL) {}

   IRCPointer(const IRCPointer& irc)
   :rc(irc.rc) { ref(); }

   template<class T2>
   IRCPointer(const IRCPointer<T2>& irc)
   :rc(irc.rc) { ref(); }

   IRCPointer( T* p )
   :rc(NULL)
   {
      rc = p;
      ref();
   }
   
   ~IRCPointer()
   { unref(); }

   IRCPointer& operator = (const IRCPointer& irc)
   { irc.ref(); unref(); rc = irc.rc; return *this; }

   template<class T2>
   IRCPointer& operator = (const IRCPointer<T2>& irc)
   { irc.ref(); unref(); rc = irc.rc; return *this; }

   IRCPointer& operator = (T* p)
   { if(p) p->ref(); unref(); rc = p; return *this; }
   
   inline bool operator == (T* p)
   { return ((static_cast<ReferenceCounted*>(p) == rc) ? true : false ); }

   inline bool operator != (T* p)
   { return ((static_cast<ReferenceCounted*>(p) != rc) ? true : false ); }

   inline operator T* (void)
   { return static_cast<T*>(rc); }
   
   inline T* operator ->(void)
   { return static_cast<T*>(rc); }

   T& operator *(void)
   { return *(static_cast<T*>(rc)); }
   
   inline void ref(void) const
   {
      if( rc )
         rc->ref();
   }
      
   inline void unref(void)
   {
      if( rc )
         rc = rc->unref();
   }
};


template <class T, bool HasArray = false, class R = T>
class RCPointer
{
protected:
   typedef std::pair<int, void*> pairType;
   pairType* countedPointer;

public:

   RCPointer();
   RCPointer(T*);
   RCPointer(const RCPointer&);
   template <class T2>
   RCPointer(const RCPointer<T2, HasArray, T2>&);

   ~RCPointer();

   RCPointer& operator = (const RCPointer&);

   template <class T2>
   RCPointer& operator = (const RCPointer<T2, HasArray, T2>&);

   RCPointer& operator = (T* p)
   {
      PRINT(typeid(this).name()<<"::operator = ("<<p<<") used")
      if(countedPointer)
      {
         if(p != countedPointer->second)
            unref();        //not a reused pointer
         else
            return *this;
      }

      countedPointer = new pairType(1,p);
      return *this;
   }

   inline bool operator == (T*);
   inline bool operator != (T*);


   inline operator T* (void);
   inline T* operator ->(void);
   T& operator *(void);
   R& operator [](const int);

   inline void ref(void) const;
   inline void unref(void);

   inline pairType* getCountedPointer() const { return countedPointer; }
};

template <class T, bool HasArray, class R>
RCPointer<T,HasArray,R>::RCPointer()
:countedPointer(NULL)
{
   PRINT(typeid(this).name()<<" created with no countedPointer ");
}

template <class T, bool HasArray, class R>
RCPointer<T,HasArray,R>::RCPointer(T* p)
:countedPointer(NULL)
{
   if(p)
   {
      countedPointer = new pairType(1,p);
      PRINT(typeid(this).name()<<" created with count: "<<countedPointer->first);
   }
}

template <class T, bool HasArray, class R>
RCPointer<T,HasArray,R>::RCPointer(const RCPointer& rc)
:countedPointer(NULL)
{

   PRINT(typeid(this).name()<<" copied ");
   if( &rc )
   {
      countedPointer = rc.countedPointer;

      ref();
   }
}

template <class T, bool HasArray, class R>
template <class T2>
RCPointer<T,HasArray,R>::RCPointer(const RCPointer<T2, HasArray, T2>& rc)
:countedPointer(NULL)
{

   PRINT(typeid(this).name()<<" copied from "<<typeid(&rc).name())

   if( &rc )
   {
      if( rc.getCountedPointer() )
      {
         countedPointer = rc.getCountedPointer();
         ref();
      }
   }
}

template <class T, bool HasArray, class R>
RCPointer<T,HasArray,R>::~RCPointer()
{
   if(countedPointer)
   {
      PRINT(typeid(this).name()<<" attempted deletion at count: "<<countedPointer->first -1);
      unref();
   }
}

template <class T, bool HasArray, class R>
RCPointer<T,HasArray,R>& RCPointer<T,HasArray,R>::operator = (const RCPointer<T,HasArray,R>& rc)
{
   PRINT(typeid(this).name()<<"::operator = ("<<typeid(this).name()<<") used")

   rc.ref();

   unref();

   countedPointer = rc.countedPointer;

   return *this;
}

template <class T, bool HasArray, class R>
template <class T2>
RCPointer<T,HasArray,R>& RCPointer<T,HasArray,R>::operator = (const RCPointer<T2, HasArray, T2>& rc)
{
   PRINT(typeid(this).name()<<"::operator = ("<<typeid(&rc).name()<<") used")

   rc.ref();

   unref();

   countedPointer = rc.getCountedPointer();

   if( dynamic_cast<T*>( static_cast<T2*>(countedPointer->second) ) )
   {// casting is possible

   }
   else
   {
      unref();
   }

   return *this;
}

template <class T, bool HasArray, class R>
bool RCPointer<T,HasArray,R>::operator == (T* p)
{
   PRINT(typeid(this).name()<<"::operator == ("<<p<<") used")

   if(countedPointer)
   {
      if(countedPointer->second == p)
         return true;
      else
         return false;
   }
   else
   {
      if(p == NULL)
         return true;
      else
         return false;
   }
}

template <class T, bool HasArray, class R>
bool RCPointer<T,HasArray,R>::operator != (T* p)
{
   PRINT(typeid(this).name()<<"::operator != ("<<p<<") used")

   if(countedPointer)
   {
      if(p != countedPointer->second)
         return true;
      else
         return false;
   }
   else
   {
      if(p == NULL)
         return false;
      else
         return true;
   }
}

template <class T, bool HasArray, class R>
RCPointer<T,HasArray,R>::operator T* (void)
{
   PRINT(typeid(this).name()<<"::operator (T*) () used")
   if(countedPointer)
      return static_cast<T*>(countedPointer->second);
   else
      return NULL;
}

template <class T, bool HasArray, class R>
inline T* RCPointer<T,HasArray,R>::operator ->(void)
{
   PRINT(typeid(this).name()<<"::operator -> () used")
   if(countedPointer)
      return static_cast<T*>(countedPointer->second);
   else
      return NULL;
}

template <class T, bool HasArray, class R>
T& RCPointer<T,HasArray,R>::operator *(void)
{
   PRINT(typeid(this).name()<<"::operator * () used")

   customAssert(countedPointer, "no valid pointer in T& op * from RCP");

   return *(static_cast<T*>(countedPointer->second));
}

template <class T, bool HasArray, class R>
R& RCPointer<T,HasArray,R>::operator [](const int index)
{
   PRINT(typeid(this).name()<<"::operator [] ("<<index<<") used")

   customAssert(countedPointer, "no valid pointer in R& op [] from RCP");

   return (static_cast<T*>(countedPointer->second)) [index];
}

template <class T, bool HasArray, class R>
void RCPointer<T,HasArray,R>::ref (void) const
{
   PRINT(typeid(this).name()<<" ref used")

   if(countedPointer)
      ++(countedPointer->first); //reference pointer
}

template <class T, bool HasArray, class R>
void RCPointer<T,HasArray,R>::unref (void)
{
   PRINT(typeid(this).name()<<" unref used")

   if(countedPointer)
   {
      --(countedPointer->first); //unreference pointer

      if(countedPointer->first < 1)
      {//last reference expired
         PRINT(typeid(this).name()<<" has gone out of reference, is deleted by default.")
         if(countedPointer->second)
         {
            if(HasArray)
               delete [] (static_cast<T*>(countedPointer->second));
            else
               delete (static_cast<T*>(countedPointer->second));
         }

         delete countedPointer;
      }

      countedPointer = NULL;
      
      //else someone else is referencing the pointer
      //not ready to be deleted
   }
}


#endif

---