TnbFile.h

[詳解]

#pragma once
#include "TnbWriter.h"
#include "TnbTime.h"
#include "TnbHandleHandle.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CAbstractFile
{
public:
    enum EMode
    {
        READ,       
        CREATE,     
        ACCESS,     
        WRITE,      
    };
 
    CAbstractFile(void) : m_boCanWrite(false), m_attributes(0)
    {
    }
 
    virtual ~CAbstractFile(void)
    {
        Close();
    }
 
    void Close(void)
    {
        SetHandle(INVALID_HANDLE_VALUE);
    }
 
    void SetCreatedAttributes(DWORD attr)
    {
        m_attributes = attr;
    }
 
    bool OpenOnMode(LPCTSTR lpszName, EMode eMode = ACCESS, bool isShare = true)
    {
        Close();
        m_strName = lpszName;
        m_boCanWrite = true;
        DWORD dwDesiredAccess;
        DWORD dwShareMode;
        DWORD dwCreationDisposition;
        switch ( eMode )
        {
        default:
        case READ:      // 読み込みオープン(既存でなければエラーになります)
            dwDesiredAccess         = GENERIC_READ;
            dwCreationDisposition   = OPEN_EXISTING;
            dwShareMode = isShare ? (FILE_SHARE_READ) : 0;
            m_boCanWrite = false;
            break;
        case WRITE:     // 書き込みオープン(既存でなければ作成されます)
            dwDesiredAccess         = GENERIC_WRITE;
            dwCreationDisposition   = OPEN_ALWAYS;
            dwShareMode = isShare ? (FILE_SHARE_WRITE) : 0;
            break;
        case ACCESS:    // 読み書きオープン(既存でなければ作成されます)
            dwDesiredAccess         = GENERIC_WRITE | GENERIC_READ;
            dwCreationDisposition   = OPEN_ALWAYS;
            dwShareMode = isShare ? (FILE_SHARE_READ | FILE_SHARE_WRITE) : 0;
            break;
        case CREATE:    // 新規書き込みオープン(既存ファイルは消されます)
            dwDesiredAccess         = GENERIC_WRITE | GENERIC_READ;
            dwCreationDisposition   = CREATE_ALWAYS;
            dwShareMode = isShare ? (FILE_SHARE_READ | FILE_SHARE_WRITE) : 0;
            break;
        }
        SetHandle(ApiCreateFile(lpszName, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, m_attributes, NULL));
        if ( GetHandle() != INVALID_HANDLE_VALUE )
        {
            return true;
        }
        return false;
    }
 
    bool CanRead(void) const
    {
        return GetHandle() != INVALID_HANDLE_VALUE;
    }
 
    bool CanWrite(void) const
    {
        return CanRead() && m_boCanWrite;
    }
 
    bool GetInformation(LPBY_HANDLE_FILE_INFORMATION _lpFileInformation) const
    {
        bool r = !! ApiGetFileInformationByHandle(GetHandle(), _lpFileInformation);
        return r;
    }
 
    LONGLONG GetSize(void) const
    {
        ::SetLastError(NO_ERROR);
        ULARGE_INTEGER r;
        r.LowPart = ApiGetFileSize(GetHandle(), &r.HighPart);
        if ( ::GetLastError() != NO_ERROR )
        {
            return -1;
        }
        return static_cast<LONGLONG>(r.QuadPart);
    }
 
    LONGLONG Seek(LONGLONG llOffset, IReader::ESeekMode eSeek = IReader::TOP) const
    {
        LARGE_INTEGER r;
        r.QuadPart = llOffset;
        r.LowPart = ApiSetFilePointer(GetHandle(), r.LowPart, &r.HighPart, eSeek);
        if ( r.LowPart == INVALID_SET_FILE_POINTER )
        {
            if ( ::GetLastError() != NO_ERROR )
            {
                r.QuadPart = -1;
            }
        }
        return r.QuadPart;
    }
 
    size_t Read(size_t size, LPVOID _P) const
    {
        if ( size > ULONG_MAX )
        {
            size = ULONG_MAX;
        }
        DWORD dwRead;
        BOOL boRc = ApiReadFile(GetHandle(), _P, ToDword(size), &dwRead, NULL);
        if ( ! boRc )
        {
            throw CReadFailureException(::GetLastError());
        }
        return dwRead;
    }
 
    operator HANDLE(void) const
    {
        return GetHandle();
    }
 
    LPCTSTR GetOpenName(void) const
    {
        return m_strName;
    }
 
    virtual HANDLE GetHandle(void) const
    {
        return m_hhFile;
    }
    
protected:
    virtual void SetHandle(HANDLE h)
    {
        m_hhFile = h;
    }
 
    #ifndef _TnbDOXYGEN //Document作成用シンボル
 
    virtual BOOL ApiGetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation) const
    {
        return ::GetFileInformationByHandle(hFile, lpFileInformation);
    }
    virtual HANDLE ApiCreateFile(LPCTSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes,
            DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
    {
        return ::CreateFile(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
    }
    virtual DWORD ApiGetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh) const
    {
        return ::GetFileSize(hFile, lpFileSizeHigh);
    }
    virtual DWORD ApiSetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod) const
    {
        return ::SetFilePointer(hFile, lDistanceToMove, lpDistanceToMoveHigh, dwMoveMethod);
    }
    virtual BOOL ApiReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped) const
    {
        return ::ReadFile(hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped);
    }
    virtual BOOL ApiSetFileTime(HANDLE hFile, CONST ::FILETIME *lpCreationTime, CONST ::FILETIME *lpLastAccessTime, CONST ::FILETIME *lpLastWriteTime)
    {
        return ::SetFileTime(hFile, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
    }
    virtual BOOL ApiSetEndOfFile(HANDLE hFile)
    {
        return ::SetEndOfFile(hFile);
    }
    virtual BOOL ApiWriteFile(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped)
    {
        return ::WriteFile(hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped);
    }
 
    #endif // _TnbDOXYGEN
 
private:
    mutable CHandleHandle   m_hhFile;       
    CStr                    m_strName;      
    bool                    m_boCanWrite;   
    DWORD                   m_attributes;   
};
 
 
 
