registry.h

Go to the documentation of this file.

#pragma once
 
#include <parcel/cell.h>
#include <parcel/descriptor.h>
#include <parcel/error.h>
#include <parcel/json.h>
 
#include <cstddef>
#include <functional>
#include <map>
#include <memory>
#include <ranges>
#include <stdexcept>
#include <string>
#include <string_view>
#include <typeindex>
#include <typeinfo>
#include <utility>
#include <vector>
 
#if PARCEL_HAS_EXPECTED
#include <expected>
#endif
 
namespace parcel {
 
struct BuiltinsOptions {
    bool primitives = true;
    bool collections = true;
    bool typed_collections = true;
    bool std = true;
    bool commons = true;
    bool ulid = true;
};
 
struct Definition {
    cell_type_descriptor_t root;
    std::map<std::string, cell_type_descriptor_t, std::less<>> referenced;
 
    [[nodiscard]] json_t to_json() const {
        json_t refs = json_t::object();
        for (auto const& [k, d] : referenced) {
            refs[k] = d->to_json();
        }
        return json_t{
            {"root", root->to_json()},
            {"referenced", std::move(refs)},
        };
    }
};
 
class ParcelRegistry {
    std::map<std::string, cell_type_descriptor_t, std::less<>> by_kind_;
 
public:
    explicit ParcelRegistry(BuiltinsOptions opts = {});
 
    void register_kind(cell_type_descriptor_t d);
 
    template <typename... Ds>
    ParcelRegistry& register_kinds(Ds&&... ds) {
        (register_kind(std::forward<Ds>(ds)), ...);
        return *this;
    }
 
    template <typename... Cs>
    ParcelRegistry& register_cells() {
        (register_kind(Cs::descriptor()), ...);
        return *this;
    }
 
    [[nodiscard]] cell_type_descriptor_t find(std::string_view kind) const;
 
    [[nodiscard]] cell_t cell_from_json(json_t const& j) const;
 
#if PARCEL_HAS_EXPECTED
    [[nodiscard]] std::expected<cell_t, ParcelError> try_cell_from_json(json_t const& j) const;
 
    [[nodiscard]] std::expected<cell_t, ParcelError> try_cell_from_string(std::string_view s) const;
#endif
 
    [[nodiscard]] std::vector<cell_type_descriptor_t> all() const;
 
    [[nodiscard]] std::vector<std::string_view> kinds() const;
 
    [[nodiscard]] std::size_t count() const noexcept;
 
    [[nodiscard]] bool contains(std::string_view kind) const;
 
    [[nodiscard]] std::vector<cell_type_descriptor_t>
    find_by_category(descriptor::CellCategory c) const;
 
    [[nodiscard]] std::vector<cell_type_descriptor_t> find_by_storage(std::type_index ti) const;
 
    template <typename T>
    [[nodiscard]] std::vector<cell_type_descriptor_t> find_by_storage() const {
        return find_by_storage(std::type_index(typeid(T)));
    }
 
