XFile.h

Go to the documentation of this file.

//! @file XFile.h
//! @brief CXFile is the base class for different kind of file (CXStdioFile, CXMemFile...)
//!
//////////////////////////////////////////////////////////////////////
 
#if !defined(CXFILE_INCLUDE_H)
#define CXFILE_INCLUDE_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
BEGIN_MOOTOOLS_NAMESPACE
 
    // Memory callback handlers
    typedef enum 
    {
        OPEN_FILE = 1,
        CLOSE_FILE = 1,
    } fileEventType;
 
    typedef void (*fileCallbackEvent)(xFileHandle fileHandle, fileEventType type);
 
    typedef struct XFileCallback
    {
        fileCallbackEvent callback;
 
        XFileCallback()
        {
            callback = NULL;
        }
    } XFileCallback;
 
    // Use this file callback object to receive notification on open / close files
    extern XFileCallback fileCallbackNotify;
    
    ////////////////////////////////////////////////////////////////////////////////////////////////
    //! @class CXFile
    //! @brief CXFile is the base class for CXStdioFile, CXStdioFileEx, CXMemFile
    class CXFileException;
    class DLL_TOOLSFUNCTION CXFile : public CXObject
    {
        friend CXArchive;
 
        DECLARE_DYNAMIC_XOBJECT(CXFile)
 
    public:
        //! @enum OpenFlags
        //! @brief Specify the open mode for file.
        //! @details By default an open file is no inherited by child processes
        typedef enum XEnumType( unsigned int)
        {
            modeRead =          0x00000,
            modeWrite =         0x00001,
            modeReadWrite =     0x00002,
            readFlags =         modeRead|modeWrite|modeReadWrite,
 
            shareExclusive =    0x00010, //!< Default mode, if nothing specified. Deny file being opened for reading/writing to other process
            shareDenyWrite =    0x00020, //!< Deny file being opened for writing to other process
            shareDenyRead =     0x00030, //!< Deny file being opened for reading to other process
            shareDenyNone =     0x00040, //!< file could be opened by other process
            shareFlags    =     shareExclusive| shareDenyWrite|shareDenyRead|shareDenyNone,
 
            typeUnicode =       0x00400, //!< used in derived classes (e.g. CXStdioFile) only
            typeUtf8    =       0x00800, //!< Windows only, as it is always the case under MacOS / Linux. used in derived classes (e.g. CXStdioFile) only
 
            modeCreate =        0x01000, //!< Existing file is replaced, unless modeNoTruncate is used
            modeNoTruncate =    0x02000,
            typeText =          0x04000, //!< CXFile are always binary, intended to be used in derived classes (e.g. CXStdioFile) only
            typeBinary =        0x08000, //!< CXFile are always binary, intended to be used in derived classes (e.g. CXStdioFile) only
 
            noException =       0x100000, //!< By default CXFile send exception. This flag turn off exception.
 
            specificFlags =     0x10000000, //!< Override class mode base flags
        } OpenFlags;
 
 
        //! @enum OpenFlags
        //! @brief Specify the open mode for file.
        //! @details By default an open file is no inherited by child processes
        typedef enum SeekPosition XEnumType( unsigned int)
        {
            begin = 0x00,
            current = 0x01,
            end = 0x02
        } SeekPosition;
 
        // Constructors
        CXFile(bool allowException = true);
        CXFile(xFileHandle hFile, bool allowException = true);
        CXFile(LPCTSTR lpszFileName, unsigned int openFlags);
#ifdef MOOTOOLS_MFC_PRODUCT_BUILD
        CXFile(CFile *pfile, bool allowException = true); //!< allowException = false then no exception is send by the class which return false instead
#endif
 
        // Attributes
        virtual fileuint GetPosition() const;
        virtual CXString GetFileName() const;
        virtual CXString GetFilePath() const;
        virtual void SetFilePath(LPCTSTR lpszNewName);
 
        // Operations
        virtual bool Open(LPCTSTR lpszFileName, unsigned int openMode, CXFileException *pError = NULL); //!< Open does not send any exception but can fill CXFileException with the appropriate cause of the failing.
 
        fileuint SeekToEnd();
        void SeekToBegin();
 
        // Overridables
        virtual fileuint Seek(longint lOff, CXFile::SeekPosition nFrom);
        virtual bool SetLength(fileuint newlength);
        virtual fileuint GetLength() const;
 
        virtual unsigned int Read(void* buffer, unsigned int maxByteToRead);
        virtual void Write(const void* buffer, unsigned int byteToWrite);
 
        virtual void Abort();
        virtual void Flush();
        virtual void Close();
 
        // Implementation
    public:
        virtual ~CXFile();
 
#ifdef _DEBUG
        virtual void Dump() const;
#endif
 
    protected:
        typedef enum XEnumType( unsigned int)
        {
            bufferRead,
            bufferWrite,
            bufferCommit,
            bufferCheck
        } BufferCommandType;
 
        typedef enum XEnumType( unsigned int)
        {
            bufferNone = 0x00,
            bufferDirect = 0x01
        } BufferFlags;
 
        void Init(xFileHandle hFile);
        virtual SIZET BufferCommand(unsigned int bufferCommand, SIZET nCount = 0, unsigned char **ppBufStart = NULL, unsigned char **ppBufMax = NULL);
 
        xFileHandle fileHandle;
        bool autoClose, sendException;
        CXString filename;
    };
 
END_MOOTOOLS_NAMESPACE
 
#include "xfileoperation.h"
 
#endif // !defined(CXFILE_INCLUDE_H)