Struct KeyVals 

pub struct KeyVals { /* private fields */ }

Implementations

impl KeyVals

pub fn new(options: KeyvalsConfig) -> Self

====================================================================== The KeyVals constructor

This defines the KeyVals data object that can appear in the datastream along with tokens, boxes, etc. Thus it has to be digestible, however we may not want to digest it more than once.

---

pub fn get_value(&self, key: &str) -> Option<&ArgWrap>

return the value of a given key. If multiple values are given, return the last one.

pub fn get_value_digested(&self, key: &str) -> Option<&Digested>

return the digested value of a given key. If multiple values are given, return the last one. This call does not digest the value, and will return None if called pre-digestion

pub fn get_values(&self, key: &str) -> Option<&Vec<ArgWrap>>

return a list of values for a given key

pub fn get_pairs(&self) -> Iter<'_, (String, ArgWrap)>

return the set of key-value pairs

pub fn as_flat_hash(self) -> HashMap<String, ArgWrap>

consume KeyVals and return a flat HashMap

pub fn as_hash(self) -> HashMap<String, Vec<ArgWrap>>

consume KeyVals and return the cached HashMap of input values

pub fn as_hash_digested(self) -> HashMap<String, Vec<Digested>>

consume KeyVals and return the cached HashMap of digested values

pub fn get_hash(&self) -> HashMap<String, String>

returns a key => ToString(value)

pub fn get_hash_digested(&self) -> HashMap<String, String>

returns a key => ToString(value)

pub fn get_keyvals(&self) -> &HashMap<String, Vec<ArgWrap>>

pub fn has_key(&self, key: &str) -> bool

pub fn set_keys_expansion(&self) -> Tokens

pub fn revert(&self) -> Result<Tokens>

pub fn add_value( &mut self, key: &str, value_arg: ArgWrap, use_default: bool, no_rebuild: bool, ) -> Result<()>

pub fn set_value( &mut self, key: &str, value: ArgWrap, use_default: bool, ) -> Result<()>

pub fn read_from(&mut self, until: Token, silence_missing: bool) -> Result<()>

pub fn into_tokens(self) -> Result<Tokens>

TODO: This is an improvised method for switching KeyVals into Tokens, but losing all collected metadata. The long-term solution ought to be via a type system extension, where the arguments to our before-digest closures are a vector of a new type ReadValue ::= [Token, KeyVals, RegisterValue] potentially? On the other hand, we can also put the extra effort of postponing the build of KV metadata until digestion, this way not losing any time reserializing metadata

Trait Implementations

impl BoxOps for KeyVals

fn with_properties<R, FnR>(&self, caller: FnR) -> R

where FnR: FnOnce(&SymHashMap<Stored>) -> R,

execute a function using this object’s named properties

fn get_string(&self) -> Result<Cow<'_, str>>

build a string representation of the underlying digested data

fn set_property<T: Into<Stored>>(&mut self, _key: &str, _value: T)

set a named property (allows all Stored types for values)

fn be_absorbed(&self, _document: &mut Document) -> Result<Vec<Node>>

absorb the current object into the Document XML - returning the corresponding nodes

fn get_font(&self) -> Result<Option<Rc<Font>>>

gets the associated font, if any

fn compute_size( &self, _options: SymHashMap<Stored>, ) -> Result<(Dimension, Dimension, Dimension)>

computes and returns the size of a box-like object

fn unlist(&self) -> Vec<Digested>

If composite, unwrap into the contained digested objects (or return self)

fn unlist_ref(&self) -> Vec<Cow<'_, Digested>>

fn be_absorbed_mut(&mut self, _document: &mut Document) -> Result<Vec<Node>>

be_absorbed but with allowed side-effects on the carrier (for Alignment only)

fn get_tokens(&self) -> Option<&Tokens>

get the underlying tokens (preceding digestion)

fn get_properties(&self) -> &HashMap<Stored>

deprecated: get the map of named properties. This can not be usable as long as we have any data behind a RefCell wrapper. Use with_properties instead.

fn get_properties_mut(&mut self) -> &mut HashMap<Stored>

get a mutable reference to the map of named properties

fn get_property(&self, key: &str) -> Option<Cow<'_, Stored>>

get a single named property (with special “isSpace” check)

