#include <iostream>


class Consumable
{
public:
    explicit Consumable(int *pPointer) :
	Pointer(pPointer) {}

    Consumable(Consumable &eEqual) :
	Pointer(eEqual.Pointer)
    { eEqual.Pointer = 0; }

    operator Consumable&() { return *this; }

    int Value() const { return Pointer? *Pointer : 0; }

    ~Consumable() { delete Pointer; }

private:
    explicit Consumable(const Consumable&) {}
    Consumable &operator = (const Consumable&) { return *this; }

    int *Pointer;
};


Consumable Transfer(Consumable oOld)
{ return oOld; }


int main()
{
    int *Value = new int(100);

    Consumable Test1 = Value;
    std::cout << "Test1: " << Test1.Value() << "\n";

    Consumable Test2 = Test1;
    std::cout << "Test2: " << Test2.Value() << "\n";
    std::cout << "Test1: " << Test1.Value() << "\n";

    Consumable Test3 = Transfer(Test2);
    std::cout << "Test3: " << Test3.Value() << "\n";
    std::cout << "Test2: " << Test2.Value() << "\n";
    std::cout << "Test1: " << Test1.Value() << "\n";
}

///////////////////////////////////////////////////////////////////////////////
///  shared_ptr.h
///  A very simple implementation of a shared scope pointer.
///  On going out of scope if decrements the counter so you must store it if
///  you want to use it later/
///  @remarks 
///  It should look and feel like a normal pointer if you see anything
///  that does not seem correct, please let me know.
///  Warning!!!!!!!!!!!!!!!!  
///  do not delete/null the pointer returned by ptr() you do not own it.
///  We could make it a T const* but this may cause problems????????????????
///  Added a release which will decrement the counter and delete if its zero.
///  @author Liam Devine @date 17/02/2007
///  update:
///  added static and dynamic casting
///////////////////////////////////////////////////////////////////////////////
#ifndef SHARED_PTR_H_
#	define SHARED_PTR_H_
#	include <cassert>
#	include <stdexcept>

namespace LDR
{
	//removed the ref counter to outside of the shared_ptr scope as 
	//when casting the raw underlying pointer it would require another cast
	struct Counter
	{
		Counter():m_amount(0){}
		int m_amount;
	};

	//forward declarations
	template<typename T>class Shared_ptr;
	template<typename TO,typename FROM>Shared_ptr<TO> sp_dynamic_cast(FROM rhs);
	template<typename TO,typename FROM>Shared_ptr<TO> sp_static_cast(FROM rhs);

	template<typename T>
	class Shared_ptr
	{
	public:
		//struct Counter
		//{
		//	Counter():m_amount(0){}
		//	int m_amount;
		//};
	public:
		Shared_ptr():m_ptr(0),m_count(0){}

		Shared_ptr(T* pointer):m_ptr(pointer),m_count(new Counter)
		{
			assert(m_ptr && m_count);
			++m_count->m_amount;
		}
		Shared_ptr(T* pointer, Counter* c):m_ptr(pointer),m_count(c)
		{
			assert(m_ptr && m_count);
			++m_count->m_amount;
		}
		Shared_ptr(Shared_ptr<T> const& rhs):m_ptr(rhs.m_ptr),m_count(rhs.m_count)
		{
			assert(rhs.m_ptr && rhs.m_count);
			++m_count->m_amount;
		}
		Shared_ptr<T>& operator = (Shared_ptr<T> const& rhs)
		{
			assert(rhs.m_ptr && rhs.m_count);
			m_ptr = rhs.m_ptr;
			m_count = rhs.m_count;
			++m_count->m_amount;
			return *this;
		}
		~Shared_ptr()
		{
			if(m_count)
			{
				if(m_count->m_amount>0)
				{
					--m_count->m_amount;
					if(m_count->m_amount==0)
					{
						delete m_ptr;m_ptr=0;
						delete m_count;m_count=0;
					}
				}
			}
		}
		T* operator->()const
		{
			return m_ptr;
		}
		T& operator*()const
		{
			return *m_ptr;
		}
		T* ptr()const
		{
			return m_ptr;
		}
		T& ref()const
		{
			return *m_ptr;
		}
		bool operator ==(Shared_ptr<T> const& rhs)const
		{
			return m_ptr == rhs.m_ptr;
		}
		bool operator !=(Shared_ptr<T> const& rhs)const
		{
			return ! (m_ptr == rhs.m_ptr);
		}
		operator bool ()const
		{
			return m_ptr !=0;//&& m_count && m_count->m_amount != 0;
		}
		int count()const
		{
			return m_count ? m_count->m_amount : 0;
		}
		void release()
		{
			if(m_count)
			{
				if(m_count->m_amount > 0)
				{
					--m_count->m_amount;
				}
				else
				{
					delete m_count;
					if(m_ptr)delete m_ptr;
				}
				m_count=0;
				m_ptr=0;
			}
		}
	private:
		//casting friends
		template<typename TO,typename FROM>friend Shared_ptr<TO> sp_dynamic_cast(FROM);
		template<typename TO,typename FROM>friend Shared_ptr<TO> sp_static_cast(FROM);
		T* m_ptr;
		Counter* m_count;
	};


	template<typename TO,typename FROM>
		Shared_ptr<TO> sp_static_cast(FROM rhs)
	{	
		Shared_ptr<TO> r ( static_cast<TO*>( rhs.m_ptr),rhs.m_count );
		return r;
	}


	template<typename TO,typename FROM>
		Shared_ptr<TO> sp_dynamic_cast(FROM rhs)
	{
		TO* p = dynamic_cast<TO*>(rhs.m_ptr);
		if(!p){ throw std::runtime_error("dynamic_cast error"); }
		return Shared_ptr<TO> (p,rhs.m_count);
	};

}


#endif//SHARED_PTR_H_