IoFile.h

Go to the documentation of this file.

//! @file IoFile.h
//! @brief CXStringT is a template class for handling unicode, utf8 or ansi strings
//! 
////////////////////////////////////////////////////////////////////////////////////////
#ifndef IOFILE_H
#define IOFILE_H
 
#include "StdioFileEx.h"
#include "FileInfo.h"
 
BEGIN_MOOTOOLS_NAMESPACE
 
//! @enum IOFILE_FLAGS
//! Specify the way an IoFile is opened
typedef enum IOFILE_FLAGS
{
    IOFILE_NONE = 0x00,
    IOFILE_SILENT_MODE = 0x01,
    IOFILE_MEMORY_FILE = 0x02,
    IOFILE_ALLOW_EXCEPTIONS = 0x04,
    IOFILE_TEXT_MODE = 0x08, //!< When reading, this will also automatically process file as unicode file if a BOM is present. When writing, the file is output as non unicode file
    IOFILE_UNICODE_TEXT_MODE = 0x10, //!< When reading this acts as IOFILE_TEXT_MODE. When writing must be specified to write in Unicode mode
    IOFILE_UTF8_TEXT_MODE = 0x20, //!< Combine with IOFILE_TEXT_MODE to force UTF8. Windows only.
 
    // Internal flags
    IOFILE_IS_READING = 0x1000, // Flag automatically set after OpenFile call (load = true or false)
} IOFILE_FLAGS;
 
DLL_TOOLSFUNCTION void ReverseBuffer(void *, int);
 
/*
 * Macros
 */
#define END_OF_FILE CXFile::end
#define BEGIN_OF_FILE CXFile::begin
#define CURRENT_POS_OF_FILE CXFile::current
 
class CXWaitCursor;
//! @class IoFile
//! @brief IoFile is a class for reading binary or ascii file using internally a CStdioFileEx.
//! @details IoFile can also write data to a memory block using internally a CCustomMemFile.
//! 
//! IoFile can be used to as a file finder using internally a CXFileFind\n
class DLL_TOOLSFUNCTION IoFile
{
    private:
        unsigned int flags;
        
        CStdioFileEx *pFile; // Could be ever been open in text or binary mode
        CCustomMemFile *pMemFile;
        CXFile *pCurrentFile;
        CXString filename;
 
        // File Finder
        CXFileFind *fileFinder;
        bool fileFindContinue;
        CXString extension;
 
        // UI
        CXWaitCursor *wait;
 
    public:
        IoFile();
        IoFile(unsigned int ioFileFlags);
        IoFile(bool silentMode, unsigned int ioFileFlags);
        void Init(unsigned int ioFileFlags);
        virtual ~IoFile();
        void DeleteFiles();
        bool GetErrorMessage(CXString& error, CXException* e = NULL);
        void ReportError(CXException *e = NULL);
        FILE *GetFileStream(void);
        CXFile *GetCFile(void) { return pCurrentFile; }
        
        CStdioFileEx *GetTextFile(void)
        {
            return pFile;
        }
 
        CXString GetFileName(void) { return filename; }
        CXString GetFilePath();
        CXString GetName();
 
        bool OpenFile(const CXString& name, bool load, CXFileException* pException = NULL);
        void CloseFile(bool abort = false);
        void CloseAndDeleteFile(bool abort = false);
 
        bool FindFileOpen(const CXString& name, const CXString& extension = CXString(), FILENAME_TYPE qualifyType = FILENAME_UNKNOWN);
        bool FindFileNext(CXString&, bool& matchExtension, bool noPath = false);
        void FindFileClose();
        CXFileFind *GetFileFinder() {return fileFinder; }
 
        inline bool IsWriting() const
        {
            return !(flags & IOFILE_IS_READING);
        }
 
        inline bool IsBinaryMode() const
        {
            return !(flags & IOFILE_TEXT_MODE);
        }
 
        unsigned int FileBufferRead(void *ptr, unsigned int sz) // Read atmost sz byte. return 0 means eof
        {
            sz = pCurrentFile->Read(ptr, sz);
 
            if ((flags & IOFILE_ALLOW_EXCEPTIONS) && sz == 0)
                XThrowExceptionWithArgs(CXFileException, CXFileException::endOfFile, filename);
 
            return sz;
        }
 
        bool FileRead(void *ptr, unsigned int sz) // Read exactly sz byte or return false
        {
            if (pCurrentFile->Read(ptr, sz) == sz)
                return true;
 
            if (flags & IOFILE_ALLOW_EXCEPTIONS)
                XThrowExceptionWithArgs(CXFileException,  CXFileException::endOfFile, filename);
 
            return false;
        }
 
