Struct Reader 

pub struct Reader<'r> {
    pub problems: Vec<Problem>,
    pub refs: Vec<Found<Ref>>,
    pub tags: Vec<Found<Ref>>,
    pub resources: Vec<Found<Res>>,
    /* private fields */
}

The state of reading a value: where it is, the problems so far, and the references met (for the build to check against the content there is).

Fields

problems: Vec<Problem>

refs: Vec<Found<Ref>>

tags: Vec<Found<Ref>>

resources: Vec<Found<Res>>

Implementations

impl<'r> Reader<'r>

pub fn new() -> Self

pub fn with_resolver(resolver: &'r mut dyn Resolve) -> Self

A reader handing references and texts to resolver.

pub fn resolve_ref(&mut self, r: &Ref) -> Option<String>

r resolved (a problem if it’s wrong); its id without a resolver.

pub fn resolve_text(&mut self, t: &Text) -> Option<String>

t resolved (a problem if it’s wrong).

pub fn take_text(&mut self, t: Text) -> Option<String>

Reader::resolve_text, taking t: without a resolver its words move into the result instead of being copied.

pub fn take_ref(&mut self, r: Ref) -> Option<String>

Reader::resolve_ref, taking r: without a resolver the id moves.

pub fn keeps_found(&self) -> bool

Whether references are kept for the caller (read_value doesn’t).

pub fn resolves(&self) -> bool

Whether references and texts go through a resolver (else kept as written).

pub fn words(&mut self, r: &Res) -> Option<String>

The words of .yres text r, if the resolver knows them.

pub fn path(&self) -> Path

Where the reader is.

pub fn problem(&mut self, message: impl Into<String>)

Reports a problem with the value being read.

pub fn expected(&mut self, what: &str, found: &ValueRef<'_>)

“expected X, found Y”.

pub fn at<T>(&mut self, seg: Seg, f: impl FnOnce(&mut Self) -> T) -> T

Runs f one step deeper.

pub fn note_ref(&mut self, r: Ref)

pub fn note_tag(&mut self, r: Ref)

pub fn note_res(&mut self, r: Res)

pub fn map<'v>(&mut self, v: &ValueRef<'v>) -> Option<MapRef<'v>>

v as an object, or a problem.

pub fn unknown_keys(&mut self, map: MapRef<'_>, known: &[&str])

Reports keys of map that aren’t known (nor metadata, nor allowed by an enclosing enum).

pub fn unknown_name(&mut self, name: &str, known: &[&str])

Reports a name that isn’t one of known (an enum’s variant).

pub fn field<T: Schema>( &mut self, map: MapRef<'_>, key: &'static str, ) -> Option<T>

Field key of map: read, or its absent value, or a problem.

pub fn field_or<T: Schema>( &mut self, map: MapRef<'_>, key: &'static str, default: impl FnOnce() -> T, ) -> Option<T>

Field key of map, default() when it isn’t there.

pub fn field_with<W: With<F>, F>( &mut self, map: MapRef<'_>, key: &'static str, ) -> Option<F>

Field key of map through codec W.

pub fn field_or_with<W: With<F>, F>( &mut self, map: MapRef<'_>, key: &'static str, default: impl FnOnce() -> F, ) -> Option<F>

Field key of map through codec W, default() when it isn’t there.

pub fn with_allowed<T>( &mut self, key: &'static str, f: impl FnOnce(&mut Self) -> T, ) -> T

Reads v as T with key allowed in it — the tag of the enum variant T is.

pub fn with_allowed_all<T>( &mut self, keys: &[&'static str], f: impl FnOnce(&mut Self) -> T, ) -> T

Reads with every one of keys allowed (the fields of a struct read from the same object — see read_both).

pub fn own_keys<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T

Reads a struct’s own keys with no allowance inherited from outside.

impl Reader<'_>

pub fn in_range<T: Numbers>( &mut self, key: &str, value: Option<T>, lo: f64, hi: f64, ) -> Option<T>

value (field key) checked against lo..=hi; None (a problem) if it’s out.

Trait Implementations

impl<'r> Default for Reader<'r>

fn default() -> Self

Returns the “default value” for a type.