ComponentFactory.hpp

Go to the documentation of this file.

#pragma once

 
#include <icarus/core/Component.hpp>
#include <icarus/core/ComponentConfig.hpp>
#include <icarus/core/Error.hpp>
 
#include <janus/core/JanusTypes.hpp>
 
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace icarus {

template <typename Scalar> class ComponentFactory {
  public:
    using Creator = std::function<std::unique_ptr<Component<Scalar>>(const ComponentConfig &)>;

    void Register(const std::string &type_name, Creator creator) {
        creators_[type_name] = std::move(creator);
    }

    [[nodiscard]] std::unique_ptr<Component<Scalar>> Create(const ComponentConfig &config) {
        auto it = creators_.find(config.type);
        if (it == creators_.end()) {
            throw ConfigError("Unknown component type: '" + config.type +
                              "'. Registered types: " + ListTypesString());
        }
        return it->second(config);
    }

    [[nodiscard]] bool HasType(const std::string &type_name) const {
        return creators_.count(type_name) > 0;
    }

    [[nodiscard]] std::vector<std::string> GetRegisteredTypes() const {
        std::vector<std::string> types;
        types.reserve(creators_.size());
        for (const auto &pair : creators_) {
            types.push_back(pair.first);
        }
        return types;
    }

    [[nodiscard]] std::size_t NumRegistered() const { return creators_.size(); }

    static ComponentFactory &Instance() {
        static ComponentFactory instance;
        return instance;
    }

    void Clear() { creators_.clear(); }
 
  private:
    ComponentFactory() = default;
 
    [[nodiscard]] std::string ListTypesString() const {
        std::string result;
        for (const auto &pair : creators_) {
            if (!result.empty())
                result += ", ";
            result += pair.first;
        }
        return result.empty() ? "(none)" : result;
    }
 
    std::unordered_map<std::string, Creator> creators_;
};
 
// =============================================================================
// Registration Macros
// =============================================================================

#define ICARUS_REGISTER_COMPONENT(ComponentType)                                                   \
    namespace {                                                                                    \
    static bool _reg_numeric_##ComponentType = []() {                                              \
        ::icarus::ComponentFactory<janus::NumericScalar>::Instance().Register(                     \
            #ComponentType, [](const ::icarus::ComponentConfig &config) {                          \
                auto comp = std::make_unique<ComponentType<janus::NumericScalar>>(config.name,     \
                                                                                  config.entity);  \
                comp->SetConfig(config);                                                           \
                return comp;                                                                       \
            });                                                                                    \
        return true;                                                                               \
    }();                                                                                           \
    static bool _reg_symbolic_##ComponentType = []() {                                             \
        ::icarus::ComponentFactory<janus::SymbolicScalar>::Instance().Register(                    \
            #ComponentType, [](const ::icarus::ComponentConfig &config) {                          \
                auto comp = std::make_unique<ComponentType<janus::SymbolicScalar>>(config.name,    \
                                                                                   config.entity); \
                comp->SetConfig(config);                                                           \
                return comp;                                                                       \
            });                                                                                    \
        return true;                                                                               \
    }();                                                                                           \
    }

#define ICARUS_REGISTER_COMPONENT_IMPL2(ComponentType, TypeName, Counter)                          \
    namespace {                                                                                    \
    static const bool _icarus_reg_numeric_##Counter = []() {                                       \
        ::icarus::ComponentFactory<janus::NumericScalar>::Instance().Register(                     \
            TypeName, [](const ::icarus::ComponentConfig &config) {                                \
                auto comp = std::make_unique<ComponentType<janus::NumericScalar>>(config.name,     \
                                                                                  config.entity);  \
                comp->SetConfig(config);                                                           \
                return comp;                                                                       \
            });                                                                                    \
        return true;                                                                               \
    }();                                                                                           \
    static const bool _icarus_reg_symbolic_##Counter = []() {                                      \
        ::icarus::ComponentFactory<janus::SymbolicScalar>::Instance().Register(                    \
            TypeName, [](const ::icarus::ComponentConfig &config) {                                \
                auto comp = std::make_unique<ComponentType<janus::SymbolicScalar>>(config.name,    \
                                                                                   config.entity); \
                comp->SetConfig(config);                                                           \
                return comp;                                                                       \
            });                                                                                    \
        return true;                                                                               \
    }();                                                                                           \
    }
 
#define ICARUS_REGISTER_COMPONENT_IMPL(ComponentType, TypeName, Counter)                           \
    ICARUS_REGISTER_COMPONENT_IMPL2(ComponentType, TypeName, Counter)
 
#define ICARUS_REGISTER_COMPONENT_AS(ComponentType, TypeName)                                      \
    ICARUS_REGISTER_COMPONENT_IMPL(ComponentType, TypeName, __COUNTER__)

#define ICARUS_REGISTER_COMPONENT_WITH_CREATOR_IMPL2(TypeName, CreatorLambda, Counter)             \
    namespace {                                                                                    \
    static bool _icarus_reg_creator_##Counter = []() {                                             \
        ::icarus::ComponentFactory<janus::NumericScalar>::Instance().Register(TypeName,            \
                                                                              CreatorLambda);      \
        return true;                                                                               \
    }();                                                                                           \
    }
 
#define ICARUS_REGISTER_COMPONENT_WITH_CREATOR_IMPL(TypeName, CreatorLambda, Counter)              \
    ICARUS_REGISTER_COMPONENT_WITH_CREATOR_IMPL2(TypeName, CreatorLambda, Counter)
 
#define ICARUS_REGISTER_COMPONENT_WITH_CREATOR(TypeName, CreatorLambda)                            \
    ICARUS_REGISTER_COMPONENT_WITH_CREATOR_IMPL(TypeName, CreatorLambda, __COUNTER__)
 
} // namespace icarus