Struct Decoder 

pub struct Decoder<R> { /* private fields */ }

A decoder for decoding lilliput-encoded values.

Implementations

impl<'de, R> Decoder<R>

where R: Read<'de>,

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

where R: Read<'de>,

Decodes a boolean value.

pub fn decode_bool_value(&mut self) -> Result<BoolValue>

Decodes a boolean value, as a BoolValue.

pub fn decode_bool_header(&mut self) -> Result<BoolHeader>

Decodes a boolean value’s header.

pub fn skip_bool_value_of(&mut self, header: BoolHeader) -> Result<()>

where R: Read<'de>,

Skips the boolean value for a given header.

pub fn decode_bool_value_of(&mut self, header: BoolHeader) -> Result<BoolValue>

Decodes boolean value for a given header, as a BoolValue.

impl<'de, R> Decoder<R>

where R: Read<'de>,

pub fn decode_bytes<'s>( &'s mut self, scratch: &'s mut Vec<u8>, ) -> Result<Reference<'de, 's, [u8]>>

Decodes a byte array value, as a slice reference.

pub fn decode_bytes_buf(&mut self) -> Result<Vec<u8>>

Decodes a byte array value, as an owned buffer.

pub fn decode_bytes_value(&mut self) -> Result<BytesValue>

Decodes a byte array value, as a BytesValue.

pub fn decode_bytes_header(&mut self) -> Result<BytesHeader>

Decodes a byte array value’s header.

pub fn skip_bytes_value_of(&mut self, header: BytesHeader) -> Result<()>

where R: Read<'de>,

Skips the byte array value for a given header.

pub fn decode_bytes_value_of( &mut self, header: BytesHeader, ) -> Result<BytesValue>

Decodes byte array value for a given header, as a BytesValue.

impl<'de, R> Decoder<R>

where R: Read<'de>,

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

Decodes a 32-bit floating-point value.

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

Decodes a 64-bit floating-point value.

pub fn decode_float_value(&mut self) -> Result<FloatValue>

Decodes a floating-point value, as a FloatValue.

pub fn decode_float_header(&mut self) -> Result<FloatHeader>

Decodes a floating-point value’s header.

pub fn skip_float_value_of(&mut self, header: FloatHeader) -> Result<()>

Skips the floating-point value for a given header.

pub fn decode_float_value_of( &mut self, header: FloatHeader, ) -> Result<FloatValue>

Decodes floating-point value for a given header, as a FloatValue.

impl<'de, R> Decoder<R>

where R: Read<'de>,

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

Decodes a 8-bit signed integer value.

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

Decodes a 16-bit signed integer value.

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

Decodes a 32-bit signed integer value.

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

Decodes a 64-bit signed integer value.

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

Decodes a 8-bit unsigned integer value.

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

Decodes a 16-bit unsigned integer value.

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

Decodes a 32-bit unsigned integer value.

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

Decodes a 64-bit unsigned integer value.

pub fn decode_signed_int<T>(&mut self) -> Result<T>

where T: Signed + TryFrom<SignedIntValue, Error = TryFromIntError>,

Decodes a signed integer value.

pub fn decode_unsigned_int<T>(&mut self) -> Result<T>

where T: Unsigned + TryFrom<UnsignedIntValue, Error = TryFromIntError>,

Decodes a unsigned integer value.

pub fn decode_signed_int_value(&mut self) -> Result<SignedIntValue>

Decodes a signed integer value, as a SignedIntValue.

pub fn decode_unsigned_int_value(&mut self) -> Result<UnsignedIntValue>

Decodes a unsigned integer value, as a UnsignedIntValue.

pub fn decode_int_value(&mut self) -> Result<IntValue>

Decodes a integer value, as an IntValue.

pub fn decode_int_header(&mut self) -> Result<IntHeader>

Decodes a integer value’s header.

pub fn skip_int_value_of(&mut self, header: IntHeader) -> Result<()>

Skips the integer value for a given header.

pub fn decode_int_value_of(&mut self, header: IntHeader) -> Result<IntValue>

Decodes integer value for a given header, as an IntValue.

impl<'de, R> Decoder<R>

where R: Read<'de>,

pub fn decode_map(&mut self) -> Result<Map>

Decodes a map value.

pub fn decode_map_value(&mut self) -> Result<MapValue>

Decodes a map value, as a MapValue.

pub fn decode_map_header(&mut self) -> Result<MapHeader>

