Struct FlattenToTuple 

pub struct FlattenToTuple<'sval, S> { /* private fields */ }

A stream that flattens the fields of a value onto a tuple.

Implementations

impl<'sval, S: Stream<'sval>> FlattenToTuple<'sval, S>

pub fn new(stream: S, offset: isize) -> Self

Wrap the given stream.

The offset is the current length of the tuple being flattened onto. Call FlattenToTuple::end after streaming a value to get the new length of the tuple.

pub fn end(self) -> (isize, S)

Finish flattening a value.

This method returns the length of the map after flattening that can be used to reconstruct a FlattenToTuple for a future value.

Trait Implementations

impl<'sval, S: Stream<'sval>> Stream<'sval> for FlattenToTuple<'sval, S>

fn value<V: Value + ?Sized>(&mut self, v: &'sval V) -> Result

Recurse into a nested value.

fn value_computed<V: Value + ?Sized>(&mut self, v: &V) -> Result

Recurse into a nested value, borrowed for some arbitrarily short lifetime.

fn null(&mut self) -> Result

Stream null, the absence of any other meaningful value.

fn u8(&mut self, value: u8) -> Result

Stream an unsigned 8bit integer.

fn u16(&mut self, value: u16) -> Result

Stream an unsigned 16bit integer.

fn u32(&mut self, value: u32) -> Result

Stream an unsigned 32bit integer.

fn u64(&mut self, value: u64) -> Result

Stream an unsigned 64bit integer.

fn u128(&mut self, value: u128) -> Result

Stream an unsigned 128bit integer.

fn i8(&mut self, value: i8) -> Result

Stream a signed 8bit integer.

fn i16(&mut self, value: i16) -> Result

Stream a signed 16bit integer.

fn i32(&mut self, value: i32) -> Result

Stream a signed 32bit integer.

fn i64(&mut self, value: i64) -> Result

Stream a signed 64bit integer.

fn i128(&mut self, value: i128) -> Result

Stream a signed 128bit integer.

fn f32(&mut self, value: f32) -> Result

Stream a 32bit binary floating point number.

fn f64(&mut self, value: f64) -> Result

Stream a 64bit binary floating point number.

fn bool(&mut self, value: bool) -> Result

Stream a boolean.

fn text_begin(&mut self, num_bytes: Option<usize>) -> Result

Start a UTF8 text string.

fn text_end(&mut self) -> Result

Complete a UTF8 text string.

fn text_fragment(&mut self, fragment: &'sval str) -> Result

Stream a fragment of UTF8 text.

fn text_fragment_computed(&mut self, fragment: &str) -> Result

Stream a fragment of UTF8 text, borrowed for some arbitrarily short lifetime.

fn binary_begin(&mut self, num_bytes: Option<usize>) -> Result

Start a bitstring.

fn binary_end(&mut self) -> Result

Complete a bitstring.

fn binary_fragment(&mut self, fragment: &'sval [u8]) -> Result

Stream a fragment of a bitstring.

fn binary_fragment_computed(&mut self, fragment: &[u8]) -> Result

Stream a fragment of a bitstring, borrowed for some arbitrarily short lifetime.

fn map_begin(&mut self, num_entries: Option<usize>) -> Result

Start a heterogeneous mapping of arbitrary keys to values.

fn map_end(&mut self) -> Result

Complete a heterogeneous mapping of arbitrary keys to values.

fn map_key_begin(&mut self) -> Result

Start a key in a key-value mapping.

fn map_key_end(&mut self) -> Result

Complete a key in a key-value mapping.

fn map_value_begin(&mut self) -> Result

Start a value in a key-value mapping.

fn map_value_end(&mut self) -> Result

Complete a value in a key-value mapping.

fn seq_begin(&mut self, num_entries: Option<usize>) -> Result

Start a heterogeneous sequence of values.

fn seq_end(&mut self) -> Result

Complete a heterogeneous sequence of values.

fn seq_value_begin(&mut self) -> Result

Start an individual value in a sequence.

fn seq_value_end(&mut self) -> Result

Complete an individual value in a sequence.

fn tagged_begin( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, ) -> Result

Start a tagged value.

fn tagged_end( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, ) -> Result

Complete a tagged value.

fn tag( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, ) -> Result

Stream a standalone tag.

fn tag_hint(&mut self, tag: &Tag) -> Result

Use a tag as a hint without streaming it as a value.

fn record_begin( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, num_entries: Option<usize>, ) -> Result

Start a record.

fn record_value_begin(&mut self, tag: Option<&Tag>, label: &Label<'_>) -> Result

Start a field in a record.

fn record_value_end(&mut self, tag: Option<&Tag>, label: &Label<'_>) -> Result

Complete a field in a record.

fn record_end( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, ) -> Result

Complete a record.

fn tuple_begin( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, num_entries: Option<usize>, ) -> Result

Start a tuple.

fn tuple_value_begin(&mut self, tag: Option<&Tag>, index: &Index) -> Result

Start a field in a tuple.

fn tuple_value_end(&mut self, tag: Option<&Tag>, index: &Index) -> Result

Complete a field in a tuple.

fn tuple_end( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, ) -> Result

Complete a tuple.

fn record_tuple_begin( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, num_entries: Option<usize>, ) -> Result

Begin a type that may be treated as either a record or a tuple.

fn record_tuple_value_begin( &mut self, tag: Option<&Tag>, label: &Label<'_>, index: &Index, ) -> Result

Begin a field in a type that may be treated as either a record or a tuple.

fn record_tuple_value_end( &mut self, tag: Option<&Tag>, label: &Label<'_>, index: &Index, ) -> Result

Complete a field in a type that may be treated as either a record or a tuple.

fn record_tuple_end( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, ) -> Result

Complete a type that may be treated as either a record or a tuple.

fn enum_begin( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, ) -> Result

Start a variant in an enumerated type.

fn enum_end( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, ) -> Result

Complete a variant in an enumerated type.