Struct Probe

pub struct Probe<'a, 'b> { /* private fields */ }

A decoding probe to to look ahead what comes next.

A Probe derefs to Decoder and thus can be used like one without affecting the decoder from which it was created.

Methods from Deref<Target = Decoder<'b>>

pub fn decode<T: Decode<'b, ()>>(&mut self) -> Result<T, Error>

Decode any type that implements Decode.

pub fn decode_with<C, T: Decode<'b, C>>( &mut self, ctx: &mut C, ) -> Result<T, Error>

Decode any type that implements Decode.

pub fn position(&self) -> usize

Get the current decode position.

pub fn set_position(&mut self, pos: usize)

Set the current decode position.

pub fn input(&self) -> &'b [u8]

Get a reference to the input bytes.

pub fn probe<'a>(&'a mut self) -> Probe<'a, 'b>

Get a decoding probe to look ahead what is coming next.

This will not affect the decoding state of self and after the returned Probe has been dropped, decoding can continue from its current position as if probe was never called.

pub fn bool(&mut self) -> Result<bool, Error>

Decode a bool value.

pub fn u8(&mut self) -> Result<u8, Error>

Decode a u8 value.

pub fn u16(&mut self) -> Result<u16, Error>

Decode a u16 value.

pub fn u32(&mut self) -> Result<u32, Error>

Decode a u32 value.

pub fn u64(&mut self) -> Result<u64, Error>

Decode a u64 value.

pub fn i8(&mut self) -> Result<i8, Error>

Decode an i8 value.

pub fn i16(&mut self) -> Result<i16, Error>

Decode an i16 value.

pub fn i32(&mut self) -> Result<i32, Error>

Decode an i32 value.

pub fn i64(&mut self) -> Result<i64, Error>

Decode an i64 value.

pub fn int(&mut self) -> Result<Int, Error>

Decode a CBOR integer.

See Int for details regarding the value range of CBOR integers.

pub fn f32(&mut self) -> Result<f32, Error>

Decode an f32 value.

pub fn f64(&mut self) -> Result<f64, Error>

Decode an f64 value.

pub fn char(&mut self) -> Result<char, Error>

Decode a char value.

pub fn bytes(&mut self) -> Result<&'b [u8], Error>

Decode a byte slice.

This only decodes byte slices of definite lengths. See Decoder::bytes_iter for indefinite byte slice support.

pub fn bytes_iter(&mut self) -> Result<BytesIter<'_, 'b>, Error>

Iterate over byte slices.

This supports indefinite byte slices by returing a byte slice on each iterator step. If a single definite slice is decoded the iterator will only yield one item.

pub fn str(&mut self) -> Result<&'b str, Error>

Decode a string slice.

This only decodes string slices of definite lengths. See Decoder::str_iter for indefinite string slice support.

pub fn str_iter(&mut self) -> Result<StrIter<'_, 'b>, Error>

Iterate over string slices.

This supports indefinite string slices by returing a string slice on each iterator step. If a single definite slice is decoded the iterator will only yield one item.

pub fn array(&mut self) -> Result<Option<u64>, Error>

Begin decoding an array.

CBOR arrays are heterogenous collections and may be of indefinite length. If the length is known it is returned as a Some, for indefinite arrays a None is returned.

pub fn array_iter<T>(&mut self) -> Result<ArrayIter<'_, 'b, T>, Error>

where T: Decode<'b, ()>,

Iterate over all array elements.

This supports indefinite and definite length arrays and uses the Decode trait to decode each element. Consequently only homogenous arrays are supported by this method.

pub fn array_iter_with<'a, C, T>( &'a mut self, ctx: &'a mut C, ) -> Result<ArrayIterWithCtx<'a, 'b, C, T>, Error>

where T: Decode<'b, C>,

Iterate over all array elements.

This supports indefinite and definite length arrays and uses the Decode trait to decode each element. Consequently only homogenous arrays are supported by this method.

pub fn map(&mut self) -> Result<Option<u64>, Error>

Begin decoding a map.

CBOR maps are heterogenous collections (both in keys and in values) and may be of indefinite length. If the length is known it is returned as a Some, for indefinite maps a None is returned.

pub fn map_iter<K, V>(&mut self) -> Result<MapIter<'_, 'b, K, V>, Error>

where K: Decode<'b, ()>, V: Decode<'b, ()>,

Iterate over all map entries.

This supports indefinite and definite length maps and uses the Decode trait to decode each key and value. Consequently only homogenous maps are supported by this method.

pub fn map_iter_with<'a, C, K, V>( &'a mut self, ctx: &'a mut C, ) -> Result<MapIterWithCtx<'a, 'b, C, K, V>, Error>

where K: Decode<'b, C>, V: Decode<'b, C>,

Iterate over all map entries.

This supports indefinite and definite length maps and uses the Decode trait to decode each key and value. Consequently only homogenous maps are supported by this method.

pub fn tag(&mut self) -> Result<Tag, Error>

Decode a CBOR tag.

pub fn null(&mut self) -> Result<(), Error>

Decode a CBOR null value.

pub fn undefined(&mut self) -> Result<(), Error>

Decode a CBOR undefined value.

pub fn simple(&mut self) -> Result<u8, Error>

Decode a CBOR simple value.

pub fn datatype(&self) -> Result<Type, Error>

Inspect the CBOR type at the current position.

pub fn skip(&mut self) -> Result<(), Error>

Skip over the current CBOR value.

Without feature alloc, skipping over maps or arrays that contain an indefinite-length map or array will return an error.

Trait Implementations

impl<'a, 'b> Debug for Probe<'a, 'b>

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

Formats the value using the given formatter.

impl<'b> Deref for Probe<'_, 'b>

type Target = Decoder<'b>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'b> DerefMut for Probe<'_, 'b>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 12 bytes