Enum MapRepr 

#[non_exhaustive]
pub enum MapRepr {
    HashMap,
    BTreeMap,
    Custom(String),
}

The owned Rust collection a proto map<K, V> field maps to in generated owned structs.

The default is HashMap (std::collections::HashMap, or hashbrown::HashMap under no_std). BTreeMap selects the buffa-provided alloc::collections::BTreeMap for deterministic iteration order with no extra dependency or consumer code. Custom substitutes any map that satisfies the buffa::map_codec::MapStorage bound — for example a crate-local newtype wrapping indexmap::IndexMap.

Unlike the repeated knob (which wraps the element type and needs a * placeholder template), a map type is always path<K, V> with both parameters positional and buffa-resolved, so a custom path is a plain type path (e.g. "::my_crate::OrderedMap") with no placeholder.

Select a representation through buffa_build’s map_type / map_type_custom builder methods. The wire format is identical regardless of the collection; only the in-memory owned type changes.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

HashMap

::buffa::__private::HashMap<K, V> — the default. Generated output is byte-identical to a build without the knob.

BTreeMap

::buffa::alloc::collections::BTreeMap<K, V> — buffa-provided, no extra dependency, deterministic key order (so encoded bytes are stable across runs). The key type must be Ord, which every proto map key type (integers, bool, string) satisfies.

Custom(String)

A custom map named by a fully-qualified Rust type path (e.g. "::my_crate::OrderedMap"). The named type must satisfy buffa::map_codec::MapStorage and be a crate-local newtype (a foreign map cannot implement the buffa-owned reflection / serde traits).

Limitations

• The path is a plain type path applied as path<K, V> — it must not include the <K, V> parameters or a * placeholder. A path that does not parse as a Rust type surfaces as CodeGenError::InvalidTypePath at generation (.compile()) time.
• The newtype must implement buffa::map_codec::MapStorage plus the derive / FromIterator / ReflectMap / serde / arbitrary bounds listed on that trait’s docs (the canonical list). JSON and arbitrary now work for every proto map key/value type regardless of the container. The buffa-provided BTreeMap already satisfies every bound, so prefer it unless you need a specific foreign map.

Trait Implementations

impl Clone for MapRepr

fn clone(&self) -> MapRepr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MapRepr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MapRepr

fn default() -> MapRepr

Returns the “default value” for a type.

impl Eq for MapRepr

impl PartialEq for MapRepr

fn eq(&self, other: &MapRepr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for MapRepr