TnbFileMapping.h

[詳解]

#pragma once
#include "TnbFile.h"
#include "TnbTemporaryFile.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
template<typename TYP>
class CFileMappingT : public ICollectionT<TYP>, CCopyImpossible
{
    DEFSUPER(ICollectionT<TYP>);
public:
 
    CFileMappingT(DWORD multi = 2) : _super(), m_pType(NULL), m_hMapping(NULL), m_nowPage(-1), m_isSeeked(false), m_offset(0)
    {
        SYSTEM_INFO si;
        ::GetSystemInfo(&si);
        m_pageSize = si.dwAllocationGranularity * multi;
    }
 
    ~CFileMappingT(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_writer.CanWrite();
    }
 
    bool Open(LPCTSTR lpszName = NULL, LONGLONG offset = 0)
    {
        m_offset = offset;
        CStr n = lpszName;
        if ( n.IsEmpty() )
        {
            n = m_tempFileName.Create();
        }
        return m_writer.Open(n, false, true);
    }
 
    void Close(void)
    {
        m_Unmapping();
        m_writer.Close();
        m_tempFileName.Free();
    }
 
    virtual size_t GetSize(void) const
    {
        return ToIndex((m_writer.GetSize() - m_offset) / sizeof(TYP));
    }
 
    virtual bool SetSize(size_t size)
    {
        m_Unmapping();
        if ( m_writer.Seek(m_IndexToFilePos(size)) < 0 )
        {
            return false;
        }
        m_writer.SetEnd();
        m_isSeeked = true;
        return true;
    }
 
    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();
    }
 
    virtual TYP& Ref(INDEX index)
    {
        TYP* P = m_Mapping(index);
        if ( P != NULL )
        {
            return *P;
        }
        throw CIndexOutOfBoundsException();
    }
 
    const TYP& operator[](INDEX index) const
    {
        return At(index);
    }
 
    TYP& operator[](INDEX index)
    {
        return Ref(index);
    }
 
    virtual INDEX Add(const TYP& t)
    {
        m_Unmapping();
        m_writer.Write(sizeof(TYP), &t);
        return true; 
    }
 
    virtual bool Remove(INDEX index)
    {
        if ( IsInRange(index) )
        {
            size_t nl = GetSize();
            loop ( i, (nl - index) - 1 )
            {
                INDEX d = i + index;
                Set(d, Ref(d + 1));
            }
            return SetSize(nl - 1);
        }
        return false;
    }
 
    virtual bool RemoveAll(void)
    {
        m_Unmapping();
        if ( ! m_writer.CanWrite() )
        {
            return false;
        }
        m_writer.Seek(m_offset);
        m_writer.SetEnd();
        return true;
    }
 
    virtual bool Set(INDEX index, const TYP& t)
    {
        if ( IsInRange(index) )
        {
            Ref(index) = t;
            return true;
        }
        return false;
    }
 
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;
        }
        if ( m_isSeeked )
        {
            m_isSeeked = false;
            m_writer.Seek(0, CFileWriter::END);
        }
    }
    TYP* m_Mapping(INDEX index) const
    {
        if ( ! IsInRange(index) )
        {
            return NULL;
        }
        if ( m_hMapping == NULL )
        {
            m_hMapping = ::CreateFileMapping(m_writer, NULL, PAGE_READWRITE, 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_writer.GetSize() - pl);
            m_pType = static_cast<BYTE*>(::MapViewOfFile(m_hMapping, FILE_MAP_ALL_ACCESS, 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]);
    }
 
    CFileWriter         m_writer;       
    CTemporaryFile      m_tempFileName; 
    DWORD               m_pageSize;     
    CSyncSection        m_sync;         
    bool                m_isSeeked;     
    LONGLONG            m_offset;       
    mutable HANDLE      m_hMapping;     
    mutable BYTE*       m_pType;        
    mutable LONGLONG    m_nowPage;      
};
 
 
 
typedef CFileMappingT<BYTE> CFileMapping;
 
 
 
}; // TNB