#ifndef __SAFEPTR_H__
#define __SAFEPTR_H__

#define DEBUG cout

#define protected public
#define private public

template <class TYPE>
class RefCountPtr
{
  protected:
    TYPE* m_pointer;
    int* m_refcount;
    
  public:
    RefCountPtr(TYPE * pointer) {
        m_pointer = pointer;
        m_refcount = new int;
        *m_refcount = 1;
    }
    
    RefCountPtr(RefCountPtr<TYPE> & object) {
        m_pointer = object.m_pointer;
        m_refcount = object.m_refcount;
        ref();
    }

    ~RefCountPtr() {
        destroy();
    }
    
    TYPE* pointer () {
        return m_pointer;
    }

    int refcount() {
        return *m_refcount;
    }
    
    void ref() {
        (*m_refcount)++;
    }
    
    void unref() {
        (*m_refcount)--;
    }
    
    operator TYPE* () {
        return pointer();
    }
    
    TYPE* operator -> () {
        return pointer();
    }
    
    RefCountPtr<TYPE>& operator = (RefCountPtr<TYPE> & object) {
        destroy();
        m_pointer = object.m_pointer;
        m_refcount = object.m_refcount;
        ref();
    }
    
    void destroy() {
        unref();
        DEBUG << "reference " << *m_refcount << endl;
        if (m_refcount != 0) {
            if (*m_refcount == 0) {
                delete m_refcount;
                delete m_pointer;
                m_pointer = 0;
                m_refcount = 0;
            }
        }
        DEBUG << "*** RefCountPtr::destroy() ends here ***" << endl;
    }
};

template <class TYPE>
class SafePtr
{
  protected:
    RefCountPtr<TYPE> m_rcp;
    
  public:
    SafePtr(TYPE* pointer): m_rcp(pointer) {}
    
    SafePtr(SafePtr<TYPE> & object): m_rcp(object.m_rcp) {}
    
    ~SafePtr() {}
    
    TYPE* pointer () {
        return m_rcp.pointer();
    }
    
    operator TYPE* () {
        return pointer();
    }
    
    TYPE* operator -> () {
        return pointer();
    }
    
    SafePtr<TYPE>& operator = (SafePtr<TYPE> & object) {
        m_rcp = object.m_rcp;
        return *this;
    }
};

#endif