        void WriteFloat(float value)
        {
            pCurrentFile->Write(&value, sizeof(float));
        }
 
        void WriteInt(int value)
        {
            pCurrentFile->Write(&value, sizeof(int));
        }
 
        //void WriteLong(long value)
        //{
        //  pCurrentFile->Write(&value, sizeof(long));
        //}
 
        //void WriteULong(unsigned long value)
        //{
        //  pCurrentFile->Write(&value, sizeof(unsigned long));
        //}
 
        void WriteUInt(unsigned int value)
        {
            pCurrentFile->Write(&value, sizeof(unsigned int));
        }
 
        void WriteShort(short value)
        {
            pCurrentFile->Write(&value, sizeof(short));
        }
 
        void WriteUShort(unsigned short value)
        {
            pCurrentFile->Write(&value, sizeof(unsigned short));
        }
 
        void WriteChar(char value)
        {
            pCurrentFile->Write(&value, sizeof(char));
        }
 
        void WriteUChar(unsigned char value)
        {
            pCurrentFile->Write(&value, sizeof(unsigned char));
        }
 
        void FileWrite(const void *ptr, unsigned int sz)
        {
            pCurrentFile->Write(ptr, sz);
        }
 
        void FileReverseWrite(void *ptr, unsigned int sz)
        {
            unsigned char *buf = xAllocateArray(unsigned char, sz);
 
            memcpy(buf, ptr, sz);
            ReverseBuffer(buf, sz);
 
            pCurrentFile->Write(buf, sz);
 
            xDeallocateArray(buf);
        }
 
        void FileReverseWrite(void *ptr, unsigned int elementNbr, unsigned int elementSize)
        {
            unsigned char *buf = xAllocateArray(unsigned char, elementNbr*elementSize);
 
            memcpy(buf, ptr, elementNbr*elementSize);
 
            for (unsigned int i = 0; i<elementNbr; i++)
                ReverseBuffer((void *)(buf+i*elementSize), elementSize);
 
            pCurrentFile->Write(buf, elementNbr*elementSize);
 
            xDeallocateArray(buf);
        }
 
        void Flush()
        {
            // Flush is needed only for writing operation
            // Flushing on an opened file erase the buffer: this causes data be missed while reading...
            if (IsWriting())
                pCurrentFile->Flush();
        }
 
        bool FileSeek(longint offset, CXFile::SeekPosition type)
        {
            Flush();
            pCurrentFile->Seek(offset, type);
 
            // return an exception if bad...
            return 1;
        }
 
        fileuint FileGetPosition()
        {
            Flush();
            return pCurrentFile->GetPosition();
        }
 
        fileuint FileGetLength()
        {
            Flush();
            return pCurrentFile->GetLength();
        }
 
        bool FileReverseRead(void *ptr, unsigned int sz)
        {
            if (pCurrentFile->Read(ptr, sz) != sz)
            {
                if (flags & IOFILE_ALLOW_EXCEPTIONS)
                    XThrowExceptionWithArgs(CXFileException,  CXFileException::endOfFile, filename);
 
                return false;
            }
 
            ReverseBuffer(ptr, sz);
 
            return true;
        }
 
        bool FileReverseRead(void *ptr, unsigned int elementNbr, unsigned int elementSize)
        {
            if (pCurrentFile->Read(ptr, elementNbr*elementSize) != elementNbr*elementSize)
            {
                if (flags & IOFILE_ALLOW_EXCEPTIONS)
                    XThrowExceptionWithArgs(CXFileException,  CXFileException::endOfFile, filename);
 
                return false;
            }
 
            for (unsigned int i = 0; i<elementNbr; i++)
                ReverseBuffer((void *)((unsigned char *)ptr+i*elementSize), elementSize);
 
            return true;
        }
 
        bool ReadString(CXString& rString)
        {
            XASSERT(!(flags & IOFILE_MEMORY_FILE));
            if (pFile->ReadString(rString))
                return true;
 
            if (flags & IOFILE_ALLOW_EXCEPTIONS)
                XThrowExceptionWithArgs(CXFileException,  CXFileException::endOfFile, filename);
 
            return false;
        }
 
        void WriteString(LPCTSTR wString)
        {
            XASSERT(!(flags & IOFILE_MEMORY_FILE));
            pFile->WriteString(wString);
        }
};
 
END_MOOTOOLS_NAMESPACE
 
#endif /* IOFILE_H */