resources.h

// This file is part of Einstein Puzzle

// Einstein Puzzle
// Copyright (C) 2003-2005  Flowix Games

// Modified 2012-08-04 by Jordan Evens <jordan.evens@gmail.com>

// Einstein Puzzle is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.

// Einstein Puzzle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.


#ifndef __RESOURCES_H__
#define __RESOURCES_H__

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


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

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


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


class ResourceFile;


/// Abstract interface for streamed resource access
class ResourceStream
{
    public:
        virtual ~ResourceStream() = default;
        
        /// Get size of resource
        virtual size_t getSize() = 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=nullptr);
        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);
        // prevent generation by compiler
        ResourceFile(const ResourceFile&);
};


/// 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; }

        /// 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.
        explicit 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);

    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
        explicit 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