struct.h

Go to the documentation of this file.

#pragma once
 
#include <parcel/cell.h>
#include <parcel/defaults.h>
#include <parcel/descriptor.h>
#include <parcel/list.h>
#include <parcel/map.h>
#include <parcel/primitive.h>
#include <parcel/registry.h>
 
#include <algorithm>
#include <map>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace parcel {
class ParcelRegistry;
 
namespace detail {
 
template <typename T>
struct member_pointer_traits;
 
template <typename C, typename F>
struct member_pointer_traits<F C::*> {
    using class_type = C;
    using field_type = F;
};
 
template <typename T>
struct is_optional : std::false_type {};
template <typename U>
struct is_optional<std::optional<U>> : std::true_type {};
 
template <typename T>
inline constexpr bool is_optional_v = is_optional<T>::value;
 
}  // namespace detail
 
template <typename Payload>
struct IPayloadFieldDescriptor : virtual IFieldDescriptor {
    virtual void to_json_into(json_t& v_obj, Payload const& p) const = 0;
 
    virtual void
    from_json_into(json_t const& field_json, Payload& p, ParcelRegistry const& reg) const = 0;
 
    virtual void to_string_into(std::string& out, Payload const& p) const = 0;
 
    [[nodiscard]] virtual std::partial_ordering compare(Payload const& a,
                                                        Payload const& b) const = 0;
 
    virtual DisplayInfo& mutable_display_info() = 0;
 
    virtual void set_required(bool r) = 0;
};
 
template <typename Payload, typename FieldT, CellLike CellT>
class MemberFieldDescriptor final : public IPayloadFieldDescriptor<Payload> {
    // clang-format-22 minor versions disagree on Payload::* spacing.
    // clang-format off
    FieldT Payload::*member_ptr_;
    // clang-format on
    std::string key_;
    DisplayInfo display_info_;
    bool required_ = !detail::is_optional_v<FieldT>;
 
public:
    // clang-format off
    MemberFieldDescriptor(FieldT Payload::*member_ptr, std::string key, DisplayInfo info)
        // clang-format on
        : member_ptr_(member_ptr), key_(std::move(key)), display_info_(std::move(info)) {}
 
    [[nodiscard]] std::string_view key() const override {
        return key_;
    }
    [[nodiscard]] std::string_view kind() const override {
        return CellT::kind_id;
    }
    [[nodiscard]] DisplayInfo display_info() const override {
        return display_info_;
    }
    [[nodiscard]] bool is_required() const override {
        return required_;
    }
 
    [[nodiscard]] json_t to_json() const override {
        return json_t{
            {"key", key_},
            {"kind", CellT::kind_id},
            {"display_info", json_t(display_info_)},
            {"required", required_},
        };
    }
 
    DisplayInfo& mutable_display_info() override {
        return display_info_;
    }
    void set_required(const bool r) override {
        required_ = r;
    }
 
    void to_json_into(json_t& v_obj, Payload const& p) const override {
        if constexpr (detail::is_optional_v<FieldT>) {
            if (!(p.*member_ptr_).has_value()) {
                return;
            }
            CellT wrapper(*(p.*member_ptr_));
            v_obj[key_] = wrapper.to_json();
        } else {
            CellT wrapper(p.*member_ptr_);
            v_obj[key_] = wrapper.to_json();
        }
    }
 
    void
    from_json_into(json_t const& field_json, Payload& p, ParcelRegistry const& reg) const override {
        const cell_t v = CellT::from_json(field_json, reg);
        auto* typed = dynamic_cast<CellT*>(v.get());
        if (typed == nullptr) {
            throw TypeException(
                "StructCell: field '" + key_ + "' from_json did not return CellT", {}, key_);
        }
        p.*member_ptr_ = std::move(typed->value);
    }
 
    // Overrides IPayloadFieldDescriptor::compare(a, b); signature is fixed.
    // NOLINTNEXTLINE(bugprone-easily-swappable-parameters)
    [[nodiscard]] std::partial_ordering compare(Payload const& a, Payload const& b) const override {
        if constexpr (detail::is_optional_v<FieldT>) {
            const auto& oa = a.*member_ptr_;
            const auto& ob = b.*member_ptr_;
            if (!oa.has_value() && !ob.has_value()) {
                return std::partial_ordering::equivalent;
            }
            if (!oa.has_value()) {
                return std::partial_ordering::less;
            }
            if (!ob.has_value()) {
                return std::partial_ordering::greater;
            }
            CellT wa(*oa);
            CellT wb(*ob);
            return wa.compare(wb);
        } else {
            CellT wa(a.*member_ptr_);
            CellT wb(b.*member_ptr_);
            return wa.compare(wb);
        }
    }
 
