Struct Block 

pub struct Block {
    v: Vec<BlockItem>,
    pub tag: Option<Box<Token>>,
    pub loc: Loc,
    pub source: Option<Box<(Vec<MacroComponent>, PdxfileMemory)>>,
}

This type represents the most basic structural element of Pdx script code. Blocks are delimited by { and }. An entire file is also a Block.

A Block can contain a mix of these kinds of items:

• Assignments: key = value
• Definitions: key = { ... }
• Loose sub-blocks: { ... } { ... } ...
• Loose values: value value ...
• Comparisons: key < value for a variety of comparators, including = for equality
• key < { ... } is accepted by the parser but is not used anywhere

The same key can occur multiple times in a block. If a single field is requested and its key occurs multiple times, the last instance is returned (which is how the game usually resolves this).

Fields

v: Vec<BlockItem>

The contents of this block.

tag: Option<Box<Token>>

The tag is a short string that precedes a block, as in color = hsv { 0.5 0.5 1.0 }. Only a small number of hardcoded tags are parsed this way. It is in a Box to save space in blocks that don’t have a tag, which is most of them.

loc: Loc

The location of the start of the block. Used mostly for error reporting.

source: Option<Box<(Vec<MacroComponent>, PdxfileMemory)>>

If the block is a top-level block and contains macro substitutions, this field will hold the original source for re-parsing. The source has already been split into a vec that alternates content with macro parameters. It is in a Box to save space (80 bytes) from blocks that don’t contain macro substitutions, which is most of them.

Implementations

impl Block

pub fn new(loc: Loc) -> Self

Open a new Block at the given location.

pub fn add_value(&mut self, value: Token)

Add a loose value to this Block. Mostly used by the parser.

pub fn add_block(&mut self, block: Block)

Add a loose sub-block to this Block. Mostly used by the parser.

pub fn add_key_bv(&mut self, key: Token, cmp: Comparator, value: BV)

Add a key = value or key = { ... } field to this Block. Mostly used by the parser.

pub fn add_item(&mut self, item: BlockItem)

Add a BlockItem to this Block. It can contain any of the variations of things that a Block can hold.

pub fn add_item_check_tag(&mut self, item: BlockItem)

Add a BlockItem to this Block. If it is a BlockItem::Block and the previous item is a key = tag, where the tag is one of a predefined set of strings, then combine the block with that previous item.

pub fn append(&mut self, other: &mut Block)

Combine two blocks by adding the contents of other to this block. To avoid lots of cloning, other will be emptied in the process.

pub fn get_field_value(&self, name: &str) -> Option<&Token>

Get the value of a single name = value assignment.

pub fn field_value_is(&self, name: &str, value: &str) -> bool

Check if name is a field that has the literal string value as its value.

pub fn get_field_bool(&self, name: &str) -> Option<bool>

Get the value of a literal boolean field

pub fn get_field_integer(&self, name: &str) -> Option<i64>

Get the value of a literal integer field

pub fn get_field_date(&self, name: &str) -> Option<Date>

Get the value of a literal date field

pub fn get_field_values(&self, name: &str) -> Vec<&Token>

Get all the values of name = value assignments in this block

TODO: should be an iterator

pub fn get_field_block(&self, name: &str) -> Option<&Block>

Get the block of a name = { ... } definition

pub fn get_field_blocks(&self, name: &str) -> Vec<&Block>

Get all the blocks of name = { ... } definitions in this block

pub fn get_field_list(&self, name: &str) -> Option<Vec<Token>>

Get the values of a single name = { value value ... } list

pub fn get_multi_field_list(&self, name: &str) -> Vec<Token>

Get the combined values of any number of name = { value value ... } list

pub fn get_field(&self, name: &str) -> Option<&BV>

Get the value or block on the right-hand side of a field name.

pub fn get_key(&self, name: &str) -> Option<&Token>

Get the key of a field name in the Block. The string value of the key will be equal to name, but it can be useful to get this key as a Token with its location.

pub fn get_keys(&self, name: &str) -> Vec<&Token>

Get all the keys of fields with key name. The string values of these keys will be equal to name, but it can be useful to get these keys as Token with their locations.

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

Return true iff the name occurs in this block at least once as a field key.

pub fn has_key_recursive(&self, name: &str) -> bool

pub fn count_keys(&self, name: &str) -> usize

Return the number of times name occurs in this block as a field key.

pub fn num_items(&self) -> usize

Return the number of items in this block.

pub fn iter_items(&self) -> Iter<'_, BlockItem>

Return an iterator over the contents of this block.

pub fn drain(&mut self) -> Drain<'_, BlockItem>

Return a destructive iterator over the contents of this block. It will give ownership of the returned BlockItem objects.

pub fn iter_fields(&self) -> IterFields<'_>

Return an iterator over all the key = ... fields in this block, ignoring the loose values and loose blocks.

pub fn iter_fields_warn(&self) -> IterFields<'_>

Return an iterator over all the key = ... fields in this block, while warning about loose values and loose blocks.

pub fn iter_assignments(&self) -> IterAssignments<'_>

Return an iterator over all the key = value fields in this block, ignoring other kinds of contents.

