Struct ContainerShape 

pub struct ContainerShape { /* private fields */ }

Facts about a map or sequence.

The shape is carried by Event::MapStart and Event::SeqStart. It holds information that formats can use to encode or decode a container, all of which can be ignored:

• order: how significant the order of the elements is.
• len: the number of elements (entries for maps) if known.
• is_multimap: the keys of the map can be given more than once.

use deser::{ContainerShape, Order};

const SHAPE: ContainerShape =
    ContainerShape::new().with_order(Order::Sorted);
assert_eq!(SHAPE.order(), Order::Sorted);
assert_eq!(SHAPE.len(), None);

Implementations

impl ContainerShape

pub const fn new() -> ContainerShape

Creates the default shape: unknown length and natural order.

pub const fn with_len(self, len: usize) -> ContainerShape

Sets the number of elements.

pub const fn with_order(self, order: Order) -> ContainerShape

Sets the order.

pub const fn len(&self) -> Option<usize>

Returns the number of elements (entries for maps) if known.

pub const fn order(&self) -> Order

Returns how significant the order of the elements is.

pub const fn with_multimap(self, yes: bool) -> ContainerShape

Marks a map as a multimap: its keys can be given more than once.

Formats where keys can repeat (like query strings with a=1&a=2, the elements of XML or the columns of CSV files) emit their maps with this flag and pass on every occurrence of a key as an entry of its own, in the order of the input. How repeated keys are resolved is up to the type that receives the map:

• The fields of derived structs and the values of maps whose type is a collection (like Vec<T> or HashSet<T>) collect the values of all occurrences of their key. A key that is given once is a collection of one value and a key that is missing is an empty collection.
• Other fields and values receive a single value, DuplicateKeys in the State decides which one: the last one, the first one or an error (the default).

Types that do not know about multimaps receive the entries like those of any other map. See State::is_multimap.

use deser::de::DeserializeDriver;
use deser::{Atom, ContainerShape, Deserialize, Event};

#[derive(Deserialize, Debug, PartialEq)]
struct Query {
    tag: Vec<String>,
    page: u32,
    user: Vec<String>,
}

let mut out = None::<Query>;
let mut driver = DeserializeDriver::new(&mut out);
driver
    .emit(Event::MapStart(ContainerShape::new().with_multimap(true)))
    .unwrap();
for (key, value) in [("tag", "a"), ("page", "1"), ("tag", "b")] {
    driver.emit(key).unwrap();
    driver.emit(Atom::Lexical(value.into())).unwrap();
}
driver.emit(Event::MapEnd).unwrap();
drop(driver);
assert_eq!(out, Some(Query {
    tag: vec!["a".into(), "b".into()],
    page: 1,
    user: vec![],
}));

pub const fn is_multimap(&self) -> bool

Returns true if the keys of the map can be given more than once.

See with_multimap.

Trait Implementations

impl Clone for ContainerShape

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for ContainerShape

impl Debug for ContainerShape

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

Formats the value using the given formatter.

impl Default for ContainerShape

fn default() -> ContainerShape

Returns the “default value” for a type.

impl Eq for ContainerShape

impl Hash for ContainerShape

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ContainerShape

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for ContainerShape