    void to_string_into(std::string& out, Payload const& p) const override {
        out += key_;
        out += ": ";
        if constexpr (detail::is_optional_v<FieldT>) {
            if (!(p.*member_ptr_).has_value()) {
                out += "<nullopt>";
                return;
            }
            CellT wrapper(*(p.*member_ptr_));
            out += wrapper.to_string();
        } else {
            CellT wrapper(p.*member_ptr_);
            out += wrapper.to_string();
        }
    }
};
 
template <typename DerivedPayload, typename ParentPayload>
class InheritedFieldDescriptor final : public IPayloadFieldDescriptor<DerivedPayload> {
    static_assert(std::is_base_of_v<ParentPayload, DerivedPayload>,
                  "InheritedFieldDescriptor: DerivedPayload must derive from ParentPayload");
 
    std::shared_ptr<IPayloadFieldDescriptor<ParentPayload>> inner_;
 
public:
    explicit InheritedFieldDescriptor(std::shared_ptr<IPayloadFieldDescriptor<ParentPayload>> inner)
        : inner_(std::move(inner)) {}
 
    [[nodiscard]] std::string_view key() const override {
        return inner_->key();
    }
    [[nodiscard]] std::string_view kind() const override {
        return inner_->kind();
    }
    [[nodiscard]] DisplayInfo display_info() const override {
        return inner_->display_info();
    }
    [[nodiscard]] bool is_required() const override {
        return inner_->is_required();
    }
    [[nodiscard]] json_t to_json() const override {
        return inner_->to_json();
    }
 
    DisplayInfo& mutable_display_info() override {
        return inner_->mutable_display_info();
    }
    void set_required(const bool r) override {
        inner_->set_required(r);
    }
 
    void to_json_into(json_t& v_obj, DerivedPayload const& p) const override {
        inner_->to_json_into(v_obj, static_cast<ParentPayload const&>(p));
    }
    void from_json_into(json_t const& field_json,
                        DerivedPayload& p,
                        ParcelRegistry const& reg) const override {
        inner_->from_json_into(field_json, static_cast<ParentPayload&>(p), reg);
    }
    void to_string_into(std::string& out, DerivedPayload const& p) const override {
        inner_->to_string_into(out, static_cast<ParentPayload const&>(p));
    }
    [[nodiscard]] std::partial_ordering compare(DerivedPayload const& a,
                                                DerivedPayload const& b) const override {
        return inner_->compare(static_cast<ParentPayload const&>(a),
                               static_cast<ParentPayload const&>(b));
    }
};
 
template <typename Payload>
class FieldsBuilder {
public:
    using payload_field_t = std::shared_ptr<IPayloadFieldDescriptor<Payload>>;
    using payload_field_descriptors_t = std::vector<payload_field_t>;
 
    template <auto MemberPtr, CellLike CellT>
    FieldsBuilder& field(std::string key) {
        using mp_t = decltype(MemberPtr);
        using traits = detail::member_pointer_traits<mp_t>;
        static_assert(std::is_base_of_v<typename traits::class_type, Payload>,
                      "FieldsBuilder: member pointer's class must be Payload "
                      "or a base class of Payload");
 
        using FieldT = typename traits::field_type;
        // Implicit base-to-derived member-pointer conversion happens here at
        // runtime — the conversion isn't constexpr, so the pointer is held
        // by the descriptor instead of a non-type template parameter.
        // clang-format off
        FieldT Payload::*mp = MemberPtr;
        // clang-format on
        auto fd = std::make_shared<MemberFieldDescriptor<Payload, FieldT, CellT>>(
            mp, std::move(key), DisplayInfo{});
        replace_or_append(std::move(fd));
        return *this;
    }
 
    template <auto MemberPtr>
    FieldsBuilder& field(std::string key)
        requires HasDefaultCellWrapper<
            typename detail::member_pointer_traits<decltype(MemberPtr)>::field_type>
    {
        using FieldT = typename detail::member_pointer_traits<decltype(MemberPtr)>::field_type;
        return field<MemberPtr, default_cell_for_t<FieldT>>(std::move(key));
    }
 
    FieldsBuilder& name(std::string v) {
        require_last("name")->mutable_display_info().name = std::move(v);
        return *this;
    }
 