fn get_property_string(&self, key: &str) -> String

fn get_property_mut(&mut self, key: &str) -> Option<&mut Stored>

get a mutable reference to a single named property (does NOT have the “isSpace” check)

fn has_property(&self, key: &str) -> bool

checks if a property key has been set

fn get_property_bool(&self, key: &str) -> bool

obtains a boolean property value (false unless Stored::Bool)

fn get_body(&self) -> Result<Option<Digested>>

obtains the “body” of a digested object which captured it

fn set_font(&mut self, _font: Rc<Font>)

sets an associated font

fn set_width<T: Into<Stored>>(&mut self, width: T)

sets a “width” property, for sizing

fn get_width( &self, options: Option<HashMap<Stored>>, ) -> Result<Option<RegisterValue>>

gets the “width” property value, if any

fn set_height<T: Into<Stored>>(&mut self, width: T)

sets a “height” property value, for sizing

fn get_height(&self) -> Option<RegisterValue>

gets the “height” property value, if any. Checks “height”, then “cached_height”, then computes from font if needed.

fn set_depth<T: Into<Stored>>(&mut self, width: T)

sets a “depth” property value, for sizing

fn get_depth(&self) -> Option<RegisterValue>

gets the “depth” property value, if any. Checks “depth”, then “cached_depth”, then computes from font if needed.

fn get_size( &mut self, options: Option<HashMap<Stored>>, ) -> Result<(Dimension, Dimension, Dimension, Dimension, Dimension, Dimension)>

gets the box size as a triple of (width, height, depth) the generic implementation is immutable and will recompute the size on each call see Digested::get_size for a variant with interior mutability which caches the box size

fn compute_size_and_cache( &mut self, options: HashMap<Stored>, ) -> Result<(Dimension, Dimension, Dimension)>

computes and caches (via named properties) the size of a box-like object. Perl #2798 (S5, padding slice): after computing the size, add any requested pad{top,bottom,left,right} to the computed dimensions. This is the SAFE part of computeSizeStore — additive and inert until the app layer sets a pad* property (display math \abovedisplayskip/\belowdisplayskip, \overline/\underline 2pt, items/equations). The riskier requested-vs- computed merge + full-spec bypass + isEmpty are deliberately NOT included here — a mechanical port of those regressed (Rust boxes don’t use width/height/depth uniformly as “requested box size”); see SYNC_STATUS U2.

impl Clone for KeyVals

fn clone(&self) -> KeyVals

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyVals

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

Formats the value using the given formatter.

impl Default for KeyVals

fn default() -> Self

Returns the “default value” for a type.

impl Display for KeyVals

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

Formats the value using the given formatter.

impl From<KeyVals> for Stored

fn from(kvs: KeyVals) -> Stored

Converts to this type from the input type.

impl From<KeyVals> for ArgWrap

fn from(kv: KeyVals) -> Self

Converts to this type from the input type.

impl From<KeyVals> for Digested

fn from(value: KeyVals) -> Digested

Converts to this type from the input type.

impl From<KeyVals> for Result<Option<Digested>>

fn from(value: KeyVals) -> Result<Option<Digested>>

Converts to this type from the input type.

impl IntoDigestedOptionResult<Result<Option<Digested>, Error>> for KeyVals

fn into_digested_option_result(self) -> Result<Option<Digested>>

impl Object for KeyVals

fn stringify(&self) -> String

fn be_digested(self) -> Result<Digested>

fn isa_box(&self) -> bool

fn is_expandable(&self) -> bool

fn is_definition(&self) -> bool

fn is_comment(&self) -> bool

fn get_locator(&self) -> Option<Locator>

The object’s stored source locator, if it has one. None is the honest “no recorded source position” (replacing the old Locator::default() file!()/line!() sentinel). For “where the parser is now” (error reporting, box creation), use the free fn gullet::get_locator().

fn revert(&self) -> Result<Tokens>

each concrete object needs to provide its own path back to tokens

impl PartialEq for KeyVals

fn eq(&self, _other: &KeyVals) -> bool

Equality operator ==.

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

Inequality operator !=.

impl TryFrom<ArgWrap> for KeyVals

type Error = Error

The type returned in the event of a conversion error.

fn try_from(aw: ArgWrap) -> Result<KeyVals>

Performs the conversion.