// WARNING: Quick and dirty proof of concept code!!!!
// All the code below is probably trivially parametrizable
// to a generic template-based solution

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <stdexcept>
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>


/// PRIVATE IMPLEMENTATION:
// classes Storage and StorageBase could actually be private inner classes of DataManager
// the user does not need to know about them


class DataManager;    // forgive me for my class names

class StorageBase : boost::noncopyable
{
    public:
        virtual ~StorageBase()
        {
            Registry &reg = registry();
            reg.erase(std::remove(reg.begin(), reg.end(), this), reg.end());
        }

        static void unregister(const DataManager *mgr)
        {
            // this is a rather ugly solution and may need to be replaced with a
            // more efficient one

            Registry &reg = registry();
            for(Registry::iterator i = reg.begin(); i != reg.end(); ++i)
            {
                (*i)->unregister(mgr);
            }
        }

    protected:
        StorageBase()
        {
        }

    private:
        typedef std::vector<StorageBase*> Registry;

        static Registry& registry()
        {
            static Registry reg;
            return reg;
        }
};

template <class T>
class Storage : StorageBase
{
    public:
        static boost::shared_ptr<T> getResource(const DataManager *manager, const std::string &name)
        {
            boost::shared_ptr<Storage> ptr = getStorage(manager, false);
            return ptr->get(name);
        }

        static void addResource(const DataManager *mgr, const std::string& name, const boost::shared_ptr<T> &datum)
        {
            getStorage(mgr, true)->data[name] = datum;
        }

        void unregister(const DataManager *mgr)
        {
            Registry &reg = registry();
            reg.erase(std::remove(reg.begin(), reg.end(), mgr), reg.end());
        }

        // TODO: a function that removes all unique data

    private:
        Storage() {}

        boost::shared_ptr<T> get(const std::string &name)
        {
            typename std::map<std::string, boost::shared_ptr<T> >::iterator iter = data.find(name);
            if(iter == data.end()) throw std::runtime_error("datum not found");
            return iter->second;
        }

        std::map<std::string, boost::shared_ptr<T> > data;
        
        typedef std::map<const DataManager*, boost::shared_ptr<Storage> > Registry;

        static boost::shared_ptr<Storage> &getStorage(const DataManager *mgr, bool create)
        {
            Registry &reg = registry();
            typename Registry::iterator iter = reg.find(mgr);

            if(iter == reg.end())
            {
                if(!create) throw std::runtime_error("storage not found");
                return reg[mgr] = boost::shared_ptr<Storage>(new Storage);
            }

            return iter->second;
        }


        static Registry& registry()
        {
            static Registry reg;
            return reg;
        }
        
};

// the public interface, all the user needs to know about

class DataManager : boost::noncopyable
{
    public:
        ~DataManager()
        {
            StorageBase::unregister(this);
        }

        template <typename T>
        boost::shared_ptr<T> getResource(const std::string &name)
        {
            return Storage<T>::getResource(this, name);
        }

        template <typename T>
        void addResource(const std::string &name, const boost::shared_ptr<T> &resource)
        {
            Storage<T>::addResource(this, name, resource);
        }
};

struct A : boost::noncopyable { explicit A(int x) : x(x) {} int x; };
struct B : boost::noncopyable { explicit B(int y) : y(y) {} int y; };

int main()
{
    DataManager mgr;
    mgr.addResource("a1", boost::shared_ptr<A>(new A(1)));
    mgr.addResource("a2", boost::shared_ptr<A>(new A(2)));
    mgr.addResource("b1", boost::shared_ptr<B>(new B(3)));

    boost::shared_ptr<A> a = mgr.getResource<A>("a1");
    std::cout << a->x << std::endl;
    std::cout << mgr.getResource<B>("b1")->y << std::endl;

    DataManager mgr2;
    mgr2.getResource<A>("a1"); // this will throw an exception as it's supposed to

}