cpp-parcel/builtins_8h_source.html

#pragma once


#include <parcel/commons.h>

#include <parcel/ext/chrono.h>

#include <parcel/ext/filesystem.h>

#include <parcel/ext/ulid.h>

#include <parcel/list.h>

#include <parcel/map.h>

#include <parcel/primitive.h>

#include <parcel/registry.h>

#include <parcel/unordered_map.h>


namespace parcel {


using CharListCell = TypedListCell<CharCell>;

using BoolListCell = TypedListCell<BoolCell>;

using U8ListCell = TypedListCell<U8Cell>;

using U16ListCell = TypedListCell<U16Cell>;

using U32ListCell = TypedListCell<U32Cell>;

using U64ListCell = TypedListCell<U64Cell>;

using I8ListCell = TypedListCell<I8Cell>;

using I16ListCell = TypedListCell<I16Cell>;

using I32ListCell = TypedListCell<I32Cell>;

using I64ListCell = TypedListCell<I64Cell>;

using FloatListCell = TypedListCell<FloatCell>;

using DoubleListCell = TypedListCell<DoubleCell>;

using StringListCell = TypedListCell<StringCell>;

#ifdef COMMONS_HAS_INT128

using U128ListCell = TypedListCell<U128Cell>;

using I128ListCell = TypedListCell<I128Cell>;

#endif


using CharMapCell = TypedMapCell<CharCell>;

using BoolMapCell = TypedMapCell<BoolCell>;

using U8MapCell = TypedMapCell<U8Cell>;

using U16MapCell = TypedMapCell<U16Cell>;

using U32MapCell = TypedMapCell<U32Cell>;

using U64MapCell = TypedMapCell<U64Cell>;

using I8MapCell = TypedMapCell<I8Cell>;

using I16MapCell = TypedMapCell<I16Cell>;

using I32MapCell = TypedMapCell<I32Cell>;

using I64MapCell = TypedMapCell<I64Cell>;

using FloatMapCell = TypedMapCell<FloatCell>;

using DoubleMapCell = TypedMapCell<DoubleCell>;

using StringMapCell = TypedMapCell<StringCell>;

#ifdef COMMONS_HAS_INT128

using U128MapCell = TypedMapCell<U128Cell>;

using I128MapCell = TypedMapCell<I128Cell>;

#endif


using CharHashMapCell = TypedHashMapCell<CharCell>;

using BoolHashMapCell = TypedHashMapCell<BoolCell>;

using U8HashMapCell = TypedHashMapCell<U8Cell>;

using U16HashMapCell = TypedHashMapCell<U16Cell>;

using U32HashMapCell = TypedHashMapCell<U32Cell>;

using U64HashMapCell = TypedHashMapCell<U64Cell>;

using I8HashMapCell = TypedHashMapCell<I8Cell>;

using I16HashMapCell = TypedHashMapCell<I16Cell>;

using I32HashMapCell = TypedHashMapCell<I32Cell>;

using I64HashMapCell = TypedHashMapCell<I64Cell>;

using FloatHashMapCell = TypedHashMapCell<FloatCell>;

using DoubleHashMapCell = TypedHashMapCell<DoubleCell>;

using StringHashMapCell = TypedHashMapCell<StringCell>;

#ifdef COMMONS_HAS_INT128

using U128HashMapCell = TypedHashMapCell<U128Cell>;

using I128HashMapCell = TypedHashMapCell<I128Cell>;

#endif


// Complex typed collections (wire kinds e.g. "l:cf64", "m:cs8", "hm:cu32").


using Cs8ListCell = TypedListCell<Cs8Cell>;

using Cs16ListCell = TypedListCell<Cs16Cell>;

using Cs32ListCell = TypedListCell<Cs32Cell>;

using Cs64ListCell = TypedListCell<Cs64Cell>;

using Cu8ListCell = TypedListCell<Cu8Cell>;

using Cu16ListCell = TypedListCell<Cu16Cell>;

using Cu32ListCell = TypedListCell<Cu32Cell>;

using Cu64ListCell = TypedListCell<Cu64Cell>;

using Cf32ListCell = TypedListCell<Cf32Cell>;

using Cf64ListCell = TypedListCell<Cf64Cell>;


using Cs8MapCell = TypedMapCell<Cs8Cell>;

using Cs16MapCell = TypedMapCell<Cs16Cell>;

using Cs32MapCell = TypedMapCell<Cs32Cell>;

using Cs64MapCell = TypedMapCell<Cs64Cell>;

using Cu8MapCell = TypedMapCell<Cu8Cell>;

using Cu16MapCell = TypedMapCell<Cu16Cell>;

using Cu32MapCell = TypedMapCell<Cu32Cell>;

using Cu64MapCell = TypedMapCell<Cu64Cell>;

using Cf32MapCell = TypedMapCell<Cf32Cell>;

using Cf64MapCell = TypedMapCell<Cf64Cell>;


using Cs8HashMapCell = TypedHashMapCell<Cs8Cell>;

using Cs16HashMapCell = TypedHashMapCell<Cs16Cell>;

using Cs32HashMapCell = TypedHashMapCell<Cs32Cell>;

using Cs64HashMapCell = TypedHashMapCell<Cs64Cell>;

using Cu8HashMapCell = TypedHashMapCell<Cu8Cell>;

using Cu16HashMapCell = TypedHashMapCell<Cu16Cell>;

using Cu32HashMapCell = TypedHashMapCell<Cu32Cell>;

using Cu64HashMapCell = TypedHashMapCell<Cu64Cell>;

using Cf32HashMapCell = TypedHashMapCell<Cf32Cell>;

using Cf64HashMapCell = TypedHashMapCell<Cf64Cell>;


inline void register_primitives(ParcelRegistry& reg) {

    reg.register_kind(CharCell::descriptor());

    reg.register_kind(BoolCell::descriptor());

    reg.register_kind(U8Cell::descriptor());

    reg.register_kind(U16Cell::descriptor());

    reg.register_kind(U32Cell::descriptor());

    reg.register_kind(U64Cell::descriptor());

    reg.register_kind(I8Cell::descriptor());

    reg.register_kind(I16Cell::descriptor());

    reg.register_kind(I32Cell::descriptor());

    reg.register_kind(I64Cell::descriptor());

    reg.register_kind(FloatCell::descriptor());

    reg.register_kind(DoubleCell::descriptor());

    reg.register_kind(Cs8Cell::descriptor());

    reg.register_kind(Cs16Cell::descriptor());

    reg.register_kind(Cs32Cell::descriptor());

    reg.register_kind(Cs64Cell::descriptor());

    reg.register_kind(Cu8Cell::descriptor());

    reg.register_kind(Cu16Cell::descriptor());

    reg.register_kind(Cu32Cell::descriptor());

    reg.register_kind(Cu64Cell::descriptor());

    reg.register_kind(Cf32Cell::descriptor());

    reg.register_kind(Cf64Cell::descriptor());

    reg.register_kind(StringCell::descriptor());

#ifdef COMMONS_HAS_INT128

    reg.register_kind(U128Cell::descriptor());

    reg.register_kind(I128Cell::descriptor());

#endif

}


inline void register_collections(ParcelRegistry& reg) {

    reg.register_kind(ListCell::descriptor());

    reg.register_kind(MapCell::descriptor());

    reg.register_kind(HashMapCell::descriptor());

}


inline void register_typed_collections(ParcelRegistry& reg) {

    reg.register_kind(CharListCell::descriptor());

    reg.register_kind(BoolListCell::descriptor());

    reg.register_kind(U8ListCell::descriptor());

    reg.register_kind(U16ListCell::descriptor());

    reg.register_kind(U32ListCell::descriptor());

    reg.register_kind(U64ListCell::descriptor());

    reg.register_kind(I8ListCell::descriptor());

    reg.register_kind(I16ListCell::descriptor());

    reg.register_kind(I32ListCell::descriptor());

    reg.register_kind(I64ListCell::descriptor());

    reg.register_kind(FloatListCell::descriptor());

    reg.register_kind(DoubleListCell::descriptor());

    reg.register_kind(StringListCell::descriptor());

#ifdef COMMONS_HAS_INT128

    reg.register_kind(U128ListCell::descriptor());

    reg.register_kind(I128ListCell::descriptor());

#endif

    reg.register_kind(Cs8ListCell::descriptor());

    reg.register_kind(Cs16ListCell::descriptor());

    reg.register_kind(Cs32ListCell::descriptor());

    reg.register_kind(Cs64ListCell::descriptor());

    reg.register_kind(Cu8ListCell::descriptor());

    reg.register_kind(Cu16ListCell::descriptor());

    reg.register_kind(Cu32ListCell::descriptor());

    reg.register_kind(Cu64ListCell::descriptor());

    reg.register_kind(Cf32ListCell::descriptor());

    reg.register_kind(Cf64ListCell::descriptor());


    reg.register_kind(CharMapCell::descriptor());

    reg.register_kind(BoolMapCell::descriptor());

    reg.register_kind(U8MapCell::descriptor());

    reg.register_kind(U16MapCell::descriptor());

    reg.register_kind(U32MapCell::descriptor());

    reg.register_kind(U64MapCell::descriptor());

    reg.register_kind(I8MapCell::descriptor());

    reg.register_kind(I16MapCell::descriptor());

    reg.register_kind(I32MapCell::descriptor());

    reg.register_kind(I64MapCell::descriptor());

    reg.register_kind(FloatMapCell::descriptor());

    reg.register_kind(DoubleMapCell::descriptor());

    reg.register_kind(StringMapCell::descriptor());

#ifdef COMMONS_HAS_INT128

    reg.register_kind(U128MapCell::descriptor());

    reg.register_kind(I128MapCell::descriptor());

#endif

    reg.register_kind(Cs8MapCell::descriptor());

    reg.register_kind(Cs16MapCell::descriptor());

    reg.register_kind(Cs32MapCell::descriptor());

    reg.register_kind(Cs64MapCell::descriptor());

    reg.register_kind(Cu8MapCell::descriptor());

    reg.register_kind(Cu16MapCell::descriptor());

    reg.register_kind(Cu32MapCell::descriptor());

    reg.register_kind(Cu64MapCell::descriptor());

    reg.register_kind(Cf32MapCell::descriptor());

    reg.register_kind(Cf64MapCell::descriptor());


    reg.register_kind(CharHashMapCell::descriptor());

    reg.register_kind(BoolHashMapCell::descriptor());

    reg.register_kind(U8HashMapCell::descriptor());

    reg.register_kind(U16HashMapCell::descriptor());

    reg.register_kind(U32HashMapCell::descriptor());

    reg.register_kind(U64HashMapCell::descriptor());

    reg.register_kind(I8HashMapCell::descriptor());

    reg.register_kind(I16HashMapCell::descriptor());

    reg.register_kind(I32HashMapCell::descriptor());

    reg.register_kind(I64HashMapCell::descriptor());

    reg.register_kind(FloatHashMapCell::descriptor());

    reg.register_kind(DoubleHashMapCell::descriptor());

    reg.register_kind(StringHashMapCell::descriptor());

#ifdef COMMONS_HAS_INT128

    reg.register_kind(U128HashMapCell::descriptor());

    reg.register_kind(I128HashMapCell::descriptor());

#endif

    reg.register_kind(Cs8HashMapCell::descriptor());

    reg.register_kind(Cs16HashMapCell::descriptor());

    reg.register_kind(Cs32HashMapCell::descriptor());

    reg.register_kind(Cs64HashMapCell::descriptor());

    reg.register_kind(Cu8HashMapCell::descriptor());

    reg.register_kind(Cu16HashMapCell::descriptor());

    reg.register_kind(Cu32HashMapCell::descriptor());

    reg.register_kind(Cu64HashMapCell::descriptor());

    reg.register_kind(Cf32HashMapCell::descriptor());

    reg.register_kind(Cf64HashMapCell::descriptor());

}


inline void register_std(ParcelRegistry& reg) {

    reg.register_kind(SystemTimePointCell::descriptor());

    reg.register_kind(UnixMillisCell::descriptor());

    reg.register_kind(DurationMsCell::descriptor());

    reg.register_kind(YmdCell::descriptor());

    reg.register_kind(PathCell::descriptor());

}


inline void register_commons(ParcelRegistry& reg) {

    reg.register_kind(ColorCell::descriptor());

    reg.register_kind(IconCell::descriptor());

    reg.register_kind(DisplayInfoCell::descriptor());

    reg.register_kind(FlagCell::descriptor());

    reg.register_kind(FlagSetCell::descriptor());

    reg.register_kind(SemVerCell::descriptor());

    reg.register_kind(VersionConstraintCell::descriptor());

    reg.register_kind(OriginCell::descriptor());

}


#if PARCEL_HAS_ULID

inline void register_ulid(ParcelRegistry& reg) {

    reg.register_kind(UlidCell::descriptor());

}

#endif


inline void register_builtins(ParcelRegistry& reg, const BuiltinsOptions opts = {}) {

    if (opts.primitives) {

        register_primitives(reg);

    }

    if (opts.collections) {

        register_collections(reg);

    }

    if (opts.typed_collections) {

        register_typed_collections(reg);

    }

    if (opts.std) {

        register_std(reg);

    }

    if (opts.commons) {

        register_commons(reg);

    }

#if PARCEL_HAS_ULID

    if (opts.ulid) {

        register_ulid(reg);

    }

#endif

}


// Defined here (rather than in registry.h) so the registry header doesn't

// pull in every primitive / collection cell. The declaration lives on

// ParcelRegistry; this is just the inline body.


inline ParcelRegistry::ParcelRegistry(const BuiltinsOptions opts) {

    register_builtins(*this, opts);

}


}  // namespace parcel

