GUIResourceFileHandler.h

/*
* Copyright (C) TES Electronic Solutions GmbH,
* All Rights Reserved.
* Contact: info@guiliani.de
*
* This file is part of the Guiliani HMI framework
* for the development of graphical user interfaces on embedded systems.
*/
 
#ifndef GUIRESOURCEFILE_HANDLER__H_
#define GUIRESOURCEFILE_HANDLER__H_
 
#include "eC_Types.h"
#include "eC_TList_doubleLinked.h"
#include "eC_String.h"
 
#include "GUIComponentManager.h"
 
class eC_File;
 
#define GETRESHANDLER CGUIComponentManager::GetInstance().GetResourceFileHandler()
 
 
class CGUIResourceFileHandler
{
    friend class CGUIComponentManager; 
 
public:
    enum FileOpenOrder_t
    {
        RESOURCE_FILE_FIRST, 
        RESOURCE_FILE_LAST 
    };
 
    enum BufferingStrategy_t
    {
        BUFFERING_OFF = 0,  
        BUFFERING_ALWAYS,   
        BUFFERING_DEFAULT   
    };
 
public:
    static void CreateInstance();
 
    static void DeleteInstance();
 
    void DeInit();
 
    eC_File* Open(const eC_String& kPath, const BufferingStrategy_t eBufferingStrategy = BUFFERING_DEFAULT);
 
    eC_Bool Close(eC_File* file);
 
    eC_Bool SetResourceData(const eC_UByte* pubResourceData);
 
    eC_Bool RemoveResourceData(const eC_UByte* pubResourceData);
 
    eC_Bool SetResourceFile(const eC_String& rkResourceFilePath, const eC_Bool& bEmulateROMFile = false);
 
    eC_Bool RemoveResourceFile(const eC_String& rkResourceFilePath);
 
    void UnloadResourceFile();
 
    eC_Bool AddMemoryResource(const eC_String& kResourceName, const eC_UInt uiResourceSize, eC_UByte* pubResourceLocation);
 
    eC_Bool RemoveMemoryResource(const eC_String& kResourceName);
 
    eC_Bool GetFileInformation(const eC_String& kPath, eC_UInt &uiFileSize, const eC_UByte** ppubData);
 
    void SetResourcePathPrefix(const eC_String& kResourcePrefix);
 
    inline const eC_String& GetResourcePathPrefix() const { return m_kResourcePrefix; }
 
    inline void SetFileOpenOrder(const FileOpenOrder_t eFileOpenOrder) { m_eFileOpenOrder = eFileOpenOrder; }
 
    inline void SetDiskBuffering(eC_Bool bBufferFileFromDisk) { m_bBufferFileFromDisk = bBufferFileFromDisk; }
 
    inline void SetHeaderBuffering(eC_Bool bBufferHeader) { m_bBufferHeader = bBufferHeader; }
 
private:
    //struct of resource header
    struct ResourceFileHeader_t
    {
        ResourceFileHeader_t() :
            uiResourceVersion(0),
            uiHeaderLength(0),
            uiFileCnt(0),
            uiFileSize(0),
            uiAlignmentBytes(0),
            uiReserved1(0),
            uiReserved2(0),
            uiReserved3(0)
        {}
 
        eC_UInt uiResourceVersion; 
        eC_UInt uiHeaderLength; 
        eC_UInt uiFileCnt; 
        eC_UInt uiFileSize; 
        eC_UInt uiAlignmentBytes; 
        eC_UInt uiReserved1; 
        eC_UInt uiReserved2; 
        eC_UInt uiReserved3; 
    };
 
    struct ResourceFileInfo_t
    {
        ResourceFileInfo_t() :
            kResourceFileHeader(),
            pkResourceFileHandle(NULL),
            pkResourceFileName(NULL),
            pubResourceData(NULL),
            ubSegmentIndex(0)
        {}
 
        ResourceFileHeader_t kResourceFileHeader;   // header information of resource-file
        eC_File* pkResourceFileHandle;              // file handle to either memory-file or platform-file
        const eC_String* pkResourceFileName;        // name of resource-file if container was loaded
        const eC_UByte* pubResourceData;            // resource-data in memory from statically linked byte-array
        eC_UByte ubSegmentIndex;                    // segment-index of file
    };
 
    // struct to handle memory locations and treat them as files
    // the actual pointer and size of the data is managed by eC_MemoryFile
    struct MemoryFileInfo_t
    {
        MemoryFileInfo_t() :
            pkMemoryFileName(NULL),
            uiMemoryFileSize(0),
            pubMemoryFileLocation(NULL)
        {}
 
        const eC_String* pkMemoryFileName;  // name of resource-file to identify it
        eC_UInt uiMemoryFileSize;           // size of attached memory-file
        eC_UByte* pubMemoryFileLocation;    // pointer to memory-location
    };
 
    //struct of pointers to header info for each file in ResourceFile
    struct FileSearchEntry_t
    {
        FileSearchEntry_t() :
            kPath(""),
            uiFileSize(0),
            uiArrayOffset(0),
            ubSegmentIndex(0)
        {}
 
