factory.h

Go to the documentation of this file.

 
#ifndef FACTORY_H 
#define FACTORY_H
 
template <typename CtorSignature> class Factory;
 
template<class BaseType, class ...ParamType>
class Factory<BaseType (ParamType...)>
{
    protected:
        /* The constructor signature */
        using CreateObjectFunc = BaseType (*)(ParamType...);
 
    public:
 
        vector<string> getNames() const {
            std::vector<string> names;
            for(auto const& createIter: _create)
                names.push_back(createIter.first);
            return names;
        }
 
        Factory<BaseType (ParamType...)> *Instance()
        {
            static Factory<BaseType (ParamType...)> fact;
            return &fact;
        
        }
 
        const Factory<BaseType (ParamType...)> * operator() () const { return Instance();}
        Factory<BaseType (ParamType...)> * operator() () { return Instance();}
 
        BaseType Create(string name, ParamType ...param) {
            typename map<string,CreateObjectFunc>::const_iterator objItr = _create.find(name);
            if (objItr != _create.end()) {
                return (objItr->second)(param...);
                /* auto created = (objItr->second)(param...); */
                /* created->name1 = name; */
                /* return created; */
            }
            return nullptr;
        }
 
        template<class DerivedType>
            bool Register(string name)
            {
                _create[name] = &createObj<DerivedType>;
                return true;
            }
 
    protected:
        map<string,CreateObjectFunc> _create;        // The name->constructor map
 
        /* Create the new object */
        template <class DerivedType>
            static BaseType createObj(ParamType ...param) 
            { return new DerivedType(param...);}
 
};
 
class EstimatorBase;
class MoveBase;
class ActionBase;
class Path;
class MTRand;
 
/* Typedefs used for actually creating factories */
typedef Factory<EstimatorBase* (Path &, ActionBase *, MTRand &, double)> EstimatorFactory;
typedef Factory<EstimatorBase* (Path &, Path &, ActionBase *, ActionBase *, MTRand &, double)> MultiEstimatorFactory;
typedef Factory<MoveBase* (Path &, ActionBase *, MTRand &)> MoveFactory;
 
/* template<typename BaseType, class DerivedType, class ...ParamType> */
/* BaseType CreateObject(ParamType ...param) */
/* { */
/*    return new DerivedType(param...); */
/* } */
 
#endif