event_type_registry.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <conduit/event.hpp>
#include <conduit/exception.hpp>
 
#include <concepts>
#include <optional>
#include <shared_mutex>
#include <string>
#include <string_view>
#include <vector>
 
#include <parcel/parcel.h>
 
namespace conduit {
 
struct EventTypeInfo {
    std::string_view name;     
    std::string_view kind_id;  
    parcel::cell_type_descriptor_t descriptor;
 
    [[nodiscard]] parcel::DisplayInfo display_info() const {
        return descriptor->display_info();
    }
 
    [[nodiscard]] parcel::json_t schema() const {
        return descriptor->to_json();
    }
};
 
class EventTypeRegistry {
public:
    EventTypeRegistry() = default;
 
    template <typename T>
    EventTypeRegistry& add() {
        static_assert(std::derived_from<T, parcel::ICell>,
                      "EventTypeRegistry::add<T>: T must be a parcel ICell-derived event type");
        std::unique_lock lock(mu_);
        registry_.register_kind(T::descriptor());
        return *this;
    }
 
    [[nodiscard]] std::vector<EventTypeInfo> types() const {
        std::shared_lock lock(mu_);
        std::vector<EventTypeInfo> out;
        for (const auto& desc : registry_.all()) {
            const std::string_view kind = desc->kind();
            if (!kind.starts_with(event_kind_prefix)) {
                continue;
            }
            out.push_back(EventTypeInfo{
                .name = kind.substr(event_kind_prefix.size()),
                .kind_id = kind,
                .descriptor = desc,
            });
        }
        return out;
    }
 
    [[nodiscard]] std::optional<EventTypeInfo> find(const std::string_view name_or_kind) const {
        std::shared_lock lock(mu_);
        const auto desc = resolve(name_or_kind);
        if (!desc) {
            return std::nullopt;
        }
        const std::string_view kind = desc->kind();
        return EventTypeInfo{
            .name = kind.substr(event_kind_prefix.size()),
            .kind_id = kind,
            .descriptor = desc,
        };
    }
 
    [[nodiscard]] bool contains(const std::string_view name_or_kind) const {
        std::shared_lock lock(mu_);
        return resolve(name_or_kind) != nullptr;
    }
 
    [[nodiscard]] parcel::json_t schema(const std::string_view name_or_kind) const {
        std::shared_lock lock(mu_);
        const auto desc = resolve(name_or_kind);
        if (!desc) {
            throw UnknownEventTypeError{"EventTypeRegistry::schema: unknown event type '" +
                                        std::string{name_or_kind} + "'"};
        }
        return desc->to_json();
    }
 
private:
    [[nodiscard]] parcel::cell_type_descriptor_t
    resolve(const std::string_view name_or_kind) const {
        if (name_or_kind.starts_with(event_kind_prefix)) {
            return registry_.find(name_or_kind);
        }
        std::string kind;
        kind.reserve(event_kind_prefix.size() + name_or_kind.size());
        kind.append(event_kind_prefix).append(name_or_kind);
        return registry_.find(kind);
    }
 
    mutable std::shared_mutex mu_;
    parcel::ParcelRegistry registry_;
};
 
[[nodiscard]] inline EventTypeRegistry& global_event_types() {
    static EventTypeRegistry r;
    return r;
}
 
template <typename T>
struct EventTypeRegistrar {
    EventTypeRegistrar() noexcept {
        global_event_types().add<T>();
    }
};
 
[[nodiscard]] inline std::vector<EventTypeInfo> registered_event_types() {
    return global_event_types().types();
}
 
}  // namespace conduit
 
#define CONDUIT_REGISTER_EVENT(Ident)                                                              \
    inline const ::conduit::EventTypeRegistrar<Ident> conduit_event_type_registrar_##Ident {}