cell.h

Go to the documentation of this file.

#pragma once
 
#include <parcel/common.h>
#include <parcel/error.h>
 
#include <compare>
#include <concepts>
#include <cstddef>
#include <functional>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <variant>
 
#if PARCEL_HAS_EXPECTED
#include <expected>
#endif
 
namespace parcel {
class ParcelRegistry;
struct ICellTypeDescriptor;
 
namespace detail {
template <typename T>
struct is_std_variant : std::false_type {};
template <typename... Ts>
struct is_std_variant<std::variant<Ts...>> : std::true_type {};
 
// Used to suppress the BaseCell::compare default for storage types whose
// `operator==` is unconstrained but instantiates per-element comparisons —
// they would emit hard errors on substitution even though the cell type
// (UnionCell, TypedListCell, TypedMapCell) overrides compare(). Names match
// nominally; specializations are added for the std container types we
// expose as cell storage.
template <typename T>
struct disables_basecell_compare : std::false_type {};
}  // namespace detail
 
template <typename T>
inline constexpr bool is_std_variant_v = detail::is_std_variant<std::remove_cvref_t<T>>::value;
 
template <typename T>
inline constexpr bool disables_basecell_compare_v =
    detail::disables_basecell_compare<std::remove_cvref_t<T>>::value;
 
using cell_type_descriptor_t = std::shared_ptr<ICellTypeDescriptor>;
 
struct ICell;
 
using cell_t = std::shared_ptr<ICell>;
 
struct ICell {
    static constexpr std::string_view KEY_KIND = "k";
    static constexpr std::string_view KEY_VALUE = "v";
    static constexpr std::string_view KEY_DESCRIPTION = "d";
 
    virtual ~ICell() = default;
 
    [[nodiscard]] virtual std::string_view kind() const = 0;
 
    [[nodiscard]] virtual std::optional<DisplayInfo> const& overridden_display_info() const = 0;
 
    [[nodiscard]] virtual json_t to_json() const = 0;
 
    [[nodiscard]] virtual std::string to_string() const = 0;
 
    [[nodiscard]] virtual std::string to_formatted_string() const {
        return to_string();
    }
 
    [[nodiscard]] virtual cell_t clone() const = 0;
 
    [[nodiscard]] virtual std::partial_ordering compare(ICell const& other) const = 0;
 
    [[nodiscard]] virtual std::size_t hash_value() const noexcept {
        const std::size_t hk = std::hash<std::string_view>{}(this->kind());
        try {
            const auto j = this->to_json();
            const auto it = j.find(KEY_VALUE);
            const std::size_t hv =
                (it != j.end()) ? std::hash<std::string>{}(it->dump()) : std::size_t{0};
            return hk ^ (hv + 0x9e3779b97f4a7c15ULL + (hk << 6) + (hk >> 2));
        } catch (...) {
            return hk;
        }
    }
 
    friend bool operator==(ICell const& a, ICell const& b) {
        return a.compare(b) == std::partial_ordering::equivalent;
    }
 
    friend std::partial_ordering operator<=>(ICell const& a, ICell const& b) {
        return a.compare(b);
    }
 
    // Immutable builders: each clones the cell, mutates the clone's display info,
    // and returns the new cell_t. The original is untouched.
 
    [[nodiscard]] cell_t with_display_info(DisplayInfo m) const {
        auto c = clone();
        c->set_display_info(std::move(m));
        return c;
    }
 
    [[nodiscard]] cell_t with_name(std::string v) const {
        auto m = overridden_display_info().value_or(DisplayInfo{});
        m.name = std::move(v);
        return with_display_info(std::move(m));
    }
 
    [[nodiscard]] cell_t with_description(std::string v) const {
        auto m = overridden_display_info().value_or(DisplayInfo{});
        m.description = std::move(v);
        return with_display_info(std::move(m));
    }
 
    [[nodiscard]] cell_t with_icon(comms::Icon icon) const {
        auto m = overridden_display_info().value_or(DisplayInfo{});
        m.icon = icon;
        return with_display_info(std::move(m));
    }
 
    [[nodiscard]] cell_t with_icon(std::string const& v) const {
        return with_icon(comms::Icon::from(v));
    }
 
    [[nodiscard]] cell_t with_color(comms::Color color) const {
        auto m = overridden_display_info().value_or(DisplayInfo{});
        m.color = color;
        return with_display_info(std::move(m));
    }
 
    [[nodiscard]] cell_t with_color(std::string const& v) const {
        const auto parsed = comms::Color::parse(v);
        if (!parsed) {
            throw InvalidJsonException("with_color: '" + v + "' is not a valid color");
        }
        return with_color(*parsed);
    }
 
protected:
    virtual void set_display_info(std::optional<DisplayInfo> m) = 0;
 