    FieldsBuilder& description(std::string v) {
        require_last("description")->mutable_display_info().description = std::move(v);
        return *this;
    }
 
    FieldsBuilder& icon(comms::Icon icon) {
        require_last("icon")->mutable_display_info().icon = icon;
        return *this;
    }
 
    FieldsBuilder& icon(std::string const& v) {
        return icon(comms::Icon::from(v));
    }
 
    FieldsBuilder& color(comms::Color color) {
        require_last("color")->mutable_display_info().color = color;
        return *this;
    }
 
    FieldsBuilder& color(std::string const& v) {
        const auto parsed = comms::Color::parse(v);
        if (!parsed) {
            throw InvalidJsonException("FieldsBuilder::color: '" + v + "' is not a valid color");
        }
        return color(*parsed);
    }
 
    FieldsBuilder& is_required(bool v = true) {
        require_last("is_required")->set_required(v);
        return *this;
    }
 
    FieldsBuilder& optional() {
        return is_required(false);
    }
 
    template <CellLike ParentCell>
        requires std::is_base_of_v<typename ParentCell::payload_type, Payload>
    FieldsBuilder& extend() {
        using ParentPayload = typename ParentCell::payload_type;
        for (auto parent_fields = ParentCell::field_descriptors();
             auto& parent_field : parent_fields) {
            auto adapter = std::make_shared<InheritedFieldDescriptor<Payload, ParentPayload>>(
                std::move(parent_field));
            replace_or_append(std::move(adapter));
        }
        return *this;
    }
 
    FieldsBuilder& remove_field(const std::string_view key) {
        std::erase_if(fields_, [&](payload_field_t const& f) { return f->key() == key; });
        last_ = nullptr;
        return *this;
    }
 
    payload_field_descriptors_t build() {
        last_ = nullptr;
        return std::move(fields_);
    }
 
private:
    payload_field_descriptors_t fields_;
    IPayloadFieldDescriptor<Payload>* last_ = nullptr;
 
    [[nodiscard]] IPayloadFieldDescriptor<Payload>*
    require_last(const std::string_view modifier) const {
        if (last_ == nullptr) {
            throw std::runtime_error("FieldsBuilder::" + std::string(modifier) +
                                     " called before any .field<>()");
        }
        return last_;
    }
 
    void replace_or_append(payload_field_t fd) {
        const auto key = fd->key();
        for (auto& existing : fields_) {
            if (existing->key() == key) {
                existing = fd;
                last_ = fd.get();
                return;
            }
        }
        last_ = fd.get();
        fields_.push_back(std::move(fd));
    }
};
 
template <typename Derived, typename Payload>
class StructCellTypeDescriptor final : public BaseCellTypeDescriptor<Derived>,
                                       public IHasFields,
                                       public ISubTypes {
    using base_t = BaseCellTypeDescriptor<Derived>;
 
public:
    using payload_field_descriptors_t =
        typename FieldsBuilder<Payload>::payload_field_descriptors_t;
 
    StructCellTypeDescriptor(DisplayInfo info, payload_field_descriptors_t fields)
        : base_t(std::move(info)), fields_(std::move(fields)) {}
 
    [[nodiscard]] descriptor::CellCategory category() const override {
        return descriptor::CellCategory::Struct;
    }
 
    [[nodiscard]] cell_t cell_from_json(json_t const& j, ParcelRegistry const& reg) const override {
        return Derived::from_json(j, reg);
    }
 
    [[nodiscard]] json_t to_json() const override {
        auto j = base_t::base_to_json();
        json_t arr = json_t::array();
        for (auto const& f : fields_) {
            arr.push_back(f->to_json());
        }
        j["fields"] = std::move(arr);
        return j;
    }
 
    [[nodiscard]] field_descriptors_t fields() const override {
        field_descriptors_t out;
        for (auto const& f : fields_) {
            out.emplace(std::string(f->key()), std::static_pointer_cast<IFieldDescriptor>(f));
        }
        return out;
    }
 
    [[nodiscard]] std::vector<std::string_view> sub_kinds() const override {
        std::vector<std::string_view> out;
        out.reserve(fields_.size());
        for (auto const& f : fields_) {
            out.push_back(f->kind());
        }
        return out;
    }
 
    [[nodiscard]] payload_field_descriptors_t const& payload_fields() const {
        return fields_;
    }
 
private:
    payload_field_descriptors_t fields_;
};
 
