object_factory.hpp

Go to the documentation of this file.

//   ___ __  __ ___ 
//  / __|  \/  | _ \ GMP(Generative Metaprogramming)
// | (_ | |\/| |  _/ version 0.3.0
//  \___|_|  |_|_|   https://github.com/lkimuk/gmp
//
// SPDX-FileCopyrightText: 2020-2026 Miles Li <https://www.cppmore.com/>
// SPDX-License-Identifier: MIT
//
// This file is part of the GMP (Generative Metaprogramming) library.
// Full project source: https://github.com/lkimuk/gmp
//
// This object factory implementation was originally written by the same author
// for the okdp library in 2020 and later adapted for GMP:
// https://github.com/lkimuk/okdp
 
#ifndef GMP_DP_OBJECT_FACTORY_HPP_
#define GMP_DP_OBJECT_FACTORY_HPP_
 
#include <functional>
#include <map>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
 
#include <gmp/dp/singleton.hpp>
#include <gmp/macro/macro.hpp>
 
#if GMP_CPP_AT_LEAST(20)
#include <concepts>
#endif // C++20 or later
 
namespace gmp {
 
template <typename AbstractProduct, typename... ConstructorArgs>
class object_factory : public singleton<object_factory<AbstractProduct, ConstructorArgs...>> {
  using this_type = object_factory<AbstractProduct, ConstructorArgs...>;
 
public:
  template <typename T>
#if GMP_CPP_AT_LEAST(20)
    requires std::derived_from<T, AbstractProduct>
#endif
  struct register_type {
    // Registers T into object factory
    register_type(const std::string& key) {
      this_type::instance().map_.emplace(key,
        [](const ConstructorArgs&... args) { return new T(args...); });
    }
  };
 
  void unregister_type(const std::string& key) {
    this_type::instance().map_.erase(key);
  }
 
  bool contains(const std::string& key) const {
    return this_type::instance().map_.find(key) != this_type::instance().map_.end();
  }
 
  std::vector<std::string> registered_keys() const {
    std::vector<std::string> keys;
    keys.reserve(this_type::instance().map_.size());
    for (const auto& entry : this_type::instance().map_) {
      keys.push_back(entry.first);
    }
    return keys;
  }
 
  AbstractProduct* create(const std::string& key, const ConstructorArgs&... args) const {
    auto product = try_create_unique(key, args...);
    if (!product) {
      throw std::invalid_argument("Unknown object type passed to factory!");
    }
    return product.release();
  }
 
  std::shared_ptr<AbstractProduct> create_shared(
    const std::string& key, const ConstructorArgs&... args) const {
    return std::shared_ptr<AbstractProduct>(create(key, args...));
  }
 
  std::unique_ptr<AbstractProduct> create_unique(
    const std::string& key, const ConstructorArgs&... args) const {
    return std::unique_ptr<AbstractProduct>(create(key, args...));
  }
 
  std::unique_ptr<AbstractProduct> try_create_unique(
    const std::string& key, const ConstructorArgs&... args) const {
    const auto& map = this_type::instance().map_;
    const auto found = map.find(key);
    if (found == map.end()) {
      return {};
    }
    return std::unique_ptr<AbstractProduct>(found->second(args...));
  }
 
