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, the default are the strict rules. Formats where everything is text have other defaults (query strings, environment variables and CSV use the lenient rules), which rules in the Context (or in the State, see set) override. 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::set_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 fn set_default(self, state: &mut State)

Sets the rules unless the state or the context has rules.

Formats use this for their default (see State::set_default).

pub const fn set_lenient_bools(&mut self, yes: bool)

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

pub const fn lenient_bools(&self) -> bool

Returns true if booleans are also yes, on and 1 and no, off and 0 (see set_lenient_bools).

pub const fn set_empty_is_null(&mut self, yes: bool)

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

pub const fn empty_is_null(&self) -> bool

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

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