Struct Everything

pub struct Everything {

    config: Block,
    pub parser: ParserMemory,
    warned_defines: RwLock<HashSet<String>>,
    pub(crate) fileset: Fileset,
    pub(crate) dds: DdsFiles,
    pub(crate) database: Db,
    pub(crate) localization: Localization,
    pub(crate) scripted_lists: ScriptedLists,
    pub(crate) defines: Defines,
    pub(crate) events: Events,
    pub(crate) decisions_imperator: Decisions,
    pub(crate) scripted_modifiers: ScriptedModifiers,
    pub(crate) on_actions: OnActions,
    pub(crate) interaction_cats: CharacterInteractionCategories,
    pub(crate) provinces_ck3: Ck3Provinces,
    pub(crate) provinces_vic3: Vic3Provinces,
    pub(crate) provinces_imperator: ImperatorProvinces,
    pub(crate) province_histories: ProvinceHistories,
    pub(crate) province_properties: ProvinceProperties,
    pub(crate) province_terrains: ProvinceTerrains,
    pub(crate) gameconcepts: GameConcepts,
    pub(crate) titles: Titles,
    pub(crate) characters: Characters,
    pub(crate) script_values: ScriptValues,
    pub(crate) triggers: Triggers,
    pub(crate) effects: Effects,
    pub(crate) traits: Traits,
    pub(crate) title_history: TitleHistories,
    pub(crate) doctrines: Doctrines,
    pub(crate) menatarmstypes: MenAtArmsTypes,
    pub(crate) gui: Gui,
    pub(crate) data_bindings: DataBindings,
    pub(crate) assets: Assets,
    pub(crate) music: Musics,
    pub(crate) coas: Coas,
    pub(crate) history: History,
    pub(crate) wars: Wars,
}

A record of everything known about the game and mod being validated.

References to Everything are passed down through nearly all of the validation logic, so that individual functions can access all the defined game items.

The validator has two main phases: parsing and validation.

• During parsing, the script files are read, parsed, and loaded into the various databases. Everything is mutable during this period.
• During validation, Everything is immutable and cross-checking between item types can be done safely.

Fields

config: Block

Config from file

parser: ParserMemory

The global parser state, carrying information between files. Currently only used by the pdxfile parser, to handle the reader_export directory, which is specially processed before all other files.

warned_defines: RwLock<HashSet<String>>

A cache of define values (from common/defines) that are missing and that have already been warned about as missing. This is to avoid duplicate warnings.

fileset: Fileset

Tracks all the files (vanilla and mods) that are relevant to the current validation.

dds: DdsFiles

Tracks specifically the .dds files, and their formats and sizes.

database: Db

A general database of item types. Most items go here. The ones that need special handling go in the separate databases listed below.

localization: Localization

scripted_lists: ScriptedLists

defines: Defines

events: Events

decisions_imperator: Decisions

scripted_modifiers: ScriptedModifiers

on_actions: OnActions

interaction_cats: CharacterInteractionCategories

provinces_ck3: Ck3Provinces

provinces_vic3: Vic3Provinces

provinces_imperator: ImperatorProvinces

province_histories: ProvinceHistories

province_properties: ProvinceProperties

province_terrains: ProvinceTerrains

gameconcepts: GameConcepts

titles: Titles

characters: Characters

script_values: ScriptValues

triggers: Triggers

effects: Effects

traits: Traits

title_history: TitleHistories

doctrines: Doctrines

menatarmstypes: MenAtArmsTypes

gui: Gui

data_bindings: DataBindings

assets: Assets

music: Musics

coas: Coas

history: History

wars: Wars

Implementations

impl Everything

pub fn new( config_filepath: Option<&Path>, vanilla_dir: Option<&Path>, mod_root: &Path, replace_paths: Vec<PathBuf>, ) -> Result<Self>

Create a new Everything instance, ready for validating a mod.

vanilla_dir is the path to the base game files. If it’s None, then no vanilla files will be loaded. This will seriously affect validation, but it’s ok if you just want to load and examine the mod files.

mod_root is the path to the mod files. The config file will also be looked for there.

replace_paths is from the similarly named field in the .mod file.

fn read_config(name: &str, path: &Path) -> Option<Block>

pub fn load_config_filtering_rules(&self)

fn load_output_styles(&self, default_color: bool) -> OutputStyle

Load the OutputStyle settings from the config. Note that the settings from the config can still be overridden by supplying the –no-color flag.

pub fn load_output_settings(&self, default_colors: bool)

fn load_json<F>(&mut self, itype: Item, add_json: F)

where F: Fn(&mut Db, Block) + Sync + Send,

fn load_reader_export(&mut self)

fn load_pdx_files(&mut self, loader: &ItemLoader)

fn load_all_normal_pdx_files(&mut self)

fn load_all_generic(&mut self)

fn load_all_ck3(&mut self)

