Factory.h

#ifndef FIRE_FACTORY_FACTORY_H
#define FIRE_FACTORY_FACTORY_H
 
#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 <boost/core/demangle.hpp> // for demangling
 
#include "fire/exception/Exception.h"
 
namespace fire::factory {
 
void loadLibrary(const std::string& libname);
 
template <typename Prototype,
          typename PrototypePtr = std::unique_ptr<Prototype>,
          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()) {
      throw Exception("Factory","An object named " + full_name +
                       " has not been declared.",false);
    }
    return lib_it->second(maker_args...);
  }
 
  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_;
};  // Factory
 
}  // namespace fire::factory
 
#endif  // FACTORY_FACTORY_H