TnbReportWatchAdapter.h

[詳解]

#pragma once
#include "TnbReport.h"
#include "TnbSync.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CReportWatchAdapter : public IReport, CCopyImpossible
{
    DEFSUPER(IReport);
public:
 
    struct ILogger
    {
        enum EKind
        {
            Kind_Send,      
            Kind_SendError, 
            Kind_Received,  
        };
 
        virtual ~ILogger(void) {}
 
        virtual void OnReportWatchEventLog(EReportEvent ev) = 0;
 
        virtual void OnReportWatchDataLog(EKind kind, size_t dataSize, const BYTE* pData) = 0;
    };
 
 
    //-----------------------------
 
 
    CReportWatchAdapter(IReport* pRep)
    {
        ASSERT( pRep != NULL ); //インスタンスを指定してください
        m_pReporter = pRep;
        m_in.pListener = NULL;
        m_in.pLogger = NULL;
    }
 
    bool SetReporter(IReport* pRep)
    {
        if ( ! IsAlive() && pRep != NULL )
        {
            m_pReporter = pRep;
            return true;
        }
        return false;
    }
 
    void SetLogger(ILogger* pLogger)
    {
        m_in.pLogger = pLogger;
    }
 
    virtual CStr GetReportName(void) const
    {
        return m_pReporter->GetReportName();
    }
 
    virtual DWORD GetReportID(void) const
    {
        return m_pReporter->GetReportID();
    }
 
    virtual void SetListener(IReport::IListener* piCommListener = NULL)
    {
        m_in.pListener = piCommListener;
    }
 
    virtual DWORD GetInterfaceId(void) const
    {
        return m_pReporter->GetInterfaceId();
    }
 
    virtual void SetIdleEventMode(int iInterval = 0)
    {
        m_pReporter->SetIdleEventMode(iInterval);
    }
 
    virtual bool Start(void)
    {
        m_pReporter->SetListener(&m_in);
        return m_pReporter->Start();
    }
 
    virtual void Stop(void)
    {
        m_pReporter->Stop();
    }
 
    virtual bool IsAlive(void) const
    {
        return m_pReporter->IsAlive();
    }
    
    virtual bool IsConnect(void) const
    {
        return m_pReporter->IsConnect();
    }
 
    virtual bool Send(size_t dataSize, LPCVOID lpcData)
    {
        bool r = m_pReporter->Send(dataSize, lpcData);
        if ( m_in.pLogger != NULL )
        {
            EXCLUSIVE( &m_in.sync );
            m_in.pLogger->OnReportWatchDataLog((r ? (ILogger::Kind_Send) : (ILogger::Kind_SendError)), dataSize, static_cast<const BYTE*>(lpcData));
        }
        return r;
    }
 
    virtual void Purge(void)
    {
        m_pReporter->Purge();
    }
 
private:
    class CInner : public IReport::IListener
    {
    public:
        IReport::IListener* pListener;      // リスナー
        ILogger*            pLogger;        // ロガー
        CSyncSection        sync;           // 同期
        //[通知] イベント発生
        virtual bool OnReportEvent(const CReportEvent& ev)
        {
            if ( pListener != NULL )
            {
                if ( pLogger != NULL )
                {
                    EXCLUSIVE( &sync );
                    if ( ev.HasData() )
                    {
                        pLogger->OnReportWatchDataLog(ILogger::Kind_Received, ev.GetDataSize(), ev.GetData());
                    }
                    else
                    {
                        pLogger->OnReportWatchEventLog(ev.GetEvent());
                    }
                }
                return pListener->OnReportEvent(ev);
            }
            return true;
        }
    };
    CInner      m_in;           
    IReport*    m_pReporter;    
};
 
 
 
};