    [[nodiscard]] Definition define(std::string_view kind) const;
};
 
inline void ParcelRegistry::register_kind(cell_type_descriptor_t d) {
    if (d == nullptr) {
        throw std::runtime_error("ParcelRegistry::register_kind: null descriptor");
    }
    by_kind_.insert_or_assign(std::string(d->kind()), std::move(d));
}
 
inline cell_type_descriptor_t ParcelRegistry::find(const std::string_view kind) const {
    if (const auto it = by_kind_.find(kind); it != by_kind_.end()) {
        return it->second;
    }
    return nullptr;
}
 
inline cell_t ParcelRegistry::cell_from_json(json_t const& j) const {
    if (!j.is_object()) {
        throw InvalidJsonException("ParcelRegistry::cell_from_json: expected JSON object");
    }
    const auto it_k = j.find(ICell::KEY_KIND);
    if (it_k == j.end() || !it_k->is_string()) {
        throw InvalidJsonException("ParcelRegistry::cell_from_json: missing/invalid 'k'");
    }
    const auto kind = it_k->get<std::string_view>();
    const auto desc = find(kind);
    if (desc == nullptr) {
        throw UnknownKindException("ParcelRegistry::cell_from_json: unknown kind '" +
                                       std::string(kind) + "'",
                                   std::string(kind));
    }
    return desc->cell_from_json(j, *this);
}
 
#if PARCEL_HAS_EXPECTED
inline std::expected<cell_t, ParcelError>
ParcelRegistry::try_cell_from_json(json_t const& j) const {
    if (!j.is_object()) {
        return std::unexpected(
            ParcelError::make(ParcelError::Code::InvalidJson, "expected JSON object"));
    }
    const auto it_k = j.find(ICell::KEY_KIND);
    if (it_k == j.end() || !it_k->is_string()) {
        return std::unexpected(
            ParcelError::make(ParcelError::Code::InvalidJson, "missing or non-string 'k'"));
    }
    const auto kind = it_k->get<std::string_view>();
    const auto desc = find(kind);
    if (desc == nullptr) {
        return std::unexpected(
            ParcelError::make(ParcelError::Code::UnknownKind, "unknown kind", std::string(kind)));
    }
    try {
        return desc->cell_from_json(j, *this);
    } catch (ParcelException const& e) {
        // Preserve the structured code / kind / field carried by the
        // exception. If the throw site didn't tag a kind, fall back to the
        // dispatch kind we already know.
        auto err = e.to_error();
        if (err.kind.empty()) {
            err.kind = std::string(kind);
        }
        return std::unexpected(std::move(err));
    } catch (std::exception const& e) {
        return std::unexpected(
            ParcelError::make(ParcelError::Code::TypeError, e.what(), std::string(kind)));
    } catch (...) {
        return std::unexpected(ParcelError::make(
            ParcelError::Code::TypeError, "unknown deserialization error", std::string(kind)));
    }
}
 
inline std::expected<cell_t, ParcelError>
ParcelRegistry::try_cell_from_string(std::string_view s) const {
    json_t j;
    try {
        j = json_t::parse(s);
    } catch (std::exception const& e) {
        return std::unexpected(ParcelError::make(ParcelError::Code::InvalidJson, e.what()));
    } catch (...) {
        return std::unexpected(
            ParcelError::make(ParcelError::Code::InvalidJson, "JSON parse failed"));
    }
    return try_cell_from_json(j);
}
#endif
 
inline std::vector<cell_type_descriptor_t> ParcelRegistry::all() const {
    std::vector<cell_type_descriptor_t> out;
    out.reserve(by_kind_.size());
    for (const auto& d : by_kind_ | std::views::values) {
        out.push_back(d);
    }
    return out;
}
 
inline std::vector<std::string_view> ParcelRegistry::kinds() const {
    std::vector<std::string_view> out;
    out.reserve(by_kind_.size());
    for (const auto& d : by_kind_ | std::views::values) {
        out.push_back(d->kind());
    }
    return out;
}
 
inline std::size_t ParcelRegistry::count() const noexcept {
    return by_kind_.size();
}
 
inline bool ParcelRegistry::contains(const std::string_view kind) const {
    return by_kind_.contains(kind);
}
 
inline std::vector<cell_type_descriptor_t>
ParcelRegistry::find_by_category(const descriptor::CellCategory c) const {
    std::vector<cell_type_descriptor_t> out;
    for (const auto& d : by_kind_ | std::views::values) {
        if (d->category() == c) {
            out.push_back(d);
        }
    }
    return out;
}
 
inline std::vector<cell_type_descriptor_t>
ParcelRegistry::find_by_storage(const std::type_index ti) const {
    std::vector<cell_type_descriptor_t> out;
    for (const auto& d : by_kind_ | std::views::values) {
        if (d->storage_type() == ti) {
            out.push_back(d);
        }
    }
    return out;
}
 
inline Definition ParcelRegistry::define(const std::string_view kind) const {
    const auto root = find(kind);
    if (root == nullptr) {
        throw UnknownKindException(
            "ParcelRegistry::define: unknown kind '" + std::string(kind) + "'", std::string(kind));
    }
    Definition out{root, {}};
    std::vector<std::string_view> queue;
 
    auto enqueue_subs = [&](cell_type_descriptor_t const& d) {
        if (auto const* st = dynamic_cast<ISubTypes const*>(d.get()); st != nullptr) {
            for (auto sk : st->sub_kinds()) {
                queue.push_back(sk);
            }
        }
    };
 
    enqueue_subs(root);
    while (!queue.empty()) {
        auto k = queue.back();
        queue.pop_back();
        if (k == root->kind()) {
            continue;
        }
        if (out.referenced.contains(k)) {
            continue;
        }
        auto d = find(k);
        if (d == nullptr) {
            throw UnknownKindException(
                "ParcelRegistry::define: kind '" + std::string(root->kind()) +
                    "' references unregistered kind '" + std::string(k) + "'",
                std::string(k));
        }
        out.referenced.emplace(std::string(k), d);
        enqueue_subs(d);
    }
    return out;
}
 
}  // namespace parcel