Struct Dependencies 

pub struct Dependencies { /* private fields */ }

Central dependencies manager for all reference data relevant to a Pack.

This struct caches and manages all data needed for reference lookups, diagnostics, and other operations that require knowledge of vanilla game data or parent mods.

Data Categories

The dependencies are organized into three persistence levels:

Serialized to Disk (cached)

These fields are saved to .pak files and only regenerated when the game files change or RPFM is updated:

• vanilla_files - All files from CA’s official PackFiles
• vanilla_tables - Index of DB table paths by table name
• vanilla_locs - Set of Loc file paths
• vanilla_folders - Set of folder paths for existence checks
• vanilla_paths - Case-insensitive path lookup map
• asskit_only_db_tables - Tables only present in Assembly Kit

Regenerated on Rebuild

These fields are rebuilt each time rebuild() is called, as they depend on the current environment:

• vanilla_loose_* - Files from the game’s /data folder (not in packs)
• parent_* - Files from parent mods the current pack depends on

Runtime Cache

Built on-demand during editing and not persisted:

• local_tables_references - Cached reference data for edited tables
• localisation_data - Merged Loc data for quick lookups

Implementations

impl Dependencies

pub fn build_date(&self) -> &u64

Date of the generation of this dependencies cache. For checking if it needs an update.

pub fn version(&self) -> &String

Version of the program used to generate the dependencies, so they’re properly invalidated on update.

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

Data to quickly load loose files as part of the dependencies.

Not serialized, regenerated on rebuild because these can frequently change.

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

Data to quickly load CA dependencies from disk.

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

Data to quickly load dependencies from parent mods from disk.

Not serialized, regenerated from parent Packs on rebuild.

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

List of DB tables on the CA loose files. Not really used, but just in case.

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

List of DB tables on the CA files.

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

List of DB tables on the parent files.

Not serialized, regenerated from parent Packs on rebuild.

pub fn vanilla_loose_locs(&self) -> &HashSet<String>

List of Loc tables on the CA loose files. Not really used, but just in case.

pub fn vanilla_locs(&self) -> &HashSet<String>

List of Loc tables on the CA files.

pub fn parent_locs(&self) -> &HashSet<String>

List of Loc tables on the parent files.

Not serialized, regenerated from parent Packs on rebuild.

pub fn vanilla_loose_folders(&self) -> &HashSet<String>

Data to quickly check if a path exists in the vanilla loose files.

pub fn vanilla_folders(&self) -> &HashSet<String>

Data to quickly check if a path exists in the vanilla files.

pub fn parent_folders(&self) -> &HashSet<String>

Data to quickly check if a path exists in the parent mod files.

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

List of vanilla loose paths lowercased, with their casing counterparts. To quickly find files.

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

List of vanilla paths lowercased, with their casing counterparts. To quickly find files.

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

List of parent paths lowercased, with their casing counterparts. To quickly find files.

Not serialized, regenerated from parent Packs on rebuild.

pub fn local_tables_references( &self, ) -> &HashMap<String, HashMap<i32, TableReferences>>

Cached data for local tables.

This is for runtime caching, and it must not be serialized to disk.

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

Data from all the locs, so we can quickly search for a loc entry.

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

DB Files only available on the assembly kit. Usable only for references. Do not use them as the base for new tables.

impl Dependencies

pub fn rebuild( &mut self, schema: &Option<Schema>, parent_pack_names: &[String], file_path: Option<&Path>, game_info: &GameInfo, game_path: &Path, secondary_path: &Path, ) -> Result<()>

This function takes care of rebuilding the whole dependencies cache to be used with a new Pack.

If a file path is passed, the dependencies cache at that path will be used, replacing the currently loaded dependencies cache. If a schema is not passed, no tables/locs will be pre-decoded. Make sure to decode them later with Dependencies::decode_tables.

pub fn generate_dependencies_cache( schema: &Option<Schema>, game_info: &GameInfo, game_path: &Path, asskit_path: &Option<PathBuf>, ignore_game_files_in_ak: bool, ) -> Result<Self>

This function generates the dependencies cache for the game provided and returns it.

pub fn generate_local_db_references( &mut self, schema: &Schema, packs: &BTreeMap<String, Pack>, table_names: &[String], )

This function builds the local db references data for the tables you pass to it from the Packs provided.

Table names must be provided as full names (with _tables at the end).

NOTE: This function, like many others, assumes the tables are already decoded in the Packs. If they’re not, they’ll be ignored.

pub fn generate_local_definition_references( &mut self, schema: &Schema, table_name: &str, definition: &Definition, )

