Struct holochain::prelude::dependencies::kitsune_p2p_types::dependencies::lair_keystore_api::dependencies::hc_seed_bundle::dependencies::rmp_serde::encode::MaybeUnknownLengthCompound

pub struct MaybeUnknownLengthCompound<'a, W, C>
where
    W: 'a,
    C: 'a,
{ /* private fields */ }

Contains a Serializer for encoding elements of sequences and maps.

Note

If , for example, a field inside a struct is tagged with #serde(flatten) the total number of fields of this struct will be unknown to serde because flattened fields may have name clashes and then will be overwritten. So, serde wants to serialize the struct as a map with an unknown length.

For the described case a UnknownLengthCompound is used to encode the elements. On end() the counted length and the encoded elements will be written to the Serializer. A caveat is, that structs that contain flattened fields arem always written as a map, even when compact representaion is desired.

Otherwise, if the length is known, the elements will be encoded directly by the Serializer.

Trait Implementations

impl<'a, W, C> Debug for MaybeUnknownLengthCompound<'a, W, C>

where W: Debug + 'a, C: Debug + 'a,

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

Formats the value using the given formatter.

impl<'a, W, C> SerializeMap for MaybeUnknownLengthCompound<'a, W, C>

where W: Write + 'a, C: SerializerConfig,

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_key<T>( &mut self, key: &T ) -> Result<(), <MaybeUnknownLengthCompound<'a, W, C> as SerializeMap>::Error>

where T: Serialize + ?Sized,

Serialize a map key.

fn serialize_value<T>( &mut self, value: &T ) -> Result<(), <MaybeUnknownLengthCompound<'a, W, C> as SerializeMap>::Error>

where T: Serialize + ?Sized,

Serialize a map value.

fn end( self ) -> Result<<MaybeUnknownLengthCompound<'a, W, C> as SerializeMap>::Ok, <MaybeUnknownLengthCompound<'a, W, C> as SerializeMap>::Error>

Finish serializing a map.

fn serialize_entry<K, V>( &mut self, key: &K, value: &V ) -> Result<(), Self::Error>

where K: Serialize + ?Sized, V: Serialize + ?Sized,

Serialize a map entry consisting of a key and a value.

impl<'a, W, C> SerializeSeq for MaybeUnknownLengthCompound<'a, W, C>

where W: Write + 'a, C: SerializerConfig,

type Ok = ()

Must match the Ok type of our Serializer.

type Error = Error

Must match the Error type of our Serializer.

fn serialize_element<T>( &mut self, value: &T ) -> Result<(), <MaybeUnknownLengthCompound<'a, W, C> as SerializeSeq>::Error>

where T: Serialize + ?Sized,

Serialize a sequence element.

fn end( self ) -> Result<<MaybeUnknownLengthCompound<'a, W, C> as SerializeSeq>::Ok, <MaybeUnknownLengthCompound<'a, W, C> as SerializeSeq>::Error>

Finish serializing a sequence.