Struct Whatsit 

pub struct Whatsit {
    pub args: Vec<Option<Digested>>,
    pub properties: SymHashMap<Stored>,
    pub definition: Rc<dyn Definition>,
    pub reversion: Option<Box<Tokens>>,
    pub dual_reversion: Option<Box<SymHashMap<Tokens>>>,
    pub locator: Option<Locator>,
}

Represents a digested object that can generate arbitrary elements in the XML Document.

Fields

args: Vec<Option<Digested>>

arguments

properties: SymHashMap<Stored>

additional properties, such as font information or sizing

definition: Rc<dyn Definition>

the definition responsible for creating this object

reversion: Option<Box<Tokens>>

cached tokens for reverting back (note that the “reversion” property is currently also used)

Boxed: this is the memo slot of a reversion cache that Rust cannot yet fill — revert(&self) has no mutability, so the write-back in revert stays commented out (Perl does cache here, Whatsit.pm L136-138). Held inline it charged 24 B to every Whatsit for a value measured None on 100 % of ~601 K whatsits across five documents. Option<Box<_>> is 8 B via the null-pointer niche and allocates nothing while None, so the slot costs almost nothing until the cache is actually wired up (issue #361 M4).

dual_reversion: Option<Box<SymHashMap<Tokens>>>

special-case reversion tokens for whatsits representing Dual math structures. Boxed for the same reason as Whatsit::reversion — see there.

locator: Option<Locator>

point of origin in the source file (None = not recorded; set under --source-map at constructor digest, Perl Constructor.pm L106)

Implementations

impl Whatsit

pub fn is_math(&self) -> bool

checks the “isMath” property was set to true

pub fn is_empty(&self) -> Result<bool>

A Whatsit is empty if it is marked empty, or space-like, or has an empty body.

pub fn set_properties(&mut self, props: HashMap<Stored>)

sets a pre-assembled HashMap of properties

pub fn get_definition(&self) -> Rc<dyn Definition>

accessor for the definition which built this Whatsit

pub fn get_arg(&self, n: usize) -> Option<&Digested>

accessor for the argument at index n (starting from 1) Access argument at 1-based index n (matching Perl’s $whatsit->getArg(n)). Returns None for n == 0 (defensive — Perl convention uses 1-based indexing).

pub fn get_arg_mut(&mut self, n: usize) -> Option<&mut Digested>

Mutably borrow argument at 1-based index n (matching Perl’s $whatsit->getArg(n)). Panics if n == 0 — use 1-based indexing.

pub fn get_args(&self) -> &Vec<Option<Digested>>

accessor for the full list of arguments

pub fn set_args(&mut self, args: Vec<Option<Digested>>)

Sets the list of arguments for this whatsit (each arg should be Digested::List).

pub fn get_trailer(&self) -> Option<Digested>

accessor for the trailer property. See whatsit::set_body

pub fn set_body(&mut self, body: Vec<Digested>)

Sets the body of the whatsit to the boxes in body. The last box in body is assumed to represent the trailer, that is the result of the invocation that closed the environment or math. It is stored separately in the properties under “trailer”.

Trait Implementations

impl BoxOps for Whatsit

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 with_properties<R, FnR>(&self, caller: FnR) -> R

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

execute a function using this object’s named properties

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_mut(&mut self, key: &str) -> Option<&mut Stored>

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

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

build a string representation of the underlying digested data

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

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

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

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

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

gets the associated font, if any

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

sets an associated font

fn compute_size( &self, options: HashMap<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 set_property<T: Into<Stored>>(&mut self, key: &str, value: T)

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

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

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 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 Whatsit

fn clone(&self) -> Whatsit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Whatsit

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

Formats the value using the given formatter.

impl Default for Whatsit

fn default() -> Self

Returns the “default value” for a type.

impl Display for Whatsit

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

Formats the value using the given formatter.

impl From<Whatsit> for Digested

fn from(value: Whatsit) -> Digested

Converts to this type from the input type.

impl IntoDigestedResult<Result<Vec<Digested>, Error>> for Whatsit

fn into_digested_result(self) -> Result<Vec<Digested>>

Performs the conversion, used for DefPrimitive return values etc

impl Object for Whatsit

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 stringify(&self) -> String

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

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

fn isa_box(&self) -> bool

fn is_expandable(&self) -> bool

fn is_definition(&self) -> bool

fn is_comment(&self) -> bool

fn be_digested(self) -> Result<Digested>

where Self: Sized + Debug,

impl PartialEq for Whatsit

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

Equality operator ==.

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

Inequality operator !=.