Registrar.h

Go to the documentation of this file.

#ifndef __REGISTRAR_H
#define __REGISTRAR_H

#include <iostream>
#include <map>
#include <string>
#include <assert.h>

namespace Teem
{
    template<typename T, typename IdT, typename Arg1T = void, typename Arg2T = void> class Registrar
    {
    public:
        template<typename Sub> void registerItem(const IdT &id)
        {
            mItems[id] = &Creator<Sub>;
        }
        
        T* createItem(const IdT &id, Arg1T arg1, Arg2T arg2)
        {
            if (mItems.find(id) == mItems.end())
            {
                std::cerr << "Class of type " << id << " unregistred, aborting.\n\nKnown classes are:\n";
                dump(std::cerr);
                std::cerr << std::endl;
                exit(1);
            }
            return mItems[id](arg1, arg2);
        }
        
        void dump(std::ostream &stream)
        {
            for (typename std::map<IdT, CreatorFunc>::iterator it = mItems.begin(); it != mItems.end(); ++it)
                stream << "* " << it->first << "\n";
        }
    
    protected:
        typedef T* (*CreatorFunc)(Arg1T, Arg2T);
        std::map<IdT, CreatorFunc> mItems; 
        
        template<typename Sub> static T* Creator(Arg1T arg1, Arg2T arg2)
        {
            return new Sub(arg1, arg2);
        }
    };
    
    template<typename T, typename IdT, typename ArgT> class Registrar<T, IdT, ArgT, void>
    {
    public:
        template<typename Sub> void registerItem(const IdT &id)
        {
            mItems[id] = &Creator<Sub>;
        }
        
        T* createItem(const IdT &id, ArgT arg)
        {
            if (mItems.find(id) == mItems.end())
            {
                std::cerr << "Class of type " << id << " unregistred, aborting.\n\nKnown classes are:\n";
                dump(std::cerr);
                std::cerr << std::endl;
                exit(1);
            }
            return mItems[id](arg);
        }
        
        void dump(std::ostream &stream)
        {
            for (typename std::map<IdT, CreatorFunc>::iterator it = mItems.begin(); it != mItems.end(); ++it)
                stream << "* " << it->first << "\n";
        }
        
    protected:
        typedef T* (*CreatorFunc)(ArgT);
        std::map<IdT, CreatorFunc> mItems; 
        
        template<typename Sub> static T* Creator(ArgT arg)
        {
            return new Sub(arg);
        }
    };
    
    template<typename T, typename IdT> class Registrar<T, IdT, void, void>
    {
    public:
        template<typename Sub> void registerItem(const IdT &id)
        {
            mItems[id] = &Creator<Sub>;
        }
        
        T* createItem(const IdT &id)
        {
            if (mItems.find(id) == mItems.end())
            {
                std::cerr << "Class of type " << id << " unregistred, aborting.\n\nKnown classes are:\n";
                dump(std::cerr);
                std::cerr << std::endl;
                exit(1);
            }
            return mItems[id]();
        }
        
        void dump(std::ostream &stream)
        {
            for (typename std::map<IdT, CreatorFunc>::iterator it = mItems.begin(); it != mItems.end(); ++it)
                stream << "* " << it->first << "\n";
        }
        
    protected:
        typedef T* (*CreatorFunc)();
        std::map<IdT, CreatorFunc> mItems; 
        
        template<typename Sub> static T* Creator()
        {
            return new Sub();
        }
    };
}

#endif

---