kk_ptr.hh

Go to the documentation of this file.

#ifndef KK_PTR
#define KK_PTR

#include <iostream>
#include <typeinfo>

#ifdef KK_PTR_DEBUG

using std::cout;
using std::endl;

#define KK_PTR_OUT(x) cout<<x;

#ifndef KK_DEBUG
#define KK_DEBUG
#endif

#else

#define KK_PTR_OUT(x) 

#endif

#include "kk_defines.hh"

//#define KK_USE_VPTR

namespace KK {

  long int acquire_gid();

  void release_gid(long int gid);

  class sptr_Err : public KK::Err {};

#ifdef KK_USE_VPTR

  class vptr 
  {
  public:
    virtual ~vptr(){};
    
    virtual operator bool() const=0;
    virtual long int GID() const=0;

  };
#endif


  template<typename T>
  class sptr 
#ifdef KK_USE_VPTR
: public vptr
#endif
  {
    template<typename TO, typename FROM> friend sptr<TO> sptr_cast( sptr<FROM> &p );
    template<typename TO, typename FROM> friend sptr<TO> sptr_static_cast( sptr<FROM> &p );
    template<typename TO, typename FROM> friend sptr<TO> sptr_dynamic_cast( sptr<FROM> &p );
  public:
    
    inline sptr(T*d_=0) : data(d_), count(0), gid(-1)
    { 
      if (data) 
        {
          gid=acquire_gid(); 
          increment();
        }
      KK_PTR_OUT("built sptr for address "<<data<<", gid "<<gid<<", count "<<(count ? (*count) : -1)<<endl);
    }
    
    inline sptr( const sptr<T> &p ) : data(p.data), count(p.count), gid(p.gid)
    {
      if ( data ) increment();
      KK_PTR_OUT("built sptr for address "<<data<<", gid "<<gid<<", count "<<(count ? (*count) : -1)<<endl);
    }

    inline
    ~sptr()
    {
      KK_PTR_OUT("del sptr for address "<<data<<", gid "<<gid<<", count "<<(count ? (*count) : -1)<<endl);
      if ( data )
        if ( decrement()==0 )
          destroy();
        else if ( (*count)<0 )
          throw sptr_Err();
    }

    inline sptr<T> & operator=( const sptr<T> & p )
    {
      if ( *this==p ) return *this;

      if ( data && decrement()==0 )
        destroy();

      data = p.data;
      count = p.count;
      gid = p.gid;

      if ( data ) increment();

      KK_PTR_OUT("opr= sptr for address "<<data<<", gid "<<gid<<", count "<<(count ? (*count) : -1)<<endl);
      return *this;
    }


    inline bool operator==(const sptr<T> &p) const
    {
      KK::Assert<sptr_Err> ( (data==p.data && gid==p.gid) || (data!=p.data && gid!=p.gid), 
                             "ERROR: sptr_Err: sptr::== called but data and global id do not match!" );

      KK_PTR_OUT("this : "<<data<<"  "<<gid<<" ; p : "<<p.data<<"  "<<p.gid<<endl);
      return (data==p.data && gid==p.gid);
    }


    inline bool operator!=(const sptr<T> &p) const
    { return !(*this==p); }

    inline T* operator->()
    { 
      KK::Assert<sptr_Err> ( data, "ERROR: sptr_Err: sptr-> called for null pointer!" );
      return data; 
    }

    inline const T* operator->() const
    { 
      KK::Assert<sptr_Err> ( data, "ERROR: sptr_Err: sptr-> called for null pointer!" );
      return data; 
    }

    inline T& operator*()
    { 
      KK::Assert<sptr_Err> ( data, "ERROR: sptr_Err: *sptr called for null pointer!" );
      return *data; 
    }

    inline const T& operator*() const
    { 
      KK::Assert<sptr_Err> ( data, "ERROR: sptr_Err: *sptr called for null pointer!" );
      return *data; 
    }

    inline const T* raw() const 
    { return data; }

    inline operator bool() const
    { 
      KK::Assert<sptr_Err>( (data==0&&gid==-1)||(data!=0 && gid>-1) );
      return (data!=0 && gid>-1);
    }

    inline long int GID() const { return gid; }

    inline int nRefs() const { return count ? *count : 0; }

  protected:

    sptr( T* rp, int * start_count, long int gid_) : data(rp), count(start_count), gid(gid_)
    {
      KK::Assert(start_count>0, "ERROR : protected sptr constructor : invalid initial count");

      if ( data ) increment();
    }

    inline int increment() 
    { 
      // data has to be here for the increment to be valid (a null sptr should never get incremented)
      KK::Assert<sptr_Err>( data, "ERROR: sptr_Err: sptr::increment called with no data!" );
      
      if ( !count ) 
        {
          count = new int;
          (*count) = 0;
        }

      KK_PTR_OUT("count is at address "<<count<<endl);
      KK_PTR_OUT("incrementing "<<data<<", gid "<<gid<<", count "<<(count ? (*count) : -1)<<endl);

      return ++(*count);
    }

    inline int decrement()
    {
      // data has to be here for the increment to be valid (a null sptr should never get decremented)
      KK::Assert<sptr_Err>( data, "ERROR: sptr_Err: sptr::decrement called with no data!" );
      // check to make sure the reference count makes at least a little sense (>0)
      KK::Assert<sptr_Err>( count && (*count)>0, 
                            "ERROR: sptr_Err: sptr::decrement called with invalid reference count!" );
      KK_PTR_OUT("decrementing "<<data<<", gid "<<gid<<", count "<<(count ? (*count) : -1)<<endl);

      return --(*count);
    }

    inline void destroy()
    {
      KK::Assert<sptr_Err>( (*count)==0, "ERROR: sptr_Err: sptr::destroy called with nonzero count!" );
      delete data;
      delete count;
      data  = 0;
      count = 0;
      release_gid(gid);
    }

  private:
    T *data;
    int *count;
    long int gid;
  };

  template<typename TO, typename FROM>
  inline
  sptr<TO> sptr_cast( sptr<FROM> &p )
  {
    TO * to = static_cast<TO*>((FROM*)p.raw());

    if ( to )
      return sptr<TO>(to, p.count, p.gid);
    else
      return sptr<TO>(); // just return a null pointer
  }

  template<typename TO, typename FROM>
  inline
  sptr<TO> sptr_static_cast( sptr<FROM> &p )
  {
    return sptr_cast<TO>(p);
  }

  template<typename TO, typename FROM>
  inline
  sptr<TO> sptr_dynamic_cast( sptr<FROM> &p ) 
  {
    TO * to = dynamic_cast<TO*>((FROM*)p.raw());

    if ( to )
      return sptr<TO>(to, p.count, p.gid);
    else
      return sptr<TO>(); // just return a null pointer
  }

#ifdef KK_USE_VPTR
  template<typename TO>
  inline
  sptr<TO> vptr_cast( vptr &p )
  {
    sptr<TO> *sp = dynamic_cast< sptr<TO>* >(&p);
    if ( sp )
      return *sp;
    else 
      return sptr<TO>();
  }
#endif
}

#endif