class CFileReader : public IReader, public CAbstractFile
{
    DEFSUPER(IReader);
    typedef CAbstractFile _base;
public:
 
    CFileReader(void) : _base() 
    {
    }
 
    virtual void Close(void)
    {
        _base::Close();
    }
 
    bool Open(LPCTSTR lpszName, bool boIsShare = true, bool boDummy = false)
    {
        return _base::OpenOnMode(lpszName, _base::READ, boIsShare);
    }
 
    virtual LPCTSTR GetOpenName(void) const
    {
        return _base::GetOpenName();
    }
 
    virtual bool CanRead(void) const
    {
        return _base::CanRead();
    }
 
    virtual LONGLONG Seek(LONGLONG llOffset, ESeekMode eSeek = TOP) const
    {
        return _base::Seek(llOffset, eSeek);
    }
 
    virtual LONGLONG GetSize(void) const
    {
        return _base::GetSize();
    }
 
    virtual size_t Read(size_t size, LPVOID _P) const
    {
        return _base::Read(size, _P);
    }
 
    static bool ReadAll(CByteVector& _content, LPCTSTR lpszFileName, CFileReader& fr = CFileReader())
    {
        if ( fr.Open(lpszFileName) )
        {
            try
            {
                _content = fr.ReadInto();
                return true;
            }
            catch ( ... )
            {
            }
        }
        return false;
    }
};
 
 
 
class CFileWriter : public IWriter, public CAbstractFile
{
    DEFSUPER(IWriter);
    typedef CAbstractFile _base;
public:
 
    CFileWriter(void) : _base()
    {
    }
 
    virtual void Close(void)
    {
        _base::Close();
    }
 
    bool New(LPCTSTR lpszName, bool boIsShare = true)
    {
        return _base::OpenOnMode(lpszName, _base::CREATE, boIsShare);
    }
 
    bool Open(LPCTSTR lpszName, bool boIsShare = true, bool boIsBottom = true)
    {
        bool r =_base::OpenOnMode(lpszName, _base::ACCESS, boIsShare);
        if ( r && boIsBottom )
        {
            Seek(0, END);
        }
        return r;
    }
 
    virtual LPCTSTR GetOpenName(void) const
    {
        return _base::GetOpenName();
    }
 
    virtual bool CanRead(void) const
    {
        return _base::CanRead();
    }
 
    virtual bool CanWrite(void) const
    {
        return _base::CanWrite();
    }
 
    virtual LONGLONG Seek(LONGLONG llOffset, ESeekMode eSeek = TOP) const
    {
        return _base::Seek(llOffset, eSeek);
    }
 
    virtual LONGLONG GetSize(void) const
    {
        return _base::GetSize();
    }
 
    virtual size_t Read(size_t size, LPVOID _P) const
    {
        return _base::Read(size, _P);
    }
 
    void SetTime(const CFileTimeEx& timeCreation, const CFileTimeEx& timeLastAccess, const CFileTimeEx& timeLastWrite)
    {
        BOOL r = ApiSetFileTime(GetHandle(), &timeCreation, &timeLastAccess, &timeLastWrite);
        if ( ! r )
        { 
            throw CWriteFailureException(::GetLastError());
        }
    }
 