Decodes a map value’s header.

pub fn skip_map_value_of(&mut self, header: MapHeader) -> Result<()>

Skips the map value for a given header.

pub fn decode_map_value_of(&mut self, header: MapHeader) -> Result<MapValue>

Decodes map value for a given header, as a MapValue.

impl<'r, R> Decoder<R>

where R: Read<'r>,

pub fn decode_null(&mut self) -> Result<()>

Decodes a null value.

pub fn decode_null_value(&mut self) -> Result<NullValue>

Decodes a null value, as a NullValue.

pub fn decode_null_header(&mut self) -> Result<NullHeader>

Decodes a null value’s header.

pub fn skip_null_value_of(&mut self, header: NullHeader) -> Result<()>

Skips the null value for a given header.

pub fn decode_null_value_of(&mut self, header: NullHeader) -> Result<NullValue>

Decodes null value for a given header, as a NullValue.

impl<'de, R> Decoder<R>

where R: Read<'de>,

pub fn decode_seq(&mut self) -> Result<Seq>

Decodes a sequence value.

pub fn decode_seq_value(&mut self) -> Result<SeqValue>

Decodes a sequence value, as a SeqValue.

pub fn decode_seq_header(&mut self) -> Result<SeqHeader>

Decodes a sequence value’s header.

pub fn skip_seq_value_of(&mut self, header: SeqHeader) -> Result<()>

Skips the sequence value for a given header.

pub fn decode_seq_value_of(&mut self, header: SeqHeader) -> Result<SeqValue>

Decodes sequence value for a given header, as a SeqValue.

impl<'de, R> Decoder<R>

where R: Read<'de>,

pub fn decode_str<'s>( &'s mut self, scratch: &'s mut Vec<u8>, ) -> Result<Reference<'de, 's, str>>

Decodes a string value, as a reference.

pub fn decode_str_bytes<'s>( &'s mut self, scratch: &'s mut Vec<u8>, ) -> Result<Reference<'de, 's, [u8]>>

Decodes a string value’s raw-bytes, as a reference.

pub fn decode_string(&mut self) -> Result<String>

Decodes a string value, as an owned string.

pub fn decode_string_bytes_buf(&mut self) -> Result<Vec<u8>>

Decodes a string value’s raw-bytes, as an owned buffer.

pub fn decode_string_value(&mut self) -> Result<StringValue>

Decodes a string value, as a StringValue.

pub fn decode_string_header(&mut self) -> Result<StringHeader>

Decodes a string value’s header.

pub fn skip_string_value_of(&mut self, header: StringHeader) -> Result<()>

Skips the map value for a given header.

pub fn decode_string_value_of( &mut self, header: StringHeader, ) -> Result<StringValue>

Decodes map value for a given header, as a MapValue.

impl<'r, R> Decoder<R>

where R: Read<'r>,

pub fn decode_unit(&mut self) -> Result<()>

Decodes a unit value.

pub fn decode_unit_value(&mut self) -> Result<UnitValue>

Decodes a unit value, as a UnitValue.

pub fn decode_unit_header(&mut self) -> Result<UnitHeader>

Decodes a unit value’s header.

pub fn skip_unit_value_of(&mut self, header: UnitHeader) -> Result<()>

Skips the unit value for a given header.

pub fn decode_unit_value_of(&mut self, header: UnitHeader) -> Result<UnitValue>

Decodes unit value for a given header, as a UnitValue.

impl<R> Decoder<R>

pub fn from_reader(reader: R) -> Self

Creates a decoder from a reader.

pub fn into_reader(self) -> R

Returns the decoder’s internal reader, consuming self.

pub fn pos(&self) -> usize

Returns the decoder’s current read position.

impl<'de, R> Decoder<R>

where R: Read<'de>,

pub fn decode_value(&mut self) -> Result<Value>

Decodes a Value.

pub fn peek_marker(&mut self) -> Result<Marker>

Decodes a value’s type Marker.

pub fn decode_header(&mut self) -> Result<Header>

Decodes a value’s Header.

pub fn skip_value(&mut self) -> Result<()>

Skips the next to-be-decoded value.

pub fn skip_value_of(&mut self, header: Header) -> Result<()>

Skips the value for a given header.

pub fn decode_value_of(&mut self, header: Header) -> Result<Value>

Decodes value for a given header.

Trait Implementations

impl<R: Debug> Debug for Decoder<R>

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

Formats the value using the given formatter.