TnbBufferingReporter.h

[詳解]

#pragma once
#include "TnbAbstractReport.h"
#include "TnbThread.h"
#include "TnbQueue.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CBufferingReporter : public CAbstractReport
{
public:
 
    explicit CBufferingReporter(int queueSize = 10000) : m_in(queueSize)
    {
    }
 
    void SetEnvironment(IReport* pReport)
    {
        m_in.pReport = pReport;
    }
    
    virtual void SetListener(IReport::IListener* piCommListener = NULL)
    {
        m_in.pListener = piCommListener;
    }
    
    virtual CStr GetReportName(void) const
    {
        ASSERT( m_in.pReport != NULL );
        return m_in.pReport->GetReportName();
    }
 
    virtual DWORD GetReportID(void) const
    {
        ASSERT( m_in.pReport != NULL );
        return m_in.pReport->GetReportID();
    }
 
    virtual bool IsAlive(void) const
    { 
        ASSERT( m_in.pReport != NULL );
        return m_thread.IsAlive() && m_in.pReport->IsAlive();
    }
 
    virtual bool IsConnect(void) const 
    {
        ASSERT( m_in.pReport != NULL );
        return m_in.pReport->IsConnect(); 
    }
 
    virtual void SetIdleEventMode(int iInterval = 0)
    {
        ASSERT( m_in.pReport != NULL );
        m_in.pReport->SetIdleEventMode(iInterval);
    }
 
    virtual bool Start(void)
    {
        if ( m_in.pReport != NULL )
        {
            if ( m_thread.IsAlive() )
            {
                //スレッド停止
                m_thread.Stop();
            }
            m_in.pReport->SetListener(&m_in);
            if ( m_in.pReport->Start() )
            {
                m_thread.SetRunner(&m_in);
                m_in.event.ToLock();
                m_in.canRunnable = true;
                #ifdef _DEBUG
                    m_thread.Start(CStr::Fmt(_T("BufferingReport[%s]:監視"), GetReportName()));
                #else
                    m_thread.Start();
                #endif
                return true;
            }
        }
        return false;
    }
 
    virtual void Stop(void)
    {
        ASSERT( m_in.pReport != NULL );
        m_in.canRunnable = false;
        m_in.event.Unlock();
        m_in.pReport->Stop();
        if ( m_thread.IsAlive() )
        {
            //スレッド停止
            m_thread.Stop();
        }
    }
 
    virtual bool Send(size_t dataSize, LPCVOID lpcvData)
    {
        ASSERT( m_in.pReport != NULL );
        return m_in.pReport->Send(dataSize, lpcvData);
    }
 
    virtual void Purge(void)
    {
        ASSERT( m_in.pReport != NULL );
        m_in.pReport->Purge();
    }
 
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_thread;
    }
 
private:
    struct TInner : IReport::IListener, TNB::CThread::IRunner
    {
        DEFPARENTLISTENER(CBufferingReporter, IParentListener);
 
        IReport*                        pReport;        
        IParentListener*                pListener;      
        CBlockingQueueT<CByteVector>    queue;          
        CSyncEvent                      event;          
        bool                            canRunnable;    
        TInner(int queueSize = 10000) : queue(queueSize), event(true, true), pReport(NULL), pListener(NULL)
        {
        }
        virtual bool OnReportEvent(const CReportEvent& ev)
        {
            if ( pListener != NULL )
            {
                if ( ev.HasEvent() )
                {
                    return pListener->OnReportEvent(ev);
                }
                CByteVector vb;
                vb.SetElements(ev.GetDataSize(), ev.GetData());
                queue.Add(vb);
                event.Pulse();
                TRACE0("a1\n");
            }
            return true;
        }
        virtual DWORD Run(void)
        {
            while ( IsRunnable() && canRunnable )
            {
                ::WaitForSingleObject(event, 100000);
                TRACE0("p1\n");
                while ( ! queue.IsEmpty() )
                {
                    queue.Lock();
                    CByteVector vb = queue.Take();
                    queue.Unlock();
                    if ( pListener != NULL )
                    {
                        CReportEvent e(pReport);
                        e.SetData(vb.GetSize(), vb.ReferBuffer());
                        pListener->OnReportEvent(e);
                    }
                }
            }
            TRACE0("p2\n");
            return 0;
        };
    };
    TInner      m_in;       
    CThread     m_thread;   
};
 
 
 
}; // TNB