Generic Resource Manager, 90% done! Boost enabled!

Just posting for constructive nitpicking

Code:

#include <vector>
#include <map>
#include <boost\shared_ptr.hpp>
#include <boost\weak_ptr.hpp>

template< typename T_ >
class Resource_Manager
{  

public:
	Resource_Manager<T_>() {};
	~Resource_Manager<T_>() {};

	boost::weak_ptr<T_> Request_Resource(const std::string &name)
    {
		std::map< std::string, boost::shared_ptr<T_> >::iterator  it = mResources.find(name);

      if(it == mResources.end())
	  {

		  boost::shared_ptr<T_> Raw_Resource(new T_);
		  Raw_Resource->Load_Resource(name);
		  mResources.insert(std::make_pair(name, Raw_Resource));
		  boost::weak_ptr<T_> Resource(Raw_Resource);
		  return Resource;
	  }
	  else
	  {
		  boost::weak_ptr<T_> Resource(it->second);
		  return Resource;
	  }
    }

	void Request_Resource_Removal(const std::string &name)
	{
		std::map<std::string, boost::shared_ptr<T_> >::iterator it = mResources.find(name);

		if (it != mResources.end())
		{
			// how do I remove an element of the map without breaking anything?
		}
	}

private:
	std::map< std::string, boost::shared_ptr<T_> >  mResources;
};

One question, It won't let me do a delete it->second in the remove resource function, it is having an issue with boost::shared_ptr...

TODO:

Count references to each shared pointer, release resource when reference count gets to zero.

Code:

#include <vector>
#include <map>
#include <boost\shared_ptr.hpp>
#include <boost\weak_ptr.hpp>

template< typename T_ >
class Resource_Manager
{  

public:

	typedef T_ value_type; // std library convention 

	typedef boost::shared_ptr<T_> Resource_Ptr;
	typedef boost::weak_ptr<T_> Resource_Observer;
	typedef std::map< std::string, Resource_Ptr > Resource_Map;

	Resource_Manager<T_>() {};
	~Resource_Manager<T_>() {};

	Resource_Observer Request_Resource(const std::string &name)
	{
		Resource_Map::iterator  it = mResources.find(name);

		if (it == mResources.end())
		{
			Resource_Ptr Raw_Resource(new T_);
			Raw_Resource->Load_Resource(name);
			mResources.insert(std::make_pair(name, Raw_Resource));
			Resource_Observer Resource(Raw_Resource);
			return Resource;
		}
		else
		{
			return Resource_Observer(it->second);
		}
	}

	void Request_Resource_Removal(const std::string &name)
	{
		Resource_Map::iterator it = mResources.find(name);

		if (it != mResources.end())
		{
			mResources.erase(it);
		}
	}

private:
	Resource_Map  mResources;
};

Originally Posted by Shamino

One question, It won't let me do a delete it->second in the remove resource function, it is having an issue with boost::shared_ptr...

TODO:

Count references to each shared pointer, release resource when reference count gets to zero.

I'm not sure you're understanding what a shared_ptr does? you don't need to do reference counting or deleting it->second, shared_ptr takes care of that internally. for the most part, you can happily ignore the fact that it's dynamic memory and shared_ptr will clean up for you. gotta love that!

not sure about the naming of Request_Resource, either. It's creating a resource if the one you request doesn't exist. I think the interface would be clearer if Request_Resource returned existing resources and informed you of an error if you requested a non-existent resource. I'd also add an Add_Resource method that allows you to add an existing object to the resource manager (what if T_ requires arguements to it's constructor?)

something like

Code:

void Add_Resource(const std::string &name, const Resource_Ptr& resource)
{
	mResources.insert(std::make_pair(name, resource));
}

// then Request_Resource becomes
Resource_Observer Request_Resource(const std::string &name)
{
	Resource_Map::iterator  it = mResources.find(name);

	if (it == mResources.end())
	{
		throw Bad_Resource; // or return a null 
		// up to you how you want to indicate error
	}
	else
	{
		return Resource_Observer(it->second);
	}
}

To be honest, the more you refine this class the more it becomes a very simple wrapper around map, with a few convenience methods. This is a good thing, as it minimises the amount of code you have to maintain.

About making the interface clearer, you might be right, though.

I figure the system doing the resource gathering doesn't care if it is there or not, it just wants a freakin resource, the logic engine wants to create a geometry node out of a raw resource and a transformation matrix. If resources aren't getting dynamically allocated by the logic engine, what manages what resources the game has loaded?

Seeing as how there might be no way to tell what resources I need before I start my game, I think this is the way to go.

The logic engine doesn't care if the resource is loaded, he wants it, simple as that.

But yeah, you're probably right, I really don't fully understand what a shared pointer