    virtual void SetEnd(void)
    {
        if ( ! ApiSetEndOfFile(GetHandle()) )
        {
            throw CWriteFailureException(::GetLastError()); 
        }
    }
 
    virtual void Write(size_t size, LPCVOID P)
    {
        if ( size >= ULONG_MAX )
        {
            throw CWriteFailureException(ERROR_BAD_LENGTH);
        }
        DWORD dwWrite;
        bool boRc = !! ApiWriteFile(GetHandle(), P, ToDword(size), &dwWrite, NULL);
        DWORD dwError = boRc ? 0 : ::GetLastError();
        if ( ! boRc || size != dwWrite )
        {
            throw CWriteFailureException(dwError);
        }
    }
 
    static bool NewFile(LPCTSTR lpszFileName, size_t size, LPCVOID P, CFileWriter& fw = CFileWriter())
    {
        if ( fw.New(lpszFileName, false) )
        {
            try
            {
                fw.Write(size, P);
                return true;
            }
            catch ( ... )
            {
            }
        }
        return false;
    }
 
    static bool AddFile(LPCTSTR lpszFileName, size_t size, LPCVOID P, CFileWriter& fw = CFileWriter())
    {
        if ( fw.Open(lpszFileName, false, true/*bottom*/) )
        {
            try
            {
                fw.Write(size, P);
                return true;
            }
            catch ( ... )
            {
            }
        }
        return false;
    }
};
 
 
 
inline void SaveCollection(IWriter& wr, LPCTSTR lpszHead, const ISequenceCollectionT<BYTE>& c)
{
    //- Head書込み
    CAscii asc = lpszHead;
    size_t dwLen = asc.GetLength() + 1;
    wr.Write(sizeof(DWORD), &dwLen);
    wr.Write(sizeof(DWORD), &dwLen);
    wr.Write(dwLen, LPCSTR(asc));
    //- SUM計算
    size_t size = c.GetSize();
    WORD wSum = 0;
    const BYTE* B = c.ReferBuffer();
    for ( size_t i = 0; i < size; i++ )
    {
        wSum = static_cast<WORD>(wSum + *B++);
    }
    //- 書込み
    wr.Write(sizeof(size_t), &size);
    wr.Write(size, c.ReferBuffer());
    wr.Write(sizeof(WORD), &wSum);
}
 
 
 
inline void SaveCollection(LPCTSTR lpszFile, LPCTSTR lpszHead, const ISequenceCollectionT<BYTE>& c)
{
    CFileWriter fw;
    if ( ! fw.New(lpszFile, false) )
    {
        throw COpenFailureException(::GetLastError());
    }
    SaveCollection(fw, lpszHead, c);
}
 
 
 
inline void LoadCollection(const IReader& rr, LPCTSTR lpszHead, CVectorT<BYTE>& _vb)
{
    //- Head読み込み
    {
        CAscii asc;
        DWORD dwLen1;
        rr.ReadExactly(sizeof(DWORD), &dwLen1);
        DWORD dwLen2;
        rr.ReadExactly(sizeof(DWORD), &dwLen2);
        if ( dwLen1 != dwLen2 )
        {
            throw CNotSupportException(); 
        }
        rr.ReadExactly(dwLen1, asc.GetBuffer(dwLen1));
        asc.ReleaseBuffer();
        if ( ! asc.IsEqual(CAscii(lpszHead)) )
        {
            throw CNotSupportException(); 
        }
    }
    //
    size_t size;
    rr.ReadExactly(sizeof(size_t), &size);
    rr.ReadExactly(size, _vb.GetBuffer(size));
    _vb.ReferBuffer();
    WORD wFileSum;
    rr.ReadExactly(sizeof(WORD), &wFileSum);
    //- SUM計算
    WORD wSum = 0;
    const BYTE* B = _vb.ReferBuffer();
    for ( size_t i = 0; i < size; i++ )
    {
        wSum = static_cast<WORD>(wSum + *B++);
    }
    if ( wFileSum != wSum )
    {
        throw CNoSuchTypeException(); 
    }
}
 
 
 
inline void LoadCollection(LPCTSTR lpszFile, LPCTSTR lpszHead, CVectorT<BYTE>& _vb)
{
    CFileReader fr;
    if ( ! fr.Open(lpszFile) )
    {
        throw COpenFailureException(::GetLastError());
    }
    LoadCollection(fr, lpszHead, _vb);
}
 
 
 
}; // TNB