einstein/einstein-2.0/resources.h

#ifndef __RESOURCES_H__
#define __RESOURCES_H__

/** \file resources.h
 * Classes for resources loading and unloading.
 */

#include <string>
#include <fstream>
#include <list>
#include <map>
#include <vector>

#include "visitor.h"
#include "buffer.h"

typedef std::list<std::wstring> StringList;


class ResourceFile;


/// Abstract interface for streamed resource access
class ResourceStream
{
    public:
        virtual ~ResourceStream() { };

        /// Get size of resource
        virtual size_t getSize() = 0;

        /// Seek into resource.
        /// \param offset offset from resource start
        virtual void seek(long offset) = 0;

        /// Read data from resource into buffer.
        /// \param buffer buffer of size bytes.
        /// \param size number of bytes to read.
        virtual void read(char *buffer, size_t size) = 0;

        /// Get current position
        virtual long getPos() = 0;

        /// Return true if end of resource reached
        virtual bool isEof() { return (size_t)getPos() >= getSize(); };

        /// Get count of bytes left
        virtual long getAvailable() { return (long)getSize() - getPos(); };
};


/***
   * Low level resource file interface.
   * Never use it, use ResourcesCollection instead.
   ***/
class ResourceFile
{
    private:
        std::ifstream stream;           /// resource file input stream
        int priority;                   /// priority of resource file
        std::wstring name;              /// resource file name
        Buffer *buffer;
        bool ownBuffer;

    public:
        /// Resource file directory entry
        typedef struct {
            std::wstring name;           /// resource name
            long offset;                /// offset from start of resource file
            long packedSize;            /// compressed size
            long unpackedSize;          /// uncompressed size
            std::wstring group;          /// group name
            int level;                  /// pack level
        } DirectoryEntry;
        /// List of directory entries.
        typedef std::list<DirectoryEntry> Directory;

    public:
        /// Create resource file.  Throws exception if file can't be opened.
        /// \param fileName the name of resource file.
        /// \param buffer buffer for temporary data.
        /// Can be shared with other resource files.
        ResourceFile(const std::wstring &fileName, Buffer *buffer=NULL);
        virtual ~ResourceFile();

    public:
        /// Load directory listing.
        /// \param directory list where resource entries will be placed.
        void getDirectory(Directory &directory);

        /// Load data in preallocated buffer buf of size unpackedSize.
        /// \param buf buffer of unpackedSize bytes where unpacked data will
        /// be placed
        /// \param offset offset from start of resource file to packed data
        /// \param packedSize size of packed resource
        /// \param unpackedSize size of unpacked resource
        void load(char *buf, long offset, long packedSize,
                long unpackedSize, int level);

        /// Allocate buffer and load data.  Memory returned by this
        ///  method must be freed by free() function call.
        /// \param offset offset from start of resource file to packed data
        /// \param packedSize size of packed resource
        /// \param unpackedSize size of unpacked resource
        void* load(long offset, long packedSize, long unpackedSize,
                int level);

        /// Get priority of this resource file.
        int getPriority() const { return priority; };

        /// Get the name of resource file.
        const std::wstring& getFileName() const { return name; };

        /// Get file stream.
        std::ifstream& getStream() { return stream; };

    private:
        /// Unpack memory buffer
        /// \param in buffer of inSize bytes filled with packed data
        /// \param inSize size of packed data
        /// \param out buffer of outSize bytes where unpacked data will
        /// be placed
        /// \param outSize size of unpacked data
        void unpack(char *in, int inSize, char *out, int outSize);
};


/// Simple resource file wrapper.
/// Used at boot time when ResourcesCollection
/// is not available yet.
class SimpleResourceFile: public ResourceFile
{
    private:
        typedef std::map<std::wstring, DirectoryEntry> DirectoryMap;
        DirectoryMap directory;  /// Directory map.

    public:
        /// Open resource file.  Throws exception if file can't be opened.
        /// \param fileName the name of resource file.
        /// \param buffer buffer for temporary data.
        /// Can be shared with other resource files.
        SimpleResourceFile(const std::wstring &fileName, Buffer *buffer=NULL);

    public:
        /// Load data.  Memory returned by this method should be freed
        /// by free() function call.
        /// \param name name of resource
        /// \param size returns size of resource
        virtual void* load(const std::wstring &name, int &size);

        /// Load data into the buffer.
        /// \param name name of resource
        /// \param buffer buffer for resource data
        virtual void load(const std::wstring &name, Buffer &buffer);
};


/// Internationalized resource entity.
class ResVariant
{
    private:
        int i18nScore;
        ResourceFile *file;
        long offset;
        long unpackedSize;
        long packedSize;
        int refCnt;
        void *data;
        int level;

    public:
        /// Create resource variation.
        /// \param file reesource file
        /// \param score locale compability score
        /// \param entry entry in global resources directory
        ResVariant(ResourceFile *file, int score,
                const ResourceFile::DirectoryEntry &entry);

        ~ResVariant();

    public:
        /// Return locale compability score.
        int getI18nScore() const { return i18nScore; };

        /// Get pointer to unpacked resource data.
        /// Must be freed after use this delRef()
        void* getRef();

        /// Get pointer to unpacked resource data and return resource size.
        /// Must be freed after use this delRef().
        /// \param size returned size of resource data.
        void* getRef(size_t &size);

        /// Delete referene to data.
        /// \param data pointer to unpacked data.
        void delRef(void *data);

        /// Return reference counter.
        int getRefCount() const { return refCnt; };

        /// Is data managed by this object
        /// \param data pointer to dataa
        bool isDataOwned(void *data) const { return refCnt && data == this->data; };

