class __iCallback
	{
	private:
		inline __iCallback()
		{
			RefCount = 0;
		}
	private:
		virtual void __CallMethod()=0;
	private:
		unsigned int RefCount;
	private:
		friend class Callback;
		template <class T>
			friend class __CallBack;
	};
class Callback 
	{
	public:
		Callback();
		~Callback();
		Callback(const Callback &other);
		Callback(__iCallback *prv);
	public:
		void operator = (const Callback &other);
		void operator = (__iCallback *prv);
		void Detach();
		inline bool isEmpty()const
		{
			return (method == 0);
		}
	public:
		inline void exec()
		{
			if(method)
				method->__CallMethod();
		}
		inline void operator()()
		{
			if(method)
				method->__CallMethod();
		}
		//------------------------------------------------
	private:
		__iCallback *method;
	};
	//------------------------------------------------
	//------------------------------------------------
	template <class T>
	class __CallBack : public __iCallback
	{
	private:
		typedef void (T::*CallProcedure)();
	public:
		__CallBack(T * s ,void (T::*m)())
			:source(s),method(m)
		{}
	public:
		virtual void __CallMethod()
		{
			(source->*method)();
		}
	private:
		T * source;
		CallProcedure method;
	private:
		friend class Callback;
	};

//----------------------------------
template <typename OBJ>
	inline __iCallback* callback(OBJ * what, void(OBJ::*method)())
	{
		return new __CallBack<OBJ>(what,&method);
	}

Callback::Callback()
	: method(0)
{
}
Callback::~Callback()
{
	if(method)
	{
		method->RefCount--;
		if(method->RefCount==0)
			delete method;
	}
}
Callback::Callback(const Callback& other)
	:method(other.method)
{
	method->RefCount++;
}
Callback::Callback(__iCallback* prv)
{
	method = prv;
	method->RefCount++;
}
void Callback::Detach()
{
	if(method)
	{
		method->RefCount--;
		if(method->RefCount==0)
			delete method;
	}
	method = 0;
}
//---------------------------------------------
void Callback::operator =(const Callback& other)
{
	if(method)
	{
		method->RefCount--;
		if(method->RefCount==0)
			delete method;
	}
	method = other.method;
	method->RefCount++;
}
void Callback::operator = (__iCallback* prv)
{
	if(method)
	{
		method->RefCount--;
		if(method->RefCount==0)
			delete method;
	}
	method = prv;
	method->RefCount++;
}