#ifndef _THREAD_THREADMESSAGE_HPP_
#define _THREAD_THREADMESSAGE_HPP_
#ifndef _COMMON_WINDOWS_HPP_
#include <common/windows.hpp>
#endif
#ifndef _COMMON_SYSTEMTIME_HPP_
#include <common/systime.hpp>
#endif

class ThreadMessage
{
public:
  enum TMMsg{TM_VOID,TM_CREATE,TM_DESTROY,TM_USER};
  enum TMPriority{PriorityLow,PriorityNormal,PriorityHigh};
  ThreadMessage(void);
  ThreadMessage(TMMsg message,DWORD userDataOne=0L,DWORD userDataTwo=0L,TMPriority priority=PriorityNormal);
  ThreadMessage(const ThreadMessage &someThreadMessage);
  virtual ~ThreadMessage();
  ThreadMessage &operator=(const ThreadMessage &someThreadMessage);
  WORD operator==(const ThreadMessage &someThreadMessage)const;
  TMMsg message(void)const;
  void message(TMMsg message);
  DWORD userDataOne(void)const;
  void userDataOne(DWORD userDataOne);
  DWORD userDataTwo(void)const;
  void userDataTwo(DWORD userDataTwo);
  TMPriority priority(void)const;
	void priority(TMPriority priority);
	SystemTime &messageTime(void);
  void messageTime(const SystemTime &messageTime);
private:
  TMMsg mMessage;
	TMPriority mPriority;
  SystemTime mMessageTime;
	DWORD mUserDataOne;
  DWORD mUserDataTwo;
};

inline
ThreadMessage::ThreadMessage(void)
: mMessage(TM_VOID), mUserDataOne(0L), mUserDataTwo(0L), mPriority(PriorityNormal) 
{
}

inline
ThreadMessage::ThreadMessage(TMMsg message,DWORD userDataOne,DWORD userDataTwo,TMPriority priority)
: mMessage(message), mUserDataOne(userDataOne), mUserDataTwo(userDataTwo),
  mPriority(priority)
{
}

inline
ThreadMessage::ThreadMessage(const ThreadMessage &someThreadMessage)
{
  *this=someThreadMessage;
}

inline
ThreadMessage::~ThreadMessage()
{
}

inline
ThreadMessage &ThreadMessage::operator=(const ThreadMessage &someThreadMessage)
{
  message(someThreadMessage.message());
  userDataOne(someThreadMessage.userDataOne());
  userDataTwo(someThreadMessage.userDataTwo());
  priority(someThreadMessage.priority());
  return *this;
}

inline
WORD ThreadMessage::operator==(const ThreadMessage &someThreadMessage)const
{
  return message()==someThreadMessage.message();
}

inline
ThreadMessage::TMMsg ThreadMessage::message(void)const
{
  return mMessage;
}

inline
void ThreadMessage::message(TMMsg message)
{
  mMessage=message;
}

inline
DWORD ThreadMessage::userDataOne(void)const
{
  return mUserDataOne;
}

inline
void ThreadMessage::userDataOne(DWORD userDataOne)
{
  mUserDataOne=userDataOne;
}

inline
DWORD ThreadMessage::userDataTwo(void)const
{
  return mUserDataTwo;
}

inline
void ThreadMessage::userDataTwo(DWORD userDataTwo)
{
  mUserDataTwo=userDataTwo;
}

inline
ThreadMessage::TMPriority ThreadMessage::priority(void)const
{
  return mPriority;
}

inline
void ThreadMessage::priority(TMPriority priority)
{
  mPriority=priority;
}

inline
SystemTime &ThreadMessage::messageTime(void)
{
  return mMessageTime;
}

inline
void ThreadMessage::messageTime(const SystemTime &messageTime)
{
  mMessageTime=messageTime;
}
#endif