#ifndef _myHandle_
#define _myHandle_

#include "body.h"

//	********************************************************
//  *                      myHandle						   *
//  ********************************************************
//
//	Implementerar designmönstret Handle-Body.
//	Detta tillåter att data lagras och delas mellan flera 
//	 myHandle-objekt.
//	Nya myHandle-objekt kan skapas med ny data eller skapas
//   baserade på existerade myHandle-objekt vilket då innebär
//   att de delar på data.
//
//  --------- Krav på typen som myHanlde kan lagra ---------
//
//	Följande krav ställs på typen som myHandle kan lagra:
//	
//		• myHandles typ skall vara en modell av EqualityCombarable
//
//

 
template <typename T>
class myHandle
{
	public:
		//Konstruktör som tar emot ny data
		//Pre:  True
		//Post: Skapat ett nytt objekt med in som data
		myHandle(const T& in);
		
		//Kopieringskonstruktör
		//Pre:  True
		//Post: Låter denna myHandle dela på data med ett annat myHandle-objekt
		explicit myHandle(const myHandle<T>& in);
		
		//Destruktör
		//Pre:  True
		//Post: Om datan är delad har en referens tagits bort, om datan inte är delad
		//  	så har den raderats
		~myHandle();
	
		//Operator *
		//Pre:	True 
		//Post: Om const används så kommer en referens till datamedlemmen att returneras, även om data är delad.
		//		Om const ej används så kommer en referens datamedelemmen att returneras ifall data inte är delad,
		//			i annat fall kommer datamedlemmen att kopieras till ett nytt objekt, och en referens till detta returneras.
		const T& operator*() const;
		T& operator*();
		
		//Operator ->
		//Pre:  True
		//Post: Om const används så kommer en pekare till datamedlemmen att returneras, även om data är delad.
		//		Om const ej används så kommer en pekare datamedelemmen att returneras ifall data inte är delad,
		//			i annat fall kommer datamedlemmen att kopieras till ett nytt objekt, och en pekare till detta returneras. 
		//		0 returneras ifall ingen data finns lagrad.
		const T* operator->() const;
		T* operator->();
		
		//Tilldelningsoperator
		//Pre:  True 
		//Post: Tilldelar en kopia av ett dataobjekt till detta handtag. 
		//      Om datan för detta handtag är delad kommer denna data att dupliceras innan 
		//		den skrivs över. 
		myHandle<T>& operator=(const T& rh);	
		
		//Jämförelseoperator (EqualityCombarable)
		//Pre:  True
		//Post: Returnerat true om objekten innehåller samma datavärde 
		bool operator==(const myHandle<T>& rh);
		
		//Jämförelseoperator (EqualityCombarable)
		//Pre:  True
		//Post: Returnerat true om objekten inte innehåller samma datavärde
		bool operator!=(const myHandle<T>& rh);
	
	private:
		
		//Pekare till ett dataobjekt.
		//Pekar alltid på ett objekt av typen myBody<T>
		myBody<T>* data;
	
};

#include "handle.cpp"

#endif