TnbCommunicationReporter.h

[詳解]

#pragma once
#include "TnbAbstractReport.h"
#include "TnbThread.h"
#include "TnbCommunication.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CCommunicationReporter : public CAbstractReport, TNB::CThread::IRunner
{
    DEFSUPER(CAbstractReport);
public:
 
    explicit CCommunicationReporter(ICommunication* pComm, DWORD dwInterfaceId = 0) : _super(dwInterfaceId)
    {
        m_piCommunication = pComm;      // 通信クラス
        m_lpbReceiveWork = NULL;        // 受信用バッファアドレス
        m_dwPollingTiming = 1;          // 間隔
        m_boIsConnect = false;
        m_receivePacketMaxSize = E_ReceiveDataBufferSize;
        m_hasOndemandStop = false;
    }
 
    virtual ~CCommunicationReporter(void)
    {
        if ( m_lpbReceiveWork != NULL )
        {
            delete[] m_lpbReceiveWork;
            m_lpbReceiveWork = NULL;
        }
    }
 
    virtual CStr GetReportName(void) const
    {
        return m_piCommunication->GetProperty().typeName;
    }
 
    virtual DWORD GetReportID(void) const
    {
        return m_piCommunication->GetProperty().typeId;
    }
 
    virtual bool IsAlive(void) const
    { 
        return m_threadRecv.IsAlive() && m_piCommunication->IsOpened();
    }
 
    virtual bool IsConnect(void) const 
    {
        return m_piCommunication->IsConnect(); 
    }
 
    virtual void SetIdleEventMode(int iInterval = 0)
    {
        _super::SetIdleEventMode(iInterval);
    }
 
    void SetReceivePollingTiming(DWORD dwPollingTiming)
    {
        m_dwPollingTiming = dwPollingTiming;
    }
 
    virtual bool Start(void)
    {
        if ( m_threadRecv.IsAlive() )
        {
            //スレッド停止
            m_threadRecv.Stop();
        }
        if ( m_piCommunication->Open() )
        {
            const ICommunication::TProperty& param = m_piCommunication->GetProperty();
            if ( param.receivePacketSize != INVALID_SIZE )
            {
                //サイズ固定だ
                m_receivePacketMaxSize = param.receivePacketSize;
            }
            if ( m_lpbReceiveWork != NULL )
            {
                delete[] m_lpbReceiveWork;
            }
            m_lpbReceiveWork = new BYTE[m_receivePacketMaxSize];
            //
            m_threadRecv.SetRunner(this);
            #ifdef _DEBUG
                m_threadRecv.Start(CStr::Fmt(_T("%s:監視"), GetReportName()));
            #else
                m_threadRecv.Start();
            #endif
            return true;
        }
        return false;
    }
 
    virtual void Stop(void)
    {
        m_hasOndemandStop = true;
        m_piCommunication->Close();
        if ( m_threadRecv.IsAlive() )
        {
            //スレッド停止
            m_threadRecv.Stop();
        }
        m_hasOndemandStop = false;
    }
 
    virtual bool Send(size_t dataSize, LPCVOID lpcvData)
    {
        if ( ! m_piCommunication->IsOpened() )
        {
            return false;
        }
        bool r = m_piCommunication->Send(dataSize, lpcvData) == dataSize;
        if ( r )
        {
            _super::m_OnSend(dataSize, lpcvData);
        }
        return r;
    }
 
    virtual void Purge(void)
    {
        EXCLUSIVE( &m_syncReceive );
        m_piCommunication->Purge();
    }
 
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_threadRecv;
    }
 
