TnbCeMsgQueueWatcher.h

[詳解]

#pragma once
#ifndef _WIN32_WCE
    #error TnbCeMsgQueueWatcher.h is only supported on Windows CE platforms.
#endif // _WIN32_WCE
 
 
 
#include "TnbThread.h"
#include <Msgqueue.h>
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP>
class CMsgQueueWatcherT : CThread::IRunner
{
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual void OnMsgQueueWatcherEvent(const TYP& data, size_t length, bool isAlert) = 0;
    };
 
 
    //---------------------------
 
 
    CMsgQueueWatcherT(void) : m_handle(NULL), m_pListener(NULL)
    {
    }
 
    ~CMsgQueueWatcherT(void)
    {
        Stop();
    }
 
    HANDLE GetSafeHandle(void) const
    {
        return m_handle;
    }
 
    operator HANDLE(void) const
    {
        return m_handle;
    }
 
    void SetListener(IListener* P)
    {
        m_pListener = P;
    }
 
    bool IsStarted(void) const
    {
        return m_handle != NULL;
    }
 
    bool Start(size_t maxMessagesCount = 0, bool isRead = true, LPCTSTR lpszThreadName = NULL)
    {
        MSGQUEUEOPTIONS opt = { 0 };
        opt.dwSize = sizeof(MSGQUEUEOPTIONS);
        opt.dwFlags = 0;
        opt.dwMaxMessages = maxMessagesCount;
        if ( maxMessagesCount == 0 )
        {
            opt.dwFlags = MSGQUEUE_NOPRECOMMIT;
        }
        opt.cbMaxMessage = sizeof(TYP);
        opt.bReadAccess = isRead;
        return m_Start(NULL, opt, lpszThreadName);
    }
 
    bool Start(LPCTSTR lpszQueueName, const MSGQUEUEOPTIONS& option, LPCTSTR lpszThreadName = NULL)
    {
        MSGQUEUEOPTIONS opt = option;
        return m_Start(lpszQueueName, opt,lpszThreadName);
    }
 
    bool Stop(void)
    {
        bool r = true;
        if ( m_handle != NULL )
        {
            r = !! ::CloseMsgQueue(m_handle);
            m_handle = NULL;
        }
        m_thread.Stop();
        return r;
    }
 
    bool Send(const TYP& data, DWORD timeout = INFINITE, bool isAlert = false)
    {
        DWORD fg = isAlert ? MSGQUEUE_MSGALERT : 0;
        TYP t = data;
        return !! ::WriteMsgQueue(m_handle, &t, sizeof(data), timeout, fg);
    }
 
    bool GetInfo(MSGQUEUEINFO& _info) const
    {
        _info.dwSize = sizeof(MSGQUEUEINFO);
        return !! ::GetMsgQueueInfo(m_handle, &_info);
    }
 
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_thread;
    }
 
protected:
    
    virtual DWORD Run(void)
    {
        while ( IsRunnable() && IsStarted() )
        {
//          DWORD dw = ::MsgWaitForMultipleObjects(1, &m_handle, FALSE, INFINITE, QS_ALLEVENTS);
            DWORD dw = ::WaitForSingleObject(m_handle, INFINITE);
            if ( dw == WAIT_OBJECT_0 || dw == WAIT_ABANDONED_0 )
            {
                TYP buf;
                DWORD dwRead = 0;
                DWORD dwFlags = 0;
                while ( ::ReadMsgQueue(m_handle, &buf, sizeof(TYP), &dwRead, 0, &dwFlags) )
                {
                    if ( m_pListener != NULL )
                    {
                        m_pListener->OnMsgQueueWatcherEvent(buf, dwRead, dwFlags == MSGQUEUE_MSGALERT);
                    }
                }
                DWORD err = ::GetLastError();
                if ( err != ERROR_TIMEOUT && err != ERROR_INVALID_HANDLE )
                {
                    if ( ERROR_INSUFFICIENT_BUFFER == _GetLastError("ReadMsgQueue") )
                    {
                        ASSERT( false );
                    }
                }
            }
        }
        return 0;
    }
 
private:
    bool m_Start(LPCTSTR lpszQueueName, MSGQUEUEOPTIONS& _opt, LPCTSTR lpszThreadName)
    {
        Stop();
        _opt.dwSize = sizeof(MSGQUEUEOPTIONS);
        m_handle = ::CreateMsgQueue(lpszQueueName, &_opt);
        if ( m_handle != NULL )
        {
            m_thread.SetRunner(this);
            if ( lpszThreadName == NULL )
            {
                lpszThreadName = _T("CMsgQueueWatcher");
            }
            if ( m_thread.Start(lpszThreadName) )
            {
                return true;
            }
        }
        Stop();
        return false;
    }
 
    HANDLE      m_handle;           
    IListener*  m_pListener;        
    CThread     m_thread;           
};
 
 
 
}; // TNB