ModuleFactory.h

Go to the documentation of this file.

/*
 *  CepGen: a central exclusive processes event generator
 *  Copyright (C) 2018-2024  Laurent Forthomme
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CepGen_Modules_ModuleFactory_h
#define CepGen_Modules_ModuleFactory_h
 
#include <memory>
#include <sstream>
 
#include "CepGen/Modules/NamedModule.h"
 
#define BUILDERNM(obj) obj##Builder
#define DEFINE_FACTORY(name, obj_type, descr)                       \
  struct name : public ModuleFactory<obj_type> {                    \
    explicit name() : ModuleFactory(descr) {}                       \
    inline static name& get() {                                     \
      static name instance;                                         \
      return instance;                                              \
    }                                                               \
    inline name& addIndex(int index, const std::string& mod_name) { \
      indices_[index] = mod_name;                                   \
      return *this;                                                 \
    }                                                               \
  };                                                                \
  static_assert(true, "")
 
namespace cepgen {
  template <typename T>
  class ModuleFactory {
  public:
    ModuleFactory(const ModuleFactory&) = delete;   
    virtual ~ModuleFactory() = default;             
    void operator=(const ModuleFactory&) = delete;  
 
    inline const std::string& description() const { return description_; }  
 
    template <typename U>
    inline void registerModule(const std::string& name, const ParametersList& def_params = ParametersList()) {
      static_assert(std::is_base_of<T, U>::value,
                    "\n\n  *** Failed to register an object with improper inheritance into the factory. ***\n");
      if (has(name)) {
        std::ostringstream oss;
        oss << "\n\n  *** " << description_ << " detected a duplicate module registration for index/name \"" << name
            << "\"! ***\n";
        throw std::invalid_argument(oss.str());
      }
      map_.insert(std::make_pair(name, &buildModule<U>));
      auto desc = U::description();
      if (!def_params.empty())
        desc.parameters() += def_params;
      desc.parameters().setName(name);
      params_map_[name] = desc;
    }
    std::unique_ptr<T> build(const ParametersList&) const;
    std::unique_ptr<T> build(const std::string& name, const ParametersList& params = ParametersList()) const;
    std::unique_ptr<T> build(int index, const ParametersList& params = ParametersList()) const;
 
    typedef std::unique_ptr<T> (*Builder)(const ParametersList&);  
 
    std::string describe(const std::string& name) const;  
    ParametersDescription describeParameters(const ParametersList&) const;
    ParametersDescription describeParameters(const std::string& name,
                                             const ParametersList& params = ParametersList()) const;
    ParametersDescription describeParameters(int index, const ParametersList& params = ParametersList()) const;
 
    std::vector<std::string> modules() const;           
    inline bool empty() const { return map_.empty(); }  
    inline size_t size() const { return map_.size(); }  
 
    inline const std::unordered_map<int, std::string>& indices() const { return indices_; }
 
    inline bool has(const std::string& name) const { return map_.count(name) > 0; }
 
  private:
    template <typename U>
    inline static std::unique_ptr<T> buildModule(const ParametersList& params) {
      return std::unique_ptr<T>(new U(params));
    }
    const std::string description_;                 
    std::unordered_map<std::string, Builder> map_;  
    std::unordered_map<std::string, ParametersDescription> params_map_;  
    const ParametersDescription empty_params_desc_;                      
 
  protected:
    explicit ModuleFactory(const std::string&);     
    std::unordered_map<int, std::string> indices_;  
  };
}  // namespace cepgen
 
#endif