This function builds the local db references data for the table with the definition you pass to and stores it in the cache.

pub fn generate_references( &self, schema: &Schema, local_table_name: &str, definition: &Definition, ) -> HashMap<i32, TableReferences>

This function builds the local db references data for the table with the definition you pass to, and returns it.

pub fn load(file_path: &Path, schema: &Option<Schema>) -> Result<Self>

This function tries to load dependencies from the path provided.

pub fn save(&mut self, file_path: &Path) -> Result<()>

This function saves a dependencies cache to the provided path.

pub fn needs_updating( &self, game_info: &GameInfo, game_path: &Path, ) -> Result<bool>

This function is used to check if the game files used to generate the dependencies cache have changed, requiring an update.

pub fn decode_tables(&mut self, schema: &Option<Schema>)

Function to force-decode all tables/locs in the dependencies.

Many operations require them to be decoded, so if you did not decoded them on load, make sure to call this to decode them after load.

pub fn file( &self, file_path: &str, include_vanilla: bool, include_parent: bool, case_insensitive: bool, ) -> Result<&RFile>

This function returns a reference to a specific file from the cache, if exists.

pub fn file_mut( &mut self, file_path: &str, include_vanilla: bool, include_parent: bool, ) -> Result<&mut RFile>

This function returns a mutable reference to a specific file from the cache, if exists.

pub fn files_mut_by_paths( &mut self, paths: &HashSet<String>, include_vanilla: bool, include_parent: bool, ) -> HashMap<String, &mut RFile>

Batch variant of Dependencies::file_mut that returns one &mut RFile per matching path.

pub fn files_by_path( &self, file_paths: &[ContainerPath], include_vanilla: bool, include_parent: bool, case_insensitive: bool, ) -> HashMap<String, &RFile>

This function returns a reference to all files corresponding to the provided paths.

pub fn files_by_types( &self, file_types: &[FileType], include_vanilla: bool, include_parent: bool, ) -> HashMap<String, &RFile>

This function returns a reference to all files of the specified FileTypes from the cache, if any, along with their path.

pub fn files_by_types_mut( &mut self, file_types: &[FileType], include_vanilla: bool, include_parent: bool, ) -> HashMap<String, &mut RFile>

This function returns a mutable reference to all files of the specified FileTypes from the cache, if any, along with their path.

pub fn loc_data( &self, include_vanilla: bool, include_parent: bool, ) -> Result<Vec<&RFile>>

This function returns the vanilla/parent locs from the cache, according to the params you pass it.

It returns them in the order the game will load them.

pub fn db_data( &self, table_name: &str, include_vanilla: bool, include_parent: bool, ) -> Result<Vec<&RFile>>

This function returns the vanilla/parent db tables from the cache, according to the params you pass it.

It returns them in the order the game will load them.

NOTE: table_name is expected to be the table’s folder name, with “_tables” at the end.

pub fn db_data_datacored<'a>( &'a self, table_name: &str, packs: &'a BTreeMap<String, Pack>, include_vanilla: bool, include_parent: bool, ) -> Result<Vec<&'a RFile>>

This function returns the vanilla/parent db tables from the cache, according to the params you pass it, applying to them any datacore from the provided Pack.

It returns them in the order the game will load them.

NOTE: table_name is expected to be the table’s folder name, with “_tables” at the end.

pub fn db_and_loc_data( &self, include_db: bool, include_loc: bool, include_vanilla: bool, include_parent: bool, ) -> Result<Vec<&RFile>>

This function returns the vanilla/parent DB and Loc tables from the cache, according to the params you pass it.

It returns them in the order the game will load them.

pub fn db_reference_data( &self, schema: &Schema, packs: &BTreeMap<String, Pack>, table_name: &str, definition: &Definition, loc_data: &Option<HashMap<Cow<'_, str>, Cow<'_, str>>>, ) -> HashMap<i32, TableReferences>

This function returns the reference/lookup data of all relevant columns of a DB Table.

NOTE: This assumes you’ve populated the runtime references before this. If not, it’ll fail.

pub fn loc_key_source(&self, key: &str) -> Option<(String, String, Vec<String>)>

This function returns the table/column/key from the provided loc key.

We return the table without “_tables”. Keep that in mind if you use this.

pub fn file_exists( &self, file_path: &str, include_vanilla: bool, include_parent: bool, case_insensitive: bool, ) -> bool

This function returns if a specific file exists in the dependencies cache.

pub fn folder_exists( &self, folder_path: &str, include_vanilla: bool, include_parent: bool, case_insensitive: bool, ) -> bool

This function returns if a specific folder exists in the dependencies cache.

