TnbTemporaryCommunicator.h

[詳解]

#pragma once
#include "TnbCommunication.h"
#include "TnbVector.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CTemporaryCommunicator : public ICommunication, CCopyImpossible
{
    DEFSUPER(ICommunication);
public:
 
    CTemporaryCommunicator(void) : m_property(_T("TemporaryCommunicator"), TNBVIW_KIND_TEMP), m_isOpened(false), m_isSendError(false)
    {
    }
 
    virtual const TProperty& GetProperty(void) const 
    {
        return m_property; 
    }
 
    void SetPacketSize(DWORD receivePacketSize, DWORD sendPacketSize)
    {
        m_property.receivePacketSize = receivePacketSize;
        m_property.sendPacketSize = sendPacketSize;
    }
 
    virtual bool SetReceiveTimeout(DWORD to)
    {
        m_property.receiveTimeout = to;
        return true;
    }
 
    virtual bool Open(void)
    { 
        Purge();
        m_isOpened = true;
        return true;
    }
    
    virtual void Close(void)
    {
        Purge();
        m_isOpened = false;
    }
    
    virtual bool IsOpened(void) const
    {
        return m_isOpened;
    }
 
    virtual size_t Send(size_t size, LPCVOID P)
    {
        if ( ! m_isOpened || m_isSendError )
        {
            return INVALID_SIZE;
        }
        CByteVector vb;
        vb.SetElements(size, static_cast<const BYTE*>(P));
        EXCLUSIVE( &m_sentData );
        m_sentRowData.Add(vb);
        m_sentData.Append(vb);
        return size;
    }
 
    virtual size_t Receive(size_t size, LPVOID _P)
    {
        EXCLUSIVE( &m_receiveReserves );
        if ( m_isOpened )
        {
            INDEX idx = m_Find();
            if ( idx != INVALID_INDEX )
            {
                TParam& p = m_receiveReserves[idx];
                BYTE* B = static_cast<BYTE*>(_P);
                size_t l = min(p.data.GetSize(), size);
                MemCopy(B, p.data.ReferBuffer(), l);
                if ( l >= p.data.GetSize() )
                {
                    m_receiveReserves.Remove(idx);
                }
                else
                {
                    p.data.RemoveElements(0, l);
                }
                return l;
            }
        }
        return 0;
    }
 
    virtual size_t GetReceivingDataSize(void) const
    {
        EXCLUSIVE( &m_receiveReserves );
        if ( m_isOpened )
        {
            INDEX idx = m_Find();
            if ( idx != INVALID_INDEX )
            {
                return m_receiveReserves[idx].data.GetSize();
            }
        }
        return 0;
    }
 
    virtual EState Check(void) const 
    { 
        return m_isOpened ? CONNECTING : CLOSED;
    }
 
    virtual void Purge(void)
    {
        EXCLUSIVE2( &m_receiveReserves, &m_sentData );
        m_receiveReserves.RemoveAll();
        m_sentData.RemoveAll();
        m_sentRowData.RemoveAll();
    }
 
    void AddReceivingData(size_t size, LPCVOID pData, DWORD delay = 0)
    {
        EXCLUSIVE( &m_receiveReserves );
        if ( size > 0 )
        {
            TParam p;
            p.tick = ::GetTickCount();
            p.delay = delay;
            p.data.SetElements(size, static_cast<const BYTE*>(pData));
            m_receiveReserves.Add(p);
        }
    }
 
    void AddReceivingData(const IConstCollectionT<BYTE>& data, DWORD delay = 0)
    {
        EXCLUSIVE( &m_receiveReserves );
        if ( data.GetSize() > 0 )
        {
            TParam p;
            p.tick = ::GetTickCount();
            p.delay = delay;
            p.data.Copy(data);
            m_receiveReserves.Add(p);
        }
    }
 
    CByteVector& ReferSentData(void)
    {
        return m_sentData;
    }
 
    CVectorT<CByteVector>& ReferSentRowData(void)
    {
        return m_sentRowData;
    }
 
    void SetSendErrorMode(bool isSendError)
    {
        m_isSendError = isSendError;
    }
 
private:
 
    INDEX m_Find(void) const
    {
        loop ( i, m_receiveReserves )
        {
            const TParam& p = m_receiveReserves[i];
            DWORD t = ::GetTickCount() - p.tick;
            if ( p.delay == 0 || p.delay <= t )
            {
                return i;
            }
        }
        return INVALID_INDEX;
    }
 
    
    struct TParam
    {
        DWORD       tick;       
        DWORD       delay;      
        CByteVector data;       
    };
    CVectorT<TParam>        m_receiveReserves;  
    CByteVector             m_sentData;         
    CVectorT<CByteVector>   m_sentRowData;      
    _super::TProperty       m_property;         
    bool                    m_isSendError;      
    bool                    m_isOpened;         
};
 
 
 
}; // TNB