TnbThreadDispatch.h

[詳解]

#pragma once
#include "TnbThread.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CThreadDispatch : TNB::CThread::IRunner, CCopyImpossible
{
    typedef TNB::CThread::IRunner __runner; 
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual bool OnThreadDispatchReceive(UINT nMsg, WPARAM wParam, LPARAM lParam) = 0;
 
        virtual void OnThreadDispatchSetup(void) {}
    };
 
 
    //-------------------------
 
 
    CThreadDispatch(void) : m_isDispatching(false)
    {
        m_lisDef.pDisp = this;
        m_piListener = &m_lisDef;
        m_thread.SetRunner(this);
    }
 
    virtual ~CThreadDispatch(void)
    {
        Stop();
    }
 
    void SetListener(IListener* piListener)
    {
        m_piListener = (piListener != NULL) ? piListener : &m_lisDef;
    }
 
    bool SetPriority(int priority)
    {
        return m_thread.SetPriority(priority);
    }
 
    DWORD GetThreadId(void) const
    {
        return m_thread.GetId();
    }
 
    bool Start(LPCTSTR lpszName = NULL)
    {
        m_isDispatching = false;
        if ( m_thread.IsAlive() )
        {
            return false;
        }
        #ifdef _DEBUG
            if ( lpszName == NULL) { lpszName = _T("ThreadDispatch:MessagePump"); }
        #endif
        if ( m_thread.Start(lpszName) )
        {
            DWORD dwTick = ::GetTickCount();
            while ( (::GetTickCount() - dwTick) < 5000 )
            {
                if ( this->PostMessage(WM_NULL) )
                {
                    return true;
                }
                ::Sleep(100);
            }
            m_thread.Stop();
        }
        return false;
    }
 
    bool Stop(void)
    {
        m_isDispatching = false;
        if ( m_thread.IsAlive() )
        {
            m_thread.PostMessage(WM_QUIT);
            return m_thread.Stop();
        }
        return true;
    }
 
    bool IsAlive(void) const
    {
        return m_thread.IsAlive();
    }
 
    bool PostMessage(UINT nMsg, WPARAM wParam = 0, LPARAM lParam = 0) const
    {
        if ( m_thread.IsAlive() )
        {
            return m_thread.PostMessage(nMsg, wParam, lParam);
        }
        return false;
    }
 
    bool IsDispatching(void) const
    {
        return m_isDispatching;
    }
 
    virtual bool OnThreadDispatchReceive(UINT nMsg, WPARAM wParam, LPARAM lParam)
    {
        ASSERT0(false, "CThreadDispatch", "継承もリスナ登録も行われずに使用されています。");
        return false;
    }
 
    virtual void OnThreadDispatchSetup(void)
    {
        ASSERT0(false, "CThreadDispatch", "継承もリスナ登録も行われずに使用されています。");
    }
 
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_thread;
    }
 
private:
    TNB::CThread    m_thread;           
    IListener*      m_piListener;       
    bool            m_isDispatching;    
 
    virtual void OnSetupThread(void) 
    {
        if ( m_piListener != NULL )
        {
            m_piListener->OnThreadDispatchSetup();
        }
    }
 
    virtual DWORD Run(void)
    {
        MSG msg;
        while ( ::GetMessage(&msg, NULL, 0, 0) > 0 )
        {
            if ( msg.message != WM_NULL && m_piListener != NULL )
            {
                m_isDispatching = true;
                bool r = m_piListener->OnThreadDispatchReceive(msg.message, msg.wParam, msg.lParam);
                m_isDispatching = false;
                if ( ! r )
                {
                    this->PostMessage(WM_QUIT);
                }
                else
                {
                    ::TranslateMessage(&msg);
                    ::DispatchMessage(&msg);
                }
            }
        }
        ASSERTLIB(msg.message == WM_QUIT);
        if ( m_piListener != NULL )
        {
            m_isDispatching = true;
            m_piListener->OnThreadDispatchReceive(msg.message, msg.wParam, msg.lParam);
            m_isDispatching = false;
        }
        return 0;
    }
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
 
    struct TDefaultListener : IListener
    {
        CThreadDispatch* pDisp;
        virtual bool OnThreadDispatchReceive(UINT nMsg, WPARAM wParam, LPARAM lParam)
        {
            return pDisp->OnThreadDispatchReceive(nMsg, wParam, lParam);
        }
        virtual void OnThreadDispatchSetup(void)
        {
            pDisp->OnThreadDispatchSetup();
        }
    } m_lisDef;
 
    #endif //_TnbDOXYGEN
};
 
 
 
template<size_t COUNT>
class CMultiThreadDispatchT : CCopyImpossible
{
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual bool OnMultiDispatchReceive(UINT nMsg, WPARAM wParam) = 0;
    };
 
 
    //-----
 
 
    CMultiThreadDispatchT(void)
    {
        m_in.pListener = NULL;
        loop ( i, COUNT )
        {
            m_in.tasks[i].SetListener(&m_in);
            m_in.isTaskWorking[i] = false;
        }
        m_in.taskIndex = 0;
    }
 
    void SetListener(IListener* l)
    {
        m_in.pListener = l;
    }
 
    void PostMessage(UINT msg, WPARAM wParam = 0)
    {
        INDEX tn = 0;
        loop ( i, COUNT )
        {
            tn = (i + m_in.taskIndex) % COUNT;
            if ( ! m_in.isTaskWorking[tn] )
            {
                break;
            }
        }
        m_in.isTaskWorking[tn] = true;
        m_in.tasks[tn].PostMessage(msg, wParam, tn);
    }
 
    void PostMessageToOne(INDEX index, UINT msg, WPARAM wParam = 0)
    {
        if ( index < COUNT )
        {
            m_in.isTaskWorking[index] = true;
            m_in.tasks[index].PostMessage(msg, wParam, index);
        }
    }
 
    bool Start(void)
    {
        bool r = true;
        m_in.taskIndex = 0;
        loop ( i, COUNT )
        {
            m_in.isTaskWorking[i] = false;
            #ifdef _DEBUG
                r &= m_in.tasks[i].Start(CStr::Fmt(_T("CMultiDispatch-%d"), i + 1));
            #else
                r &= m_in.tasks[i].Start();
            #endif
        }
        if ( ! r )
        {
            Stop();
        }
        return r;
    }
 
    void Stop(void)
    {
        loop ( i, COUNT )
        {
            m_in.tasks[i].Stop();
            m_in.isTaskWorking[i] = false;
        }
    }
 
private:
    struct TInner : CThreadDispatch::IListener
    {
        DEFPARENTLISTENER(typename CMultiThreadDispatchT<COUNT>, IParentListener);
        IParentListener*    pListener;                  
        CThreadDispatch     tasks[COUNT];               
        bool                isTaskWorking[COUNT];       
        INDEX               taskIndex;                  
        virtual bool OnThreadDispatchReceive(UINT nMsg, WPARAM wParam, LPARAM lParam)
        {
            TRACE1("OnMultiDispatch-%d\n", lParam + 1);
            if ( pListener != NULL )
            {
                pListener->OnMultiDispatchReceive(nMsg, wParam);
            }
            isTaskWorking[lParam] = false;
            return true;
        }
    };
    TInner      m_in;   
};
 
 
 
}; // TNB