map.h

Go to the documentation of this file.

#pragma once
 
#include <parcel/cell.h>
#include <parcel/descriptor.h>
#include <parcel/registry.h>
 
#include <initializer_list>
#include <map>
#include <memory>
#include <ranges>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace parcel {
 
// std::map<K, V>::operator== eagerly instantiates V::operator==; suppress
// BaseCell's default compare for map storage so cells whose value payloads
// lack `==` still compile (TypedMapCell overrides compare()).
template <typename K, typename V, typename C, typename A>
struct detail::disables_basecell_compare<std::map<K, V, C, A>> : std::true_type {
};  // namespace detail
 
class ParcelRegistry;
 
template <CellLike T>
class TypedMapCell;
 
template <CellLike T>
class TypedMapCellTypeDescriptor final : public BaseCellTypeDescriptor<TypedMapCell<T>>,
                                         public ISubTypes {
public:
    using cell_type = TypedMapCell<T>;
    using base_t = BaseCellTypeDescriptor<TypedMapCell<T>>;
 
    explicit TypedMapCellTypeDescriptor(DisplayInfo info) : base_t(std::move(info)) {}
 
    [[nodiscard]] std::string_view element_kind() const {
        return T::kind_id;
    }
 
    [[nodiscard]] descriptor::CellCategory category() const override {
        return descriptor::CellCategory::TypedMap;
    }
 
    [[nodiscard]] std::vector<std::string_view> sub_kinds() const override {
        return {T::kind_id};
    }
 
    [[nodiscard]] cell_t cell_from_json(json_t const& j, ParcelRegistry const& reg) const override {
        return TypedMapCell<T>::from_json(j, reg);
    }
 
    [[nodiscard]] json_t to_json() const override {
        auto j = base_t::base_to_json();
        j["element_kind"] = T::kind_id;
        return j;
    }
};
 