pub fn iter_assignments_warn(&self) -> IterAssignments<'_>

Return an iterator over all the key = value fields in this block, while warning about every other kind of content.

pub fn iter_definitions(&self) -> IterDefinitions<'_>

Return an iterator over all the key = { ... } fields in this block, ignoring other kinds of contents.

pub fn iter_definitions_warn(&self) -> IterDefinitions<'_>

Return an iterator over all the key = { ... } fields in this block, while warning about every other kind of content.

pub fn iter_assignments_and_definitions( &self, ) -> IterAssignmentsAndDefinitions<'_>

Return an iterator over all the key = value and key = { ... } fields in this block, ignoring every other kind of content. It differs from Block::iter_fields in that it requires the comparator to be =.

pub fn iter_assignments_and_definitions_warn( &self, ) -> IterAssignmentsAndDefinitions<'_>

Return an iterator over all the key = value and key = { ... } fields in this block, while warning about every other kind of content. It differs from Block::iter_fields_warn in that it requires the comparator to be =.

pub fn drain_definitions_warn(&mut self) -> DrainDefinitions<'_>

Like Block::iter_definitions_warn but it’s a destructive iterator that gives ownership over the returned definitions.

pub fn drain_assignments_warn(&mut self) -> DrainAssignments<'_>

Like Block::iter_assignments_warn but it’s a destructive iterator that gives ownership over the returned assignments.

pub fn iter_values(&self) -> IterValues<'_>

Iterate over the loose values in the block.

pub fn iter_values_warn(&self) -> IterValues<'_>

Iterate over the loose values in the block, while warning about everything else.

pub fn iter_blocks(&self) -> IterBlocks<'_>

Iterate over the loose sub-blocks in the block.

pub fn iter_blocks_warn(&self) -> IterBlocks<'_>

Iterate over the loose sub-blocks in the block, while warning about everything else.

pub fn get_field_at_date(&self, name: &str, date: Date) -> Option<&BV>

Search through the history fields in this block and return the block or value the field name would have at the given date. The field value that’s directly in this block, not in any history block, is considered to be the field value at the beginning of time. History fields are ones that have a date as the key, like 900.1.1 = { ... }.

pub fn get_field_value_at_date(&self, name: &str, date: Date) -> Option<&Token>

Just like Block::get_field_at_date but only for fields that have values (not blocks).

pub fn macro_parms(&self) -> Vec<&'static str>

Return a sorted vector of macro parameters taken by this block. Macro parameters are between $ like $CHARACTER$.

pub fn expand_macro( &self, args: &[(&str, Token)], loc: Loc, global: &PdxfileMemory, ) -> Option<Block>

Expand a block that has macro parameters by substituting arguments for those parameters, then re-parsing the script, that links the expanded content back to loc.

pub fn equivalent(&self, other: &Self) -> bool

Return true iff this block has the same block items in the same order as other, including equivalence of blocks inside them.

pub fn condense_tag(self, tag: &str) -> Self

Create a version of this block where the tag is combined with a token that follows it. Example: color1 = list colorlist becomes color1 = list"colorlist (where the " character is used as the separator because it can’t show up in normal parsing).

This function is used as a last resort when validating awkward syntax.

Trait Implementations

impl Clone for Block

fn clone(&self) -> Block

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl ErrorLoc for &Block

fn into_loc(self) -> Loc

fn loc_length(&self) -> usize

impl ErrorLoc for Block

fn into_loc(self) -> Loc

fn loc_length(&self) -> usize

impl FileHandler<Block> for CharacterInteractionCategories

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

impl FileHandler<Block> for Characters

fn config(&mut self, config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for Coas

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for DataBindings

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for Decisions

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for Defines

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for Doctrines

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

impl FileHandler<Block> for Effects

fn config(&mut self, config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for Events

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for GameConcepts

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

impl FileHandler<Block> for Gui

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

impl FileHandler<Block> for History

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for MenAtArmsTypes

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

impl FileHandler<Block> for Musics

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for OnActions

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for ProvinceHistories

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for ProvinceProperties

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for ProvinceTerrains

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for ScriptValues

fn config(&mut self, config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for ScriptedLists

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for ScriptedModifiers

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for TitleHistories

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for Titles

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for Traits

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

impl FileHandler<Block> for Triggers

fn config(&mut self, config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.

impl FileHandler<Block> for Wars

fn subpath(&self) -> PathBuf

Which files this handler is interested in. This is a directory prefix of files it wants to handle, relative to the mod or vanilla root.

fn load_file(&self, entry: &FileEntry, parser: &ParserMemory) -> Option<Block>

This is called for each matching file, in arbitrary order. If a T is returned, it will be passed to handle_file later. Since load_file is executed multi-threaded while handle_file is single-threaded, try to do the heavy work in this function.

fn handle_file(&mut self, _entry: &FileEntry, block: Block)

This is called for each matching file in turn, in lexical order. That’s the order in which the CK3 game engine loads them too.

fn config(&mut self, _config: &Block)

The FileHandler can read settings it needs from the ck3-tiger config.

fn finalize(&mut self)

This is called after all files have been handled. The FileHandler can generate indexes, perform full-data checks, etc.