parcel::TypedMapCell< T > Class Template Reference

Homogeneous string-keyed map of values of type T. More...

#include <map.h>

Inheritance diagram for parcel::TypedMapCell< T >:

Collaboration diagram for parcel::TypedMapCell< T >:

Public Member Functions
	TypedMapCell (std::initializer_list< std::pair< const std::string, element_storage_t > > elems)
	Construct from a brace-enclosed list of {key, value} pairs.
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, R &&r)
	Construct from any input range whose elements are {key, value}-like.
auto	keys () const noexcept
	Lazy view over the keys of the map.
auto	values () const noexcept
	Lazy view over the values of the map.
std::string	to_string () const override
	Render the map as {k1: v1, k2: v2} using each value's to_string.
json_t	to_json () const override
	Default JSON serialization for cells with JSON-convertible storage.
std::partial_ordering	compare (ICell const &other) const override
	Lexicographic three-way comparison over (key, value) pairs; ignores display info.
template<typename U > requires std::assignable_from<Storage&, U&&>
Derived &	operator= (U &&v)
	Assign to the storage from v.
Public Member Functions inherited from parcel::BaseCell< TypedMapCell< T >, std::map< std::string, T::storage_t > >
	explicit (false) BaseCell(U &&v)
	Construct by forwarding into the storage (v becomes Storage::value).
TypedMapCell< T > &	operator= (U &&v)
	Assign to the storage from v.
std::map< std::string, T::storage_t > &	get ()
	Mutable access to the held storage.
std::map< std::string, T::storage_t > const &	get () const
	Read-only access to the held storage.
void	inject_display_info (json_t &j) const
	Copy this cell's display info (if any) into the JSON object under "d".
Public Member Functions inherited from parcel::ICell
virtual std::string	to_formatted_string () const
	Render the cell as a multi-line, indented string.
virtual std::size_t	hash_value () const noexcept
	Equality-consistent hash that mirrors compare's display-info-insensitivity.
cell_t	with_display_info (DisplayInfo m) const
	Return a deep copy with the entire display info block replaced.
cell_t	with_name (std::string v) const
	Return a deep copy with name set to v.
cell_t	with_description (std::string v) const
	Return a deep copy with description set to v.
cell_t	with_icon (comms::Icon icon) const
	Return a deep copy with icon set to the typed icon.