parcel::register_commons
void register_commons(ParcelRegistry &reg)
Register the commons-adapter cells into reg.
Definition builtins.h:371

parcel::register_collections
void register_collections(ParcelRegistry &reg)
Register the heterogeneous ListCell, MapCell, and HashMapCell into reg.
Definition builtins.h:241

parcel::register_builtins
void register_builtins(ParcelRegistry &reg, const BuiltinsOptions opts={})
Apply the opts toggles to populate reg with built-in cells.
Definition builtins.h:401

parcel::register_std
void register_std(ParcelRegistry &reg)
Register the std-adapter cells into reg.
Definition builtins.h:353

parcel::register_primitives
void register_primitives(ParcelRegistry &reg)
Register every PrimitiveCell<T> into reg.
Definition builtins.h:207

parcel::register_typed_collections
void register_typed_collections(ParcelRegistry &reg)
Register TypedListCell<P>, TypedMapCell<P>, and TypedHashMapCell<P> for every primitive P.
Definition builtins.h:257

chrono.h
Cell adapters for std::chrono types.

parcel::ListCell::descriptor
static cell_type_descriptor_t descriptor()
Cached descriptor for ListCell.
Definition list.h:672

parcel::MapCell::descriptor
static cell_type_descriptor_t descriptor()
Cached descriptor for MapCell.
Definition map.h:658

