Bugbox Multi-Threaded

// LiveObject.h: interface for the CLiveObject class.
//
// class CLiveObject:
// Abstract base class from which live objects may be derived.

// Thread creation:
// CLiveObject::CLiveObject calls the Win32 API ::CreateThread to create a
// new suspended thread. The thread function is the static member function
// CLiveObject::ThreadFunc, and the argument passed is a pointer to the object
// being constructed (the 'this' pointer) cast to a pointer to void. In order
// that MessageLoop calls no virtual function until the entire object is
// constructed, the constructor of the most derived class must finish with this
// line:
// ::ResumeThread(m_dwThreadHandle); 

// Thread end:
// CLiveObject::EndThread ends the thread created in the constructor. This
// method *must* be called before CLiveObject::~CLiveObject is called so either
// have the creator of the live object call it before detroying it or, more
// conveniently, call it from the destructor of the most-derived class. It
// cannot be called from CLiveObject::~CLiveObject as the object will be
// partially destructed by then and so the still-running MessageLoop will fail.

// CLiveObject::ThreadFunc:
// The thread function's job is simply to take the 'this' pointer passed in the
// thread argument, cast it to a CLiveObject* and call the non-static member
// function CLiveObject::MessageLoop on it. Only when MessageLoop returns will
// ThreadFunc end and, consequently, the thread itself.

// CLiveObject::MessageLoop:
// The main message loop of the object. Before beginning the loop a timer is
// set. Each WM_TIMER message received by the thread causes the OnTimer method
// to be called. Its loop ends when a WM_QUIT message is posted to the thread.

// CLiveObject::OnTimer:
// A pure virtual function intended to be overriden by a base class. It is
// pure so that CLiveObject is abstract and cannot accidentally be instantiated
//  - CLiveObject is useless as it is. It also serves to define the interface
// for a CLiveObject-derived class. Derived classes should override OnTimer and
// perform arbitrarily small discrete changes to their state in it. How small
// depends on the timer frequency. The derived class may control this by
// passing a value to CLiveObject's constructor.

// CLiveObject::AnyLastRequests:
// A virtual function overridable by the derived class in order to do final
// cleanup. Called immediately before the thread but after the message loop
// has stopped ends.
//////////////////////////////////////////////////////////////////////

class __declspec(novtable) CLiveObject  
{
protected:
    HANDLE m_dwThreadHandle;
    DWORD m_dwThreadId;
    UINT m_nTimerInterval;
    
    virtual BOOL OnTimer() = 0;
    virtual BOOL AnyLastRequests(){return FALSE;};
    static DWORD WINAPI ThreadFunc(LPVOID pLiveObject);
    DWORD MessageLoop();
public:
    CLiveObject(UINT nTimerInterval = 10);
    virtual ~CLiveObject(){};
    void EndThread();
};