#ifndef _THREAD_THREADCALLBACK_HPP_
#define _THREAD_THREADCALLBACK_HPP_
#ifndef _THREAD_THREADMESSAGE_HPP_
#include <thread/thmsg.hpp>
#endif
#ifndef _THREAD_PURETHREADCALLBACK_HPP_
#include <thread/ptcllbck.hpp>
#endif
#ifndef _MSC_VER
#ifdef _EXPAND_THREAD_TEMPLATES_
#pragma option -Jgd
#endif
#endif

class ThreadCallbackPointer
{
public:
  ThreadCallbackPointer(void);
  ThreadCallbackPointer(PureThreadCallback *lpCallback);
  ThreadCallbackPointer(const ThreadCallbackPointer &someThreadCallbackPointer);
  virtual ~ThreadCallbackPointer();
  void operator=(ThreadCallbackPointer &someThreadCallbackPointer);
  WORD operator==(const ThreadCallbackPointer &someThreadCallbackPointer)const;
  DWORD callback(ThreadMessage &someThreadMessage);
private:
  PureThreadCallback *mlpCallback;
};

inline
ThreadCallbackPointer::ThreadCallbackPointer(void)
: mlpCallback(0)
{
}

inline
ThreadCallbackPointer::ThreadCallbackPointer(PureThreadCallback *lpCallback)
: mlpCallback(lpCallback)
{
}

inline
ThreadCallbackPointer::ThreadCallbackPointer(const ThreadCallbackPointer &someThreadCallbackPointer)
: mlpCallback(someThreadCallbackPointer.mlpCallback)
{
}

inline
ThreadCallbackPointer::~ThreadCallbackPointer()
{
}

inline
void ThreadCallbackPointer::operator=(ThreadCallbackPointer &someThreadCallbackPointer)
{
  mlpCallback=someThreadCallbackPointer.mlpCallback;
}

inline
WORD ThreadCallbackPointer::operator==(const ThreadCallbackPointer &someThreadCallbackPointer)const
{
  return (mlpCallback==someThreadCallbackPointer.mlpCallback);
}

inline
DWORD ThreadCallbackPointer::callback(ThreadMessage &someThreadMessage)
{
  if(!mlpCallback)return FALSE;
  return mlpCallback->operator*(someThreadMessage);
}

template <class T>
class ThreadCallback : public PureThreadCallback
{
public:
  typedef DWORD (T::*LPFNMETHOD)(ThreadMessage &someThreadMessage);
  ThreadCallback(void);
  ThreadCallback(const ThreadCallback<T> &someThreadCallback);
  ThreadCallback(T *lpObject,LPFNMETHOD lpMethod);
  virtual ~ThreadCallback();
  void setObject(T *lpObject);
  void setMethod(LPFNMETHOD lpMethod);
	void setCallback(T *lpObject,LPFNMETHOD lpMethod);
  WORD operator==(const ThreadCallback<T> &someThreadCallback)const;
  void operator=(const ThreadCallback<T> &someThreadCallback);
  DWORD operator*(ThreadMessage &someThreadMessage);
private:
  T *mlpObject;
  DWORD (T::*mlpMethod)(ThreadMessage &someThreadMessage);
};
#if defined(_MSC_VER)
#include <thread/tcallbck.tpp>
#endif
#endif