Struct Deserializer 

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

Deserializes a deserializable from MessagePack.

A deserializer reads items from a slice. Because MessagePack streams are just items following each other, a deserializer can be used to read more than one item:

use deser_msgpack::Deserializer;

let mut de = Deserializer::from_slice(&[0x01, 0xa2, b'h', b'i']);
assert_eq!(de.deserialize::<u32>().unwrap(), 1);
assert_eq!(de.deserialize::<String>().unwrap(), "hi");
assert!(de.is_end());

To deserialize a single item, use from_slice (or the method of the same name on DeserializerConfig).

Implementations

impl<'a> Deserializer<'a>

pub fn from_slice(input: &'a [u8]) -> Deserializer<'a>

Creates a new deserializer for a byte slice.

pub fn from_slice_with_config( input: &'a [u8], config: DeserializerConfig, ) -> Deserializer<'a>

Creates a new deserializer for a byte slice with the given configuration.

pub fn config(&self) -> &DeserializerConfig

Returns the configuration.

pub fn offset(&self) -> usize

Returns the current offset in the input.

pub fn is_end(&self) -> bool

Returns true if the entire input was consumed.

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

Fails if the input was not consumed entirely.

pub fn deserialize<T: Deserialize<'a>>(&mut self) -> Result<T, Error>

Deserializes the next item.

This does not check if there is more data after the item. Use end for this or from_slice which does it automatically.

To configure the deserialization (for instance to add layers) use deserialize_with.

pub fn deserialize_with<T, F>(&mut self, setup: F) -> Result<T, Error>

where T: Deserialize<'a>, F: FnOnce(&mut DeserializeDriver<'_, 'a>),

Deserializes the next value with a configured driver.

The callback is invoked with the driver before the value is deserialized, for instance to add Layers.

pub fn iter<T: Deserialize<'a>>(&mut self) -> Iter<'_, 'a, T>

Returns an iterator over the remaining items.

This is useful to read streams of MessagePack items. The iterator stops after the first error.

let mut de = deser_msgpack::Deserializer::from_slice(&[0x01, 0x02, 0x03]);
let items = de.iter::<u32>().collect::<Result<Vec<_>, _>>().unwrap();
assert_eq!(items, [1, 2, 3]);

pub fn drive( &mut self, driver: &mut DeserializeDriver<'_, 'a>, ) -> Result<(), Error>

Parses the next item and feeds the events into the given driver.

This is useful to deserialize into a custom Sink or to wrap the sink of a value.

Strings and binary data are passed on borrowed from the input (see emit_borrowed). The byte ranges of the items are published as input ranges (see State::input_range) and errors carry the offset in the input (see Error::offset).

The context of the configuration is given to the driver (values that the context of the driver has take precedence, see DeserializeDriver::set_default_context).

Trait Implementations

impl<'a> Deserializer<'a> for Deserializer<'a>

fn drive(&mut self, driver: &mut DeserializeDriver<'_, 'a>) -> Result<(), Error>

Parses the input and feeds the events of a value into the driver.

fn deserialize<T>(&mut self) -> Result<T, Error>

where T: Deserialize<'de>, Self: Sized,

Deserializes a value.

fn deserialize_with<T, F>(&mut self, setup: F) -> Result<T, Error>

where T: Deserialize<'de>, F: FnOnce(&mut DeserializeDriver<'_, 'de>), Self: Sized,

Deserializes a value with a configured driver.

fn update<T>(&mut self, value: &mut T) -> Result<(), Error>

where T: Deserialize<'de>, Self: Sized,

Updates an existing value with the next value.

fn update_with<T, F>(&mut self, value: &mut T, setup: F) -> Result<(), Error>

where T: Deserialize<'de>, F: FnOnce(&mut DeserializeDriver<'_, 'de>), Self: Sized,

Updates an existing value with the next value after setting up the driver.