Trait Table 

pub trait Table: Send + Sync {
    // Required methods
    fn name(&self) -> &str;
    fn definition(&self) -> &Definition;
    fn patches(&self) -> &DefinitionPatch;
    fn data(&self) -> Cow<'_, [Vec<DecodedData>]>;
    fn data_mut(&mut self) -> &mut Vec<Vec<DecodedData>>;
    fn set_name(&mut self, val: String);
    fn set_definition(&mut self, new_definition: &Definition);
    fn set_data(&mut self, data: &[Vec<DecodedData>]) -> Result<()>;
    fn column_position_by_name(&self, column_name: &str) -> Option<usize>;
    fn is_empty(&self) -> bool;
    fn len(&self) -> usize;
    fn rows_containing_data(
        &self,
        column_name: &str,
        data: &str,
    ) -> Option<(usize, Vec<usize>)>;

    // Provided method
    fn new_row(&self) -> Vec<DecodedData> { ... }
}

Abstract interface for table-like data structures.

This trait defines the common interface for all table implementations in RPFM. Tables are row-based data structures with typed columns defined by a Definition.

Thread Safety

Implementations must be Send + Sync to support concurrent access and modification in multi-threaded environments.

Implementations

• local::TableInMemory - In-memory table with full encode/decode support

Usage

fn process_table<T: Table>(table: &T) {
    // Access metadata
    let name = table.name();
    let definition = table.definition();

    // Iterate rows
    for row in table.data().iter() {
        // Process each row
    }
}

Required Methods

fn name(&self) -> &str

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

fn definition(&self) -> &Definition

Returns the table’s schema definition.

The definition specifies column structure, types, constraints, and version information.

fn patches(&self) -> &DefinitionPatch

Returns definition patches applied to this table.

Patches allow runtime modification of definitions for specific tables without changing the base schema.

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

Returns the table’s row data.

Returns a Cow to allow zero-copy access for immutable operations while supporting owned data when needed.

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

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

Safety

Using this method makes you responsible for maintaining data validity:

• Each row must have the correct number of columns
• Each cell must match the type specified in the definition
• Data integrity is not automatically validated

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.

This method enables version migration: converting table data from one schema version to another. When the definition changes:

• New columns are added with default values
• Removed columns are dropped
• Type changes are converted where possible
• Data is validated against the new schema

Use Cases

• Updating tables after game patches change the schema
• Converting tables between game versions
• Applying definition modifications from patches

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

Replaces the table’s data with the provided rows.

Validation

This method validates that:

• Each row has the correct number of columns
• Each cell matches the expected type from the definition

Errors

Returns an error if validation fails.

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

Returns the column index for a given column name.

Returns None if no column with the specified name exists. Column names are case-sensitive.

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.

Provided Methods

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

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

Default values are determined by:

1. Field-specific default values from the definition/patches
2. Type-specific defaults (0 for numbers, empty string for text, false for booleans)

Implementors

impl Table for TableInMemory