TnbFileCommunicator.h

[詳解]

#pragma once
#include "TnbFile.h"
#include "TnbCommunication.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CFileCommunicator : public ICommunication
{
    DEFSUPER(ICommunication);
public:
 
    struct IWorker
    {
        virtual ~IWorker(void) {}
 
        virtual bool OnOpen(void) = 0;
 
        virtual size_t Read(size_t size, LPVOID _P) =0;
 
        virtual size_t Write(size_t size, LPCVOID P) = 0;
 
        virtual bool Purge(void) = 0;
    };
 
 
    //--------------------------------------
 
 
    CFileCommunicator(void) : m_pWorker(NULL), m_sendTimeout(1000)
        , m_property(_T("File"), TNBVIW_KIND_FILE, 1000)
    {
    }
 
    virtual ~CFileCommunicator(void)
    {
        Close();
    }
 
    void SetWorker(IWorker* pWorker)
    {
        m_pWorker = pWorker;
    }
 
    void SetSendTimeout(DWORD to)
    {
        m_sendTimeout = to;
    }
 
    virtual bool SetReceiveTimeout(DWORD to)
    {
        m_property.receiveTimeout = to;
        return true;
    }
 
    virtual const TProperty& GetProperty(void) const
    {
        return m_property;
    }
 
    virtual bool Open(void)
    {
        if ( m_pWorker == NULL )
        {
            return false;
        }
        return m_pWorker->OnOpen();
    }
 
    virtual void Close(void)
    {
    }
 
    virtual bool IsOpened(void) const
    {
        return true;
    }
 
    virtual bool CanSend(void) const
    {
        return (m_pWorker != NULL);
    }
 
    virtual bool CanReceive(void) const
    {
        return (m_pWorker != NULL);
    }
 
    virtual size_t Send(size_t size, LPCVOID P)
    {
        size_t r = INVALID_SIZE;
        if ( m_pWorker != NULL )
        {
            CTickCount tick;
            do
            {
                size_t rr = m_pWorker->Write(size, P);
                if ( rr != INVALID_SIZE )
                {
                    r = rr;
                    break;
                }
                ::Sleep(RETRY_INTERVAL);
            }
            while ( ! tick.IsPassed(m_sendTimeout) );
        }
        return r;
    }
 
    virtual size_t Receive(size_t size, LPVOID _P)
    {
        size_t r = 0;
        if ( m_pWorker != NULL )
        {
            CTickCount tick;
            do
            {
                size_t rr = m_pWorker->Read(size, _P);
                if ( rr != INVALID_SIZE )
                {
                    r = rr;
                    break;
                }
                ::Sleep(RETRY_INTERVAL);
            }
            while ( ! tick.IsPassed(m_property.receiveTimeout) );
        }
        return r;
    }
 
    virtual size_t GetReceivingDataSize(void) const
    {
        return INVALID_SIZE;
    }
 
    virtual EState Check(void) const
    {
        return IsConnect() ? CONNECTING : CLOSED;
    }
 
    virtual void Purge(void) 
    {
        if ( m_pWorker != NULL )
        {
            CTickCount tick;
            do
            {
                if ( m_pWorker->Purge() )
                {
                    break;
                }
                ::Sleep(RETRY_INTERVAL);
            }
            while ( ! tick.IsPassed(m_property.receiveTimeout) );
        }
    }
 
protected:
    enum { RETRY_INTERVAL = 10 };
    DWORD           m_sendTimeout;      
    IWorker*        m_pWorker;          
    TProperty       m_property;         
};
 
 
 
class CFileCommunicationWorker : public CFileCommunicator::IWorker
{
public:
 
    bool SetFileName(LPCTSTR lpszReadFile, LPCTSTR lpszWriteFile)
    {
        m_readFile = lpszReadFile;
        m_writeFile = lpszWriteFile;
        return true;
    }
 
    virtual bool OnOpen(void)
    {
        Purge();
        bool isEmpty = m_readFile.IsEmpty() || m_writeFile.IsEmpty();
        return ! isEmpty;
    }
 
    virtual size_t Read (size_t size, LPVOID _P)
    {
        CFileReader fr;
        if ( fr.Open(m_readFile, false) )
        {
            size_t r = fr.Read(size, _P);
            fr.Close();
            ::DeleteFile(m_readFile);
            return r;
        }
        DWORD e = ::GetLastError();
        return (e == ERROR_FILE_NOT_FOUND) ? 0 : INVALID_SIZE;
    }
 
    virtual size_t Write(size_t size, LPCVOID P)
    {
        CFileWriter fw;
        if ( fw.New(m_writeFile, false) )
        {
            try
            {
                fw.Write(size, P);
                return size;
            }
            catch ( CWriteFailureException& e )
            {
                e.OnCatch();
            }
        }
        return INVALID_SIZE;
    }
 
    virtual bool Purge(void)
    {
        ::DeleteFile(m_writeFile);
        BOOL r = ::DeleteFile(m_readFile + _T("__"));
        r &= ::DeleteFile(m_readFile);
        return !! r;
    }
 
protected:
 
    CStr        m_readFile;     
    CStr        m_writeFile;    
};
 
 
 
}; // TNB