TnbLikenMemToFile.h

[詳解]

#pragma once
#include "TnbWriter.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
class CLikenMemToFile : public IWriter, CCopyImpossible
{
    const BYTE*                 m_pbcConstPtr;      
    BYTE*                       m_pbPtr;            
    LONGLONG                    m_llSize;           
    mutable CAutoVectorT<BYTE>  m_vbContent;        
    mutable LONGLONG            m_llPos;            
 
public:
 
    CLikenMemToFile(size_t size = 0)
        : m_pbcConstPtr(NULL)
        , m_pbPtr(NULL)
        , m_llSize(size)
        , m_llPos(0)
    {
        m_vbContent.SetSize(size);
    }
 
    CLikenMemToFile(size_t size, LPCVOID P)
        : m_pbcConstPtr(static_cast<const BYTE*>(P))
        , m_pbPtr(NULL)
        , m_llSize(size)
        , m_llPos(0)
    {
    }
 
    CLikenMemToFile(size_t size, LPVOID P)
        : m_pbcConstPtr(NULL)
        , m_pbPtr(static_cast<BYTE*>(P))
        , m_llSize(size)
        , m_llPos(0)
    {
    }
 
    virtual LPCTSTR GetOpenName(void) const { return _T("-"); }
 
    virtual void Close(void) {}
 
    virtual bool CanRead(void) const
    {
        return true;
    }
 
    virtual bool CanWrite(void) const
    {
        return m_pbcConstPtr == NULL;
    }
 
    virtual LONGLONG GetSize(void) const
    {
        if ( m_pbcConstPtr != NULL || m_pbPtr != NULL )
        {
            return m_llSize;
        }
        return m_vbContent.GetSize();
    }
 
    virtual LONGLONG Seek(LONGLONG llOffset, ESeekMode eSeek = TOP) const
    {
        LONGLONG l = GetSize();
        LONGLONG p;
        switch ( eSeek )
        {
        case TOP:
            p = llOffset;
            break;
        case END:
            p = l + llOffset;
            break;
        default:
            p = m_llPos + llOffset;
            break;
        }
        if ( p < 0 )
        {
            return -1;
        }
        else if ( p > l )
        {
            if ( m_pbcConstPtr == NULL && m_pbPtr == NULL )
            {
                m_vbContent.SetSize(ToInt(p));
            }
            else
            {
                return -1;
            }
        }
        m_llPos = p;
        return p;
    }
 
    virtual size_t Read(size_t size, LPVOID _P) const
    {
        const BYTE* B = NULL;
        if ( m_pbcConstPtr != NULL )
        {
            B = m_pbcConstPtr;
        }
        else if ( m_pbPtr != NULL )
        {
            B = m_pbPtr;
        }
        else
        {
            B = m_vbContent.ReferBuffer();
        }
        LONGLONG s = size;
        if ( s > GetLeftoverSize() )
        {
            s = GetLeftoverSize();
        }
        BYTE* Q = static_cast<BYTE*>(_P);
        MemCopy(Q, &B[m_llPos], ToInt(s));
        m_llPos += s;
        return ToInt(s);
    }
 
    virtual void Write(size_t size, LPCVOID P)
    {
        if ( m_pbcConstPtr != NULL )
        {
            throw CWriteFailureException(ERROR_ACCESS_DENIED);
        }
        if ( m_pbPtr != NULL )
        {
            if ( static_cast<LONGLONG>(size) >= GetLeftoverSize() )
            {
                throw CWriteFailureException(ERROR_ACCESS_DENIED);
            }
            MemCopy(&m_pbPtr[m_llPos], static_cast<const BYTE*>(P), size);
        }
        else
        {
            if ( m_llPos + size > m_vbContent.GetSize() )
            {
                m_vbContent.SetSize(ToInt(m_llPos + size));
            }
            const BYTE* B = static_cast<const BYTE*>(P);
            loop ( i, size )
            {
                m_vbContent.Set(ToInt(m_llPos + i), *B++);
            }
        }
        m_llPos += size;
    }
 
    virtual void SetEnd(void)
    {
        if ( m_pbcConstPtr != NULL && m_pbPtr != NULL )
        {
            throw CWriteFailureException(ERROR_ACCESS_DENIED);
        }
        m_vbContent.SetSize(ToInt(m_llPos));
    }
};
 
 
 
}; // TNB