Struct TableInMemory 

pub struct TableInMemory { /* private fields */ }

In-memory representation of a decoded table with full data and schema.

This is the primary table implementation in RPFM, storing all table rows in memory along with their schema definition. Tables are typically accessed through the Table trait interface rather than directly.

Fields

• table_name: Identifies the table type (e.g., “units_tables”, “buildings_tables”)
• definition: Complete schema definition including column types and constraints
• definition_patch: Runtime modifications to the base schema for this specific table
• table_data: All table rows as a Vec<Vec<DecodedData>> (outer vector is rows, inner is columns)
• altered: Flag indicating if data was modified during decoding (e.g., invalid values corrected)

Accessors

The struct uses the getset macro for automatic accessor generation:

• table_name() / set_table_name(): Public getters/setters via getset
• Schema and data: Accessed through Table trait methods for type safety

Thread Safety

This struct implements Send + Sync (via the Table trait requirement), allowing safe concurrent read access and message passing between threads.

Implementations

impl TableInMemory

pub fn table_name(&self) -> &String

Table type identifier (e.g., “units_tables”).

pub fn altered(&self) -> &bool

Flag indicating data was altered during decoding (e.g., invalid values corrected).

impl TableInMemory

pub fn set_table_name(&mut self, val: String) -> &mut Self

Table type identifier (e.g., “units_tables”).

pub fn set_altered(&mut self, val: bool) -> &mut Self

Flag indicating data was altered during decoding (e.g., invalid values corrected).

impl TableInMemory

pub fn new( definition: &Definition, definition_patch: Option<&DefinitionPatch>, table_name: &str, ) -> Self

Creates a new empty table from a schema definition.

Initializes a table with no rows but with a complete schema definition. This is typically used when creating new tables from scratch or before importing data from external sources.

Parameters

• definition: Schema defining column structure, types, and constraints
• definition_patch: Optional runtime modifications to the base schema
• table_name: Table type identifier (e.g., “units_tables”)

Examples

// Create empty table for manual data entry
let mut table = TableInMemory::new(definition, None, "units_tables");

// Add rows using the Table trait methods
let new_row = table.new_row();
table.data_mut().push(new_row);

pub fn decode<R: ReadBytes>( data: &mut R, definition: &Definition, definition_patch: &DefinitionPatch, entry_count: Option<u32>, return_incomplete: bool, table_name: &str, ) -> Result<Self>

Decodes a table from binary data using the provided schema.

This is the primary method for loading tables from PackFiles. It reads the binary format used by Total War games and converts it into an in-memory representation.

Parameters

• data: Binary data reader positioned at the table start
• definition: Schema definition for interpreting the binary data
• definition_patch: Runtime schema modifications
• entry_count: Optional row count (if None, reads from data stream)
• return_incomplete: If true, returns partial data on decode errors instead of failing
• table_name: Table type identifier

Behavior

• Reads entry count from stream if not provided
• Decodes each row according to schema field definitions
• Sets altered flag if invalid data is corrected during decoding
• Can return incomplete tables for error recovery if requested

Errors

Returns an error if:

• Binary data is corrupted or truncated
• Data types don’t match schema expectations
• Field decoding fails (unless return_incomplete is true)

Examples

// Decode table from binary PackFile data
let table = TableInMemory::decode(
    data,
    definition,
    &HashMap::new(),  // No patches
    Some(100),        // 100 entries
    false,            // Fail on errors
    "units_tables"
)?;

pub fn encode<W: WriteBytes>(&self, data: &mut W) -> Result<()>

Encodes the table to binary format for writing to PackFiles.

Converts the in-memory table representation back to the binary format used by Total War games. This is the inverse of decode.

Parameters

• data: Binary writer to receive the encoded table

Format

The binary output includes:

• Entry count (u32)
• Row data encoded according to field types
• Applied schema patches are used during encoding

Errors

Returns an error if:

• Writing to the output stream fails
• Data contains values that cannot be encoded in the target type

Examples

// Encode table for saving to PackFile
table.encode(output)?;

Trait Implementations

impl Clone for TableInMemory

fn clone(&self) -> TableInMemory

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TableInMemory

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TableInMemory

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Atlas> for TableInMemory

fn from(value: Atlas) -> Self

Converts to this type from the input type.

impl From<TableInMemory> for Atlas

fn from(value: TableInMemory) -> Self

Converts to this type from the input type.

impl From<TableInMemory> for DB

Implementation to create a DB from a Table.

fn from(table: TableInMemory) -> Self

Converts to this type from the input type.

impl From<TableInMemory> for Loc

Implementation to create a Loc from a Table directly.

fn from(table: TableInMemory) -> Self

Converts to this type from the input type.

impl PartialEq for TableInMemory

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TableInMemory

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Table for TableInMemory

fn name(&self) -> &str

Returns the table name (e.g., “units_tables”, “factions_tables”).

fn definition(&self) -> &Definition

Returns the table’s schema definition.

fn patches(&self) -> &DefinitionPatch

Returns definition patches applied to this table.

fn data(&self) -> Cow<'_, [Vec<DecodedData>]>

Returns the table’s row data.

fn data_mut(&mut self) -> &mut Vec<Vec<DecodedData>>

Returns a mutable reference to the table’s row data.

fn set_name(&mut self, val: String)

Sets the table name.

fn set_definition(&mut self, new_definition: &Definition)

Replaces the table’s definition and migrates data to match the new schema.

fn set_data(&mut self, data: &[Vec<DecodedData>]) -> Result<()>

Replaces the table’s data with the provided rows.

fn column_position_by_name(&self, column_name: &str) -> Option<usize>

Returns the column index for a given column name.

fn is_empty(&self) -> bool

Returns true if the table contains no rows.

fn len(&self) -> usize

Returns the number of rows in the table.

fn rows_containing_data( &self, column_name: &str, data: &str, ) -> Option<(usize, Vec<usize>)>

This function tries to find all rows with the provided data, if they exists in this table.

fn new_row(&self) -> Vec<DecodedData>

Creates a new empty row with default values for all columns.

impl StructuralPartialEq for TableInMemory