cell_t	with_icon (std::string const &v) const
	Return a deep copy with icon parsed from an Iconify set:name string (e.g.
cell_t	with_color (comms::Color color) const
	Return a deep copy with color set to the typed color.
cell_t	with_color (std::string const &v) const
	Return a deep copy with color parsed from a color string (hex like "#ffcc00", a CSS-functional form, or a CSS color name).

Static Public Member Functions
static cell_t	from_json (json_t const &j, ParcelRegistry const &reg)
	Deserialize a TypedMapCell<T> from JSON.
static cell_type_descriptor_t	descriptor ()
	Cached descriptor for this typed map.
Static Public Member Functions inherited from parcel::BaseCell< TypedMapCell< T >, std::map< std::string, T::storage_t > >
static std::shared_ptr< TypedMapCell< T > >	of (Args &&... args)
	Construct a shared_ptr<Derived> forwarding the arguments.
static std::unique_ptr< TypedMapCell< T > >	unique (Args &&... args)
	Construct a unique_ptr<Derived> forwarding the arguments.
static void	absorb_display_info (json_t const &j, Out &out)
	Read "d" (if present) from a JSON object and assign it onto a cell.
static cell_t	from_json_strict (json_t const &j)
	Strict shorthand for the recurring cell_from_json + make_shared.

Static Public Attributes
static constexpr std::string_view	kind_id = prefixed_id_v<"m:", T::kind_id>
	Wire kind id of this typed map ("m:" + T::kind_id).
Static Public Attributes inherited from parcel::ICell
static constexpr std::string_view	KEY_KIND = "k"
	JSON key for the kind id ("k").
static constexpr std::string_view	KEY_VALUE = "v"
	JSON key for the value payload ("v").
static constexpr std::string_view	KEY_DESCRIPTION = "d"
	JSON key for the optional display info block ("d").

Additional Inherited Members
Public Attributes inherited from parcel::BaseCell< TypedMapCell< T >, std::map< std::string, T::storage_t > >
std::map< std::string, T::storage_t >	value
	Held value of the cell.
Static Protected Member Functions inherited from parcel::BaseCell< TypedMapCell< T >, std::map< std::string, T::storage_t > >
static T	cell_from_json (const json_t &j, const std::string_view expected_kind)
	Validate a wrapped {"k","v"} JSON object and extract its "v" as T.
Protected Attributes inherited from parcel::BaseCell< TypedMapCell< T >, std::map< std::string, T::storage_t > >
std::optional< DisplayInfo >	display_info_
	Optional display info; omitted from JSON when empty.

Detailed Description

template<CellLike T>
class parcel::TypedMapCell< T >

Homogeneous string-keyed map of values of type T.

Wire shape (example for TypedMapCell<I32Cell>):

{"k": "m:i32", "v": {"a": 1, "b": 2}}

The element kind is part of "k" so the registry can dispatch each typed map distinctly. Storage is std::map<std::string, typename T::storage_t>, so values are raw and a curated subset of std::map's API is forwarded for ergonomic use.

Template Parameters

T	Value cell type (must satisfy CellLike).

See also

TypedMapCellTypeDescriptor

Constructor & Destructor Documentation

TypedMapCell()

template<CellLike T>

parcel::TypedMapCell< T >::TypedMapCell ( std::initializer_list< std::pair< const std::string, element_storage_t > >  elems )

inline

Construct from a brace-enclosed list of {key, value} pairs.

Parameters

elems

Initializer list of key/value pairs.

Member Function Documentation

compare()

template<CellLike T>

std::partial_ordering parcel::TypedMapCell< T >::compare ( ICell const &  other ) const

inlineoverridevirtual

Lexicographic three-way comparison over (key, value) pairs; ignores display info.

Each value pair is wrapped in T and routed through T::compare so element types whose raw storage lacks == still compare correctly.

Reimplemented from parcel::BaseCell< TypedMapCell< T >, std::map< std::string, T::storage_t > >.

descriptor()

template<CellLike T>

static cell_type_descriptor_t parcel::TypedMapCell< T >::descriptor ( )

inlinestatic

Cached descriptor for this typed map.

Returns

Shared TypedMapCellTypeDescriptor<T> instance.

from_json()

template<CellLike T>

static cell_t parcel::TypedMapCell< T >::from_json ( json_t const &  j, ParcelRegistry const &  reg  )

inlinestatic

Deserialize a TypedMapCell<T> from JSON.

Parameters

j	Input JSON object — must match {"k": kind_id, "v": {…}}.
reg	Registry (passed through to per-value from_json).

Returns

Newly built cell handle.

Exceptions

std::runtime_error

on shape or kind mismatch, or if any value fails to deserialize as T.

keys()

template<CellLike T>

auto parcel::TypedMapCell< T >::keys ( ) const

inlinenoexcept

Lazy view over the keys of the map.

Equivalent to value | std::views::keys, but slightly shorter at the call site and self-documenting on TypedMapCell.

operator=()

template<CellLike T>

template<typename U >
requires std::assignable_from<Storage&, U&&>

Derived & parcel::BaseCell< Derived, Storage >::operator= ( U &&  v )

inline

Assign to the storage from v.

Template Parameters

U	Any type assignable to the storage.

Parameters

v	Replacement value.

Returns

Reference to the derived cell for chaining.

to_json()

template<CellLike T>

json_t parcel::TypedMapCell< T >::to_json ( ) const

inlineoverridevirtual

Default JSON serialization for cells with JSON-convertible storage.

If Storage has a JSON adapter, emits {"k": kind_id, "v": value, optional "d": display info}. Otherwise the call throws — the derived cell must override to_json itself (ListCell, MapCell, etc.).

Returns

JSON object representation.

Exceptions

std::runtime_error

if Storage is not JSON-convertible.

Reimplemented from parcel::BaseCell< TypedMapCell< T >, std::map< std::string, T::storage_t > >.

to_string()

template<CellLike T>

std::string parcel::TypedMapCell< T >::to_string ( ) const

inlineoverridevirtual

Render the map as {k1: v1, k2: v2} using each value's to_string.

Returns

Brace-enclosed comma-separated form.

Implements parcel::ICell.

Member Data Documentation

kind_id

template<CellLike T>

constexpr std::string_view parcel::TypedMapCell< T >::kind_id = prefixed_id_v<"m:", T::kind_id>

staticconstexpr

Wire kind id of this typed map ("m:" + T::kind_id).

Encoded in the type so each instantiation registers under a distinct kind:

TypedMapCell<I32Cell>::kind_id    == "m:i32";
TypedMapCell<StringCell>::kind_id == "m:string";

---

The documentation for this class was generated from the following file:

• include/parcel/map.h