#ifndef	POINTER_H
#define	POINTER_H

#include "RefCount.h"

#ifndef NULL
#define NULL	0
#endif

#ifdef	NULL_POINTER
#undef	NULL_POINTER
#endif
#define	NULL_POINTER	(static_cast <T *> (NULL))

#define Obj(P) (*P)

// NOTE:
//		1) The class used to replace T in the template below must be derived from RefCount
//		2) The object that Pointer "points to" must be dynamically allocated

template <class T>
	class Pointer
		{
		public:
			enum	Exceptions		{NullPointerException};

									Pointer			();
			explicit				Pointer			(T *);
			explicit				Pointer			(const Pointer<T> &);
			virtual					~Pointer		();
					bool			DoesNotExist	() const;
					bool			Exists			() const;
					Pointer <T> &	New				();
					Pointer <T> &	New				(const T &);
					T &				ObjectOf		();
			const	T &				ObjectOf		() const;
					Pointer<T> &	PointsTo		(const Pointer<T> &);
					Pointer<T> &	SetTo			(const Pointer<T> &);
					void			SetToNull		();
					T &				operator *		();
			const	T &				operator *		() const;
					T*				operator ->		();
			const	T*				operator ->		() const;
					Pointer<T> &	operator =		(const Pointer<T> &);
					bool			operator ==		(const Pointer<T> &);
					bool			operator !		() const;
					bool			operator !=		(const Pointer<T> &);
									operator bool	() const;
		private:
					Pointer<T> &	Copy			(const Pointer<T> &);
					void			Decrement		();
					void			SetAndIncrement	(const T *);
					Pointer<T> &	SetTo			(const T *);
					Pointer<T> &	operator =		(const T *);

					T *				Ptr;
		};

template <class T>
	Pointer <T>::Pointer ():Ptr (NULL_POINTER)
		{
		}

template <class T>
	Pointer <T>::Pointer (T * p)
		{
		SetAndIncrement (p);
		}

template <class T>
	Pointer <T>::Pointer (const Pointer<T> & P)
		{
		SetAndIncrement (P.Ptr);
		}

template <class T>
	Pointer <T>::~Pointer ()
		{
		Decrement ();
		}

template <class T>
	inline bool Pointer<T>::DoesNotExist () const
		{
		return Ptr == NULL_POINTER;
		}

template <class T>
	inline bool Pointer<T>::Exists () const
		{
		return Ptr != NULL_POINTER;
		}

template <class T>
	inline Pointer <T> & Pointer<T>::New ()
		{
		Decrement ();
		SetAndIncrement (new T);
		return *this;
		}

template <class T>
	inline Pointer <T> & Pointer<T>::New (const T & t)
		{
		Decrement ();
		SetAndIncrement (new T (t));
		return *this;
		}

template <class T>
	inline T & Pointer<T>::ObjectOf ()
		{
		if (Ptr)
				return *Ptr;
			else
				throw NullPointerException;
		}

template <class T>
	inline const T & Pointer<T>::ObjectOf () const
		{
		if (Ptr)
				return *Ptr;
			else
				throw NullPointerException;
		}

template <class T>
	inline Pointer<T> & Pointer<T>::PointsTo (const Pointer<T> & P)
		{
		return Copy (P);
		}

template <class T>
	inline Pointer<T> & Pointer<T>::SetTo (const Pointer<T> & P)
		{
		return SetTo (P.Ptr);
		}

template <class T>
	inline void Pointer<T>::SetToNull ()
		{
		SetTo (NULL_POINTER);
		}

template <class T>
	inline T & Pointer<T>::operator * ()
		{
		return ObjectOf ();
		}

template <class T>
	inline const T & Pointer<T>::operator * () const
		{
		return ObjectOf ();
		}

template <class T>
	inline T * Pointer<T>::operator -> ()
		{
		if (Ptr)
				return Ptr;
			else
				throw NullPointerException;
		}

template <class T>
	inline const T * Pointer<T>::operator -> () const
		{
		if (Ptr)
				return Ptr;
			else
				throw NullPointerException;
		}

template <class T>
	inline Pointer<T> & Pointer<T>::operator = (const Pointer<T> & P)
		{
		if (this != &P)
				SetTo (P.Ptr);
			else;
		return *this;
		}

template <class T>
	inline bool Pointer<T>::operator == (const Pointer<T> & P)
		{
		return Ptr == P.Ptr;
		}

template <class T>
	inline bool Pointer<T>::operator ! () const
		{
		return DoesNotExist ();
		}

template <class T>
	inline bool Pointer<T>::operator != (const Pointer<T> & P)
		{
		return Ptr != P.Ptr;
		}

template <class T>
	inline Pointer<T>::operator bool () const
		{
		return Exists ();
		}

template <class T>
	inline Pointer<T> & Pointer<T>::Copy (const Pointer<T> & P)
		{
		return *this = P;
		}

template <class T>
	inline void Pointer<T>::Decrement ()
		{
		if (Ptr)
				(*Ptr).DownCount ();
			else;
		}

template <class T>
	inline void Pointer<T>::SetAndIncrement (const T * p)
		{
		if ((Ptr = (T *) (p)) != NULL_POINTER)
				(*Ptr).UpCount ();
			else;
		}

template <class T>
	inline Pointer<T> & Pointer<T>::SetTo (const T * p)
		{
		Decrement ();
		SetAndIncrement (p);
		return *this;
		}

template <class T>
	inline Pointer<T> & Pointer<T>::operator = (const T * p)
		{
		return SetTo (p);
		}

#endif