#include <memory>
#include <string>
#include <map>

template <typename> struct manager;

template <typename T>
struct managed_resource
{
        typedef std::shared_ptr<manager<T>> manager_ptr;

    managed_resource(manager_ptr const & parent)
            : parent_(parent)
        {
        }

        /* ... */

        manager_ptr parent_;
};

template <typename Policy>
struct manager
    : Policy
    , std::enable_shared_from_this<manager<Policy>>
{
        typedef managed_resource<Policy> resource;
        typedef std::shared_ptr<resource> resource_ptr;

    resource_ptr get_resource(std::string const & name)
        {
            Policy & p = *this;
            if(p.find(name))
            {
                return p.get(name);
            }
            resource_ptr res = std::make_shared<resource>(this->shared_from_this());
            p.store(name, res);
            return res;
        }
};

struct  map_policy
{
        typedef std::shared_ptr<managed_resource<map_policy>> resource_ptr;
        typedef std::map<std::string, resource_ptr> resources;

        bool find(std::string const & name)
        {
            resources::iterator res_it = resources_.find(name);
            return res_it != resources_.end();
        }

        resource_ptr get(std::string const & name)
        {
            resources::iterator res_it = resources_.find(name);
            return res_it->second;
        }

        void store(std::string const & name, resource_ptr const & res)
        {
            resources_[name] = res;
        }

        resources resources_;
};

typedef manager<map_policy> my_manager;

int main()
{
    auto m = std::make_shared<my_manager>();
    auto res = m->get_resource("test");
    return 0;
}