TnbQueueingReporter.h

[詳解]

#pragma once
#include "TnbReport.h"
#include "TnbQueue.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CQueueingReporter : CCopyImpossible
{
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual bool OnReportEvent(const CReportEvent& ev) = 0;
 
        virtual size_t OnReportData(bool boIsLast, const IConstCollectionT<BYTE>& c) = 0;
 
        virtual void OnReportDustyData(BYTE b) {}
    };
 
    explicit CQueueingReporter(int iQueueSize = 10000) : m_in(iQueueSize)
    {
    }
 
    ~CQueueingReporter(void)
    {
        ResetEnvironment();
    }
 
    void SetEnvironment(IReport* pReport, IListener* pListener)
    {
        Purge();
        m_in.m_pListener = pListener;
        m_in.m_pReport = pReport;
        if ( m_in.m_pReport != NULL )
        {
            m_in.m_pReport->SetListener(&m_in);
        }
    }
 
    void ResetEnvironment(void)
    {
        if ( m_in.m_pReport != NULL )
        {
            m_in.m_pReport->SetListener(NULL);
            m_in.m_pListener = NULL;
            m_in.m_pReport = NULL;
        }
    }
 
    void SetAliveTime(DWORD time = DWORD_MAX)
    {
        m_in.m_aliveTime = time;
        m_in.m_tearminalTime = DWORD_MAX;
    }
 
    void SetTearminalTime(DWORD time = DWORD_MAX)
    {
        m_in.m_tearminalTime = time;
        m_in.m_aliveTime = DWORD_MAX;
    }
 
    bool IsAlive(void) const
    {
        if ( m_in.m_pReport != NULL )
        {
            return m_in.m_pReport->IsAlive();
        }
        return false;
    }   
 
    bool IsConnect(void) const
    {
        if ( m_in.m_pReport != NULL )
        {
            return m_in.m_pReport->IsConnect();
        }
        return false;
    }
 
    bool Send(size_t dataSize, LPCVOID lpcData)
    {
        if ( m_in.m_pReport != NULL )
        {
            return m_in.m_pReport->Send(dataSize, lpcData);
        }
        return false;
    }
 
    void Purge(void)
    {
        m_in.m_queueData.RemoveAll();   //RAW情報のみ削除
    }
 
    size_t GetQueueFreeSize(void) const
    {
        return m_in.m_queueData.GetFreeSize();
    }
 
    IReport* ReferReport(void)
    {
        return m_in.m_pReport;
    }   
 
    const IReport* ReferReport(void) const
    {
        return m_in.m_pReport;
    }   
 
private:
    class CInner : public IReport::IListener
    {
        DEFPARENTLISTENER(CQueueingReporter, IParentListener);
    public:
        CInner(int queueSize = 10000) 
            : m_queueData(queueSize), m_pListener(NULL), m_pReport(NULL), m_aliveTime(DWORD_MAX), m_tearminalTime(DWORD_MAX)
        {
        }
        virtual bool OnReportEvent(const CReportEvent& ev)
        {
            if ( m_pListener == NULL )
            {
                return true; 
            }
            if ( ev.HasData() )
            {
                EXCLUSIVE( &m_queueData );
                //== データあり
                size_t size = ev.GetDataSize();
                const BYTE* B = ev.GetData();
                while ( size > 0 )
                {
                    size_t freeSize = m_queueData.GetFreeSize();
                    if ( freeSize == 0 )
                    {
                        ASSERT0( false, "CQueueingReporter", "キューがあふれました。" );
                        break;
                    }
                    size_t l = size;
                    if ( l > freeSize )
                    {
                        l = freeSize;
                    }
                    m_queueData.AddElements(l, B);
                    if ( m_tearminalTime == DWORD_MAX )
                    {
                        m_OnDeseri(false);
                    }
                    else
                    {
                        m_pReport->SetIdleEventMode(m_tearminalTime);
                    }
                    B += l;
                    size -= l;
                }
                return true;
            }
            //== イベントあり
            switch ( ev.GetEvent() )
            {
            case ReportEvent_Disconnect:
                m_OnDeseri(true);
                m_queueData.RemoveAll();    //RAW情報のみ削除
                break;
            case ReportEvent_Idle:
                if ( m_aliveTime != DWORD_MAX )
                {
                    EXCLUSIVE( &m_queueData );
                    BYTE b;
                    if ( m_queueData.TakeElements(1, &b) == 1 )
                    {
                        m_pListener->OnReportDustyData(b);
                    }
                    m_pReport->SetIdleEventMode(0);
                    m_OnDeseri(false);
                }
                if ( m_tearminalTime != DWORD_MAX )
                {
                    m_OnDeseri(false);
                    m_pReport->SetIdleEventMode(0);
                }
                break;
            default:
                break;
            }
            return m_pListener->OnReportEvent(ev);
        }
 
        CRingQueueT<BYTE>   m_queueData;    
        IParentListener*    m_pListener;    
        IReport*            m_pReport;      
        DWORD               m_aliveTime;    
        DWORD               m_tearminalTime;
 
    protected:
        void m_OnDeseri(bool boIsLast)
        {
            while ( ! m_queueData.IsEmpty() )
            {
                size_t r = m_pListener->OnReportData(boIsLast, m_queueData);
                if ( r == 0 )
                {
                    if ( boIsLast )
                    {
                        m_queueData.RemoveAll();
                    }
                    else
                    {
                        if ( m_aliveTime != DWORD_MAX )
                        {
                            m_pReport->SetIdleEventMode(m_aliveTime);
                        }
                    }
                    return;
                }
                m_queueData.EraseElements(r);
            }
        }
    };
    CInner      m_in;   
};
 
 
 
}; // TNB