TnbConstFileMapping.h

[詳解]

#pragma once
#include "TnbFileName.h"
#include "TnbCollection.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP>
class CConstFileMappingT : public IConstCollectionT<TYP>, CCopyImpossible
{
    DEFSUPER(IConstCollectionT<TYP>);
public:
 
    CConstFileMappingT(DWORD multi = 2) : _super(), m_pType(NULL), m_hMapping(NULL), m_nowPage(-1), m_offset(0), m_size(0)
    {
        SYSTEM_INFO si;
        ::GetSystemInfo(&si);
        m_pageSize = si.dwAllocationGranularity * multi;
    }
 
    ~CConstFileMappingT(void)
    {
        Close();
    }
 
    virtual bool Lock(DWORD dwTime = INFINITE) const 
    {
        return m_sync.Lock(); 
    }
 
    virtual void Unlock(void) const 
    {
        m_sync.Unlock();
    }
 
    bool IsOpened(void) const
    {
        return m_reader.CanRead();
    }
 
    bool Open(LPCTSTR lpszName, LONGLONG offset = 0, size_t size = INVALID_SIZE)
    {
        Close();
        m_offset = offset;
        if ( m_reader.Open(lpszName, true) )
        {
            m_size = ToIndex((m_reader.GetSize() - m_offset) / sizeof(TYP));
            if ( size != INVALID_SIZE )
            {
                if ( m_size > size )
                {
                    m_size = size;
                }
            }
            return true;
        }
        return false;
    }
 
    void Close(void)
    {
        m_Unmapping();
        m_reader.Close();
        m_size = 0;
    }
 
    virtual size_t GetSize(void) const
    {
        return m_size;
    }
 
    virtual TYP Get(INDEX index) const
    {
        return At(index);
    }
 
    virtual const TYP& At(INDEX index) const
    {
        const TYP* P = m_Mapping(index);
        if ( P != NULL )
        {
            return *P;
        }
        throw CIndexOutOfBoundsException();
    }
 
    const TYP& operator[](INDEX index) const
    {
        return At(index);
    }
 
private:
    LONGLONG m_IndexToFilePos(INDEX index) const
    {
        LONGLONG l = index;
        return l * sizeof(TYP) + m_offset;
    }
    void m_Unmapping(void)
    {
        if ( m_pType != NULL )
        {
            ::UnmapViewOfFile(m_pType);
            m_pType = NULL;
            m_nowPage = -1;
        }
        if ( m_hMapping != NULL )
        {
            ::CloseHandle(m_hMapping);
            m_hMapping = NULL;
        }
    }
    TYP* m_Mapping(INDEX index) const
    {
        if ( ! IsInRange(index) )
        {
            return NULL;
        }
        if ( m_hMapping == NULL )
        {
            m_hMapping = ::CreateFileMapping(m_reader, NULL, PAGE_READONLY, 0, 0, NULL);
            if ( m_hMapping == NULL )
            {
                return NULL;
            }
        }
        LONGLONG fl = m_IndexToFilePos(index);
        LONGLONG pl = fl / m_pageSize * m_pageSize;
        if ( pl != m_nowPage )
        {
            if ( m_pType != NULL )
            {
                ::UnmapViewOfFile(m_pType);
                m_pType = NULL;
            }
            m_nowPage = pl;
            LONGLONG ns = min(m_pageSize * 2, m_reader.GetSize() - pl);
            m_pType = static_cast<BYTE*>(::MapViewOfFile(m_hMapping, FILE_MAP_READ, static_cast<DWORD>(pl >> 32), static_cast<DWORD>(pl), down_cast<DWORD>(ns)));
            if ( m_pType == NULL )
            {
                _GetLastError("MapViewOfFile");
                ::CloseHandle(m_hMapping);
                m_hMapping = NULL;
                return NULL;
            }
        }
        return reinterpret_cast<TYP*>(&m_pType[fl - pl]);
    }
 
    CFileReader         m_reader;       
    DWORD               m_pageSize;     
    CSyncSection        m_sync;         
    LONGLONG            m_offset;       
    size_t              m_size;         
    mutable HANDLE      m_hMapping;     
    mutable BYTE*       m_pType;        
    mutable LONGLONG    m_nowPage;      
    friend class CConstFileMappingTest;
};
 
 
 
typedef CConstFileMappingT<BYTE> CConstFileMapping;
 
 
 
}; // TNB