#ifndef _COMMON_CALLBACKPOINTER_HPP_
#define _COMMON_CALLBACKPOINTER_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_PURECALLBACK_HPP_
#include <common/pcallbck.hpp>
#endif

template <class T>
class CallbackPointer
{
public:
	CallbackPointer(void);
	CallbackPointer(PureCallback<T> *lpCallback);
	CallbackPointer(const CallbackPointer<T> &someCallbackPointer);
	virtual ~CallbackPointer();
	void operator=(CallbackPointer &someCallbackPointer);
	WORD operator==(const CallbackPointer &someCallbackPointer)const;
	LONG callback(CallbackData<T> &someCallbackData);
	bool isOkay(void)const;
private:
	PureCallback<T> *mlpCallback;
};

template <class T>
inline
CallbackPointer<T>::CallbackPointer(void)
: mlpCallback(0)
{
}

template <class T>
inline
CallbackPointer<T>::CallbackPointer(PureCallback<T> *lpCallback)
: mlpCallback(lpCallback)
{
}

template <class T>
inline
CallbackPointer<T>::CallbackPointer(const CallbackPointer<T> &someCallbackPointer)
: mlpCallback(someCallbackPointer.mlpCallback)
{
}

template <class T>
inline
CallbackPointer<T>::~CallbackPointer()
{
}

template <class T>
inline
void CallbackPointer<T>::operator=(CallbackPointer<T> &someCallbackPointer)
{
	mlpCallback=someCallbackPointer.mlpCallback;
}

template <class T>
inline
WORD CallbackPointer<T>::operator==(const CallbackPointer<T> &someCallbackPointer)const
{
	return (mlpCallback==someCallbackPointer.mlpCallback);
}

template <class T>
inline
LONG CallbackPointer<T>::callback(CallbackData<T> &someCallbackData)
{
	if(!mlpCallback)return (LONG)0;
	return mlpCallback->operator*(someCallbackData);
}

template <class T>
inline
bool CallbackPointer<T>::isOkay(void)const
{
  return mlpCallback?true:false;
}
#endif