Struct texlang::command::Map

pub struct Map<S> { /* private fields */ }

Map is a map type where the keys are control sequence names and the values are TeX commands.

There are a number of design goals for the map:

• Make retrieving the function for a command very fast. This is achieved primarily by storing command functions by themselves in an array. The index in the array is the control sequence name, which is an integer when interned. This implementation choice means fast-as-possible lookups. Storing the function by itself means there is good cache locality.

• Insert built in commands at the start insert_built_in(cs_name, cmd),

• Insert variable commands that aren’t there at the start, but will be in the future. E.g., \countdef register_built_in(cmd) <- must have a unique ID. Is type ID stable across binary builds? Maybe need to use a string ID instead? But then need to feed that the library using this registered

• Should we enforce that the previous two steps can only be done at creation time? Probably Maybe initialize the map using Map<cs_name, cmd> and Vec<cmd>. Can provide cs_name<->str wrapper at the VM level

• While running, insert macros insert_macro(&str, macro)

• While running, alias commands by current name or using the special ID inserts alias_control_sequence(cs_name, cs_name) -> undefined control sequence error alias_registered_built_in(cs_name, cmd_id, variable_addr) alias_character(cs_name, token::Token)

Implementations

impl<S> Map<S>

pub fn get_command(&self, command_ref: &CommandRef) -> Option<&Command<S>>

pub fn get_tag(&self, command_ref: &CommandRef) -> Option<Tag>

pub fn built_in_commands(&self) -> &HashMap<CsName, BuiltIn<S>>

pub fn get_command_slow(&self, command_ref: &CommandRef) -> Option<BuiltIn<S>>

pub fn insert_variable_command( &mut self, command_ref: CommandRef, variable_command: Command<S>, scope: Scope )

pub fn insert_macro(&mut self, name: CommandRef, texmacro: Macro, scope: Scope)

pub fn alias_control_sequence( &mut self, alias: CommandRef, command: &CommandRef, scope: Scope ) -> Result<(), InvalidAlias>

pub fn alias_token(&mut self, alias: CommandRef, token: Token, scope: Scope)

pub fn insert( &mut self, command_ref: CommandRef, func: Command<S>, scope: Scope )

pub fn to_hash_map_slow(&self) -> HashMap<CsName, BuiltIn<S>>

pub fn is_empty(&self) -> bool

pub fn len(&self) -> usize

Trait Implementations

impl<State> Serialize for Map<State>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.