Struct Dictionary 

pub struct Dictionary { /* private fields */ }

The values references expand to — the words of a vocabulary, the texts of a language, the entries of a table — kept per kind and id, in the order they were added. It is a Resolve: a reference of a kind it holds is checked against its ids and, where a field takes a value (with::Expand), expanded to the value; a reference of a kind it doesn’t hold is left alone.

It is a Schema too, written { <kind>: { <id>: <value>, … }, … }, so a tool loads it from text, a value or the binary form like any document (an empty kind, { word: {} }, holds nothing and says every @word:… is missing). Keys that are notes ($…, _…, comment) are skipped, as in any object.

use substrate_data::schema::{Dictionary, from_text, from_value_with};
use substrate_data::{Ref, Value};

let mut dictionary: Dictionary =
    from_text(r#"{ project: { alpha: { name: "Alpha" } } }"#).unwrap().value;
let alpha = Ref::parse("project", "alpha").unwrap();
assert_eq!(dictionary.get(&alpha).unwrap().get("name").unwrap().as_str(), Some("Alpha"));

// As a resolver, it expands what a field reads through `Expand`.
#[derive(substrate_data::Schema)]
struct Card {
    #[data(with = "substrate_data::with::Expand<substrate_data::with::Plain>")]
    project: Value,
}
let doc: Value = from_text(r#"{ project: "@project:alpha" }"#).unwrap().value;
let card = from_value_with::<Card>(&doc, &mut dictionary).unwrap().value;
assert_eq!(card.project.get("name").unwrap().as_str(), Some("Alpha"));

Implementations

impl Dictionary

pub fn new() -> Dictionary

A dictionary holding nothing.

pub fn insert( &mut self, kind: KindName, id: RefKey, value: Value, ) -> Option<Value>

value as the value of id of kind, returning the one it replaced.

pub fn declare(&mut self, kind: KindName)

Holds kind (with no values if there are none): its references are now checked, and one to an id there isn’t is missing.

pub fn holds(&self, kind: KindName) -> bool

Whether the dictionary holds kind.

pub fn get(&self, r: &Ref) -> Option<&Value>

The value r names.

pub fn kinds(&self) -> impl Iterator<Item = KindName>

The kinds held, by name.

pub fn entries(&self, kind: KindName) -> impl Iterator<Item = (&RefKey, &Value)>

kind’s values in the order they were added (none if it isn’t held).

pub fn len(&self) -> usize

How many values it holds, all kinds together.

pub fn is_empty(&self) -> bool

Whether it holds no value.

Trait Implementations

impl Clone for Dictionary

fn clone(&self) -> Dictionary

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Dictionary

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

Formats the value using the given formatter.

impl Default for Dictionary

fn default() -> Dictionary

Returns the “default value” for a type.

impl PartialEq for Dictionary

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

Equality operator ==.

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

Inequality operator !=.

impl Resolve for Dictionary

fn reference(&mut self, r: &Ref, _path: &Path) -> Result<RefKey, Unresolved>

A reference at path: the id to keep, or why it’s wrong.

fn expand(&mut self, r: &Ref, _path: &Path) -> Result<Option<Value>, Unresolved>

A reference at path the tool replaces by a value — a word of a dictionary, a localized text: Some(value) is read in its place, None keeps it a reference. Asked only where a field says it takes a value or a reference (with::Expand); a reference met anywhere else goes through Resolve::reference.

impl Schema for Dictionary

fn shape() -> Shape

What the format looks like.

fn read(v: &ValueRef<'_>, cx: &mut Reader<'_>) -> Option<Dictionary>

Reads v. Problems go to cx at its current path; None when the value couldn’t be read (the problem is in cx).

fn write(&self) -> Value

The value, as the format writes it.

fn absent() -> Option<Self>

The value of a field that isn’t there — None: the field is required.

fn skip(&self) -> bool

Whether a struct leaves this field out when writing it.

fn encode(&self, w: &mut Writer)

Writes itself in the binary form, straight — Schema::write’s value encoded, unless the type knows better (derived ones do).

fn decode(d: &mut Decoder<'_>) -> Option<Self>

Reads itself from the binary form, straight; None when it isn’t what Schema::encode writes — then read_bytes reads the slow way, which says what’s wrong. Through a value unless the type knows better (derived ones do).

fn pack(&self, p: &mut Packer)

Packs itself into a frame (crate::frame): its binary form as bytes, unless the type packs itself (derived ones and plain types do).

fn unpack(u: &mut Unpacker<'_>) -> Option<Self>

Reads itself out of a frame; None if the bytes aren’t what Schema::pack writes.

fn pack_list(items: &[Self], p: &mut Packer)

A list of these packed: a count, then each one (floats raw).

fn unpack_list(u: &mut Unpacker<'_>) -> Option<Vec<Self>>

A list of these out of a frame.

fn encode_list(items: &[Self], w: &mut Writer)

A list of these written straight (numbers pack theirs).

fn decode_list(d: &mut Decoder<'_>) -> Option<Vec<Self>>

A list of these read straight.

impl StructuralPartialEq for Dictionary