    template <typename, typename>
    friend struct BaseCell;
 
    template <typename>
    friend class SelfStructCell;
};
 
template <typename T>
    requires std::derived_from<T, ICell>
inline void to_json(json_t& j, T const& v) {
    j = v.to_json();
}
 
template <typename T>
    requires std::derived_from<T, ICell>
inline void to_json(json_t& j, std::shared_ptr<T> const& v) {
    j = v ? v->to_json() : json_t();
}
 
template <typename T>
concept CellLike = std::derived_from<T, ICell> && requires {
    { T::kind_id } -> std::convertible_to<std::string_view>;
    {
        T::from_json(std::declval<json_t const&>(), std::declval<ParcelRegistry const&>())
    } -> std::convertible_to<cell_t>;
    { T::descriptor() } -> std::convertible_to<cell_type_descriptor_t>;
};
 
template <typename Derived, typename Storage>
struct BaseCell : ICell {
    using derived_t = Derived;
    using storage_t = Storage;
 
    Storage value{};
 
    BaseCell() = default;
 
    template <typename U>
        requires std::constructible_from<Storage, U&&>
    explicit(false) BaseCell(U&& v) : value(std::forward<U>(v)) {}
 
    template <typename U>
        requires std::assignable_from<Storage&, U&&>
    Derived& operator=(U&& v) {
        value = std::forward<U>(v);
        return static_cast<Derived&>(*this);
    }
 
    template <typename... Args>
        requires std::constructible_from<Derived, Args&&...>
    static std::shared_ptr<Derived> of(Args&&... args) {
        return std::make_shared<Derived>(std::forward<Args>(args)...);
    }
 
    template <typename... Args>
        requires std::constructible_from<Derived, Args&&...>
    static std::unique_ptr<Derived> unique(Args&&... args) {
        return std::make_unique<Derived>(std::forward<Args>(args)...);
    }
 
    Storage& get() {
        return value;
    }
 
    Storage const& get() const {
        return value;
    }
 
    [[nodiscard]] std::string_view kind() const override {
        return Derived::kind_id;
    }
 
    [[nodiscard]] std::optional<DisplayInfo> const& overridden_display_info() const override {
        return display_info_;
    }
 
    [[nodiscard]] cell_t clone() const override {
        return std::make_shared<Derived>(static_cast<Derived const&>(*this));
    }
 
    [[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;
        }
        // std::variant<T...>'s operator== is unconstrained and instantiates
        // its alternatives' ==; same for std::vector / std::map. If an
        // element type lacks ==, the body fails to compile. The cell types
        // built on those storages (UnionCell, TypedListCell, TypedMapCell,
        // ListCell, MapCell) override compare() with their own dispatch —
        // skip the body here so BaseCell stays instantiable.
        if constexpr (!is_std_variant_v<Storage> && !disables_basecell_compare_v<Storage>) {
            if constexpr (std::three_way_comparable<Storage>) {
                return this->value <=> o->value;
            } else if constexpr (std::equality_comparable<Storage>) {
                return this->value == o->value ? std::partial_ordering::equivalent
                                               : std::partial_ordering::unordered;
            }
        }
        return std::partial_ordering::unordered;
    }
 
    [[nodiscard]] json_t to_json() const override {
        if constexpr (requires(Storage const& s) { json_t(s); }) {
            json_t j{{KEY_KIND, kind()}, {KEY_VALUE, this->value}};
            inject_display_info(j);
            return j;
        } else {
            throw std::runtime_error(
                "BaseCell::to_json() requires Derived to override or Storage to be "
                "JSON-convertible");
        }
    }
 
    void inject_display_info(json_t& j) const {
        if (display_info_) {
            j[KEY_DESCRIPTION] = *display_info_;
        }
    }
 
    template <typename Out>
    static void absorb_display_info(json_t const& j, Out& out) {
        if (const auto it = j.find(KEY_DESCRIPTION); it != j.end()) {
            out->set_display_info(it->get<DisplayInfo>());
        }
    }
 
protected:
    std::optional<DisplayInfo> display_info_;
 
    void set_display_info(std::optional<DisplayInfo> m) override {
        display_info_ = std::move(m);
    }
 
