#ifndef SHARED_REF_H_
#define SHARED_REF_H_

template<class T, class P1>
class SharedRef
{
	private:
		template<class CT, class CP1>
		class Share
		{
		public:
			Share(CP1 cp1)
				: Count(1), Payload(cp1)
			{
			}
			unsigned int Count;
			T Payload;
		};
	public:
		SharedRef(P1 p1)
			: Link(new Share<T,P1>(p1))
		{
		}

		SharedRef(const SharedRef<T,P1>& anOther)
			: Link(anOther.Link)
		{
			++Link->Count;
		}
		~SharedRef()
		{
			unref();
		}
		SharedRef<T,P1>& operator=(const SharedRef<T,P1>& anOther)
		{
			unref();
			Link = anOther.Link;
			++Link->Count;
			return *this;
		}
		T* operator->()
		{
			return &Link->Payload;
		}
		const T* operator->() const
		{
			return &Link->Payload;
		}

	private:
		void unref()
		{
			--Link->Count;
			if (!Link->Count)
				delete Link;
		}

		Share<T,P1>* Link;
};

class SharedPtrShare
{
public:
	SharedPtrShare(void* ct)
		: Count(1), Payload(ct)
	{
	}
	unsigned int Count;
	void* Payload;
};


template<class T>
class SharedPtr
{
	private:
	public:
		SharedPtr()
			: Link(0)
		{
		}

		SharedPtr(T* t)
			: Link(0)
		{
			if (t)
				Link = new SharedPtrShare(t);
		}

		SharedPtr(const SharedPtr<T>& anOther)
			: Link(anOther.Link)
		{
			if (Link)
				++Link->Count;
		}

		SharedPtr(SharedPtrShare* aLink)
		: Link(aLink)
		{
			if (Link)
				++Link->Count;
		}

		~SharedPtr()
		{
			unref();
		}
		SharedPtr<T>& operator=(const SharedPtr<T>& anOther)
		{
			// Guard against unreffing in case of self-assignment
			SharedPtr<T> Guard(anOther);
			unref();
			Link = anOther.Link;
			if (Link)
				++Link->Count;
			return *this;
		}
		T* operator->()
		{
			return static_cast<T*>(Link->Payload);
		}
		const T* operator->() const
		{
			return static_cast<T*>(Link->Payload);
		}
		bool isNull() const
		{
			return !Link || !Link->Payload;
		}
		const T& cref() const
		{
			return *(static_cast<T*>(Link->Payload));
		}

		template<class V>
		SharedPtr<V> validCast()
		{
			if (Link)
			{
				V* v = static_cast<T*>(Link->Payload);
				v=v;
				return SharedPtr<V>(Link);
			}
			return SharedPtr<V>();
		}

		template<class V>
		SharedPtr<V> dynamicCast()
		{
			if (Link && dynamic_cast<V*>(static_cast<T*>(Link->Payload)))
				return SharedPtr<V>(Link);
			return SharedPtr<V>();
		}

	private:
		void unref()
		{
			if (!Link) return;
			--Link->Count;
			if (!Link->Count)
			{
				T* t = static_cast<T*>(Link->Payload);
				delete t;
				delete Link;
				Link = 0;
			}
		}

		
		SharedPtrShare* Link;
};

#endif