Struct LexicalRules 

pub struct LexicalRules { /* private fields */ }

How lexical atoms are interpreted.

Lexical atoms are text whose type the format cannot express. The types they are delivered to interpret them: numbers and booleans parse them, strings take them as they are. What text means beyond that depends on where it comes from. Keys of JSON objects are strict (a bool key is true or false), everything in a query string or an environment variable is text so on and yes are booleans too and empty values are missing values.

The rules are an extension value in the State (see State::get_mut) which formats set, the default are the strict rules. As they are part of the state (and not of the atoms), lexical atoms that are buffered and replayed are interpreted with the rules of the deserialization they are replayed in.

use deser::de::{DeserializeDriver, LexicalRules};
use deser::{Atom, Text};

let mut out = None::<bool>;
let mut driver = DeserializeDriver::new(&mut out);
LexicalRules::LENIENT.set(driver.state_mut());
driver.emit(Atom::Lexical(Text::borrowed("on"))).unwrap();
drop(driver);
assert_eq!(out, Some(true));

Implementations

impl LexicalRules

pub const STRICT: LexicalRules

The rules for text that happens to be text, like the keys of JSON objects. This is the default.

• booleans are true and false
• integers and floats are parsed with str::parse
• empty text is not a missing value

pub const LENIENT: LexicalRules

The rules for formats where everything is text, like query strings and environment variables.

• booleans are true, yes, on and 1 and false, no, off and 0 (ignoring ASCII case)
• integers and floats are parsed with str::parse
• empty text is a missing value for types that do not accept it: None for an Option<u32>, Some("") for an Option<String> and ()

These formats typically also allow keys to repeat, a key given once can then stand for a sequence of one value. That is not a rule of the text but of the maps they emit (see ContainerShape::with_multimap).

pub fn of(state: &State) -> LexicalRules

Returns the rules of a deserialization.

pub fn set(self, state: &mut State)

Sets the rules of a deserialization.

pub const fn with_lenient_bools(self, yes: bool) -> LexicalRules

Sets if booleans are also yes, on and 1 and no, off and 0 (ignoring ASCII case).

pub const fn with_empty_is_null(self, yes: bool) -> LexicalRules

Sets if empty text is a missing value for types that do not accept it.

pub const fn lenient_bools(&self) -> bool

Returns true if booleans are also yes, on, 1, no, off and 0.

pub const fn empty_is_null(&self) -> bool

Returns true if empty text is a missing value for types that do not accept it.

Trait Implementations

impl Clone for LexicalRules

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 LexicalRules

impl Debug for LexicalRules

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

Formats the value using the given formatter.

impl Default for LexicalRules

fn default() -> LexicalRules

Returns the “default value” for a type.

impl Eq for LexicalRules

impl PartialEq for LexicalRules

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for LexicalRules