    template <typename T>
    static T cell_from_json(const json_t& j, const std::string_view expected_kind) {
        if (!j.is_object()) {
            throw InvalidJsonException("Expected JSON object for ICell",
                                       std::string(expected_kind));
        }
 
        const auto it_kind = j.find(KEY_KIND);
        if (it_kind == j.end() || !it_kind->is_string()) {
            throw InvalidJsonException("Missing or invalid 'k' field in ICell JSON",
                                       std::string(expected_kind));
        }
 
        if (const auto kind = it_kind->get<std::string_view>(); kind != expected_kind) {
            throw KindMismatchException("Unexpected kind in ICell JSON: expected '" +
                                            std::string(expected_kind) + "', got '" +
                                            std::string(kind) + "'",
                                        std::string(expected_kind));
        }
 
        const auto it_value = j.find(KEY_VALUE);
        if (it_value == j.end()) {
            throw InvalidJsonException("Missing 'v' field in ICell JSON",
                                       std::string(expected_kind));
        }
 
        return it_value->get<T>();
    }
 
public:
    static cell_t from_json_strict(json_t const& j) {
        auto v = cell_from_json<Storage>(j, Derived::kind_id);
        auto cell = std::make_shared<Derived>(std::move(v));
        absorb_display_info(j, cell);
        return cell;
    }
};
 
template <typename C>
    requires std::derived_from<C, ICell>
[[nodiscard]] std::shared_ptr<C> cell_cast(cell_t const& c) {
    if (!c) {
        throw TypeException("cell_cast: null cell", std::string(C::kind_id));
    }
    auto out = std::dynamic_pointer_cast<C>(c);
    if (!out) {
        throw KindMismatchException(std::string("cell_cast: expected '") + std::string(C::kind_id) +
                                        "' but got '" + std::string(c->kind()) + "'",
                                    std::string(C::kind_id));
    }
    return out;
}
 
template <typename C>
    requires std::derived_from<C, ICell>
[[nodiscard]] std::shared_ptr<C> cell_cast_or(cell_t const& c, std::shared_ptr<C> fallback) {
    if (!c) {
        return fallback;
    }
    auto out = std::dynamic_pointer_cast<C>(c);
    return out ? out : std::move(fallback);
}
 
#if PARCEL_HAS_EXPECTED
template <typename C>
    requires std::derived_from<C, ICell>
[[nodiscard]] std::expected<std::shared_ptr<C>, ParcelError> try_cell_cast(cell_t const& c) {
    if (!c) {
        return std::unexpected(ParcelError::make(ParcelError::Code::TypeError, "null cell"));
    }
    auto out = std::dynamic_pointer_cast<C>(c);
    if (!out) {
        return std::unexpected(ParcelError::make(ParcelError::Code::KindMismatch,
                                                 std::string("expected '") +
                                                     std::string(C::kind_id) + "' but got '" +
                                                     std::string(c->kind()) + "'",
                                                 std::string(C::kind_id)));
    }
    return out;
}
#endif
 
template <typename C>
    requires std::derived_from<C, ICell>
[[nodiscard]] typename C::storage_t cell_cast_value(cell_t const& c) {
    return cell_cast<C>(c)->value;
}
 
template <typename C>
    requires std::derived_from<C, ICell>
[[nodiscard]] std::optional<typename C::storage_t> as(cell_t const& c) noexcept {
    if (!c) {
        return std::nullopt;
    }
    auto* typed = dynamic_cast<C const*>(c.get());
    if (typed == nullptr) {
        return std::nullopt;
    }
    return typed->value;
}
 
template <typename C>
    requires std::derived_from<C, ICell>
[[nodiscard]] typename C::storage_t value_or(cell_t const& c, typename C::storage_t fallback) {
    if (!c) {
        return fallback;
    }
    auto* typed = dynamic_cast<C const*>(c.get());
    return typed ? typed->value : std::move(fallback);
}
 
[[nodiscard]] inline json_t to_json(cell_t const& c) {
    return c ? c->to_json() : json_t{};
}
 
[[nodiscard]] inline std::string to_string(cell_t const& c) {
    return c ? c->to_string() : std::string{"<null>"};
}
 
[[nodiscard]] inline std::string to_string_pretty(cell_t const& c) {
    return c ? c->to_formatted_string() : std::string{"<null>"};
}
 
}  // namespace parcel
 
namespace std {
 
template <>
struct hash<parcel::ICell> {
    [[nodiscard]] size_t operator()(parcel::ICell const& c) const noexcept {
        return c.hash_value();
    }
};
 
template <>
struct hash<parcel::cell_t> {
    [[nodiscard]] size_t operator()(parcel::cell_t const& c) const noexcept {
        return c ? std::hash<parcel::ICell>{}(*c) : std::size_t{0};
    }
};
 
}  // namespace std
 
namespace parcel {
 
[[nodiscard]] inline std::size_t hash_cell(ICell const& c) noexcept {
    return std::hash<ICell>{}(c);
}
 
[[nodiscard]] inline std::size_t hash_cell(cell_t const& c) noexcept {
    return std::hash<cell_t>{}(c);
}
 
}  // namespace parcel