parcel.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <commons/color.hpp>
#include <commons/icons.hpp>
#include <md/json.hpp>  // brings ADL to_json/from_json for md::Value/Object
#include <md/object.hpp>
#include <md/ostream.hpp>  // operator<< for to_string()
#include <md/value.hpp>
 
#include <memory>
#include <sstream>
#include <string>
#include <string_view>
 
#include <parcel/parcel.h>
 
namespace md {
 
class ValueCell : public parcel::BaseCell<ValueCell, Value> {
    using base_t = parcel::BaseCell<ValueCell, Value>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
 
    static constexpr std::string_view kind_id = "md:v";
 
    [[nodiscard]] std::string to_string() const override {
        std::ostringstream os;
        os << this->value;
        return os.str();
    }
 
    [[maybe_unused]] static parcel::cell_t from_json(parcel::json_t const& j,
                                                     parcel::ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static parcel::cell_type_descriptor_t descriptor() {
        static const auto d =
            std::make_shared<parcel::SimpleCellTypeDescriptor<ValueCell>>(parcel::DisplayInfo{
                .name = "md::Value",
                .description = "Dynamic JSON-shaped value from the metadata library.",
                .icon = comms::Icons::mdi::variable,
                .color = comms::Colors::mui::deep_purple[500],
            });
        return d;
    }
};
 
class ObjectCell : public parcel::BaseCell<ObjectCell, Object> {
    using base_t = parcel::BaseCell<ObjectCell, Object>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
 
    ObjectCell(std::initializer_list<Object::value_type> il) : base_t(Object(il)) {}
 
    static constexpr std::string_view kind_id = "md:o";
 
    [[nodiscard]] std::string to_string() const override {
        std::ostringstream os;
        os << this->value;
        return os.str();
    }
 
    [[maybe_unused]] static parcel::cell_t from_json(parcel::json_t const& j,
                                                     parcel::ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static parcel::cell_type_descriptor_t descriptor() {
        static const auto d =
            std::make_shared<parcel::SimpleCellTypeDescriptor<ObjectCell>>(parcel::DisplayInfo{
                .name = "md::Object",
                .description = "Unordered string-keyed map of md::Value (md::Object/Metadata).",
                .icon = comms::Icons::mdi::code_braces,
                .color = comms::Colors::mui::amber[700],
            });
        return d;
    }
};
 
class ArrayCell : public parcel::BaseCell<ArrayCell, Array> {
    using base_t = parcel::BaseCell<ArrayCell, Array>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
 
    template <class T0, class T1, class... Rest>
        requires(std::constructible_from<Value, T0 &&> && std::constructible_from<Value, T1 &&> &&
                 (std::constructible_from<Value, Rest &&> && ...))
    ArrayCell(T0&& a, T1&& b, Rest&&... rest)
        : base_t(Array{Value(std::forward<T0>(a)),
                       Value(std::forward<T1>(b)),
                       Value(std::forward<Rest>(rest))...}) {}
 
    static constexpr std::string_view kind_id = "md:a";
 
    [[nodiscard]] std::string to_string() const override {
        std::ostringstream os;
        os << this->value;
        return os.str();
    }
 
    [[maybe_unused]] static parcel::cell_t from_json(parcel::json_t const& j,
                                                     parcel::ParcelRegistry const&) {
        return base_t::from_json_strict(j);
    }
 
    static parcel::cell_type_descriptor_t descriptor() {
        static const auto d =
            std::make_shared<parcel::SimpleCellTypeDescriptor<ArrayCell>>(parcel::DisplayInfo{
                .name = "md::Array",
                .description = "Heterogeneous vector of md::Value (md::Array).",
                .icon = comms::Icons::mdi::code_brackets,
                .color = comms::Colors::mui::green[600],
            });
        return d;
    }
};
 
inline void register_cells(parcel::ParcelRegistry& registry) {
    registry.register_kind(ValueCell::descriptor());
    registry.register_kind(ObjectCell::descriptor());
    registry.register_kind(ArrayCell::descriptor());
}
 
}  // namespace md
 
// FieldsBuilder/parcel::cell(...) inference hooks. Each macro expands to a
// `parcel::default_cell_for<Storage>` specialization at namespace scope.
PARCEL_DEFAULT_CELL(md::ValueCell);
PARCEL_DEFAULT_CELL(md::ObjectCell);
PARCEL_DEFAULT_CELL(md::ArrayCell);
 
#define METADATA_HAS_PARCEL 1