TnbReport.h

[詳解]

#pragma once
#include "TnbStr.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
enum EReportEvent
{
    ReportEvent_Non,            
    ReportEvent_Idle,           
    ReportEvent_End,            
    ReportEvent_Error,          
    ReportEvent_Connect,        
    ReportEvent_Disconnect,     
    ReportEvent_IrregularEnd,   
 
    ECE_Non = ReportEvent_Non,              
    ECE_Idle = ReportEvent_Idle,            
    ECE_End = ReportEvent_End,              
    ECE_Error = ReportEvent_Error,          
    ECE_Connect = ReportEvent_Connect,      
    ECE_Disconnect = ReportEvent_Disconnect,
};
 
typedef EReportEvent EReportEventId;
 
 
 
class CReportEvent
{
    const BYTE*     m_lpcbData;         
    size_t          m_dataSize;         
    EReportEvent    m_eEvent;           
    DWORD           m_dwErrorCode;      
    friend struct IReport;              
 
protected:
 
    mutable IReport*    m_piReport; 
 
public:
 
    explicit 
    CReportEvent(IReport* piComm, EReportEvent eEvent = ReportEvent_Non, DWORD dwError = 0)
    {
        m_lpcbData          = NULL;
        m_dataSize          = 0;
        m_eEvent            = eEvent;
        m_dwErrorCode       = dwError;
        m_piReport  = piComm;
    }
 
    virtual DWORD GetInterfaceId(void) const;   //本体はファイル下位に記述
 
    virtual bool Send(size_t dataSize, LPCVOID lpcvData) const; //本体はファイル下位に記述
 
    bool HasData(void) const
    {
        return m_lpcbData != NULL;
    }
 
    bool HasEvent(void) const
    {
        return ! HasData();
    }
 
    size_t GetDataSize(void) const
    {
        return HasData() ? m_dataSize : 0;
    }
 
    const BYTE* GetData(void) const
    {
        return m_lpcbData;
    }
 
    EReportEvent GetEvent(void) const
    {
        return HasEvent() ? m_eEvent : ReportEvent_Non;
    }
 
    DWORD GetErrorCode(void) const
    {
        if ( HasEvent() && GetEvent() == ReportEvent_Error )
        {
            return m_dwErrorCode;
        }
        return 0;
    }
 
    CStr GetEventString(void) const
    {
        switch ( GetEvent() )
        {
        case ReportEvent_Non:           return _T("なし");
        case ReportEvent_Idle:          return _T("アイドル");
        case ReportEvent_End:           return _T("終了");
        case ReportEvent_IrregularEnd:  return _T("強制終了");
        case ReportEvent_Connect:       return _T("接続");
        case ReportEvent_Disconnect:    return _T("切断");
        case ReportEvent_Error:         return CStr::Fmt(_T("エラー[%u]"), GetErrorCode());
        }
        return _T("");
    }
 
    void SetData(size_t dataSize, LPCVOID lpcData)
    {
        m_dataSize = dataSize;
        m_lpcbData = static_cast<const BYTE*>(lpcData);
    }
};
 
 
 
struct IReport
{
    friend class CReportEvent;      
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual bool OnReportEvent(const CReportEvent& ev) = 0;
    };
 
 
    //------------------------------
 
 
    virtual ~IReport(void) 
    {
    }
 
    virtual CStr GetReportName(void) const = 0; 
 
    virtual DWORD GetReportID(void) const = 0; 
 
    virtual void SetListener(IReport::IListener* piCommListener = NULL) = 0;
 
    virtual DWORD GetInterfaceId(void) const = 0;
 
    virtual void SetIdleEventMode(int iInterval = 0) = 0;
 
    virtual bool Start(void) = 0;
 
    virtual void Stop(void) = 0;
 
    virtual bool IsAlive(void) const = 0;
    
    virtual bool IsConnect(void) const = 0;
 
    virtual bool Send(size_t dataSize, LPCVOID lpcData) = 0;
 
    virtual void Purge(void) = 0;
};
 
 
 
inline bool CReportEvent::Send(size_t dataSize, LPCVOID lpcvData) const
{
    return m_piReport->Send(dataSize, lpcvData);
}
 
inline DWORD CReportEvent::GetInterfaceId(void) const
{
    return m_piReport->GetInterfaceId();
}
 
 
 
}; // TNB