template <typename Derived, typename Payload, FixedString StructId>
class StructCell : public BaseCell<Derived, Payload> {
    using base_t = BaseCell<Derived, Payload>;
 
public:
    using payload_type = Payload;
 
    using base_t::base_t;
    using base_t::operator=;
 
    static constexpr bool allow_extra_fields = false;
 
    static constexpr std::string_view struct_id = StructId.view();
 
    static constexpr std::string_view kind_id = id_join_lit_v<"s:", StructId>;
 
    static DisplayInfo display_info() {
        return {};
    }
 
    std::map<std::string, cell_t> extras;
 
    [[nodiscard]] std::string to_string() const override {
        std::string out = "{";
        bool first = true;
        for (auto const& f : Derived::field_descriptors()) {
            if (!first) {
                out += ", ";
            }
            f->to_string_into(out, this->value);
            first = false;
        }
        if constexpr (Derived::allow_extra_fields) {
            for (auto const& [key, ev] : extras) {
                if (!first) {
                    out += ", ";
                }
                out += key;
                out += ": ";
                out += ev ? ev->to_string() : "<null>";
                first = false;
            }
        }
        out += "}";
        return out;
    }
 
    [[nodiscard]] json_t to_json() const override {
        json_t v_obj = json_t::object();
        for (auto const& f : Derived::field_descriptors()) {
            f->to_json_into(v_obj, this->value);
        }
        if constexpr (Derived::allow_extra_fields) {
            for (auto const& [key, ev] : extras) {
                v_obj[key] = ev ? ev->to_json() : json_t();
            }
        }
        json_t j{
            {ICell::KEY_KIND, Derived::kind_id},
            {ICell::KEY_VALUE, std::move(v_obj)},
        };
        this->inject_display_info(j);
        return j;
    }
 
    [[nodiscard]] cell_t clone() const override {
        auto copy = std::make_shared<Derived>(static_cast<Derived const&>(*this));
        if constexpr (Derived::allow_extra_fields) {
            copy->extras.clear();
            for (auto const& [key, ev] : extras) {
                copy->extras.emplace(key, ev ? ev->clone() : nullptr);
            }
        }
        return copy;
    }
 
    [[nodiscard]] std::partial_ordering compare(ICell const& other) const override {
        if (const auto k_cmp = this->kind() <=> other.kind(); k_cmp != 0) {
            return k_cmp;
        }
        const auto* o = dynamic_cast<Derived const*>(&other);
        if (o == nullptr) {
            return std::partial_ordering::unordered;
        }
        for (auto const& f : Derived::field_descriptors()) {
            if (const auto c = f->compare(this->value, o->value); c != 0) {
                return c;
            }
        }
        if constexpr (Derived::allow_extra_fields) {
            // std::map already iterates by key; lexicographic compare on
            // (key, value-cell) pairs, with null-cell < non-null-cell.
            auto ai = extras.begin();
            auto bi = o->extras.begin();
            while (ai != extras.end() && bi != o->extras.end()) {
                if (const auto kc = ai->first <=> bi->first; kc != 0) {
                    return kc;
                }
                const bool an = ai->second == nullptr;
                if (const bool bn = bi->second == nullptr; an != bn) {
                    return an ? std::partial_ordering::less : std::partial_ordering::greater;
                }
                if (!an) {
                    if (const auto vc = *ai->second <=> *bi->second; vc != 0) {
                        return vc;
                    }
                }
                ++ai;
                ++bi;
            }
            return extras.size() <=> o->extras.size();
        }
        return std::partial_ordering::equivalent;
    }
 
