Struct Loc 

pub struct Loc { /* private fields */ }

In-memory representation of a decoded Loc (localisation) file.

Wraps a TableInMemory with a fixed three-column schema: key, text, and tooltip. Unlike DB tables, Loc files don’t require external schema definitions.

Structure

Each row contains:

• key (StringU16): Unique identifier for the localised text
• text (StringU16): The localised string content
• tooltip (Boolean): Flag of unknown purpose

Example

use rpfm_lib::files::{Decodeable, loc::Loc};
use std::io::Cursor;

let mut reader = Cursor::new(loc_data);
let loc = Loc::decode(&mut reader, &None).unwrap();

// Access entries
for row in loc.data().iter() {
    // row[0] = key, row[1] = text, row[2] = tooltip
}

Implementations

impl Loc

pub fn table(&self) -> &TableInMemory

The underlying table data with key, text, and tooltip columns.

impl Loc

pub fn set_table(&mut self, val: TableInMemory) -> &mut Self

The underlying table data with key, text, and tooltip columns.

impl Loc

Implementation of Loc.

pub fn new() -> Self

Creates a new empty Loc table.

Initializes with the standard three-column schema (key, text, tooltip) but no data rows.

pub fn definition(&self) -> &Definition

Returns the schema definition used by this Loc table.

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

Returns the table rows as a slice of decoded data.

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

Returns a mutable reference to the table rows.

Ensure modifications maintain valid structure (3 columns per row).

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

Creates a new row with default placeholder values.

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

Replaces all table data with the provided rows.

Errors

Returns an error if rows don’t match the expected 3-column structure.

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

Returns the column index for a given column name, or None if not found.

Valid column names: "key" (0), "text" (1), "tooltip" (2).

pub fn len(&self) -> usize

Returns the number of entries in the Loc table.

pub fn is_empty(&self) -> bool

Returns true if the Loc table has no entries.

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

Replaces the table definition and migrates existing data to match.

Typically not needed for Loc files since the definition is fixed.

pub fn read_header<R: ReadBytes>(data: &mut R) -> Result<(i32, u32)>

Reads and validates the Loc file header.

Returns

A tuple of (version, entry_count). Version is always 1 in known files.

Errors

Returns RLibError::DecodingLocNotALocTable if the header is invalid (wrong byte order mark, wrong file type, or insufficient data).

pub fn merge(sources: &[&Self]) -> Result<Self>

Merges multiple Loc tables into a single new table.

Combines all rows from the source tables. Duplicate keys are preserved (not deduplicated).

pub fn tsv_import( records: StringRecordsIter<'_, File>, field_order: &HashMap<u32, String>, ) -> Result<Self>

Imports a Loc table from TSV (tab-separated values) format.

Arguments

• records - CSV reader iterator over TSV records.
• field_order - Mapping of column positions to field names.

pub fn tsv_export( &self, writer: &mut Writer<File>, table_path: &str, ) -> Result<()>

Exports the Loc table to TSV (tab-separated values) format.

Arguments

• writer - CSV writer for the output file.
• table_path - Path used in the TSV metadata header.

Trait Implementations

impl Clone for Loc

fn clone(&self) -> Loc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Loc

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

Formats the value using the given formatter.

impl Decodeable for Loc

fn decode<R: ReadBytes>( data: &mut R, _extra_data: &Option<DecodeableExtraData<'_>>, ) -> Result<Self>

Decodes binary data into the implementing type.

impl Default for Loc

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Loc

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encodeable for Loc

fn encode<W: WriteBytes>( &mut self, buffer: &mut W, _extra_data: &Option<EncodeableExtraData<'_>>, ) -> Result<()>

Encodes the implementing type into binary data.

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 Loc

fn eq(&self, other: &Loc) -> 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 Loc

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Loc