TnbMappedFileReader.h

[詳解]

#pragma once
#include "TnbReader.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CMappedFileReader : public IReader
{
public:
 
    CMappedFileReader(void) : m_readPos(0), m_fileSize(0), m_pView(NULL), m_hFile(INVALID_HANDLE_VALUE), m_hMapping(NULL)
    {
    }
 
    ~CMappedFileReader(void)
    {
        Close();
    }
 
    bool Open(LPCTSTR fileName)
    {
        Close();
        m_hFile = ::CreateFile(fileName, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
        if ( m_hFile != INVALID_HANDLE_VALUE )
        {
            m_fileSize = ::GetFileSize(m_hFile, NULL);
            m_hMapping = ::CreateFileMapping(m_hFile, NULL, PAGE_READONLY, 0, 0, NULL);
            if ( m_hMapping != NULL )
            {
                m_pView = static_cast<const BYTE*>(::MapViewOfFile(m_hMapping, FILE_MAP_READ, 0, 0, 0));
                if ( m_pView != NULL )
                {
                    m_fileName = fileName;
                    return true;
                }
            }
        }
        Close();
        return false;
    }
 
    virtual LPCTSTR GetOpenName(void) const
    {
        return m_fileName;
    }
 
    virtual void Close(void)
    {
        if ( m_pView != NULL )
        {
            ::UnmapViewOfFile(m_pView);
            m_pView = NULL;
        }
        if ( m_hMapping != NULL )
        {
            ::CloseHandle(m_hMapping);
            m_hMapping = NULL;
        }
        if ( m_hFile != INVALID_HANDLE_VALUE) 
        {
            ::CloseHandle(m_hFile);
            m_hFile = INVALID_HANDLE_VALUE;
        }
        m_readPos = 0;
        m_fileSize = 0;
        m_fileName.Empty();
    }
 
    virtual bool CanRead(void) const
    {
        return m_pView != NULL;
    }
 
    virtual LONGLONG GetSize(void) const
    {
        return m_fileSize;
    }
 
    virtual LONGLONG Seek(LONGLONG llOffset, ESeekMode eSeek = TOP) const
    {
        LONGLONG l = m_fileSize;
        LONGLONG p = llOffset;
        switch ( eSeek )
        {
        case END:
            p += l;
            break;
        case CURRENT:
            p += m_readPos;
            break;
        }
        if ( p < 0 )
        {
            return -1;
        }
        else if ( p > l )
        {
            p = l;
        }
        m_readPos = static_cast<INDEX>(p);
        return p;
    }
 
    virtual size_t Read(size_t size, LPVOID _P) const
    {
        size_t s = size;
        size_t l = m_fileSize - m_readPos;
        if ( s > l )
        {
            s = l;
        }
        MemCopy(static_cast<BYTE*>(_P), &m_pView[m_readPos], s);
        m_readPos += s;
        return s;
    }
 
    const BYTE* Refer(void) const
    {
        return m_pView;
    }
 
    BYTE operator[](INDEX index) const
    {
        if ( index < m_fileSize )
        {
            return m_pView[index];
        }
        return NULL;
    }
 
private:
    const BYTE*         m_pView;        
    HANDLE              m_hFile;        
    HANDLE              m_hMapping;     
    size_t              m_fileSize;     
    CSimpleStr          m_fileName;     
    mutable INDEX       m_readPos;      
};
 
 
 
}; //TNB