#ifndef POINTER
#define POINTER

#include <exception>



/*****************
 * Pointer<T, N> 
*****************/
template <typename T, unsigned int N=1>
class Pointer
{
	public:
		class PointerOutOfRange : public std::exception{};
	
		Pointer();
		Pointer(const Pointer<T, N> & pointer);
	
		Pointer<T, N> & operator = (const Pointer<T, N> & pointer);
		~Pointer();
	
		T * operator [](unsigned int index) throw(PointerOutOfRange);

	private:
		struct Data{
			T * adress;
			unsigned int nbRef;
		};
	
		void free()
		{
			if((data->nbRef)==1)
			{
				delete[] data->adress;
				delete data;
			}
			else data->nbRef--;
		}
	
		void copy(Pointer<T, N>::Data * data)
		{
			data->nbRef++;
			this->data = data;
		}
	
		Data * data;
};
/*****************
 * Pointer<T, 1> 
*****************/
template <typename T>
class Pointer<T, 1>
{
	public:
		Pointer();
		Pointer(const Pointer<T> & pointer);
		Pointer(const T & t);
		Pointer & operator = (const Pointer<T> & pointer);
		~Pointer();
	
		T * operator->(void);
		T & operator *(void) const;
	
	private:
		struct Data{
			T * adress;
			unsigned int nbRef;
		};
	
		void free()
		{
			if((data->nbRef)==1)
			{
				delete data->adress;
				delete data;
			}
			else data->nbRef--;
		}
	
		void copy(Pointer<T, 1>::Data * data){
			data->nbRef++;
			this->data = data;
		}
	
		Data * data;
};
/*****************
 * Pointer<T, 0> 
*****************/
template <typename T>
class Pointer<T, 0>
{
	private:
		Pointer();
};


/*-----------------------------------------
		Definitions Pointer<T, N>
-----------------------------------------*/
template <typename T, unsigned N>
Pointer<T, N>::Pointer()
:data(new Data())
{
	data->adress = new T[N];
	data->nbRef=1;
}

template<typename T, unsigned int N>
Pointer<T, N>::Pointer(const Pointer<T, N> & pointer){
	copy(pointer.data);
}

template <typename T, unsigned int N>
Pointer<T, N> & Pointer<T, N>::operator =(const Pointer<T, N> & pointer)
{
	free();
	copy(pointer.data);
	return (*this);
}

template<typename T, unsigned int N>
Pointer<T, N>::~Pointer(){
	free();
}

template<typename T, unsigned int N>
T * Pointer<T, N>::operator [](unsigned int index) throw(PointerOutOfRange){
	if(index>(N-1)) throw PointerOutOfRange();
	return &data->adress[index];
}


/*-----------------------------------------
		Definitions Pointer<T, 1>
-----------------------------------------*/
template <typename T>
Pointer<T, 1>::Pointer()
:data(new Data())
{
	data->adress = new T();
	data->nbRef=1;
}

template <typename T>
Pointer<T, 1>::Pointer(const T & t)
:data(new Data())
{
	data->adress = new T(t);
	data->nbRef=1;
}

template<typename T>
Pointer<T, 1>::~Pointer(){
	free();
}

template<typename T>
T * Pointer<T, 1>::operator->(void){
	return data->adress;
}

template<typename T>
T & Pointer<T, 1>::operator *(void) const{
	return (*data->adress);
}

#endif