File.h

Go to the documentation of this file.

/*  File.h - standard Win32 file functions wrapper
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_File_h
#define OW32_File_h

#include <OW32/XHANDLE.h>

namespace OW32
{

class CFile
{
public:
    CFile() {}

    CFile(HANDLE hFile) :
        m_Handle(hFile)
    {
    }

    HANDLE Detach() 
    {
        return m_Handle.Detach();
    }

    void Attach(HANDLE h)
    {
        m_Handle = h;
    }

    operator HANDLE() const { return m_Handle; }

    HANDLE* operator&() { return &m_Handle; }

    HANDLE operator=(HANDLE h) { m_Handle = h; return m_Handle; }

    BOOL CreateA(LPCSTR lpFileName, DWORD dwDesiredAccess = 0, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwCreationDisposition = 0, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        m_Handle = ::CreateFileA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
                                dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
        return (m_Handle != INVALID_HANDLE_VALUE);
    }
    
    BOOL CreateW(LPCWSTR lpFileName, DWORD dwDesiredAccess = 0, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwCreationDisposition = 0, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        m_Handle = ::CreateFileW(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
                                dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
        return (m_Handle != INVALID_HANDLE_VALUE);
    }

    BOOL Create(LPCTSTR lpFileName, DWORD dwDesiredAccess = 0, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwCreationDisposition = 0, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        m_Handle = ::CreateFile(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes,
                                dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
        return (m_Handle != INVALID_HANDLE_VALUE);
    }

    void Close()
    {
        m_Handle.Close();
    }

    BOOL CreateAlwaysA(LPCSTR lpFileName, DWORD dwDesiredAccess = GENERIC_WRITE|GENERIC_READ, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        return CreateA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, CREATE_ALWAYS, 
                      dwFlagsAndAttributes, hTemplateFile);
    }

    BOOL CreateAlwaysW(LPCWSTR lpFileName, DWORD dwDesiredAccess = GENERIC_WRITE|GENERIC_READ, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        return CreateW(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, CREATE_ALWAYS, 
                      dwFlagsAndAttributes, hTemplateFile);
    }

    BOOL CreateAlways(LPCTSTR lpFileName, DWORD dwDesiredAccess = GENERIC_WRITE|GENERIC_READ, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        return Create(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, CREATE_ALWAYS, 
                      dwFlagsAndAttributes, hTemplateFile);
    }

    BOOL OpenExistingA(LPCSTR lpFileName, DWORD dwDesiredAccess = GENERIC_WRITE|GENERIC_READ, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        return CreateA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, OPEN_EXISTING, 
                      dwFlagsAndAttributes, hTemplateFile);
    }

    BOOL OpenExistingW(LPCWSTR lpFileName, DWORD dwDesiredAccess = GENERIC_WRITE|GENERIC_READ, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        return CreateW(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, OPEN_EXISTING, 
                      dwFlagsAndAttributes, hTemplateFile);
    }

    BOOL OpenExisting(LPCTSTR lpFileName, DWORD dwDesiredAccess = GENERIC_WRITE|GENERIC_READ, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        return Create(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, OPEN_EXISTING, 
                      dwFlagsAndAttributes, hTemplateFile);
    }

    BOOL OpenAlwaysA(LPCSTR lpFileName, DWORD dwDesiredAccess = GENERIC_WRITE|GENERIC_READ, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        return CreateA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, OPEN_ALWAYS, 
                      dwFlagsAndAttributes, hTemplateFile);
    }
    
    BOOL OpenAlwaysW(LPCWSTR lpFileName, DWORD dwDesiredAccess = GENERIC_WRITE|GENERIC_READ, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        return CreateW(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, OPEN_ALWAYS, 
                      dwFlagsAndAttributes, hTemplateFile);
    }

    BOOL OpenAlways(LPCTSTR lpFileName, DWORD dwDesiredAccess = GENERIC_WRITE|GENERIC_READ, DWORD dwShareMode = 0, 
              LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL, DWORD dwFlagsAndAttributes = 0, 
              HANDLE hTemplateFile = NULL)
    {
        return Create(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, OPEN_ALWAYS, 
                      dwFlagsAndAttributes, hTemplateFile);
    }

    BOOL Read(LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead=NULL, LPOVERLAPPED lpOverlapped=NULL)
    {
        DWORD dwNumberOfBytesRead;
        if (lpNumberOfBytesRead == NULL)
            lpNumberOfBytesRead = &dwNumberOfBytesRead;
        return ::ReadFile(m_Handle, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped);
    }
    
    BOOL Write(LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten=NULL, LPOVERLAPPED lpOverlapped=NULL)
    {
        DWORD dwNumberOfBytesWritten;
        if (lpNumberOfBytesWritten == NULL)
            lpNumberOfBytesWritten = &dwNumberOfBytesWritten;
        return ::WriteFile(m_Handle, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped);
    }

    BOOL GetSize(PULARGE_INTEGER pSize)
    {
        pSize->LowPart = ::GetFileSize(m_Handle, &pSize->HighPart);
        if (pSize->LowPart == INVALID_FILE_SIZE && GetLastError() != ERROR_SUCCESS)
            return FALSE;
        return TRUE;
    }

#if (_WIN32_WINNT >= 0x0500)

    BOOL GetSizeEx(PLARGE_INTEGER pSize)
    {
        return ::GetFileSizeEx(m_Handle, pSize);
    }

    BOOL SetPointerEx(const LARGE_INTEGER& liDistanceToMove, DWORD dwMoveMethod = FILE_BEGIN, PLARGE_INTEGER lpNewFilePointer = NULL)
    {
        return ::SetFilePointerEx(m_Handle, liDistanceToMove, lpNewFilePointer, dwMoveMethod);
    }

    BOOL SetPointerEx(__int64 i64DistanceToMove, DWORD dwMoveMethod = FILE_BEGIN, PLARGE_INTEGER lpNewFilePointer = NULL)
    {
        LARGE_INTEGER liDistanceToMove;
        liDistanceToMove.QuadPart = i64DistanceToMove;
        return ::SetFilePointerEx(m_Handle, liDistanceToMove, lpNewFilePointer, dwMoveMethod);
    }
#endif

    BOOL SetPointer(const LARGE_INTEGER& liDistanceToMove, DWORD dwMoveMethod = FILE_BEGIN, PLARGE_INTEGER lpNewFilePointer = NULL)
    {
        LONG dwPtrHigh = liDistanceToMove.HighPart;
        DWORD dwPtrLow = ::SetFilePointer(m_Handle, (LONG)liDistanceToMove.LowPart, &dwPtrHigh, dwMoveMethod);
        if (dwPtrLow == INVALID_SET_FILE_POINTER && GetLastError () != ERROR_SUCCESS)
            return FALSE;
        if (lpNewFilePointer)
        {
            lpNewFilePointer->LowPart = dwPtrLow;
            lpNewFilePointer->HighPart = dwPtrHigh;
        }
        return TRUE;
    }

    BOOL SetPointer(__int64 i64DistanceToMove, DWORD dwMoveMethod = FILE_BEGIN, PLARGE_INTEGER lpNewFilePointer = NULL)
    {
        LARGE_INTEGER li;
        li.QuadPart = i64DistanceToMove;
        return SetPointer(li, dwMoveMethod, lpNewFilePointer);
    }

    BOOL SetEnd()
    {
        return ::SetEndOfFile(m_Handle);
    }

    BOOL IsOpen()
    {
        return (m_Handle != INVALID_HANDLE_VALUE && m_Handle != NULL);
    }

    BOOL GetInformation(LPBY_HANDLE_FILE_INFORMATION lpFileInformation)
    {
        return GetFileInformationByHandle(m_Handle, lpFileInformation);
    }

    BOOL FlushBuffers()
    {
        return ::FlushFileBuffers(m_Handle);
    }
    
    BOOL SetTime(const FILETIME *lpCreationTime, const FILETIME *lpLastAccessTime, const FILETIME *lpLastWriteTime)
    {
        return SetFileTime(m_Handle, lpCreationTime, lpLastAccessTime, lpLastWriteTime);
    }

private:
    XHANDLE m_Handle;
    CFile& operator= (const CFile& );
    CFile(const CFile& );
};

}; // namespace OW32

#endif // OW32_File_h

---