BufFile.h

Go to the documentation of this file.

// Created by Vit Kovalcik (vit@pastel.cz)

// Buffered file (for sequential access)
// Supports ASCII and simple variant of UTF-16 files (double byte characters only)

#ifndef BUFFILE_H
#define BUFFILE_H

#include <vrecko/Export>

#include <osg/Vec3>

#include "DynamicArray.h"
#include <tchar.h>


#define BUFFILE_INITBUFFERSIZE  65536
#define BUFFILE_MINBUFFERSIZE   16384

#define BUFFILE_MAXBUFFILESIZE  65536
    // Kdyz se otevre soubor a zjisti se, ze je mensi nez tato konstanta
    // tak se vytvori mensi buffer

#ifndef INVALID_SET_FILE_POINTER
    #define INVALID_SET_FILE_POINTER ((DWORD)-1)
#endif


#define BUFFILE_BEHVF_UNICODE_START_HIDE    0x00000002
#define BUFFILE_BEHVF_LOADFILETOMEM         0x00000001
    // Nacte na zacatku cely soubor do pameti, soubor zavre a dale se s nim uz nepracuje.
    // Tento flag ma efekt jen pri otevreni souboru funkci 
    //      bool Init (LPCSTR lpFileName);
    // Druha funkce
    //      bool Init (HANDLE hFile, bool bCallSPF);
    // tento flag zrusi


namespace vrecko {


bool FileExists (const _TCHAR *pFileName);


class VRECKO_EXPORT BufferedFile {
public:
    BufferedFile (void);
    ~BufferedFile (void);

    bool setBehaviour (DWORD dwBehvFlags);
        // kombinace BUFFILE_BEHVF_*
        // Tuto funkci lze zavolat jen pred funkci Init.

    bool init (_TCHAR* lpFileName);

    bool init (HANDLE hFile, bool bCallSPF);
        // hFile is handle to the opened file
        // bCallSFP = true => call setFilePointer in destructor
        // to set file pointer to the right position

    HANDLE getHandle() { return hFile; };

    LPBYTE lpBuffer;
    DWORD dwPos;
    inline DWORD getFilePos (void) const;
    void close (void);
        // After this function, the behaviour of other functions is
        // undefined until calling Init.

    bool setFilePos (DWORD dwNewFilePos);
        // true = OK, false = failed
        // Pokud je specifikovan flag BUFFILE_BEHVF_UNICODE_START_HIDE, tak
        // se automaticky zmeni pozice mensi nez [dwZeroPos] na [dwZeroPos].
    inline DWORD getMaxPos (void) const;
    inline DWORD getBufSize (void) const;
    inline DWORD getFileSize (void) const;
    void setBufSize (DWORD dwNewSize);

    bool preReadBytes (DWORD dwNumOfBytes);
        // this function makes sure, that there are at least <dwNumOfBytes> bytes in buffer

    inline bool readBytes (LPVOID lpDest, DWORD dwBytesToRead);
        // This function will fail, if it doesn't read all the data.

    inline bool readBytes (LPVOID lpDest, DWORD dwBytesToRead, LPDWORD lpdwBytesRead) {
/*      Optimization, which doesn't speed things up very much, so it was turned off

        if (dwMaxPos - dwPos >= dwBytesToRead) {
            memcpy (lpDest, (LPBYTE)lpBuffer + dwPos, dwBytesToRead);
            if (lpdwBytesRead)
                *lpdwBytesRead = dwBytesToRead;
            dwPos += dwBytesToRead;
            return true;
        } else*/
            return readBytesCore(lpDest, dwBytesToRead, lpdwBytesRead);
    }
        // ReadBytes cannot 'fail', but can read zero bytes.
        // This function will return true, if it read exactly so many bytes as you specified
        // or will return false, if it read less bytes (due to eof or error).
        // lpdwBytesRead can be NULL in case you don't need this value

    inline BYTE readByte (void);
        // Reads byte WITHOUT error checking

    bool readWCharTrans (WCHAR *wChar);
        // Supports ASCII and UTF-16. (Automatic conversion)

    inline bool readBool (bool *pData) { return readBytes (pData, 1); };
    inline bool readByte (BYTE *pData) { return readBytes (pData, 1); };
    inline bool readWORD (WORD *pData) { return readBytes (pData, 2); };
    inline bool readDWORD (DWORD *pData)  { return readBytes (pData, 4); };
    inline bool readLONG (LONG *pData)  { return readBytes (pData, sizeof (LONG)); };
    inline bool readFloat (float *pData)  { return readBytes (pData, 4); };
    inline bool readVec3f (osg::Vec3f *v) { return readBytes(&v->x(), 4) && readBytes(&v->y(), 4) && readBytes(&v->z(), 4); };
    inline bool readInt (int *pData)  { return readBytes (pData, 4); };
    inline bool readPOINT (POINT *pData)  { return readBytes (pData, sizeof (POINT)); };
    inline bool readInt64 (__int64 *pData)  { return readBytes (pData, 8); };
    inline bool readRECT (RECT *pData)  { return readBytes (pData, sizeof (RECT)); };
    inline bool readStr (CHAR *pData);

#ifdef UNICODE
    inline bool tReadLine(_TCHAR* tBuffer, PDWORD pdwCharSize) { return readLineW(tBuffer, pdwCharSize); }
#else
    inline bool tReadLine(_TCHAR* tBuffer, PDWORD pdwCharSize) { return readLine(tBuffer, pdwCharSize); }
#endif