        /// return data.
        /// destroy it after use with free()
        void* getDynData();

        /// returns size of data
        long getSize() const { return unpackedSize; };

        /// Return data in buffer
        /// \param buffer buffer to store data.
        void getData(Buffer &buffer);

        /// Create ResourceStream for resource.
        /// This may be usefull for large streams unpacked data,
        /// for example video and sound.
        /// Delete stream after use.
        ResourceStream* createStream();
};


/// Internationalized resources.
/// Collection of localized data (ResVariant) with single name.
class Resource
{
    private:
        typedef std::vector<ResVariant*> Variants;
        Variants variants;
        std::wstring name;

    public:
        /// Create resource and add first entry
        /// \param file resource file
        /// \param i18nScore locale compability score
        /// \param entry resource entry in global directory
        /// \param name name of resource
        Resource(ResourceFile *file, int i18nScore,
                const ResourceFile::DirectoryEntry &entry,
                const std::wstring &name);

        ~Resource();

    public:
        /// Add resource variant.
        /// \param file resource file
        /// \param i18nScore locale compability score
        /// \param entry resource entry in global directory
        void addVariant(ResourceFile *file, int i18nScore,
                const ResourceFile::DirectoryEntry &entry);

        /// Get number of variants.
        int getVariantsCount() const { return variants.size(); };

        /// Geturns variant object.
        /// \param variant variant number.
        ResVariant* getVariant(int variant=0) { return variants[variant]; };

        /// Load data from variant.
        /// Data must be freed with delRef().
        /// \param variant variant number.
        void* getRef(int variant=0);

        /// Load data from variant.
        /// data must be freed with delRef()
        /// \param size size of data.
        /// \param variant variant number.
        void* getRef(int *size, int variant=0);

        /// Unload data
        /// param data pointer to data.
        void delRef(void *data);

        /// Get size of data.
        /// \param variant variant number.
        long getSize(int variant=0) { return variants[variant]->getSize(); };

        /// Get name of this resource.
        const std::wstring& getName() const { return name; };

        /// Load data into buffer.
        /// \param buffer buffer for data.
        /// \param variant variant number.
        void getData(Buffer &buffer, int variant=0);

        /// Create ResourceStream for resource.
        /// This may be usefull for large streams unpacked data,
        /// for example video and sound.
        /// Delete stream after use.
        /// \param variant variant number.
        ResourceStream* createStream(int variant=0);
};


/// Internationalized resource files collection.
/// When ResourceCollection created all resources checked against
/// current locale.  Resources not belonged to current locale are
/// ignored, resources that can be used in current locale sorted
/// by locale relevance score.
/// All resources names interpeted as name[_language][_COUNTRY].extension
/// where name is name of resource, language is optional two letters
/// ISO language code, country is two letters ISO country code
/// and extension is file extension.
/// After processing resource name will be truncated to name.extension.
/// By default resource with highest locale relevance score will
/// be loaded. Howether, it is possible to enumerate all variants
/// by using Resource class interface.
/// Resource files loaded in order specified by their priority.
/// Resources from file loaded later can replace resources
/// loaded before it.
class ResourcesCollection
{
    private:
        /// Map resource names to resources.
        typedef std::map<std::wstring, Resource*> ResourcesMap;

        /// List of resources.
        typedef std::list<Resource*> ResourcesList;

        /// Map group names to resources list.
        typedef std::map<std::wstring, ResourcesList> ResourcesListMap;

        /// List of resource files.
        typedef std::vector<ResourceFile*> ResourceFiles;

        ResourcesMap resources;    /// Map of all available resources.
        ResourcesListMap groups;   /// Map of all available groups.
        ResourceFiles files;       /// List of resource files.
        Buffer buffer;             /// Temporary buffer for resource files.

    public:
        /// Load resource files, make grouping and i18n optimizations.
        ResourcesCollection(StringList &directories);
        ~ResourcesCollection();

    public:
        /// Returns resource entry.
        /// If resource not found Exception will be thrown.
        Resource* getResource(const std::wstring &name);

        /// Load resource.
        /// Loaded data must be freed with delRef method.
        void* getRef(const std::wstring &name, int &size);

        /// Load resource.
        /// Loaded data must be freed with delRef method.
        void* getRef(const std::wstring &name);

        /// Delete reference to resource.
        void delRef(void *data);

        /// Visit all group members.
        void forEachInGroup(const std::wstring &groupName,
                Visitor<Resource*> &visitor);

        /// Create ResourceStream for resource.
        /// This may be usefull for large streams unpacked data,
        /// for example video and sound.
        /// Delete stream after use.
        /// \param name name of resource.
        ResourceStream* createStream(const std::wstring &name);

        /// Load data into buffer.
        /// Usually you don't need this, use getRef instead.
        /// \param name name of resource.
        /// \param buffer buffer for data.
        void loadData(const std::wstring &name, Buffer &buffer);

    private:
        /// Open resource files.
        void loadResourceFiles(StringList &directories);

        /// Make grouping and locale processing.
        void processFiles();
};


/// Helper class for simple resource loading and unloading
class ResDataHolder
{
    private:
        void *data;
        size_t size;

    public:
        /// Create holder without data
        ResDataHolder();

        /// Create holder and load data
        ResDataHolder(const std::wstring &name);

        ~ResDataHolder();

    public:
        /// Load resource data
        void load(const std::wstring &name);

        /// Returns pointer to resource data
        void* getData() const { return data; };

        /// Returns size of data
        size_t getSize() const { return size; };
};


/// Global collection of resources.
/// Careated at first step at boot time stage2
extern ResourcesCollection *resources;


#endif