        eC_String kPath;            // full name of file as given during Resourcefile creation. This is used for search.
        eC_UInt uiFileSize;         // size of file in bytes
        eC_UInt uiArrayOffset;      // offset in bytes from beginning of ResourceData to the first byte of the given file's data
        eC_UByte ubSegmentIndex;    // used to identify the segment within the resources
    };
 
    // each opened file has some management informations
    struct FileHandleEntry_t
    {
        FileHandleEntry_t() :
#ifdef DEBUG_OPENED_FILES
            kPath(""),
#endif
            pkFileHandle(NULL),
            pubFileBuffer(NULL),
            iIndexInAvailableFiles(-1),
            ubSegmentIndex(0xFF)
        {}
 
#ifdef DEBUG_OPENED_FILES
        eC_String kPath;                    // path of the opened file
#endif
        eC_File* pkFileHandle;              // The FileHandle which was returned when it was opened.
        eC_UByte* pubFileBuffer;            // The buffer where the file is loaded in ResouceFile mode
        eC_Int iIndexInAvailableFiles;      // Used to check if file was opened before (-1 = not)
        eC_UByte ubSegmentIndex;            // index of segment (0xFF = no segment)
        eC_Bool operator==(const FileHandleEntry_t& rhs) const { return pkFileHandle == rhs.pkFileHandle; }
    };
 
    // returned when searching for a file
    struct FileSearchResult_t
    {
        FileSearchResult_t() :
            iFileIndex(FILE_NOT_FOUND_INDEX),
            ubSegmentIndex(0)
        {}
 
        eC_Int iFileIndex;
        eC_UByte ubSegmentIndex;
    };
 
private:
    CGUIResourceFileHandler(void);
 
    ~CGUIResourceFileHandler();
 
    CGUIResourceFileHandler(const CGUIResourceFileHandler& kSource);
 
    CGUIResourceFileHandler& operator=(const CGUIResourceFileHandler& kSource);
 
    // comparator function for FileSearchEntry_t
    static int FileSearchEntryComparator(const void* first, const void* second)
    {
        const FileSearchEntry_t *firstEntry = static_cast<const FileSearchEntry_t*>(first);
        const FileSearchEntry_t *secondEntry = static_cast<const FileSearchEntry_t*>(second);
 
        if (firstEntry->kPath < secondEntry->kPath)
            return -1;
        else if (firstEntry->kPath > secondEntry->kPath)
            return 1;
        else
            return 0;
    }
 
    ResourceFileHeader_t ReadResourceHeader(eC_File* pkHeaderFile);
 
    void SetupSearchTable(const ResourceFileInfo_t& rkFileInfo);
 
    void RemoveSegmentFromSearchTable(const ResourceFileInfo_t& rkFileInfo);
 
    FileSearchResult_t SearchForFile(const eC_String& kFilePath);
 
    eC_Int OpenFileFromDisk(const eC_String& kPath, FileHandleEntry_t& newFile, const BufferingStrategy_t eBufferingStrategy);
 
    eC_Int OpenFileFromResourceFile(const eC_String& kPath, FileHandleEntry_t& newFile, const BufferingStrategy_t eBufferingStrategy);
 
    eC_File* GetMemoryResource(const eC_String& kResourceName);
 
    eC_Int OpenFileFromMemory(const eC_String& kPath, FileHandleEntry_t& newFile);
 
    void RemoveResourceEntry(const eC_UInt& uiIndex);
 
private:
    enum GUIResourceMode_t {RESOURCE_NONE, RESOURCE_HEADER, RESOURCE_FILE};
 
    // Return codes for OpenFileFromResourceFile
    enum
    {
        FILE_OPEN_SUCCESS = 0,
        FILE_OPEN_FAILURE = -1
    };
 
    enum
    {
        FILE_NOT_FOUND_INDEX = -1,
        RESOURCE_READ_BUFFER_SIZE = 256
    };
 
private:
    FileOpenOrder_t m_eFileOpenOrder;                               // opening order (resource-file first or last)
    eC_TArray<ResourceFileInfo_t> m_kResourceFileInfo;              // information for each loaded segment
    eC_TListDoubleLinked<MemoryFileInfo_t> m_kListMemoryFileInfo;   // lookup-table for all loaded memory locations
    FileSearchEntry_t* m_pkFileSearchTable;                         // table sorted by filename for searching individual files
    eC_UInt m_uiFileSearchEntryCount;                               // number of search entries stored in array
    eC_String m_kResourcePrefix;                                    // The resource prefix which is prepended to all file-open operations
    eC_TListDoubleLinked<FileHandleEntry_t> m_kListOfOpenedFiles;   // list of opened files
    eC_UByte m_ubLoadedSegmentCount;                                // number of loaded segments
    eC_Bool m_bBufferFileFromDisk;                                  // loading strategy for data resided on disk
    eC_Bool m_bBufferHeader;                                        // loading strategy for data in header-files
};
 
#endif