    bool readLine (PSTR pBuffer, PDWORD pdwCharSize);
        // Reads line to CHAR buffer;
        // Is is assumed, that file is in ASCII (not UTF-16)
        // dwSize is size of buffer (in characters = 2 bytes) at the start and number of characters read
        // after the function ends.
        // pdwCharSize includes terminating character
        // If dwSize is not enough to hold whole line, function will return false.

    bool readLineW (PWSTR pBuffer, PDWORD pdwCharSize);
        // Reads line to WCHAR buffer.
        // dwSize is size of buffer (in characters = 2 bytes) at the start and number of characters read
        // after the function ends.
        // pdwCharSize includes terminating character
        // If dwSize is not enough to hold whole line, function will return false.

    inline bool isEOF (void) { return (getFilePos () >= getFileSize ()); }

protected:
    HANDLE hFile;

    DWORD dwFilePos;
    DWORD dwMaxPos;
    DWORD dwBufSize;
    DWORD dwFileSize;

    bool bCloseFile;
        // Should the file be closed in destructor?
    bool bCallSFP;

    DWORD dwBehvFlags; // kombinace BUFFILE_BEHVF_*

    bool bFileIsUTF;
        // je soubor ve formatu UTF? (jinak je normalne v ASCII)
    bool bReversedWChar;
        // jsou byte ve WCHARu v souboru v obracenem poradi?

    DWORD dwZeroPos;
        // Pouziva se pouze, kdyz je specifikovan flag BUFFILE_BEHVF_UNICODE_START_HIDE.
        // Nulova pozice. UNICODE soubory tady budou mit "2",
        // protoze v prvnich dvou bytech jsou ridici znaky, ktere nechceme cist.

    bool readBytesCore(LPVOID lpDest, DWORD dwBytesToRead, LPDWORD lpdwBytesRead);

    void UNICODECheck (void);
};


class BufferedFileWrite {
public:
    BufferedFileWrite (void);
    ~BufferedFileWrite (void);

    bool init (TCHAR *lpFileName);

    HANDLE getHandle() { return hFile; };

    inline bool write (LPVOID lpBuffer, DWORD dwSize); // sadly this has to be inline due to compilation errors (bugs?) in PointShellGeneric_Object_Data<_NodeType> template

    inline bool writeByte (BYTE bData) { return write (&bData, 1); };
    inline bool writeBool (bool bData) { return write (&bData, 1); };
    inline bool writeWORD (WORD wData) { return write (&wData, 2); };
    inline bool writeLONG (LONG lData) { return write (&lData, sizeof (LONG)); };
    inline bool writeDWORD (DWORD dwData) { return write (&dwData, 4); };
    inline bool writeFloat (float fData) { return write (&fData, 4); };
    inline bool writeVec3f (osg::Vec3f *v) { return write(&v->x(), 4) && write(&v->y(), 4) && write(&v->z(), 4); };
    inline bool writeInt (int iData) { return write (&iData, 4); };
    inline bool writePOINT (POINT *pnt) { return write (pnt, sizeof (POINT)); };
    inline bool writeInt64 (__int64 iData) { return write (&iData, 8); };
    inline bool writeRECT (RECT *rData) { return write (&rData, sizeof (RECT)); };
    inline bool writeStr (PSTR pData) { return write (pData, (DWORD)strlen (pData) + 1); };
    bool writeFormattedString (TCHAR *pFormat, ...);

    bool flush (void);
    bool close (void);

protected:
    HANDLE hFile;
    DynamicArray<BYTE> buffer;

    DWORD dwBufMaxSize;
};


inline DWORD BufferedFile::getFilePos (void) const
{
    return dwFilePos + dwPos;
}


inline DWORD BufferedFile::getMaxPos (void) const
{
    return dwMaxPos;
}


inline DWORD BufferedFile::getBufSize (void) const
{
    return dwBufSize;
}


inline DWORD BufferedFile::getFileSize (void) const
{
    return dwFileSize;
}


inline bool BufferedFile::readBytes (LPVOID lpDest, DWORD dwBytesToRead)
{
    DWORD dw;
    if (!readBytes (lpDest, dwBytesToRead, &dw))
        return false;
    return (dw == dwBytesToRead);
}


inline BYTE BufferedFile::readByte (void)
{
    if (dwPos >= dwMaxPos) {
        if (!preReadBytes (1))
            return 0x00;

        if (dwMaxPos)
            return lpBuffer[dwPos++];
        return 0x00;
    }
    return lpBuffer[dwPos++];
}


bool BufferedFile::readStr (CHAR *pData)
{
    while (readByte ((PBYTE)pData)) {
        if (0x00 == *pData)
            return true;
        pData++;
    }

    return false;
}


bool BufferedFileWrite::write (LPVOID lpBuffer, DWORD dwSize)
{
    if (!dwSize)
        return true;

    while (dwSize) {
        DWORD dwTmp = dwSize;
        if (dwSize > (dwBufMaxSize - buffer.dwNum))
            dwTmp = (dwBufMaxSize - buffer.dwNum);

        memcpy (buffer.lpBuffer + buffer.dwNum, lpBuffer, dwTmp);
        buffer.dwNum += dwTmp;
        dwSize -= dwTmp;
        lpBuffer = (LPVOID)((LPBYTE)lpBuffer + dwTmp);

        if (buffer.dwNum >= dwBufMaxSize) {
            DWORD dwWritten;
            if (FALSE == ::WriteFile (hFile, buffer.lpBuffer, buffer.dwNum, &dwWritten, NULL))
                return false;
            buffer.dwNum = 0;
        }
    }
        
    return true;
}


}; // namespace vrecko


#endif // BUFFILE_H