origin.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <commons/display_info.hpp>
#include <commons/fixed_string.hpp>
 
#include <concepts>
#include <format>
#include <functional>
#include <map>
#include <memory>
#include <ostream>
#include <string>
#include <string_view>
#include <utility>
 
namespace comms {
 
class IOrigin {
public:
    virtual ~IOrigin() = default;
 
    [[nodiscard]] virtual std::string_view kind() const noexcept = 0;
 
    [[nodiscard]] virtual std::unique_ptr<IOrigin> clone() const = 0;
 
    [[nodiscard]] virtual const DisplayInfo& info() const = 0;
 
protected:
    // Protected to prevent slicing through the interface; derived types remain
    // copyable/movable via their own (implicitly defined) operations.
    IOrigin() = default;
    IOrigin(const IOrigin&) = default;
    IOrigin(IOrigin&&) = default;
    IOrigin& operator=(const IOrigin&) = default;
    IOrigin& operator=(IOrigin&&) = default;
};
 
using OriginPtr = std::unique_ptr<IOrigin>;
 
template <FixedString Kind, typename Derived>
class OriginKind : public IOrigin {
public:
    // KIND keeps the SCREAMING_CASE spelling of the reference's discriminator
    // constant rather than the project's lower_case style — it reads as the
    // type's identity tag and is the recognized convention for it.
    // NOLINTNEXTLINE(readability-identifier-naming)
    static constexpr std::string_view KIND = Kind.view();  
 
    [[nodiscard]] std::string_view kind() const noexcept override {
        return KIND;
    }
 
    [[nodiscard]] std::unique_ptr<IOrigin> clone() const override {
        return std::make_unique<Derived>(static_cast<const Derived&>(*this));
    }
 
    [[nodiscard]] const DisplayInfo& info() const override {
        return Derived::display_info();
    }
};
 
// -- built-in kinds ----------------------------------------------------------
 
class CoreOrigin final : public OriginKind<"core", CoreOrigin> {
public:
    [[nodiscard]] static const DisplayInfo& display_info() {
        static const DisplayInfo info{
            .name = "Core",
            .description = "Registered by the host core itself.",
            .icon = Icon::from("mdi:home"),
        };
        return info;
    }
};
 
class InternalOrigin final : public OriginKind<"internal", InternalOrigin> {
public:
    [[nodiscard]] static const DisplayInfo& display_info() {
        static const DisplayInfo info{
            .name = "Internal",
            .description = "Registered by an internal subsystem.",
            .icon = Icon::from("mdi:cog"),
        };
        return info;
    }
};
 
class ExternalOrigin final : public OriginKind<"external", ExternalOrigin> {
public:
    std::string source;  
 
    ExternalOrigin() = default;
    explicit ExternalOrigin(std::string src) : source(std::move(src)) {}
 
    [[nodiscard]] static const DisplayInfo& display_info() {
        static const DisplayInfo info{
            .name = "External",
            .description = "Registered by an external source.",
            .icon = Icon::from("mdi:web"),
        };
        return info;
    }
};
 
class UnknownOrigin final : public OriginKind<"unknown", UnknownOrigin> {
public:
    [[nodiscard]] static const DisplayInfo& display_info() {
        static const DisplayInfo info{
            .name = "Unknown",
            .description = "Provenance is unknown.",
            .icon = Icon::from("mdi:help-circle"),
        };
        return info;
    }
};
 
// -- registry ----------------------------------------------------------------
 
class GlobalOriginRegistry {
public:
    using Factory = OriginPtr (*)();
 
private:
    std::map<std::string, Factory, std::less<>> factories_;
    GlobalOriginRegistry() = default;
 
public:
    GlobalOriginRegistry(const GlobalOriginRegistry&) = delete;
    GlobalOriginRegistry& operator=(const GlobalOriginRegistry&) = delete;
    GlobalOriginRegistry(GlobalOriginRegistry&&) = delete;
    GlobalOriginRegistry& operator=(GlobalOriginRegistry&&) = delete;
    ~GlobalOriginRegistry() = default;
 
    [[nodiscard]] static GlobalOriginRegistry& instance() noexcept {
        static GlobalOriginRegistry r;
        return r;
    }
 
    bool register_kind(const std::string_view kind, Factory factory) {
        return factories_.emplace(std::string{kind}, factory).second;
    }
 
    [[nodiscard]] OriginPtr create(const std::string_view kind) const {
        if (const auto it = factories_.find(kind); it != factories_.end()) {
            return it->second();
        }
        return nullptr;
    }
 
    [[nodiscard]] bool contains(const std::string_view kind) const {
        return factories_.contains(kind);
    }
};
 
template <typename T>
struct OriginRegistrar {
    OriginRegistrar() noexcept {
        GlobalOriginRegistry::instance().register_kind(
            T::KIND, []() -> OriginPtr { return std::make_unique<T>(); });
    }
};
 
}  // namespace comms
 
// NOLINTNEXTLINE(bugprone-macro-parentheses)
#define COMMONS_REGISTER_ORIGIN(Ident)                                                             \
    inline const ::comms::OriginRegistrar<Ident> commons_origin_registrar_##Ident {}
 
namespace comms {
 
// The built-in kinds self-register so the JSON `from_json` dispatch resolves them.
COMMONS_REGISTER_ORIGIN(CoreOrigin);
COMMONS_REGISTER_ORIGIN(InternalOrigin);
COMMONS_REGISTER_ORIGIN(ExternalOrigin);
COMMONS_REGISTER_ORIGIN(UnknownOrigin);
 
// ---------------------------------------------------------------------------
// Text output: to_string + std::ostream insertion. (std::format support is the
// std::formatter specialization below, outside namespace comms.) Both accept any
// origin by upcast to the IOrigin base.
// ---------------------------------------------------------------------------
 
[[nodiscard]] inline std::string to_string(const IOrigin& o) {
    return std::string{o.kind()};
}
 
inline std::ostream& operator<<(std::ostream& os, const IOrigin& o) {
    return os << o.kind();
}
 
}  // namespace comms
 
// ---------------------------------------------------------------------------
// std::format support. A partial specialization constrained to IOrigin-derived
// types so any concrete origin (or an IOrigin reference) formats, mirroring the
// adl_serializer route used in json.hpp.
// ---------------------------------------------------------------------------
 
// This spec-less formatter reads no member state, but `std::formatter` requires
// `parse`/`format` to be non-static members — so silence the convert-to-static
// suggestion here.
// NOLINTBEGIN(readability-convert-member-functions-to-static)
 
template <typename T>
    requires std::derived_from<T, comms::IOrigin>
struct std::formatter<T> {
    constexpr auto parse(const std::format_parse_context& ctx) {
        const auto* it = ctx.begin();
        if (it != ctx.end() && *it != '}') {
            throw std::format_error("commons: IOrigin takes no format spec");
        }
        return it;
    }
 
    auto format(const comms::IOrigin& o, std::format_context& ctx) const {
        return std::format_to(ctx.out(), "{}", comms::to_string(o));
    }
};  // namespace std
 
// NOLINTEND(readability-convert-member-functions-to-static)