parcel::ParcelRegistry
Runtime catalog of cell-type descriptors, keyed by wire kind id.
Definition registry.h:115

parcel::ParcelRegistry::register_kind
void register_kind(cell_type_descriptor_t d)
Register or replace a descriptor by its kind id.
Definition registry.h:252

parcel::ParcelRegistry::ParcelRegistry
ParcelRegistry(BuiltinsOptions opts={})
Construct, optionally tuning which builtins are pre-registered.
Definition builtins.h:427

parcel::PrimitiveCell::descriptor
static cell_type_descriptor_t descriptor()
Cached descriptor for this primitive type.
Definition primitive.h:399

parcel::TypedHashMapCell
Homogeneous string-keyed unordered_map of values of type T.
Definition unordered_map.h:75

parcel::TypedListCell
Homogeneous list of element cells of type T.
Definition list.h:106

parcel::TypedListCell::descriptor
static cell_type_descriptor_t descriptor()
Cached descriptor for this typed list.
Definition list.h:385

parcel::TypedMapCell
Homogeneous string-keyed map of values of type T.
Definition map.h:106

parcel::TypedMapCell::descriptor
static cell_type_descriptor_t descriptor()
Cached descriptor for this typed map.
Definition map.h:368

commons.h
Parcel cell adapters for the aurimasniekis/cpp-commons vocabulary types.

filesystem.h
Cell adapter for std::filesystem::path.

list.h
TypedListCell<T> and heterogeneous ListCell with their descriptors.

map.h
TypedMapCell<T> and heterogeneous MapCell with their descriptors.

primitive.h
PrimitiveCell<T> plus the per-storage PrimitiveTraits<T> specializations.

registry.h
ParcelRegistry, Definition, and BuiltinsOptions for polymorphic dispatch.

parcel::BuiltinsOptions
Toggles for the built-in cell registrations performed by register_builtins.
Definition registry.h:50

ulid.h
Optional cell adapter for ulid::Ulid (from aurimasniekis/cpp-ulid).

unordered_map.h
Hash-backed map cells — TypedHashMapCell<T> and HashMapCell.