fn load_all_vic3(&mut self)

fn load_all_imperator(&mut self)

pub fn load_all(&mut self)

fn validate_all_generic<'a>(&'a self, s: &Scope<'a>)

fn validate_all_ck3<'a>(&'a self, s: &Scope<'a>)

fn validate_all_vic3<'a>(&'a self, s: &Scope<'a>)

fn validate_all_imperator<'a>(&'a self, s: &Scope<'a>)

pub fn validate_all(&self)

pub fn check_rivers(&mut self)

pub fn check_pod(&mut self)

pub fn check_unused(&mut self)

pub(crate) fn item_has_property( &self, itype: Item, key: &str, property: &str, ) -> bool

pub(crate) fn item_lc_has_property( &self, itype: Item, key: &Lowercase<'_>, property: &str, ) -> bool

fn item_exists_ck3(&self, itype: Item, key: &str) -> bool

fn item_exists_vic3(&self, itype: Item, key: &str) -> bool

fn item_exists_imperator(&self, itype: Item, key: &str) -> bool

pub(crate) fn item_exists(&self, itype: Item, key: &str) -> bool

fn item_exists_lc_ck3(&self, itype: Item, key: &Lowercase<'_>) -> bool

Return true iff the item key is found with a case insensitive match. This function is incomplete. It only contains the item types for which case insensitive matches are needed; this is currently the ones used in src/ck3/tables/modif.rs.

fn item_exists_lc_vic3(&self, itype: Item, key: &Lowercase<'_>) -> bool

Return true iff the item key is found with a case insensitive match. This function is incomplete. It only contains the item types for which case insensitive matches are needed; this is currently the ones used in src/vic3/tables/modif.rs.

fn item_exists_lc_imperator(&self, itype: Item, key: &Lowercase<'_>) -> bool

Return true iff the item key is found with a case insensitive match. This function is incomplete. It only contains the item types for which case insensitive matches are needed; this is currently the ones used in src/imperator/tables/modif.rs.

pub(crate) fn item_exists_lc(&self, itype: Item, key: &Lowercase<'_>) -> bool

Return true iff the item key is found with a case insensitive match. This function is incomplete. It only contains the item types for which case insensitive matches are needed; this is currently the ones used in modif lookups.

pub(crate) fn mark_used(&self, itype: Item, key: &str)

pub(crate) fn verify_exists(&self, itype: Item, token: &Token)

pub(crate) fn verify_exists_max_sev( &self, itype: Item, token: &Token, max_sev: Severity, )

pub(crate) fn verify_exists_implied_max_sev( &self, itype: Item, key: &str, token: &Token, max_sev: Severity, )

pub(crate) fn verify_exists_implied( &self, itype: Item, key: &str, token: &Token, )

pub(crate) fn verify_icon(&self, define: &str, token: &Token, suffix: &str)

pub(crate) fn mark_used_icon(&self, define: &str, token: &Token, suffix: &str)

pub(crate) fn validate_use(&self, itype: Item, key: &Token, block: &Block)

pub(crate) fn validate_call( &self, itype: Item, key: &Token, block: &Block, sc: &mut ScopeContext, )

pub(crate) fn validate_localization_sc(&self, key: &str, sc: &mut ScopeContext)

Validate the use of a localization within a specific ScopeContext. This allows validation of the named scopes used within the localization’s datafunctions.

pub(crate) fn get_item<T: DbKind>( &self, itype: Item, key: &str, ) -> Option<(&Token, &Block, &T)>

pub(crate) fn get_key_block( &self, itype: Item, key: &str, ) -> Option<(&Token, &Block)>

pub(crate) fn get_trigger(&self, key: &Token) -> Option<&Trigger>

pub(crate) fn get_effect(&self, key: &Token) -> Option<&Effect>

pub(crate) fn get_defined_string(&self, key: &str) -> Option<&Token>

pub(crate) fn get_defined_array(&self, key: &str) -> Option<&Block>

pub(crate) fn get_defined_string_warn( &self, token: &Token, key: &str, ) -> Option<&Token>

pub(crate) fn get_defined_array_warn( &self, token: &Token, key: &str, ) -> Option<&Block>

pub fn iter_keys_ck3<'a>( &'a self, itype: Item, ) -> Box<dyn Iterator<Item = &'a Token> + 'a>

fn iter_keys_vic3<'a>( &'a self, itype: Item, ) -> Box<dyn Iterator<Item = &'a Token> + 'a>

fn iter_keys_imperator<'a>( &'a self, itype: Item, ) -> Box<dyn Iterator<Item = &'a Token> + 'a>

pub fn iter_keys<'a>( &'a self, itype: Item, ) -> Box<dyn Iterator<Item = &'a Token> + 'a>

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

Trait Implementations

impl Debug for Everything

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

Formats the value using the given formatter.

impl Drop for Everything

fn drop(&mut self)

Executes the destructor for this type.