TnbCacheWriter.h

[詳解]

#pragma once
#include "TnbWriter.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CCacheWriter : public IWriter, CCopyImpossible
{
public:
 
    CCacheWriter(void) : m_pWriter(NULL)
    {
    }
 
    ~CCacheWriter(void)
    {
        m_Push();
    }
 
    bool SetWriter(IWriter* pfw, size_t size = 10000)
    {
        if ( ! pfw->CanWrite() )
        {
            return false;
        }
        m_pWriter = pfw;
        m_cache.Resize(size);
        m_cacheSize = 0;
        return true;
    }
 
    virtual LPCTSTR GetOpenName(void) const
    {
        m_Check();
        return m_pWriter->GetOpenName();
    }
 
    virtual void Close(void)
    {
        m_CheckAndPush();
        m_pWriter->Close();
    }
 
    virtual bool CanRead(void) const
    {
        m_Check();
        return m_pWriter->CanRead();
    }
 
    virtual LONGLONG GetSize(void) const
    {
        m_Check();
        return m_pWriter->GetSize();
    }
 
    virtual LONGLONG Seek(LONGLONG llOffset, ESeekMode eSeek = TOP) const
    {
        m_CheckAndPush();
        return m_pWriter->Seek(llOffset, eSeek);
    }
 
    virtual size_t Read(size_t size, LPVOID _P) const
    {
        m_CheckAndPush();
        return m_pWriter->Read(size, _P);
    }
 
    virtual bool CanWrite(void) const
    {
        m_Check();
        return m_pWriter->CanWrite();
    }
 
    virtual void SetEnd(void)
    {
        m_CheckAndPush();
        m_pWriter->SetEnd();
    }
 
    virtual void Write(size_t size, LPCVOID P)
    {
        m_Check();
        if ( m_cacheSize + size >= m_cache.GetSize() )
        {
            // キャッシュがあふれる
            m_Push();
            ASSERT( m_cacheSize == 0 );
            if ( size >= m_cache.GetSize() )
            {
                // キャッシュに入らない
                m_pWriter->Write(size, P);
            }
            else
            {
                memcpy(m_cache, P, size);
                m_cacheSize = size;
            }
        }
        else
        {
            memcpy(&m_cache[m_cacheSize], P, size);
            m_cacheSize += size;
        }
    }
 
private:
    // NULL チェック
    void m_Check(void) const
    {
        if ( m_pWriter == NULL )
        {
            throw CNullPointerException();
        }
    }
    // 追い出す
    void m_Push(void) const
    {
        if ( m_cacheSize > 0 )
        {
            m_pWriter->Write(m_cacheSize, m_cache);
            m_cacheSize = 0;
        }
    }
    // NULL チェック＆追い出す
    void m_CheckAndPush(void) const
    {
        m_Check();
        m_Push();
    }
    mutable size_t      m_cacheSize;        
    mutable CWorkMem    m_cache;            
    mutable IWriter*    m_pWriter;          
};
 
 
 
}; // TNB