Factory.h

#ifndef SIMCORE_FACTORY_H
#define SIMCORE_FACTORY_H
 
#include <algorithm>                // for for_each call in apply
#include <boost/core/demangle.hpp>  // for demangling
#include <memory>                   // for the unique_ptr default
#include <string>                   // for the keys in the library map
#include <unordered_map>            // for the library of prototypes
 
#include "Framework/Exception/Exception.h"
 
namespace simcore {
 
template <typename Prototype, typename PrototypePtr,
          typename... PrototypeConstructorArgs>
class Factory {
 public:
  using PrototypeMaker = PrototypePtr (*)(PrototypeConstructorArgs...);
 
 public:
  static Factory& get() {
    static Factory the_factory;
    return the_factory;
  }
 
  template <typename DerivedType>
  uint64_t declare() {
    std::string full_name{boost::core::demangle(typeid(DerivedType).name())};
    library_[full_name] = &maker<DerivedType>;
    return reinterpret_cast<std::uintptr_t>(&library_);
  }
 
  PrototypePtr make(const std::string& full_name,
                    PrototypeConstructorArgs... maker_args) {
    auto lib_it{library_.find(full_name)};
    if (lib_it == library_.end()) {
      EXCEPTION_RAISE("SimFactory", "An object named " + full_name +
                                        " has not been declared.");
    }
    warehouse_.emplace_back(lib_it->second(maker_args...));
    return warehouse_.back();
  }
 
  template <class UnaryFunction>
  void apply(UnaryFunction f) const {
    std::for_each(warehouse_.begin(), warehouse_.end(), f);
  }
 
  Factory(Factory const&) = delete;
 
  void operator=(Factory const&) = delete;
 
 private:
  template <typename DerivedType>
  static PrototypePtr maker(PrototypeConstructorArgs... args) {
    return PrototypePtr(
        new DerivedType(std::forward<PrototypeConstructorArgs>(args)...));
  }
 
  Factory() = default;
 
  std::unordered_map<std::string, PrototypeMaker> library_;
 
  std::vector<PrototypePtr> warehouse_;
};  // Factory
 
}  // namespace simcore
#endif  // SIMCORE_FACTORY_H