Struct TokenBuf

pub struct TokenBuf<'a> { /* private fields */ }

A buffer for collecting test tokens.

This type shouldn’t be used as a general-purpose buffer. See the sval-buffer library for that.

Implementations

impl<'a> TokenBuf<'a>

pub fn new() -> Self

Create a new, empty token buffer.

pub fn as_tokens(&self) -> &[Token<'a>]

Get the underlying tokens in this buffer.

Trait Implementations

impl<'a> Debug for TokenBuf<'a>

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

Formats the value using the given formatter.

impl<'a> Default for TokenBuf<'a>

fn default() -> TokenBuf<'a>

Returns the “default value” for a type.

impl<'a> PartialEq for TokenBuf<'a>

fn eq(&self, other: &TokenBuf<'a>) -> 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<'sval> Stream<'sval> for TokenBuf<'sval>

fn null(&mut self) -> Result

Stream null, the absence of any other meaningful value.

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_fragment_computed(&mut self, fragment: &str) -> Result

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

fn text_end(&mut self) -> Result

Complete a UTF8 text string.

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

Stream a signed 64bit integer.

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

Stream a 64bit binary floating point number.

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

Start a homogenous 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 seq_end(&mut self) -> Result

Complete a homogenous sequence of values.

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

Stream a fragment of UTF8 text.

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

Start 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 binary_end(&mut self) -> Result

Complete a bitstring.

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 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 map_begin(&mut self, num_entries_hint: Option<usize>) -> Result

Start a homogenous 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 map_end(&mut self) -> Result

Complete a homogenous mapping of arbitrary keys to values.

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.

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 record_begin( &mut self, tag: Option<&Tag>, label: Option<&Label<'_>>, index: Option<&Index>, num_entries: Option<usize>, ) -> Result

Start a record type.

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 type.

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

Start a tuple type.

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 type.

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 value<V>(&mut self, v: &'sval V) -> Result<(), Error>

where V: Value + ?Sized,

Recurse into a nested value.

fn value_computed<V>(&mut self, v: &V) -> Result<(), Error>

where V: Value + ?Sized,

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

impl<'a> StructuralPartialEq for TokenBuf<'a>