MboThread.h

Go to the documentation of this file.

/*****************************************************************************
* Copyright (c) 2001 - 2008 Marcus Boerger.  All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
* ========================================================================= */

/* ------------------------------------------------------------------------ */
/* Name:      MboThread.h / MboThread.cpp
 *
 * Requires:  
 * - Mbo.h
 * - MboSynch.h
 * - MboSynch.cpp
 */
/* ------------------------------------------------------------------------ */

#ifndef _MBOTHREAD_H_
#define _MBOTHREAD_H_

#include "Mbo.h"
#include "MboSynch.h"
#include <map>
#include <list>
#include <typeinfo.h>

#if defined(_MSC_VER)
# pragma warning(push)
# pragma warning(disable: 4251) // disable warning C4251: '...' : class '...' needs to have dll-interface to be used by clients of class '...'
# pragma warning(disable: 4275) // non dll-interface class '...' used as base for dll-interface class '...'
# pragma warning(disable: 4290) // C++-exception-specification ignored
# ifndef _CPPRTTI
#  error You must compile using RTTI
# endif // _CPPRTTI
#endif // _MSC_VER

namespace mbo
{

/* /def MBOTHREAD_USES_INSECURE_LOCK
 *
 * When defined an alternate version of determining whether or not the thread
 * is running will be used. Anyway there shouldn't be a need for that.
 */
#undef MBOTHREAD_USES_INSECURE_LOCK

/* ------------------------------------------------------------------------ */
class MBO_API MboThread
{
public:

    MboThread();

    explicit MboThread(_IN const char * szThreadName);

    virtual ~MboThread();

    bool    IsRunning()  const;

    bool    IsStopping()  const;

    bool    WaitFor(_IN DWORD nMilliseconds = INFINITE) const;

    bool KillThread(_IN DWORD nMilliseconds = 0, _IN DWORD dwExitCode = -1);

    DWORD   GetThreadId() const;

    enum EThreadPriority
    {
        PRIORITY_IDLE     = THREAD_PRIORITY_IDLE,
        PRIORITY_LOWEST   = THREAD_PRIORITY_LOWEST,
        PRIORITY_LOW      = THREAD_PRIORITY_ABOVE_NORMAL,
        PRIORITY_NORMAL   = THREAD_PRIORITY_NORMAL,
        PRIORITY_HIGH     = THREAD_PRIORITY_ABOVE_NORMAL,
        PRIORITY_HIGHEST  = THREAD_PRIORITY_HIGHEST,
        PRIORITY_CRITICAL = THREAD_PRIORITY_TIME_CRITICAL
    };

    void SetThreadPriority(_IN EThreadPriority ePriority);

    const char * GetThreadName();

    virtual void Action() = 0;

    virtual void OnActionException();

    virtual void Start();

    virtual void Stop();

    virtual void OnThreadStart();

    virtual void OnThreadStop();

    static void SetThreadName(
            _IN const char * szThreadName, 
            _IN DWORD        dwThreadID = -1
        );

protected:
    virtual void ThreadProc();

    HANDLE      m_hThread;     
    HANDLE      m_hIsStopping; 
    DWORD       m_dwThreadId;  
    CCriticalSectionImpl  m_mxStartStop; 
private:
    void ThreadProcCaller();
    void ThreadNamer();
    void ThreadProcRunner();


    virtual void ForceThreadName();

    char *      m_szThreadName;
#ifdef MBOTHREAD_USES_INSECURE_LOCK

    CCriticalSectionImpl  m_mxIsRunning;

    bool        m_bIsRunning;
#endif

    friend DWORD WINAPI MboThreadProc(LPVOID lpParameter);

private:

    MboThread& operator = (_IN const MboThread&) __THROWS(logic_error)
    {
        throw logic_error("Assignment must not be used");
    }
};

/* ------------------------------------------------------------------------ */
class MBO_API MboIntervalThread: public MboThread
{
public:
    explicit MboIntervalThread(
            _IN size_t       nMilliSeconds = 1000,
            _IN const char * szThreadName  = NULL
        );

    virtual ~MboIntervalThread();

    IncDecVal GetCounter() const;

protected:
    virtual void SetInterval(_IN size_t nMilliSeconds = 1000);

    virtual size_t GetInterval() const;

private:
    size_t      m_nInterval;  
    IncDecVal   m_nCounter;   
    virtual void ThreadProc();
};

/* ------------------------------------------------------------------------ */
class MBO_API MboEventThread: public MboThread
{
friend class MboDelayedEventThread;
public:
    explicit MboEventThread(
            _IN bool         bAutoStart    = true,
            _IN const char * szThreadName  = NULL
        );

    virtual ~MboEventThread();

    IncDecVal GetCounter() const;

    void SetEvent() const;

    virtual bool IsSignaled() const;

    virtual void Stop();

private:
    IncDecVal   m_nCounter;   
    HANDLE      m_hEvent;     
    virtual void ThreadProc();
};

/* ------------------------------------------------------------------------ */
class MBO_API MboDelayedEventThread: public MboEventThread
{
public:
    explicit MboDelayedEventThread(
            _IN size_t       nMilliSeconds = 0,
            _IN bool         bAutoStart    = true,
            _IN const char * szThreadName  = NULL
        );

    virtual ~MboDelayedEventThread();

    virtual void Stop();

    virtual void SetDelay(_IN size_t nMilliSeconds = 0);

    virtual size_t GetDelay() const;

private:
    CCriticalSectionImpl  m_mxDelay;    
    size_t      m_nDelay;     
    HANDLE      m_hDelay;     
    virtual void ThreadProc();

private:

    MboDelayedEventThread& operator = (_IN const MboDelayedEventThread&) __THROWS(logic_error)
    {
        throw logic_error("Assignment must not be used");
    }
};

/* ------------------------------------------------------------------------ */
class MBO_API MboWinMsgHandler
    : public mbo::MboThread
{
friend LRESULT CALLBACK MboWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
typedef std::map<HWND, MboWinMsgHandler*> MAP_HWND;
typedef std::list<MboString> WndClassList;
public:

    explicit MboWinMsgHandler(
            _IN const MboString& strWndClassName = "MboWinMsgHandler",
            _IN bool             bStart          = true
        );

    virtual ~MboWinMsgHandler();

    virtual HWND GetHWND() const;

    virtual void Stop();

    virtual LRESULT ProcessMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

    virtual LRESULT ProcessDefault(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

    virtual bool PostMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);

    virtual bool PostMessage(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);

    virtual HINSTANCE GetModuleHandle() const;

protected:

    virtual const MboString& WndClassName() const;

    virtual const MboString& WndTitleText() const;

    virtual void Action();

    virtual void OnWindowCreated();

    virtual void MessageHandler(MSG & msg);

    virtual bool WndCreate();

    virtual bool WndCalcMetrics();

    virtual void WndDestroy();

    virtual bool WndRegister();

    void AddHWND();

    HWND                m_hwnd;          
    const MboString     m_strWndClassName; 
    static WndClassList g_vWndClassList; 
private:

    static MAP_HWND     g_mhwndList;

#ifdef _MSC_VER
# pragma warning(pop)
#endif

};

/* ------------------------------------------------------------------------ */
}; // namespace

#endif // _MBOTHREAD_H_

---