private:
 
    enum
    {
        E_ReceiveDataBufferSize = 10000,        
    };
    CSyncSection    m_syncReceive;          
    CThread         m_threadRecv;           
    ICommunication* m_piCommunication;      
    LPBYTE          m_lpbReceiveWork;       
    DWORD           m_dwPollingTiming;      
    bool            m_boIsConnect;          
    bool            m_hasOndemandStop;      
    size_t          m_receivePacketMaxSize; 
 
    virtual DWORD Run(void)
    {
        CTickCount tick;
        bool isReceived = true;
        DWORD ec = 0;
        //
        while ( IsRunnable() )
        {
            if ( isReceived )
            {
                isReceived = false;
            }
            else if ( m_dwPollingTiming > 0 )
            {
                ::Sleep(m_dwPollingTiming);
            }
            //== 受信中排他ON
            m_syncReceive.Lock();
            ICommunication::EState s = m_piCommunication->Check();
            ec = ::GetLastError();
            if ( s == ICommunication::CLOSED )
            {
                m_syncReceive.Unlock();
                break;  //Closeされたら、終了
            }
            if ( s == ICommunication::OPENNING && m_boIsConnect )
            {
                //受信中排他OFF
                m_syncReceive.Unlock();
                //切断を通知。
                m_OnEvent(CReportEvent(this, ReportEvent_Disconnect));
                m_boIsConnect = false;
                continue;
            }
            if ( s == ICommunication::CONNECTING && ! m_boIsConnect )
            {
                //接続を通知。
                if ( ! m_OnEvent(CReportEvent(this, ReportEvent_Connect)) )
                {
                    break;
                }
                m_boIsConnect = true;
            }
            if ( m_piCommunication->CanReceive() )
            {
                size_t dwReceivedDataCount = INVALID_SIZE;
                {
                    //---- 1Byte以上ある or わからない(INVALID_SIZE)。
                    if ( dwReceivedDataCount > m_receivePacketMaxSize )
                    {
                        dwReceivedDataCount = m_receivePacketMaxSize;
                    }
                    if ( m_lpbReceiveWork == NULL )
                    {
                        //受信中排他OFF
                        m_syncReceive.Unlock();
                        continue;
                    }
                    size_t dwReadBytes = m_piCommunication->Receive(dwReceivedDataCount, m_lpbReceiveWork);
                    //
                    if ( dwReadBytes == INVALID_SIZE )
                    {
                        //失敗
                        //受信中排他OFF
                        m_syncReceive.Unlock();
                        continue;
                    }
                    //コールバック関数へ通知。
                    if ( dwReadBytes > 0 )
                    {
                        //受信中排他OFF
                        m_syncReceive.Unlock();
                        CReportEvent ev(this);
                        ev.SetData(dwReadBytes, m_lpbReceiveWork);
                        if ( ! m_OnEvent(ev) )
                        {
                            break;
                        }
                        isReceived = true;
                        tick.Reset();
                        continue;
                    }
                }
            }   
            //受信中排他OFF
            m_syncReceive.Unlock();
            if ( _super::GetIdleInterval() > 0 )
            {
                //---- 受信データなし&IDLEイベント要求あり。
                if ( tick.IsPassedAndReset(_super::GetIdleInterval()) )
                {
                    //コールバック関数へ通知。
                    if ( ! m_OnEvent(CReportEvent(this, ReportEvent_Idle)) )
                    {
                        break;
                    }
                }
            }
        }
        //コールバック関数へ通知。
        if ( m_boIsConnect )
        {
            m_boIsConnect = false;
            //切断を通知。
            m_OnEvent(CReportEvent(this, ReportEvent_Disconnect));
        }
        m_piCommunication->Close();
        ::SetLastError(ec);
        if ( ! m_hasOndemandStop )
        { 
            m_OnEvent(CReportEvent(this, ReportEvent_IrregularEnd));
        }
        m_OnEvent(CReportEvent(this, ReportEvent_End));
        return 0;
    }
 
    friend class CCommunicationReporterTest;        
};
 
 
 
template<typename COMM>
class CCommunicationReporterT : public CCommunicationReporter
{
    DEFSUPER(CCommunicationReporter);
public:
 
    explicit CCommunicationReporterT(DWORD dwInterfaceId = 0) : _super(&m_comm, dwInterfaceId)
    {
    }
 
    virtual ~CCommunicationReporterT(void)
    {
        Stop();
    }
 
    COMM& ReferCommunication(void)
    {
        return m_comm;
    }
 
    COMM* operator->(void)
    {
        return &m_comm;
    }
 
    const COMM& ReferCommunication(void) const
    {
        return m_comm;
    }
 
    const COMM* operator->(void) const
    {
        return &m_comm;
    }
 
private:
    COMM    m_comm;
};
 
 
 
}; // TNB