xrb_resourcelibrary.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_resourcelibrary.hpp by Victor Dods, created 2005/06/05
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

#if !defined(_XRB_RESOURCELIBRARY_HPP_)
#define _XRB_RESOURCELIBRARY_HPP_

#include "xrb.hpp"

#include <map>
#include <string>

namespace Xrb
{

template <typename T> class Resource;

class ResourceLibrary
{
public:

    enum
    {
        UNSPECIFIED_LOAD_PARAMETER = static_cast<Sint32>(SINT32_LOWER_BOUND)
    };

    ResourceLibrary ();
    ~ResourceLibrary ();

    template <typename T>
    Resource<T> LoadPath (
        T *(*LoadFunction)(std::string const &),
        std::string const &path);
    template <typename T>
    Resource<T> LoadPath (
        T *(*LoadFunction)(std::string const &, Sint32),
        std::string const &path,
        Sint32 load_parameter);

private:

    // used as the key in the resource instance map
    struct ResourceInstanceKey
    {
        // the resource's path
        std::string m_path;
        // an associated signed integer value (e.g. font pixel height)
        Sint32 m_load_parameter;

        inline ResourceInstanceKey (
            std::string const &path,
            Sint32 const load_parameter)
        {
            m_path = path;
            m_load_parameter = load_parameter;
        }

        // i don't want this to show up in the docs as a class, since
        // i have doxygen exclude all private declarations.
        struct LessThan
        {
            bool operator () (
                ResourceInstanceKey const &left_operand,
                ResourceInstanceKey const &right_operand) const;
        }; // end of struct LessThan
    }; // end of struct ResourceInstanceKey

    void UnmapKey (ResourceInstanceKey const &key);

    // only used for storing pointers to ResourceInstance<T> in
    // an array, for proper casting and type safety.
    class ResourceInstanceBase
    {
    public:

        inline std::string const &Path () const
        {
            return m_key.m_path;
        }
        inline Sint32 LoadParameter () const
        {
            return m_key.m_load_parameter;
        }

        inline void IncrementReferenceCount ()
        {
            ASSERT1(m_reference_count < UINT32_UPPER_BOUND);
            ++m_reference_count;
        }
        inline bool DecrementReferenceCount ()
        {
            ASSERT1(m_reference_count > 0);
            --m_reference_count;
            if (m_reference_count == 0)
            {
                m_library->UnmapKey(m_key);
//                 fprintf(stderr, "ResourceLibrary * unloading ");
//                 Print(stderr);
                DeleteData();
                return true;
            }
            else
                return false;
        }

        void Print (FILE *fptr) const
        {
            fprintf(fptr, "\"%s\", ", m_key.m_path.c_str());
            if (m_key.m_load_parameter == UNSPECIFIED_LOAD_PARAMETER)
                fprintf(stderr, "no load parameter\n");
            else
                fprintf(stderr, "load parameter = %d\n", m_key.m_load_parameter);
        }
                
    protected:
            
        inline ResourceInstanceBase (
            ResourceLibrary *const library,
            ResourceLibrary::ResourceInstanceKey const &key)
            :
            m_key(key)
        {
            ASSERT1(!key.m_path.empty());
            m_library = library;
            m_reference_count = 0;
        }
        inline virtual ~ResourceInstanceBase () { }
    
        virtual void DeleteData () = 0;
    
        ResourceInstanceKey m_key;
        ResourceLibrary *m_library;
        Uint32 m_reference_count;
    }; // end of class ResourceInstanceBase

    // actually holds the reference-counted resource data
    template <typename T>
    class ResourceInstance : public ResourceInstanceBase
    {
    public:

        ResourceInstance (
            ResourceLibrary *const library,
            ResourceLibrary::ResourceInstanceKey const &key,
            T *const data)
            :
            ResourceInstanceBase(library, key)
        {
            ASSERT1(data != NULL);
            m_data = data;
        }
        ~ResourceInstance ()
        {
            ASSERT1(m_data == NULL);
        }

        inline T *Data () const
        {
            return m_data;
        }

    protected:

        virtual void DeleteData ()
        {
            DeleteAndNullify(m_data);
        }
        
    private:

        T *m_data;
    }; // end of class ResourceInstance<T>

    typedef std::map<
        ResourceInstanceKey,
        ResourceInstanceBase *,
        ResourceInstanceKey::LessThan> InstanceMap;

    InstanceMap m_instance_map;

    // so ResourceInstance<T> can call UnmapPath()
    template <typename T> friend class ResourceInstance;
    // so Resource<T> can use ResourceInstance<T>
    template <typename T> friend class Resource;
}; // end of class ResourceLibrary

template <typename T>
class Resource
{
public:

    inline Resource ()
    {
        m_instance = NULL;
    }
    inline Resource (ResourceLibrary::ResourceInstance<T> *const instance)
    {
        ASSERT1(instance != NULL);
        m_instance = instance;
        m_instance->IncrementReferenceCount();
    }
    inline Resource (Resource<T> const &source)
    {
        m_instance = source.m_instance;
        if (m_instance != NULL)
            m_instance->IncrementReferenceCount();
    }
    inline ~Resource ()
    {
        if (m_instance != NULL)
        {
            if (m_instance->DecrementReferenceCount())
                DeleteAndNullify(m_instance);
        }
    }