pub fn are_dependencies_generated(file_path: &Path) -> bool

This function checks if the dependencies cache file exists on disk.

pub fn is_vanilla_data_loaded(&self, include_asskit: bool) -> bool

This function checks if there is vanilla data loaded in the provided cache.

pub fn is_asskit_data_loaded(&self) -> bool

This function checks if there is assembly kit data loaded in the provided cache.

pub fn is_db_outdated(&self, rfile: &RFileDecoded) -> bool

This function is used to check if a table is outdated or not.

pub fn db_version(&self, table_name: &str) -> Option<i32>

This function is used to get the version of a table in the game files, if said table is in the game files.

pub fn db_values_from_table_name_and_column_name( &self, packs: Option<&BTreeMap<String, Pack>>, table_name: &str, column_name: &str, include_vanilla: bool, include_parent: bool, ) -> HashSet<String>

This function returns the list of values a column of a table has, across all instances of said table in the dependencies and the provided Packs.

pub fn db_values_from_table_name_and_column_name_for_value( &self, packs: Option<&BTreeMap<String, Pack>>, table_name: &str, key_column_name: &str, desired_column_name: &str, include_vanilla: bool, include_parent: bool, ) -> HashMap<String, String>

This function returns the value a table has in the row it has a specific value in a specific column.

pub fn update_db( &mut self, rfile: &mut RFileDecoded, ) -> Result<(i32, i32, Vec<String>, Vec<String>)>

This function updates a DB Table to its latest valid version, being the latest valid version the one in the vanilla files.

It returns both, old and new versions, or an error.

pub fn generate_missing_loc_data( &self, packs: &mut BTreeMap<String, Pack>, ) -> Result<Vec<ContainerPath>>

Function to generate the missing loc entries in a pack.

pub fn bruteforce_loc_key_order( &self, schema: &mut Schema, locs: Option<HashMap<String, Vec<String>>>, local_packs: Option<&BTreeMap<String, Pack>>, ak_files: Option<&mut HashMap<String, DB>>, ) -> Result<()>

This function bruteforces the order in which multikeyed tables get their keys together for loc entries.

pub fn generate_automatic_patches( &self, schema: &mut Schema, packs: &BTreeMap<String, Pack>, ) -> Result<()>

This function generates automatic schema patches based mainly on bruteforcing and some clever logic.

pub fn add_tile_maps_and_tiles( &mut self, packs: &mut BTreeMap<String, Pack>, pack_key: Option<&str>, game: &GameInfo, schema: &Schema, options: OptimizerOptions, tile_maps: Vec<PathBuf>, tiles: Vec<(PathBuf, String)>, ) -> Result<(Vec<ContainerPath>, Vec<ContainerPath>)>

Function to add tiles and tile maps to the provided pack.

Only for Warhammer 3.

pub fn build_starpos_pre( &self, packs: &mut BTreeMap<String, Pack>, pack_key: Option<&str>, game: &GameInfo, game_path: &Path, campaign_id: &str, process_hlp_spd_data: bool, sub_start_pos: &str, ) -> Result<()>

pub fn build_starpos_post( &self, packs: &mut BTreeMap<String, Pack>, pack_key: Option<&str>, game: &GameInfo, game_path: &Path, asskit_path: Option<PathBuf>, campaign_id: &str, process_hlp_spd_data: bool, cleanup_mode: bool, sub_start_pos: &[String], ) -> Result<Vec<ContainerPath>>

Function to trigger the second part of the startpos build process, which involves importing the startpos file into the provided pack.

Call this when the game closes after the pre function launched it.

NOTE: The assembly kit path is only needed for Rome 2.

pub fn import_from_ak(&self, table_name: &str, schema: &Schema) -> Result<DB>

This function imports a specific table from the data it has in the AK.

Tables generated with this are VALID.

pub fn insert_loc_as_vanilla_loc(&mut self, rfile: RFile)

This function manually inserts a loc file from this into the dependencies as a vanilla loc.

THIS IS DANGEROUS. DO NOT USE IT UNLESS YOU KNOW WHAT YOU’RE DOING.

pub fn add_recursive_lookups_to_definition( &self, schema: &Schema, definition: &mut Definition, table_name: &str, )

This function manipulates a definition to recursively add reference lookups if found.

THIS IS DANGEROUS IF WE FIND A CYCLIC DEPENDENCY.

Trait Implementations

impl Clone for Dependencies

fn clone(&self) -> Dependencies

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Dependencies

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

Formats the value using the given formatter.

impl Default for Dependencies

fn default() -> Dependencies

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Dependencies

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Dependencies

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.