gls_resource_file_mgr.h

#ifndef GLS_RESOURCE_FILE_MGR_H_INCLUDED
#define GLS_RESOURCE_FILE_MGR_H_INCLUDED
 
/// Provides support for creating DLLs.
#if( defined( GLSGEN_EXPORT_GLSGEOMETRYRESOURCE ) || defined( GLSGEN_IMPORT_GLSGEOMETRYRESOURCE ) || defined( GLS_EXPORT_GENERATED ) || defined( GLS_IMPORT_GENERATED ) ) \
    && defined( _MSC_VER )
#    if defined( GLSGEN_EXPORT_GLSGEOMETRYRESOURCE ) || defined( GLS_EXPORT_GENERATED )
#        define GLSGEN_GlsGeometryResource_EXPORT __declspec( dllexport )
#    else
#        define GLSGEN_GlsGeometryResource_EXPORT __declspec( dllimport )
#    endif
#else
#    define GLSGEN_GlsGeometryResource_EXPORT
#endif
///////////////////////////////////////////////////////////////////////////////
 
namespace disti
{
/// \details class GlsResourceFileMgr
/// This class manages all known resource files and provides an
/// API for objects to access the data for a named resource.
/// This allows the runtime code to access required resources without
/// knowing their location.  Resources may be stored in individual files,
/// in an archive file, inline data in the source code, RCDATA, etc.
class GlsResourceFileMgr
{
protected:
    GlsResourceFileMgr();
    ~GlsResourceFileMgr();
 
public:
    /** Reference counted handle to binary resource data
     */
    class BinaryResource
    {
    protected:
        BinaryResource();
        virtual ~BinaryResource();
 
    public:
        /// Should be called to release this BinaryResource when it is longer needed
        virtual void Release() = 0;
 
        /// \returns the resource string name
        virtual const char* GetName() = 0;
 
        /// \returns size of the data in bytes
        virtual unsigned int GetDataSize() = 0;
 
        /// \returns raw pointer to the binary resource data (Read-only)
        virtual const char* GetDataPtr() = 0;
    };
 
    /** Lightweight reference to a resource
      */
    class ResourceRef
    {
    protected:
        // Need virtual destructor
        virtual ~ResourceRef() {}
 
    public:
        /// Increment the ResourceRef reference count
        virtual void AddRef() = 0;
 
        /// Should be called to release this ResourceRef when it is longer needed
        virtual void Release() = 0;
 
        /// \return The resource string name.
        virtual const char* GetName() = 0;
 
        /// \return A pointer to the resource data.
        /// Make sure to Release() the BinaryResource when you are done with it (a SmartPtr can be used for this purpose).
        virtual BinaryResource* LoadBinaryData() = 0;
    };
 
    /// \details Used to hold a resource file open for loading time performance.
    /// \see CacheResourceFile
    class ResourceCache
    {
    public:
        virtual ~ResourceCache() {}
        /// Increment the reference count
        virtual void AddRef() = 0;
        /// Decrement the reference count
        virtual void Release() = 0;
    };
 
    /// \details Automatically release a resource when no more AutoRelease instances reference it.
    /// \see CacheResourceFile
    template<class T>
    class AutoRelease
    {
    protected:
        T* _ptr; ///< Pointer to an object with a refernce counting interface.
 
    public:
        /// Constructor
        /// \param obj The object to wrap.
        AutoRelease( T* obj ) { _ptr = obj; }
 
        /// Copy constructor
        /// \note Does not copy the underlying object, instead increments the underlying objects reference count.
        /// \param other The object to copy.
        AutoRelease( const AutoRelease& other )
        {
            _ptr = other._ptr;
            if( _ptr )
            {
                _ptr->AddRef();
            }
        }
 
        ~AutoRelease()
        {
            if( _ptr )
            {
                _ptr->Release();
            }
        }
 
        /// \return A pointer to the underlying object with reference counting interface.
        T* get() { return _ptr; }
    };
 
    /**
      * \returns Reference to the GlsResourceFileMgr
      */
    GLSGEN_GlsGeometryResource_EXPORT static GlsResourceFileMgr& Instance();
 
    /** Get a reference to a given resource
      * \param resource_name The unique string name of the resource (relative path to the file if using resource folders)
      * \returns reference to the resource or NULL if the resource was not found.
      */
    GLSGEN_GlsGeometryResource_EXPORT ResourceRef* GetResourceRef( const char* resource_name );
 
    /** Tell the resource manager to load resources from the given location
      * This method may be called multiple times to specify multiple locations
      *
      * \param url path to the resources. e.g. "./resources/".  This may be a directory or zip file.
      * \param silent if false, then a popup is displayed to the user if the location is not found
      * \returns true if resources were successfully opened, false otherwise
      */
    GLSGEN_GlsGeometryResource_EXPORT bool AddResourceFolder( const char* url, bool silent = false );
 
    /// Loads resources for a given component into RAM.
    /// The resources remain cached until the ResourceCache is Released.
    /// \param componentClassName The generated class name of the component.
    /// \return A reference counted pointer to the resources.
    GLSGEN_GlsGeometryResource_EXPORT AutoRelease<ResourceCache> CacheResourcesForComponent( const char* componentClassName );
};
 
} // end namespace disti
 
#endif