TnbFileAdapter.h

[詳解]

#pragma once
#include "TnbFile.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CReaderAdapter : public IConstCollectionT<BYTE>
{
    DEFSUPER(IConstCollectionT<BYTE>);
public:
 
    CReaderAdapter(void) : _super(), m_pReader(NULL), m_iTempNo(0)
    {
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const 
    {
        return true; 
    }
 
    virtual void Unlock(void) const
    {
    }
 
    bool Attach(const IReader* pReader)
    {
        Detach();
        if ( ! pReader->CanRead() )
        {
            return false;
        }
        m_pReader = pReader;
        return true;
    }
 
    void Detach(void)
    {
        if ( m_pReader == NULL )
        {
            m_pReader = NULL;
        }
    }
 
    virtual size_t GetSize(void) const
    {
        if ( m_pReader == NULL )
        {
            return 0;
        }
        return ToIndex(m_pReader->GetSize());
    }
 
    virtual BYTE Get(INDEX index) const
    {
        if ( m_pReader == NULL || ! IsInRange(index) )
        {
            throw CIndexOutOfBoundsException();
        }
        if ( m_pReader->Seek(index) >= 0 )
        {
            CByteVector vb = m_pReader->ReadExactly(1);
            if ( vb.IsValid() )
            {
                return vb[0];
            }
        }
        throw CReadFailureException(ERROR_ACCESS_DENIED);
    }
 
    virtual const BYTE& At(INDEX index) const
    {
        m_iTempNo = (m_iTempNo + 1) & 0x0F;
        return m_abTemp[m_iTempNo] = Get(index);
    }
 
    BYTE operator[](INDEX index) const
    {
        return Get(index);
    }
 
private:
    const IReader*      m_pReader;      
    mutable BYTE        m_abTemp[16];   
    mutable INDEX       m_iTempNo;      
};
 
 
 
class CWriterAdapter : public ICollectionT<BYTE>
{
    DEFSUPER(ICollectionT<BYTE>);
public:
 
    class CRef
    {
        friend class CWriterAdapter;
        CWriterAdapter* m_fa;
        INDEX           m_index;
        BYTE m_Set(BYTE b)
        {
            if ( ! m_fa->Set(m_index, b) )
            {
                throw CWriteFailureException(ERROR_ACCESS_DENIED);
            }
            return b;
        }
        BYTE m_Get(void) const
        {
            return m_fa->Get(m_index);
        }
        CRef(CWriterAdapter* P, INDEX i)
        {
            m_fa = P;
            m_index = i;
        }
    public:
        operator BYTE(void) const
        {
            return m_Get();
        }
        BYTE operator=(BYTE b)
        {
            return m_Set(static_cast<BYTE>(b));
        }
        BYTE operator+=(BYTE b)
        {
            return m_Set(static_cast<BYTE>(m_Get() + b));
        }
        BYTE operator-=(BYTE b)
        {
            return m_Set(static_cast<BYTE>(m_Get() - b));
        }
    };
 
 
    //-----------------
 
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
    // const_iterator型宣言
    typedef CConstIteratorBaseT<CWriterAdapter, BYTE> const_iterator;
    // iterator宣言
    class iterator
    {
        _ITERATORCORE(iterator, CWriterAdapter)
    public:
        CRef operator*(void)
        {
            return (*m_V)[m_ind];
        }
        CRef operator[](int i)
        {
            return (*m_V)[m_ind+i];
        }
    };
    #endif //_TnbDOXYEM
 
    const_iterator begin(void) const { return const_iterator(this, 0); }
 
    const_iterator end(void) const { return const_iterator(this, GetSize()); }
 
    iterator begin(void) { return iterator(this, 0); }
 
    iterator end(void) { return iterator(this, GetSize()); }
 
 
    //-----------------
 
 
    CWriterAdapter(void) : _super(), m_pWriter(NULL), m_iTempNo(0)
    {
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const 
    {
        return true; 
    }
 
    virtual void Unlock(void) const 
    {
    }
 
    bool Attach(IWriter* pWriter)
    {
        Detach();
        if ( ! pWriter->CanWrite() )
        {
            return false;
        }
        m_pWriter = pWriter;
        return true;
    }
 
    void Detach(void)
    {
        if ( m_pWriter == NULL )
        {
            m_pWriter = NULL;
        }
    }
 
    virtual size_t GetSize(void) const
    {
        if ( m_pWriter == NULL )
        {
            return 0;
        }
        return ToIndex(m_pWriter->GetSize());
    }
 
    virtual bool SetSize(size_t size)
    {
        if ( m_pWriter == NULL || m_pWriter->Seek(size) < 0 )
        {
            return false;
        }
        m_pWriter->SetEnd();
        return true;
    }
 
    virtual BYTE Get(INDEX index) const
    {
        if ( m_pWriter == NULL || ! IsInRange(index) )
        {
            throw CIndexOutOfBoundsException(); 
        }
        if ( m_pWriter->Seek(index) >= 0 )
        {
            CByteVector vb = m_pWriter->ReadExactly(1);
            if ( vb.IsValid() )
            {
                return vb[0];
            }
        }
        throw CReadFailureException(ERROR_ACCESS_DENIED);
    }
 
    virtual const BYTE& At(INDEX index) const
    {
        m_iTempNo = (m_iTempNo + 1) & 0x0F;
        m_abTemp[m_iTempNo] = Get(index);
        return m_abTemp[m_iTempNo];
    }
 
    virtual BYTE& Ref(INDEX index)
    {
        throw CNotSupportException();
    }
 
    BYTE operator[](INDEX index) const
    {
        return Get(index);
    }
 
    CRef operator[](INDEX index)
    {
        if ( m_pWriter == NULL || ! IsInRange(index) )
        {
            throw CIndexOutOfBoundsException(); 
        }
        return CRef(this, index);
    }
 
    virtual INDEX Add(const BYTE& t)
    {
        if ( m_pWriter == NULL )
        {
            return INVALID_INDEX;
        }
        INDEX r = static_cast<INDEX>(m_pWriter->Seek(0, CFileWriter::END));
        if ( r != INVALID_INDEX )
        {
            m_pWriter->Write(1, &t);
        }
        return r; 
    }
 
    virtual bool Remove(INDEX index)
    {
        return false;
    }
 
    virtual bool RemoveAll(void)
    {
        if ( m_pWriter == NULL )
        {
            return false;
        }
        m_pWriter->Seek(0);
        m_pWriter->SetEnd();
        return true;
    }
 
    virtual bool Set(INDEX index, const BYTE& t)
    {
        if ( m_pWriter != NULL && IsInRange(index) && m_pWriter->Seek(index) >= 0 )
        {
            m_pWriter->Write(1, &t);
            return true;
        }
        return false;
    }
 
private:
    IWriter*        m_pWriter;      
    mutable BYTE    m_abTemp[16];   
    mutable INDEX   m_iTempNo;      
};
 
 
 
}; // TNB