    static cell_t from_json(json_t const& j, ParcelRegistry const& reg) {
        if (!j.is_object()) {
            throw InvalidJsonException(std::string("Expected JSON object for StructCell '") +
                                           std::string(Derived::kind_id) + "'",
                                       std::string(Derived::kind_id));
        }
 
        const auto it_k = j.find(ICell::KEY_KIND);
        if (it_k == j.end() || !it_k->is_string()) {
            throw InvalidJsonException(std::string("StructCell '") + std::string(Derived::kind_id) +
                                           "': missing/invalid 'k'",
                                       std::string(Derived::kind_id));
        }
        if (it_k->get<std::string_view>() != Derived::kind_id) {
            throw KindMismatchException(std::string("StructCell '") +
                                            std::string(Derived::kind_id) +
                                            "': missing/invalid 'k'",
                                        std::string(Derived::kind_id));
        }
 
        const auto it_v = j.find(ICell::KEY_VALUE);
        if (it_v == j.end() || !it_v->is_object()) {
            throw InvalidJsonException(std::string("StructCell '") + std::string(Derived::kind_id) +
                                           "': missing/invalid 'v' (expected object)",
                                       std::string(Derived::kind_id));
        }
 
        auto out = std::make_shared<Derived>();
        auto field_descs = Derived::field_descriptors();
 
        std::map<std::string_view, IPayloadFieldDescriptor<Payload> const*> by_key;
        for (auto const& f : field_descs) {
            by_key.emplace(f->key(), f.get());
        }
 
        for (auto const& f : field_descs) {
            const auto it = it_v->find(f->key());
            if (it == it_v->end()) {
                if (f->is_required()) {
                    throw MissingFieldException(
                        std::string("StructCell '") + std::string(Derived::kind_id) +
                            "': missing required field '" + std::string(f->key()) + "'",
                        std::string(Derived::kind_id),
                        std::string(f->key()));
                }
                continue;
            }
            f->from_json_into(*it, out->value, reg);
        }
 
        for (auto const& [key, raw] : it_v->items()) {
            if (by_key.contains(key)) {
                continue;
            }
            if constexpr (Derived::allow_extra_fields) {
                out->extras.emplace(key, reg.cell_from_json(raw));
            } else {
                throw TypeException(std::string("StructCell '") + std::string(Derived::kind_id) +
                                        "': unknown field '" + key + "'",
                                    std::string(Derived::kind_id),
                                    key);
            }
        }
 
        base_t::absorb_display_info(j, out);
        return out;
    }
 
    static cell_type_descriptor_t descriptor() {
        static const auto d = std::make_shared<StructCellTypeDescriptor<Derived, Payload>>(
            Derived::display_info(), Derived::field_descriptors());
        return d;
    }
};
 
template <typename Derived>
class SelfStructCell : public ICell {
public:
    using payload_type = Derived;
 
    using storage_t = Derived;
 
    static constexpr bool allow_extra_fields = false;
 
    [[nodiscard]] std::string_view kind() const override {
        return Derived::kind_id;
    }
 
    [[nodiscard]] std::string to_string() const override {
        std::string out = "{";
        bool first = true;
        auto const& self = static_cast<Derived const&>(*this);
        for (auto const& f : Derived::field_descriptors()) {
            if (!first) {
                out += ", ";
            }
            f->to_string_into(out, self);
            first = false;
        }
        if constexpr (Derived::allow_extra_fields) {
            for (auto const& [key, ev] : cell_extras_) {
                if (!first) {
                    out += ", ";
                }
                out += key;
                out += ": ";
                out += ev ? ev->to_string() : "<null>";
                first = false;
            }
        }
        out += "}";
        return out;
    }
 
    [[nodiscard]] json_t to_json() const override {
        json_t v_obj = json_t::object();
        auto const& self = static_cast<Derived const&>(*this);
        for (auto const& f : Derived::field_descriptors()) {
            f->to_json_into(v_obj, self);
        }
        if constexpr (Derived::allow_extra_fields) {
            for (auto const& [key, ev] : cell_extras_) {
                v_obj[key] = ev ? ev->to_json() : json_t();
            }
        }
        json_t j{
            {ICell::KEY_KIND, Derived::kind_id},
            {ICell::KEY_VALUE, std::move(v_obj)},
        };
        this->inject_display_info(j);
        return j;
    }
 
    [[nodiscard]] cell_t clone() const override {
        auto copy = std::make_shared<Derived>(static_cast<Derived const&>(*this));
        if constexpr (Derived::allow_extra_fields) {
            copy->cell_extras_.clear();
            for (auto const& [key, ev] : cell_extras_) {
                copy->cell_extras_.emplace(key, ev ? ev->clone() : nullptr);
            }
        }
        return copy;
    }
 
