TnbAsyncWriter.h

[詳解]

#pragma once
#include "TnbWriter.h"
#include "TnbAbstractReport.h"
#include "TnbCollectionAdapter.h"
#include "TnbThreadDispatch.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CAsyncWriter : public CThreadDispatch::IListener
{
public:
 
    struct ICommand
    {
        virtual~ ICommand(void) {}
        virtual bool Exec(IWriter& fw) = 0;
    };
 
 
    //-------------------------
 
 
    explicit CAsyncWriter(void)
    {
        m_pWriter = NULL;
        m_threadDispatch.SetListener(this);
    }
 
    virtual ~CAsyncWriter(void)
    {
        Stop();
    }
 
    bool IsAlive(void) const 
    {
        return (m_pWriter != NULL) ? m_pWriter->CanWrite() : false;
    }
    
    bool SetPriority(int priority)
    {
        return m_threadDispatch.SetPriority(priority);
    }
 
    bool SetWriter(IWriter* pfw)
    {
        Stop();
        if ( ! pfw->CanWrite() )
        {
            return false;
        }
        m_pWriter = pfw;
        return true;
    }
 
    bool Start(void)
    {
        Stop();
        if ( m_pWriter == NULL )
        {
            return false;
        }
        if ( ! m_pWriter->CanWrite() )
        {
            return false;
        }
        return m_threadDispatch.Start(_T("AsyncWriter:書込"));
    }
 
    void Stop(void)
    {
        if ( IsAlive() )
        {
            Close();
        }
        m_threadDispatch.Stop();
    }
 
    bool Write(const IConstCollectionT<BYTE>& c)
    {
        return m_OnDispatch(new CWriteCmd(c));
    }
 
    bool Seek(int iOffset, IWriter::ESeekMode eSeek = IWriter::TOP)
    {
        return m_OnDispatch(new CSeekCmd(iOffset, eSeek));
    }
 
    bool SetEnd(void)
    {
        return m_OnDispatch(new CSetEndCmd);
    }
 
    bool Close(void)
    {
        return m_OnDispatch(new CCloseCmd);
    }
 
    bool Command(ICommand* piCmd)
    {
        return m_OnDispatch(piCmd);
    }
 
private:
 
    CThreadDispatch m_threadDispatch;   
    IWriter*        m_pWriter;          
 
    enum{ WMWF_COMMAND = WM_APP };      
 
    virtual bool OnThreadDispatchReceive(UINT nMsg, WPARAM wParam, LPARAM lParam)
    {
        if ( nMsg == WMWF_COMMAND )
        {
            IWriter* pFw = reinterpret_cast<IWriter*>(wParam);
            ICommand* piCmd = reinterpret_cast<ICommand*>(lParam);
            if ( ! piCmd->Exec(*pFw) )
            {
                m_threadDispatch.PostMessage(WM_QUIT);
            }
            delete piCmd;
        }
        return true;
    }
 
    bool m_OnDispatch(ICommand* P)
    {
        bool b = m_threadDispatch.PostMessage(
                WMWF_COMMAND, reinterpret_cast<WPARAM>(m_pWriter), reinterpret_cast<LPARAM>(P));
        if ( ! b )
        {
            delete P;
            return false;
        }
        return true;
    }
 
    class CWriteCmd : public ICommand
    {
        CByteVector m_vb;       
    public: 
        CWriteCmd(const IConstCollectionT<BYTE>& c) { m_vb.Copy(c); }
        bool Exec(IWriter& fw) { fw.WriteFrom(m_vb); return true; }
    };
 
    class CSeekCmd : public ICommand
    {
        int                 m_iOffset;  
        IWriter::ESeekMode  m_eSeek;    
    public: 
        CSeekCmd(int iOffset, IWriter::ESeekMode eSeek) { m_iOffset = iOffset; m_eSeek = eSeek; }
        bool Exec(IWriter& fw) { fw.Seek(m_iOffset, m_eSeek); return true; }
    };
 
    class CSetEndCmd : public ICommand
    {
    public: bool Exec(IWriter& fw) { fw.SetEnd(); return true; }
    };
 
    class CCloseCmd : public ICommand
    {
    public: bool Exec(IWriter& fw) { fw.Close(); return false; }
    };
};
 
 
 
}; // TNB