template <CellLike T>
class TypedMapCell
    : public BaseCell<TypedMapCell<T>, std::map<std::string, typename T::storage_t>> {
    using base_t = BaseCell<TypedMapCell<T>, std::map<std::string, typename T::storage_t>>;
 
public:
    using element_type = T;
    using element_storage_t = typename T::storage_t;
 
    using base_t::base_t;
    using base_t::operator=;
 
    TypedMapCell(std::initializer_list<std::pair<const std::string, element_storage_t>> elems)
        : base_t(std::map<std::string, element_storage_t>(elems)) {}
 
    template <std::ranges::input_range R>
        requires requires(std::ranges::range_value_t<R> p) {
            { p.first } -> std::convertible_to<std::string>;
            { p.second } -> std::convertible_to<element_storage_t>;
        }
    TypedMapCell(std::from_range_t /*tag*/, R&& r)
        : base_t(std::map<std::string, element_storage_t>(std::ranges::begin(r),
                                                          std::ranges::end(r))) {}
 
    [[nodiscard]] auto keys() const noexcept {
        return this->value | std::views::keys;
    }
 
    [[nodiscard]] auto values() const noexcept {
        return this->value | std::views::values;
    }
 
    // ---- std::map pass-through API ---------------------------------------
    // Transparent map: values are raw element_storage_t, not ICell wrappers.
 
    using map_t = std::map<std::string, element_storage_t>;
    using key_type = map_t::key_type;
    using mapped_type = map_t::mapped_type;
    using value_type = map_t::value_type;
    using size_type = map_t::size_type;
    using iterator = map_t::iterator;
    using const_iterator = map_t::const_iterator;
 
    [[nodiscard]] size_type size() const noexcept {
        return this->value.size();
    }
    [[nodiscard]] bool empty() const noexcept {
        return this->value.empty();
    }
 
    mapped_type& operator[](key_type const& k) {
        return this->value[k];
    }
    mapped_type& operator[](key_type&& k) {
        return this->value[std::move(k)];
    }
    mapped_type& at(key_type const& k) {
        return this->value.at(k);
    }
    [[nodiscard]] mapped_type const& at(key_type const& k) const {
        return this->value.at(k);
    }
 
    iterator find(key_type const& k) {
        return this->value.find(k);
    }
    [[nodiscard]] const_iterator find(key_type const& k) const {
        return this->value.find(k);
    }
    [[nodiscard]] bool contains(key_type const& k) const {
        return this->value.contains(k);
    }
    [[nodiscard]] size_type count(key_type const& k) const {
        return this->value.count(k);
    }
 
    iterator begin() noexcept {
        return this->value.begin();
    }
    [[nodiscard]] const_iterator begin() const noexcept {
        return this->value.begin();
    }
    [[nodiscard]] const_iterator cbegin() const noexcept {
        return this->value.cbegin();
    }
    iterator end() noexcept {
        return this->value.end();
    }
    [[nodiscard]] const_iterator end() const noexcept {
        return this->value.end();
    }
    [[nodiscard]] const_iterator cend() const noexcept {
        return this->value.cend();
    }
 
    std::pair<iterator, bool> insert(value_type const& v) {
        return this->value.insert(v);
    }
    std::pair<iterator, bool> insert(value_type&& v) {
        return this->value.insert(std::move(v));
    }
    template <typename... Args>
    std::pair<iterator, bool> emplace(Args&&... args) {
        return this->value.emplace(std::forward<Args>(args)...);
    }
    size_type erase(key_type const& k) {
        return this->value.erase(k);
    }
    iterator erase(const_iterator pos) {
        return this->value.erase(pos);
    }
    void clear() noexcept {
        this->value.clear();
    }
    // ----------------------------------------------------------------------
 
    static constexpr std::string_view kind_id = prefixed_id_v<"m:", T::kind_id>;
 
    [[nodiscard]] std::string to_string() const override {
        std::string out = "{";
        bool first = true;
        for (auto const& [key, el] : this->value) {
            if (!first) {
                out += ", ";
            }
            out += key;
            out += ": ";
            T wrapper(el);
            out += wrapper.to_string();
            first = false;
        }
        out += "}";
        return out;
    }
 
    [[nodiscard]] json_t to_json() const override {
        json_t obj = json_t::object();
        for (auto const& [key, el] : this->value) {
            T wrapper(el);
            obj[key] = wrapper.to_json().at(ICell::KEY_VALUE);
        }
        json_t j{
            {ICell::KEY_KIND, kind_id},
            {ICell::KEY_VALUE, std::move(obj)},
        };
        this->inject_display_info(j);
        return j;
    }
 
    [[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<TypedMapCell const*>(&other);
        if (o == nullptr) {
            return std::partial_ordering::unordered;
        }
        auto it_a = this->value.begin();
        auto it_b = o->value.begin();
        const auto end_a = this->value.end();
        const auto end_b = o->value.end();
        while (it_a != end_a && it_b != end_b) {
            if (const auto kc = it_a->first <=> it_b->first; kc != 0) {
                return kc;
            }
            T wa(it_a->second);
            T wb(it_b->second);
            if (const auto vc = wa.compare(wb); vc != 0) {
                return vc;
            }
            ++it_a;
            ++it_b;
        }
        return this->value.size() <=> o->value.size();
    }
 
    static cell_t from_json(json_t const& j, ParcelRegistry const& reg) {
        if (!j.is_object()) {
            throw InvalidJsonException("Expected JSON object for TypedMapCell",
                                       std::string(kind_id));
        }
 
        const auto it_k = j.find(ICell::KEY_KIND);
        if (it_k == j.end() || !it_k->is_string()) {
            throw InvalidJsonException("TypedMapCell: missing/invalid 'k' (expected '" +
                                           std::string(kind_id) + "')",
                                       std::string(kind_id));
        }
        if (it_k->get<std::string_view>() != kind_id) {
            throw KindMismatchException("TypedMapCell: missing/invalid 'k' (expected '" +
                                            std::string(kind_id) + "')",
                                        std::string(kind_id));
        }
 
        const auto it_v = j.find(ICell::KEY_VALUE);
        if (it_v == j.end() || !it_v->is_object()) {
            throw InvalidJsonException("TypedMapCell: missing/invalid 'v' (expected object)",
                                       std::string(kind_id));
        }
 
        std::map<std::string, element_storage_t> elems;
        for (auto const& [key, raw] : it_v->items()) {
            json_t wrapped{{ICell::KEY_KIND, T::kind_id}, {ICell::KEY_VALUE, raw}};
            cell_t v = T::from_json(wrapped, reg);
            auto* typed = dynamic_cast<T*>(v.get());
            if (typed == nullptr) {
                throw TypeException(std::string("TypedMapCell: element from_json did not return ") +
                                        std::string(T::kind_id),
                                    std::string(kind_id));
            }
            elems.emplace(key, std::move(typed->value));
        }
        auto cell = std::make_shared<TypedMapCell<T>>(std::move(elems));
        base_t::absorb_display_info(j, cell);
        return cell;
    }
 
    static cell_type_descriptor_t descriptor() {
        static const auto d = std::make_shared<TypedMapCellTypeDescriptor<T>>(DisplayInfo{
            .name = "Map",
            .description = std::string("Homogeneous map of ") + std::string(T::kind_id),
        });
        return d;
    }
};
 
class MapCell : public BaseCell<MapCell, std::map<std::string, cell_t>> {
    using base_t = BaseCell<MapCell, std::map<std::string, cell_t>>;
 
public:
    using base_t::base_t;
    using base_t::operator=;
 
    MapCell(const std::initializer_list<std::pair<const std::string, cell_t>> elems)
        : base_t(std::map<std::string, cell_t>(elems)) {}
 
    [[nodiscard]] auto keys() const noexcept {
        return this->value | std::views::keys;
    }
 
    [[nodiscard]] auto values() const noexcept {
        return this->value | std::views::values;
    }
 
    // ---- std::map pass-through API ---------------------------------------
 
    using map_t = std::map<std::string, cell_t>;
    using key_type = map_t::key_type;
    using mapped_type = map_t::mapped_type;
    using value_type = map_t::value_type;
    using size_type = map_t::size_type;
    using iterator = map_t::iterator;
    using const_iterator = map_t::const_iterator;
 
    [[nodiscard]] size_type size() const noexcept {
        return this->value.size();
    }
    [[nodiscard]] bool empty() const noexcept {
        return this->value.empty();
    }
 
    mapped_type& operator[](key_type const& k) {
        return this->value[k];
    }
    mapped_type& operator[](key_type&& k) {
        return this->value[std::move(k)];
    }
    mapped_type& at(key_type const& k) {
        return this->value.at(k);
    }
    [[nodiscard]] mapped_type const& at(key_type const& k) const {
        return this->value.at(k);
    }
 
    iterator find(key_type const& k) {
        return this->value.find(k);
    }
    [[nodiscard]] const_iterator find(key_type const& k) const {
        return this->value.find(k);
    }
    [[nodiscard]] bool contains(key_type const& k) const {
        return this->value.contains(k);
    }
    [[nodiscard]] size_type count(key_type const& k) const {
        return this->value.count(k);
    }
 
    iterator begin() noexcept {
        return this->value.begin();
    }
    [[nodiscard]] const_iterator begin() const noexcept {
        return this->value.begin();
    }
    [[nodiscard]] const_iterator cbegin() const noexcept {
        return this->value.cbegin();
    }
    iterator end() noexcept {
        return this->value.end();
    }
    [[nodiscard]] const_iterator end() const noexcept {
        return this->value.end();
    }
    [[nodiscard]] const_iterator cend() const noexcept {
        return this->value.cend();
    }
 
    std::pair<iterator, bool> insert(value_type const& v) {
        return this->value.insert(v);
    }
    std::pair<iterator, bool> insert(value_type&& v) {
        return this->value.insert(std::move(v));
    }
    template <typename... Args>
    std::pair<iterator, bool> emplace(Args&&... args) {
        return this->value.emplace(std::forward<Args>(args)...);
    }
    size_type erase(key_type const& k) {
        return this->value.erase(k);
    }
    iterator erase(const const_iterator pos) {
        return this->value.erase(pos);
    }
    void clear() noexcept {
        this->value.clear();
    }
    // ----------------------------------------------------------------------
 
    static constexpr std::string_view kind_id = "m";
 
    [[nodiscard]] std::string to_string() const override {
        std::string out = "{";
        bool first = true;
        for (auto const& [key, el] : this->value) {
            if (!first) {
                out += ", ";
            }
            out += key;
            out += ": ";
            out += el ? el->to_string() : "<null>";
            first = false;
        }
        out += "}";
        return out;
    }
 
    [[nodiscard]] json_t to_json() const override {
        json_t obj = json_t::object();
        for (auto const& [key, el] : this->value) {
            obj[key] = el ? el->to_json() : json_t();
        }
        json_t j{
            {ICell::KEY_KIND, kind_id},
            {ICell::KEY_VALUE, std::move(obj)},
        };
        this->inject_display_info(j);
        return j;
    }
 
    [[nodiscard]] cell_t clone() const override {
        std::map<std::string, cell_t> copied;
        for (auto const& [key, el] : this->value) {
            copied.emplace(key, el ? el->clone() : nullptr);
        }
        auto out = std::make_shared<MapCell>(std::move(copied));
        out->display_info_ = this->display_info_;
        return out;
    }
 
    [[nodiscard]] std::size_t hash_value() const noexcept override {
        std::size_t h = std::hash<std::string_view>{}(kind());
        // std::map iterates in sorted key order, so the digest is canonical.
        for (auto const& [key, el] : this->value) {
            const std::size_t hk = std::hash<std::string>{}(key);
            const std::size_t hv = el ? el->hash_value() : std::size_t{0};
            h ^= hk + 0x9e3779b97f4a7c15ULL + (h << 6) + (h >> 2);
            h ^= hv + 0x9e3779b97f4a7c15ULL + (h << 6) + (h >> 2);
        }
        return h;
    }
 
    [[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<MapCell const*>(&other);
        if (o == nullptr) {
            return std::partial_ordering::unordered;
        }
        auto it_a = this->value.begin();
        auto it_b = o->value.begin();
        const auto end_a = this->value.end();
        const auto end_b = o->value.end();
        while (it_a != end_a && it_b != end_b) {
            if (const auto kc = it_a->first <=> it_b->first; kc != 0) {
                return kc;
            }
            if (it_a->second && it_b->second) {
                if (const auto vc = it_a->second->compare(*it_b->second); vc != 0) {
                    return vc;
                }
            } else if (!it_a->second && it_b->second) {
                return std::partial_ordering::less;
            } else if (it_a->second && !it_b->second) {
                return std::partial_ordering::greater;
            }
            ++it_a;
            ++it_b;
        }
        return this->value.size() <=> o->value.size();
    }
 
    static cell_t from_json(json_t const& j, ParcelRegistry const& reg) {
        if (!j.is_object()) {
            throw InvalidJsonException("Expected JSON object for MapCell", std::string(kind_id));
        }
 
        const auto it_k = j.find(ICell::KEY_KIND);
        if (it_k == j.end() || !it_k->is_string()) {
            throw InvalidJsonException("MapCell: missing/invalid 'k' (expected 'm')",
                                       std::string(kind_id));
        }
        if (it_k->get<std::string_view>() != kind_id) {
            throw KindMismatchException("MapCell: missing/invalid 'k' (expected 'm')",
                                        std::string(kind_id));
        }
 
        const auto it_v = j.find(ICell::KEY_VALUE);
        if (it_v == j.end() || !it_v->is_object()) {
            throw InvalidJsonException("MapCell: missing/invalid 'v' (expected object)",
                                       std::string(kind_id));
        }
 
        std::map<std::string, cell_t> elems;
        for (auto const& [key, raw] : it_v->items()) {
            elems.emplace(key, raw.is_null() ? cell_t{} : reg.cell_from_json(raw));
        }
        auto cell = std::make_shared<MapCell>(std::move(elems));
        base_t::absorb_display_info(j, cell);
        return cell;
    }
 
    static cell_type_descriptor_t descriptor();
};
 
class MapCellTypeDescriptor final : public BaseCellTypeDescriptor<MapCell> {
public:
    using cell_type = MapCell;
    using base_t = BaseCellTypeDescriptor<MapCell>;
 
    explicit MapCellTypeDescriptor(DisplayInfo info) : base_t(std::move(info)) {}
 
    [[nodiscard]] descriptor::CellCategory category() const override {
        return descriptor::CellCategory::Map;
    }
 
    [[nodiscard]] cell_t cell_from_json(const json_t& j, const ParcelRegistry& reg) const override {
        return MapCell::from_json(j, reg);
    }
};
 
inline cell_type_descriptor_t MapCell::descriptor() {
    static const auto d = std::make_shared<MapCellTypeDescriptor>(
        DisplayInfo{.name = "Map", .description = "Heterogeneous map of cells"});
    return d;
}
 
}  // namespace parcel