Factory.h

Go to the documentation of this file.

 
#ifndef FRAMEWORK_FACTORY_H
#define FRAMEWORK_FACTORY_H
 
#include <algorithm>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "Framework/Exception/Exception.h"
 
namespace framework {
 
template <typename Prototype, typename PrototypePtr,
          typename... PrototypeConstructorArgs>
class Factory {
 public:
  using PrototypeMaker = PrototypePtr (*)(PrototypeConstructorArgs...);
 
 public:
  template <typename DerivedType>
  uint64_t declare(const std::string& derived_type_name) {
    library_[derived_type_name] = &maker<DerivedType>;
    return reinterpret_cast<std::uintptr_t>(&library_);
  }
 
  [[nodiscard]] virtual std::optional<PrototypePtr> make(
      const std::string& full_name, PrototypeConstructorArgs... maker_args) {
    auto lib_it{library_.find(full_name)};
    if (lib_it == library_.end()) {
      return std::nullopt;
    }
    return lib_it->second(maker_args...);
  }
 
  Factory(Factory const&) = delete;
 
  void operator=(Factory const&) = delete;
 
  Factory() = default;
 
  virtual ~Factory() = default;
 
 private:
  template <typename DerivedType>
  static PrototypePtr maker(PrototypeConstructorArgs... args) {
    return PrototypePtr(
        new DerivedType(std::forward<PrototypeConstructorArgs>(args)...));
  }
 
  std::unordered_map<std::string, PrototypeMaker> library_;
};  // Factory
 
template <typename Prototype, typename PrototypePtr,
          typename... PrototypeConstructorArgs>
class FactoryWithWarehouse
    : public Factory<Prototype, PrototypePtr, PrototypeConstructorArgs...> {
 public:
  using FactoryNoWarehouse =
      Factory<Prototype, PrototypePtr, PrototypeConstructorArgs...>;
 
  [[nodiscard]] std::optional<PrototypePtr> make(
      const std::string& full_name,
      PrototypeConstructorArgs... maker_args) override {
    auto obj{FactoryNoWarehouse::make(full_name, maker_args...)};
    if (obj) {
      warehouse_.emplace_back(obj.value());
    }
    return obj;
  }
 
  template <class UnaryFunction>
  void apply(UnaryFunction f) const {
    std::for_each(warehouse_.begin(), warehouse_.end(), f);
  }
 
  FactoryWithWarehouse(FactoryWithWarehouse const&) = delete;
 
  void operator=(FactoryWithWarehouse const&) = delete;
 
  FactoryWithWarehouse() = default;
 
 private:
  std::vector<PrototypePtr> warehouse_;
};  // FactoryWithWarehouse
 
}  // namespace framework
 
#define DECLARE_FACTORY(...)                                  \
  struct Factory : public ::framework::Factory<__VA_ARGS__> { \
    static Factory& get();                                    \
  }
 
#define DECLARE_FACTORY_WITH_WAREHOUSE(...)                                \
  struct Factory : public ::framework::FactoryWithWarehouse<__VA_ARGS__> { \
    static Factory& get();                                                 \
  }
 
#define DEFINE_FACTORY(classtype)                 \
  classtype::Factory& classtype::Factory::get() { \
    static classtype::Factory the_factory;        \
    return the_factory;                           \
  }
 
#define _CONCAT_INTERNAL(a, b) a##b
 
#define _CONCAT(a, b) _CONCAT_INTERNAL(a, b)
 
#define UNIQUE(a) _CONCAT(a, __COUNTER__)
 
#define FACTORY_REGISTRATION(prototype, derived)                             \
  namespace {                                                                \
  auto UNIQUE(v) = ::prototype::Factory::get().declare<::derived>(#derived); \
  }
 
#endif