source: GTP/trunk/Lib/Vis/Preprocessing/src/ResourceManager.h @ 2575

#ifndef _ResourceManager_H__
#define _ResourceManager_H__

#include <vector>
#include <string>
#include <iterator>
#include <fstream>
#include <ostream>
#include <iostream>

//#include "Containers.h"
#include "Mesh.h"
#include "Material.h"



namespace GtpVisibilityPreprocessor {

using std::iterator;
using std::map;
  

/** Resource manager controlling loading and destroying of resources.
        
        @note Resources must be created using the manager to assure that
        they are destroyed properly, otherwise the developer has the
        responsibility to destroy them himself.

        @note This class defines the pattern of singleton to assure that
        there is always only one resource manager.
*/
template <typename T> class ResourceManager
{
protected:
  typedef map<unsigned int, T* > maptype;

  /// the resource container
  maptype mEntries;
  
public:

        /** Returns the resource manager as a singleton.
        */
        static ResourceManager<T> *GetSingleton()
        {
                if (!sResourceManager)
                {
                        sResourceManager = new ResourceManager();
                }

                return sResourceManager;
        }

        /** We also want full control over the delete.
        */
        static void DelSingleton()
        {
                DEL_PTR(sResourceManager);
        }

        /** Creates new entry with a unique id
        */
        T *CreateResource()
        {
                const unsigned int id = CreateUniqueId();

                T *resource = new T(id);
                mEntries[id] = resource;
                
                return resource;
        }

        
        /** Searches for the mesh with the given name.
                @returns mesh or NULL if mesh was not found.
        */
        T *FindEntry(const unsigned int id) const
        {
          typename maptype::const_iterator mit = mEntries.find(id);

          if (mit != mEntries.end()) 
            {
              return (*mit).second;
            }

                return NULL;
        }

        /** Destroys mesh with the given name.
                @returns true if the mesh was found, false if not
        */
        bool DestroyEntry(const unsigned int id)
        {       
                if (!FindEntry(id))
                {
                        T *resource = mEntries[id];

                        mEntries.erase(id);
                        DEL_PTR(resource);

                        return true;
                }
                
                return false;
        }
        
        bool ExportEntries(const std::string &filename)
        {
          std::ofstream stream(filename.c_str(), std::ios::binary);
        
                if (!stream.is_open())
                        return false;

                typename std::map<unsigned int, T *>::const_iterator mit, mit_end = mEntries.end();

                for (mit = mEntries.begin(); mit != mit_end; ++ mit)
                {
                        int id = (*mit).first;
                        stream.write(reinterpret_cast<char *>(&id), sizeof(int));
                }

                return true;
        }

        /** Returns size of resource container.
        */
        const int GetSize()
        {
                return (int)mEntries.size();
        }

protected:

        /** Default constructor. The constructor is protected
                to have control over instantiation using the 
                singleton pattern.
        */
        ResourceManager<T>()
        {}
        /** Release resources.
        */
        ~ResourceManager<T>()
        {
          typename std::map<unsigned int, T *>::iterator mit, mit_end = mEntries.end();

                for (mit = mEntries.begin(); mit != mEntries.end(); ++ mit)
                {
                        //cout << "mesh: " << (*mit).first << " " << (*mit).second << endl;
                        DEL_PTR((*mit).second);
                }
        }
        /** Copy constructor.
        */
    ResourceManager<T>(const ResourceManager<T>& source)
    {
    }
        /** Helper function returning unique id for resource.
        */
        static unsigned int CreateUniqueId()
        {
                return sCurrentId ++;
        }

protected:

private:

        static ResourceManager<T> *sResourceManager;
        static unsigned int sCurrentId;
};

// only instance of the resource manager
template <typename T> ResourceManager<T> *ResourceManager<T>::sResourceManager = NULL;
template <typename T> unsigned int ResourceManager<T>::sCurrentId = 0;

/// This type is responsible for creation and disposal the meshes
typedef ResourceManager<Mesh> MeshManager;
/// This type is esponsible for creation and disposal of the materials.
typedef ResourceManager<Material> MaterialManager;

}

#endif