    [[nodiscard]] std::partial_ordering compare(ICell const& other) const override {
        if (const auto k_cmp = this->kind() <=> other.kind(); k_cmp != 0) {
            return k_cmp;
        }
        const auto* o = dynamic_cast<Derived const*>(&other);
        if (o == nullptr) {
            return std::partial_ordering::unordered;
        }
        auto const& self = static_cast<Derived const&>(*this);
        for (auto const& f : Derived::field_descriptors()) {
            if (const auto c = f->compare(self, *o); c != 0) {
                return c;
            }
        }
        if constexpr (Derived::allow_extra_fields) {
            auto ai = cell_extras_.begin();
            auto bi = o->cell_extras_.begin();
            while (ai != cell_extras_.end() && bi != o->cell_extras_.end()) {
                if (const auto kc = ai->first <=> bi->first; kc != 0) {
                    return kc;
                }
                const bool an = ai->second == nullptr;
                if (const bool bn = bi->second == nullptr; an != bn) {
                    return an ? std::partial_ordering::less : std::partial_ordering::greater;
                }
                if (!an) {
                    if (const auto vc = *ai->second <=> *bi->second; vc != 0) {
                        return vc;
                    }
                }
                ++ai;
                ++bi;
            }
            return cell_extras_.size() <=> o->cell_extras_.size();
        }
        return std::partial_ordering::equivalent;
    }
 
    [[nodiscard]] const std::map<std::string, cell_t>& cell_extras() const {
        return cell_extras_;
    }
 
    static cell_t from_json(json_t const& j, ParcelRegistry const& reg) {
        if (!j.is_object()) {
            throw InvalidJsonException(std::string("Expected JSON object for SelfStructCell '") +
                                           std::string(Derived::kind_id) + "'",
                                       std::string(Derived::kind_id));
        }
 
        const auto it_k = j.find(ICell::KEY_KIND);
        if (it_k == j.end() || !it_k->is_string()) {
            throw InvalidJsonException(std::string("SelfStructCell '") +
                                           std::string(Derived::kind_id) + "': missing/invalid 'k'",
                                       std::string(Derived::kind_id));
        }
        if (it_k->get<std::string_view>() != Derived::kind_id) {
            throw KindMismatchException(std::string("SelfStructCell '") +
                                            std::string(Derived::kind_id) +
                                            "': missing/invalid 'k'",
                                        std::string(Derived::kind_id));
        }
 
        const auto it_v = j.find(ICell::KEY_VALUE);
        if (it_v == j.end() || !it_v->is_object()) {
            throw InvalidJsonException(std::string("SelfStructCell '") +
                                           std::string(Derived::kind_id) +
                                           "': missing/invalid 'v' (expected object)",
                                       std::string(Derived::kind_id));
        }
 
        auto out = std::make_shared<Derived>();
        auto field_descs = Derived::field_descriptors();
 
        std::map<std::string_view, IPayloadFieldDescriptor<Derived> const*> by_key;
        for (auto const& f : field_descs) {
            by_key.emplace(f->key(), f.get());
        }
 
        for (auto const& f : field_descs) {
            const auto it = it_v->find(f->key());
            if (it == it_v->end()) {
                if (f->is_required()) {
                    throw MissingFieldException(
                        std::string("SelfStructCell '") + std::string(Derived::kind_id) +
                            "': missing required field '" + std::string(f->key()) + "'",
                        std::string(Derived::kind_id),
                        std::string(f->key()));
                }
                continue;
            }
            f->from_json_into(*it, *out, reg);
        }
 
        for (auto const& [key, raw] : it_v->items()) {
            if (by_key.contains(key)) {
                continue;
            }
            if constexpr (Derived::allow_extra_fields) {
                out->cell_extras_.emplace(key, reg.cell_from_json(raw));
            } else {
                throw TypeException(std::string("SelfStructCell '") +
                                        std::string(Derived::kind_id) + "': unknown field '" + key +
                                        "'",
                                    std::string(Derived::kind_id),
                                    key);
            }
        }
 
        if (const auto it_d = j.find(ICell::KEY_DESCRIPTION); it_d != j.end()) {
            out->display_info_ = it_d->get<DisplayInfo>();
        }
        return out;
    }
 
    static cell_type_descriptor_t descriptor() {
        static const auto d = std::make_shared<StructCellTypeDescriptor<Derived, Derived>>(
            Derived::display_info(), Derived::field_descriptors());
        return d;
    }
 
    [[nodiscard]] std::optional<DisplayInfo> const& overridden_display_info() const override {
        return display_info_;
    }
 
protected:
    void inject_display_info(json_t& j) const {
        if (display_info_) {
            j[ICell::KEY_DESCRIPTION] = *display_info_;
        }
    }
 
    void set_display_info(std::optional<DisplayInfo> m) override {
        display_info_ = std::move(m);
    }
 
    std::optional<DisplayInfo> display_info_;
 
    std::map<std::string, cell_t> cell_extras_;
};
 
}  // namespace parcel