  std::shared_ptr<AbstractProduct> try_create_shared(
    const std::string& key, const ConstructorArgs&... args) const {
    return std::shared_ptr<AbstractProduct>(try_create_unique(key, args...));
  }
 
private:
  std::map<std::string, std::function<AbstractProduct*(const ConstructorArgs&... args)>> map_;
};
 
#define _GMP_GET_CONCRETE_PRODUCT_CLASS(ConcreteProduct) GMP_IF_THEN_ELSE(GMP_IS_TUPLE(ConcreteProduct), GMP_TUPLE_GET, ConcreteProduct)GMP_IF(GMP_IS_TUPLE(ConcreteProduct), (1, ConcreteProduct))
#define _GMP_GET_CONSTRUCTOR_TYPES(ConstructorArgs) GMP_IF_THEN_ELSE(GMP_IS_TUPLE(ConstructorArgs), GMP_REMOVE_PARENS, ConstructorArgs)GMP_IF(GMP_IS_TUPLE(ConstructorArgs), (ConstructorArgs))
#define GMP_FACTORY_REGISTER_WITH_ARGS(AbstractProduct, ConstructorArgs, ConcreteProduct) \
  static gmp::object_factory<AbstractProduct, _GMP_GET_CONSTRUCTOR_TYPES(ConstructorArgs)>::register_type<_GMP_GET_CONCRETE_PRODUCT_CLASS(ConcreteProduct)> \
        GMP_CONCAT(gmp_reg_, __COUNTER__)(GMP_IF_THEN_ELSE(GMP_IS_TUPLE(ConcreteProduct), GMP_TUPLE_GET(0, ConcreteProduct), GMP_STRINGIFY(ConcreteProduct)));
#define GMP_FACTORY_REGISTER_NO_ARGS(AbstractProduct, ConcreteProduct) \
    static gmp::object_factory<AbstractProduct>::register_type<_GMP_GET_CONCRETE_PRODUCT_CLASS(ConcreteProduct)> \
        GMP_CONCAT(gmp_reg_, __COUNTER__)(GMP_IF_THEN_ELSE(GMP_IS_TUPLE(ConcreteProduct), GMP_TUPLE_GET(0, ConcreteProduct), GMP_STRINGIFY(ConcreteProduct)));
 
#define GMP_FACTORY_REGISTER(AbstractProduct, ConstructorArgs, ...) \
  GMP_EVAL( _GMP_FACTORY_REGISTER_IMPL(AbstractProduct, ConstructorArgs, __VA_ARGS__) )
#define _GMP_FACTORY_REGISTER_IMPL(AbstractProduct, ConstructorArgs, ...) \
  _GMP_FACTORY_REGISTER_IMPL_COMPAT_MSVC(AbstractProduct, ConstructorArgs, GMP_IS_EMPTY(__VA_ARGS__), GMP_TUPLE_EMPTY(ConstructorArgs), __VA_ARGS__)
#if GMP_STANDARD_PREPROCESSOR
#define _GMP_FACTORY_REGISTER_IMPL_COMPAT_MSVC(AbstractProduct, ConstructorArgs, _0, _1, ...) \
  GMP_OVERLOAD_INVOKE(_GMP_FACTORY_REGISTER_WHEN, _0, _1)(AbstractProduct, ConstructorArgs, __VA_ARGS__)
#else
#define _GMP_FACTORY_REGISTER_IMPL_COMPAT_MSVC(AbstractProduct, ConstructorArgs, _0, _1, ...) \
  GMP_EXPAND( GMP_OVERLOAD_INVOKE(_GMP_FACTORY_REGISTER_WHEN, _0, _1)(AbstractProduct, ConstructorArgs, __VA_ARGS__) )
#endif
#define _GMP_FACTORY_REGISTER_WHEN_1(...)
#define _GMP_FACTORY_REGISTER_WHEN_0_1(AbstractProduct, ConstructorArgs, ConcreteProduct, ...) \
  GMP_FACTORY_REGISTER_NO_ARGS(AbstractProduct, ConcreteProduct) \
  GMP_IF(GMP_BOOL(GMP_SIZE_OF_VAARGS(__VA_ARGS__)), _GMP_FACTORY_REGISTER_WHEN_1_CONTINUE) GMP_IF(GMP_BOOL(GMP_SIZE_OF_VAARGS(__VA_ARGS__)), (AbstractProduct, ConstructorArgs, __VA_ARGS__))
#define _GMP_FACTORY_REGISTER_WHEN_0_0(AbstractProduct, ConstructorArgs, ConcreteProduct, ...) \
  GMP_FACTORY_REGISTER_WITH_ARGS(AbstractProduct, ConstructorArgs, ConcreteProduct) \
  GMP_IF(GMP_BOOL(GMP_SIZE_OF_VAARGS(__VA_ARGS__)), _GMP_FACTORY_REGISTER_WHEN_1_CONTINUE) GMP_IF(GMP_BOOL(GMP_SIZE_OF_VAARGS(__VA_ARGS__)), (AbstractProduct, ConstructorArgs, __VA_ARGS__))
#define _GMP_FACTORY_REGISTER_WHEN_1_CONTINUE(AbstractProduct, ConstructorArgs, ...) \
  GMP_DEFER(_GMP_FACTORY_REGISTER_INDIRECT)()(AbstractProduct, ConstructorArgs, __VA_ARGS__)
#define _GMP_FACTORY_REGISTER_INDIRECT() _GMP_FACTORY_REGISTER_IMPL
 
} // namespace gmp
 
#endif // GMP_DP_OBJECT_FACTORY_HPP_