Trait Stream

Source

pub trait Stream<'sval> {
Show 52 methods    // Required methods
    fn null(&mut self) -> Result;
    fn bool(&mut self, value: bool) -> Result;
    fn text_begin(&mut self, num_bytes: Option<usize>) -> Result;
    fn text_fragment_computed(&mut self, fragment: &str) -> Result;
    fn text_end(&mut self) -> Result;
    fn i64(&mut self, value: i64) -> Result;
    fn seq_begin(&mut self, num_entries: Option<usize>) -> Result;
    fn seq_value_begin(&mut self) -> Result;
    fn seq_value_end(&mut self) -> Result;
    fn seq_end(&mut self) -> Result;

    // Provided methods
    fn value<V: Value + ?Sized>(&mut self, v: &'sval V) -> Result { ... }
    fn value_computed<V: Value + ?Sized>(&mut self, v: &V) -> Result { ... }
    fn text_fragment(&mut self, fragment: &'sval str) -> Result { ... }
    fn binary_begin(&mut self, num_bytes: Option<usize>) -> Result { ... }
    fn binary_fragment(&mut self, fragment: &'sval [u8]) -> Result { ... }
    fn binary_fragment_computed(&mut self, fragment: &[u8]) -> Result { ... }
    fn binary_end(&mut self) -> Result { ... }
    fn u8(&mut self, value: u8) -> Result { ... }
    fn u16(&mut self, value: u16) -> Result { ... }
    fn u32(&mut self, value: u32) -> Result { ... }
    fn u64(&mut self, value: u64) -> Result { ... }
    fn u128(&mut self, value: u128) -> Result { ... }
    fn i8(&mut self, value: i8) -> Result { ... }
    fn i16(&mut self, value: i16) -> Result { ... }
    fn i32(&mut self, value: i32) -> Result { ... }
    fn i128(&mut self, value: i128) -> Result { ... }
    fn f32(&mut self, value: f32) -> Result { ... }
    fn f64(&mut self, value: f64) -> Result { ... }
    fn map_begin(&mut self, num_entries: Option<usize>) -> Result { ... }
    fn map_key_begin(&mut self) -> Result { ... }
    fn map_key_end(&mut self) -> Result { ... }
    fn map_value_begin(&mut self) -> Result { ... }
    fn map_value_end(&mut self) -> Result { ... }
    fn map_end(&mut self) -> Result { ... }
    fn enum_begin(
        &mut self,
        tag: Option<&Tag>,
        label: Option<&Label<'_>>,
        index: Option<&Index>,
    ) -> Result { ... }
    fn enum_end(
        &mut self,
        tag: Option<&Tag>,
        label: Option<&Label<'_>>,
        index: Option<&Index>,
    ) -> Result { ... }
    fn tagged_begin(
        &mut self,
        tag: Option<&Tag>,
        label: Option<&Label<'_>>,
        index: Option<&Index>,
    ) -> Result { ... }
    fn tagged_end(
        &mut self,
        tag: Option<&Tag>,
        label: Option<&Label<'_>>,
        index: Option<&Index>,
    ) -> Result { ... }
    fn tag(
        &mut self,
        tag: Option<&Tag>,
        label: Option<&Label<'_>>,
        index: Option<&Index>,
    ) -> Result { ... }
    fn tag_hint(&mut self, tag: &Tag) -> Result { ... }
    fn record_begin(
        &mut self,
        tag: Option<&Tag>,
        label: Option<&Label<'_>>,
        index: Option<&Index>,
        num_entries: Option<usize>,
    ) -> Result { ... }
    fn record_value_begin(
        &mut self,
        tag: Option<&Tag>,
        label: &Label<'_>,
    ) -> Result { ... }
    fn record_value_end(
        &mut self,
        tag: Option<&Tag>,
        label: &Label<'_>,
    ) -> Result { ... }
    fn record_end(
        &mut self,
        tag: Option<&Tag>,
        label: Option<&Label<'_>>,
        index: Option<&Index>,
    ) -> Result { ... }
    fn tuple_begin(
        &mut self,
        tag: Option<&Tag>,
        label: Option<&Label<'_>>,
        index: Option<&Index>,
        num_entries: Option<usize>,
    ) -> Result { ... }
    fn tuple_value_begin(&mut self, tag: Option<&Tag>, index: &Index) -> Result { ... }
    fn tuple_value_end(&mut self, tag: Option<&Tag>, index: &Index) -> Result { ... }
    fn tuple_end(
        &mut self,
        tag: Option<&Tag>,
        label: Option<&Label<'_>>,
        index: Option<&Index>,
    ) -> Result { ... }
    fn record_tuple_begin(
        &mut self,
        tag: Option<&Tag>,
        label: Option<&Label<'_>>,
        index: Option<&Index>,
        num_entries: Option<usize>,
    ) -> Result { ... }
    fn record_tuple_value_begin(
        &mut self,
        tag: Option<&Tag>,
        label: &Label<'_>,
        index: &Index,
    ) -> Result { ... }
    fn record_tuple_value_end(
        &mut self,
        tag: Option<&Tag>,
        label: &Label<'_>,
        index: &Index,
    ) -> Result { ... }
    fn record_tuple_end(
        &mut self,
        tag: Option<&Tag>,
        label: Option<&Label<'_>>,
        index: Option<&Index>,
    ) -> Result { ... }
}

Expand description

A consumer of structured data.

Each instance of a stream is expected to receive a single complete value.

Required Methods§

Source

fn null(&mut self) -> Result

Stream null, the absence of any other meaningful value.

Null is a complete value.

Source

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

Stream a boolean.

A boolean is complete values.

Source

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

Start a UTF8 text string.

After this call, a stream expects a series of zero or more calls to Stream::text_fragment and Stream::text_fragment_computed. A call to Stream::text_end completes the value.

This method accepts a num_bytes hint, which hints the length of the text value in bytes. If a value for num_bytes is provided, it must be accurate.

Source

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

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

This method may only be called in the context of a text value, between a call to Stream::text_begin and Stream::text_end.

Source

fn text_end(&mut self) -> Result

Complete a UTF8 text string.

This method may only be called in the context of a text value, after a call to Stream::text_begin.

Source

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

Stream a signed 64bit integer.

An integer is a complete value.

Source

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

Start a heterogeneous sequence of values.

After this call, a stream expects a series of zero or more sequence elements. Each element is a sequence of the following calls:

A call to Stream::seq_end completes the value.

This method accepts a num_entries hint, which hints the number of elements in the sequence. If a value for num_entries is provided, it must be accurate.

Source

fn seq_value_begin(&mut self) -> Result

Start an individual value in a sequence.

This method may only be called in the context of a sequence value, after a call to Stream::seq_begin. This call must be followed by a complete value, then a call to Stream::seq_value_end. Sequence elements cannot be empty.

Source

fn seq_value_end(&mut self) -> Result

Complete an individual value in a sequence.

This method may only be called in the context of an element in a sequence value, after a call to Stream::seq_value_begin. Sequence elements cannot be empty.

Source

fn seq_end(&mut self) -> Result

Complete a heterogeneous sequence of values.

This method may only be called in the context of a sequence value, after a call to Stream::seq_begin.

Provided Methods§

Source

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

Recurse into a nested value.

Source

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

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

Source

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

Stream a fragment of UTF8 text.

This method may only be called in the context of a text value, between a call to Stream::text_begin and Stream::text_end.

Source

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

Start a bitstring.

After this call, a stream expects a series of zero or more calls to Stream::binary_fragment and Stream::binary_fragment_computed. A call to Stream::binary_end completes the value.

This method accepts a num_bytes hint, which hints the length of the bitstring value in bytes. If a value for num_bytes is provided, it must be accurate.

Source

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

Stream a fragment of a bitstring.

This method may only be called in the context of a bitstring value, between a call to Stream::binary_begin and Stream::binary_end.

Source

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

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

This method may only be called in the context of a bitstring value, between a call to Stream::binary_begin and Stream::binary_end.

Source

fn binary_end(&mut self) -> Result

Complete a bitstring.

This method may only be called in the context of a bitstring value, after a call to Stream::binary_begin.

Source

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

Stream an unsigned 8bit integer.

An integer is a complete value.

Source

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

Stream an unsigned 16bit integer.

An integer is a complete value.

Source

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

Stream an unsigned 32bit integer.

An integer is a complete value.

Source

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

Stream an unsigned 64bit integer.

An integer is a complete value.

Source

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

Stream an unsigned 128bit integer.

An integer is a complete value.

Source

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

Stream a signed 8bit integer.

An integer is a complete value.

Source

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

Stream a signed 16bit integer.

An integer is a complete value.

Source

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

Stream a signed 32bit integer.

An integer is a complete value.

Source

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

Stream a signed 128bit integer.

An integer is a complete value.

Source

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

Stream a 32bit binary floating point number.

An integer is a complete value.

Source

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

Stream a 64bit binary floating point number.

An integer is a complete value.

Source

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

Start a heterogeneous mapping of arbitrary keys to values.

After this call, a stream expects a series of zero or more map key-value pairs. Each key-value pair is a sequence of the following calls:

A call to Stream::map_end completes the value.

This method accepts a num_entries hint, which hints the number of key-value pairs in the map. If a value for num_entries is provided, it must be accurate.

Source

fn map_key_begin(&mut self) -> Result

Start a key in a key-value mapping.

This method may only be called in the context of a map value, after a call to Stream::map_begin. This call must be followed by a complete value, then a call to Stream::map_key_end. Map keys cannot be empty. Each map key must be followed by a map value.

Source

fn map_key_end(&mut self) -> Result

Complete a key in a key-value mapping.

This method may only be called in the context of a key in a map value, after a call to Stream::map_key_begin. Map keys cannot be empty. Each map key must be followed by a map value.

Source

fn map_value_begin(&mut self) -> Result

Start a value in a key-value mapping.

This method may only be called in the context of a map value, after a call to Stream::map_begin. This call must be followed by a complete value. Map values cannot be empty.

Source

fn map_value_end(&mut self) -> Result

Complete a value in a key-value mapping.

This method may only be called in the context of a value in a map value, after a call to Stream::map_value_begin. Map values cannot be empty.

Source

fn map_end(&mut self) -> Result

Complete a heterogeneous mapping of arbitrary keys to values.

This method may only be called in the context of a map value, after a call to Stream::map_begin.

Source

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

Start a variant in an enumerated type.

After this call, a stream expects a complete value as the enum variant. An enum variant can be any type that accepts a Tag, Label, and Index parameter. That includes:

Enum variants may be empty.

A call to Stream::enum_end completes the value.

Source

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

Complete a variant in an enumerated type.

This method may only be called in the context of an enum value, after a call to Stream::enum_begin.

Source

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

Start a tagged value.

After this call, a stream expects a complete value.

A call to Stream::tagged_end completes the value.

Source

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

Complete a tagged value.

This method may only be called in the context of a tagged value, after a call to Stream::tagged_begin.

Source

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

Stream a standalone tag.

Standalone tags are complete values.

Source

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

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

Hints may be given at any point in a stream and may be interpreted by a stream in any way, but can’t be required for a correct result.

Source

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

Start a record.

After this call, a stream expects a series of zero or more record fields. Each field is a sequence of the following calls:

A call to Stream::record_end completes the value.

This method accepts a num_entries hint, which hints the number of fields in the record. If a value for num_entries is provided, it must be accurate.

Source

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

Start a field in a record.

This method may only be called in the context of a record value, after a call to Stream::record_begin. This call must be followed by a complete value, then a call to Stream::record_value_end. Record fields cannot be empty.

Source

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

Complete a field in a record.

This method may only be called in the context of a field in a record value, after a call to Stream::record_value_begin. Record fields cannot be empty.

Source

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

Complete a record.

This method may only be called in the context of a record value, after a call to Stream::record_begin.

Source

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

Start a tuple.

After this call, a stream expects a series of zero or more tuple fields. Each field is a sequence of the following calls:

A call to Stream::tuple_end completes the value.

This method accepts a num_entries hint, which hints the number of fields in the tuple. If a value for num_entries is provided, it must be accurate.

Source

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

Start a field in a tuple.

This method may only be called in the context of a tuple value, after a call to Stream::tuple_begin. This call must be followed by a complete value, then a call to Stream::tuple_value_end. Tuple fields cannot be empty.

Source

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

Complete a field in a tuple.

This method may only be called in the context of a field in a tuple value, after a call to Stream::tuple_value_begin. Tuple fields cannot be empty.

Source

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

Complete a tuple.

This method may only be called in the context of a tuple value, after a call to Stream::tuple_begin.

Source

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.

After this call, a stream expects a series of zero or more record tuple fields. Each field is a sequence of the following calls:

A call to Stream::record_tuple_end completes the value.

This method accepts a num_entries hint, which hints the number of fields in the record tuple. If a value for num_entries is provided, it must be accurate.

Source

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.

This method may only be called in the context of a record tuple value, after a call to Stream::record_tuple_begin. This call must be followed by a complete value, then a call to Stream::record_tuple_value_end. Record tuple fields cannot be empty.

Source

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.

This method may only be called in the context of a field in a record tuple value, after a call to Stream::record_tuple_value_begin. Record tuple fields cannot be empty.

Source

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.

This method may only be called in the context of a record tuple value, after a call to Stream::record_tuple_begin.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Trait Stream Copy item path

Required Methods§

fn null(&mut self) -> Result

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

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

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

fn text_end(&mut self) -> Result

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

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

fn seq_value_begin(&mut self) -> Result

fn seq_value_end(&mut self) -> Result

fn seq_end(&mut self) -> Result

Provided Methods§

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

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

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

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

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

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

fn binary_end(&mut self) -> Result

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

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

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

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

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

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

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

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

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

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

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

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

fn map_key_begin(&mut self) -> Result

fn map_key_end(&mut self) -> Result

fn map_value_begin(&mut self) -> Result

fn map_value_end(&mut self) -> Result

fn map_end(&mut self) -> Result

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Dyn Compatibility§

Implementations on Foreign Types§

impl<'sval, 'a, S> Stream<'sval> for &'a mut Swhere S: Stream<'sval> + ?Sized,

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

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

fn null(&mut self) -> Result

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn text_end(&mut self) -> Result

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

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

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

fn binary_end(&mut self) -> Result

Trait Stream

impl<'sval, 'a, S> Stream<'sval> for &'a mut S
where S: Stream<'sval> + ?Sized,

impl<'sval, 'a, S> Stream<'sval> for Box<S>
where S: Stream<'sval> + ?Sized,