    void operator = (Resource<T> const &source)
    {
        if (m_instance != NULL)
            if (m_instance->DecrementReferenceCount())
                Delete(m_instance);
        m_instance = source.m_instance;
        if (m_instance != NULL)
            m_instance->IncrementReferenceCount();
    }
    inline bool operator == (Resource<T> const &operand) const
    {
        return m_instance == operand.m_instance;
    }
    inline bool operator != (Resource<T> const &operand) const
    {
        return m_instance != operand.m_instance;
    }
    inline T const *operator * () const
    {
        ASSERT1(m_instance != NULL);
        return m_instance->Data();
    }
    inline T const *operator -> () const
    {
        ASSERT1(m_instance != NULL);
        return m_instance->Data();
    }

    inline bool IsValid () const
    {
        return m_instance != NULL;
    }
    inline std::string const &Path () const
    {
        ASSERT1(m_instance != NULL);
        return m_instance->Path();
    }
    inline Sint32 LoadParameter () const
    {
        ASSERT1(m_instance != NULL);
        return m_instance->LoadParameter();
    }

    void Release ()
    {
        if (m_instance != NULL)
        {
            if (m_instance->DecrementReferenceCount())
                DeleteAndNullify(m_instance);
        }
    }

private:

    ResourceLibrary::ResourceInstance<T> *m_instance;
}; // end of class Resource<T>

template <typename T>
Resource<T> ResourceLibrary::LoadPath (
    T *(*LoadFunction)(std::string const &),
    std::string const &path)
{
    Resource<T> invalid_resource;

    if (path.empty())
        return invalid_resource;

    ResourceInstanceKey const key(path, UNSPECIFIED_LOAD_PARAMETER);

    // check if the file is already loaded
    InstanceMap::iterator it = m_instance_map.find(key);
    // if it is loaded then return a Resource for it.
    if (it != m_instance_map.end())
    {
        ASSERT1(it->second != NULL);
        // make sure the existing data is of the right type
        ASSERT1(
            dynamic_cast<ResourceInstance<T> *>(it->second) != NULL &&
            "You probably are trying to load a currently loaded "
            "resource using a different type or method");
        return Resource<T>(dynamic_cast<ResourceInstance<T> *>(it->second));
    }
    // otherwise load up the given path, stick it in
    // the map and return a Resource for it.
    else
    {
        // attempt to load the path
        T *data = LoadFunction(path);

        // if successful, stick the data into a ResourceInstance to
        // be kept by this ResourceLibrary, otherwise return null.
        if (data != NULL)
        {
//             fprintf(
//                 stderr,
//                 "ResourceLibrary * loading \"%s\", "
//                 "no load parameter\n",
//                 path.c_str());

            ResourceInstance<T> *instance =
                new ResourceInstance<T>(this, key, data);
            m_instance_map[key] = instance;
            return Resource<T>(instance);
        }
        else
        {
            fprintf(
                stderr,
                "ResourceLibrary * FAILURE while "
                "loading \"%s\", no load parameter\n",
                path.c_str());
            // do some error handling
            return invalid_resource;
        }
    }
}

template <typename T>
Resource<T> ResourceLibrary::LoadPath (
    T *(*LoadFunction)(std::string const &, Sint32),
    std::string const &path,
    Sint32 const load_parameter)
{
    ASSERT1(load_parameter != UNSPECIFIED_LOAD_PARAMETER &&
            "You may not use that load parameter (it is reserved)");

    Resource<T> invalid_resource;

    if (path.empty())
        return invalid_resource;

    ResourceInstanceKey const key(path, load_parameter);

    // check if the file is already loaded
    InstanceMap::iterator it = m_instance_map.find(key);
    // if it is loaded then return a Resource for it.
    if (it != m_instance_map.end())
    {
        ASSERT1(it->second != NULL);
        // make sure the existing data is of the right type
        ASSERT1(
            dynamic_cast<ResourceInstance<T> *>(it->second) != NULL &&
            "You probably are trying to load a currently loaded "
            "resource using a different type or method");
        return Resource<T>(dynamic_cast<ResourceInstance<T> *>(it->second));
    }
    // otherwise load up the given path, stick it in
    // the map and return a Resource for it.
    else
    {
        // attempt to load the path
        T *data = LoadFunction(path, load_parameter);

        // if successful, stick the data into a ResourceInstance to
        // be kept by this ResourceLibrary, otherwise return null.
        if (data != NULL)
        {
//             fprintf(
//                 stderr,
//                 "ResourceLibrary * loading \"%s\", "
//                 "load parameter = %d\n",
//                 path.c_str(),
//                 load_parameter);

            ResourceInstance<T> *instance =
                new ResourceInstance<T>(this, key, data);
            m_instance_map[key] = instance;
            return Resource<T>(instance);
        }
        else
        {
            fprintf(
                stderr,
                "ResourceLibrary * FAILURE while "
                "loading \"%s\", load parameter = %d\n",
                path.c_str(),
                load_parameter);
            // do some error handling
            return invalid_resource;
        }
    }
}

} // end of namespace Xrb

#endif // !defined(_XRB_RESOURCELIBRARY_HPP_)

---