// http://www.josuttis.com/libbook/cont/countptr.hpp.html
// http://en.wikipedia.org/wiki/Auto_ptr
// http://www.koders.com/cpp/fidAD7781CE87A3E6FF6EEAE0B813566BDCC8EE7B1A.aspx?s=mdef%3Ainsert
// file:///home/moma/code/thinking/html/TicV2.html#_Toc305593296

#pragma once

#include <stdexcept>

struct NullPointerException : public std::runtime_error
{
    explicit NullPointerException (const char *s = "Null pointer error") :  std::runtime_error (s)
    {
        // std::cerr << "Assertion failed in file " << __FILE__ << " at line " << __LINE__ << ":" << std::endl;
        // std::cerr << #expression << std::endl;
    }

    void raise ()
    {
        throw *this;
    }
};


template <class T>
class AutoPtr
{
private:
    T *m_ptr;        // Pointer
    unsigned long m_count;   // Reference count

public:
    // initialize pointer with existing pointer
    // - requires that the pointer p is a return value of new
    explicit AutoPtr (T* p=0) : m_ptr(p), m_count(1)
    {
    }

    // copy pointer (one more owner)
    AutoPtr (const AutoPtr<T>& p) throw() : m_ptr(p.m_ptr), m_count(p.m_count)
    {
       m_count++;
    }

    // destructor (delete value if this was the last owner)
    ~AutoPtr () throw()
    {
        dispose();
    }

    // assignment (unshare old and share new value)
    AutoPtr<T>& operator= (const AutoPtr<T>& p) throw()
    {
        if (this != &p)
        {
            dispose();
            m_ptr = p.m_ptr;
            m_count = p.m_count;
            m_count++;
        }
        return *this;
    }

    // access the value to which the pointer refers
    T& operator*() const throw()
    {
        if (m_ptr == 0)
        {
            throw NullPointerException("Null pointer exception in operator*() of class AutpPtr");
        }

        return *m_ptr;
    }

    T* operator->() const throw()
    {
        if (m_ptr == 0)
        {
            throw NullPointerException("Null pointer exception in operator->() of class AutpPtr");
        }

        return m_ptr;
    }

    const T *getPtr() const
    {
        return m_ptr;
    }

    const T &getRef() const
    {
        if (m_ptr == 0)
        {
            throw NullPointerException("Null pointer exception in getRef() of class AutpPtr");
        }
        return *m_ptr;
    }

    // Explicitly delete the data pointer.
    void explicitly_delete()
    {
        if (m_ptr) delete m_ptr;
        m_ptr = 0;
        m_count = 0;
    }

    // Get reference count (number pointers on this object)
    long getRefCount()
    {
        return m_count;
    }




  private:
    void dispose()
    {
        if (m_count > 0) m_count--;

        if (m_count == 0)
        {
            delete m_ptr;
        }
    }

};

/*
template <class T>
class AutoPtr
{
  private:
    T* ptr;       // pointer to the value
    long count;   // shared number of owners

  public:
    // initialize pointer with existing pointer
    // - requires that the pointer p is a return value of new
    explicit AutoPtr (T* p=0) : ptr(p), count(1)
    {
    }

    // copy pointer (one more owner)
    AutoPtr (const AutoPtr<T>& p) throw() : ptr(p.ptr), count(p.count)
    {
        count++;
    }

    // destructor (delete value if this was the last owner)
    ~AutoPtr () throw()
    {
        dispose();
    }

    // assignment (unshare old and share new value)
    AutoPtr<T>& operator= (const AutoPtr<T>& p) throw()
    {
        if (this != &p) {
            dispose();
            ptr = p.ptr;
            count = p.count;
            count++;
        }
        return *this;
    }

    // access the value to which the pointer refers
    T& operator*() const throw()
    {
        return *ptr;
    }

    T* operator->() const throw()
    {
        return ptr;
    }

  private:
    void dispose()
    {
        if (--count == 0) {
             delete ptr;
        }
    }

};
*/