factory.hpp

/*---------------------------------------------------------------------------*\
 *
 *  mimmo
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of mimmo.
 *
 *  mimmo is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  mimmo is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with mimmo. If not, see <http://www.gnu.org/licenses/>.
 *
 \ *---------------------------------------------------------------------------*/
 
#ifndef BLOCK_FACTORY_HPP
#define BLOCK_FACTORY_HPP
 
#include <unordered_map>
#include <vector>
#include <configuration.hpp>
#include <bitpit_common.hpp>
 
 
 
namespace mimmo{
 
template <class Base>
class Factory {
 
private:
    Factory() : defaultCreator(0) {};
    Factory(const Factory&);
    Factory& operator=(const Factory&);
    ~Factory() {
        deleteCreators();
    };
 
public:
    class AbstractCreator {
        public:
            virtual ~AbstractCreator() {}
            virtual Base* create(const bitpit::Config::Section & xml_root) const = 0;
    };
 
    static Factory& instance(){
        static Factory factory;
        return factory;
    }
    static Base * create(const std::string name, const bitpit::Config::Section & xml_root){
        Factory<Base>& factory = instance();
        if (factory.creators.count(name) == 0) return 0;
        return (factory.creators[name])->create(xml_root);
    }
 
    void removeCreator(const std::string & name){
        if (creators.count(name) > 0) {
            delete creators[name];
            creators.erase(name);
        }
        return;
    }
 
    int addCreator(const std::string name, const AbstractCreator* creator){
        removeCreator(name);
        creators[name]= creator;
        return (int) creators.size() + 1;
    }
 
    bool containsCreator(const std::string & name){
        return creators.count(name) > 0;
    }
 
    int setDefaultCreator(const AbstractCreator* creator){
        defaultCreator = creator;
        return 0;
    }
 
    std::vector<std::string> mapRegisteredBlocks(){
        std::vector<std::string> result(creators.size());
        int counter = 0;
        for(auto &val : creators){
            result[counter] = val.first;
            ++counter;
        }
        return result;
    }
 
private:
    const AbstractCreator* defaultCreator; 
    std::unordered_map<std::string, const AbstractCreator*> creators; 
    void deleteCreators(){
        for(auto & val : creators){
            delete val.second;
        }
        creators.clear();
    };
};
 
template <class Base, class Derived>
class Creator : public Factory<Base>::AbstractCreator {
 
typedef Derived* (*CreateFn) (const bitpit::Config::Section & );
 
public:
    CreateFn createFn; 
    Creator(CreateFn fn = nullptr) : createFn(fn) {}
    virtual Derived* create(const bitpit::Config::Section & xml_root) const {
        return (createFn ? createFn(xml_root) : new Derived(xml_root));
    };
};
 
};
 
 
#define REGISTER(Base, Derived, name) \
/* register a Derived class with its xml default constructor that will be instantiate as Base*/ \
__attribute__((unused)) static int factory_##Base##_##Derived = mimmo::Factory<Base>::instance().addCreator(name, new mimmo::Creator<Base, Derived>());
 
#define REGISTER_CUSTOM(Base, Derived, name, customCreator) \
/* register a Derived class a custom xml constructor/creator method that will be instantiate as Base*/ \
__attribute__((unused)) static int factory_##Base##_##Derived = mimmo::Factory<Base>::instance().addCreator(name, new Creator<Base, Derived>(&customCreator));
 
template<class Base>
inline bool isREGISTERED(const std::string name){
    return mimmo::Factory<Base>::instance().containsCreator(name);
}
 
#endif