Struct JMapInfo 

pub struct JMapInfo<H: HashTable> { /* private fields */ }

The main JMap that holds fields and entries. So basically the in-memory representation of a BCSV file

This is a table-like structure where each field represents a column and each entry represents a row of data

Basically implemented what i see on this page

Implementations

impl<H: HashTable> JMapInfo<H>

pub fn new(hash_table: H) -> Self

Create a new empty JMapInfo with the given hash table

Arguments

• hash_table - The hash table to use for field name lookups

pub fn hash_table(&self) -> &H

Get a reference to the hash table

pub fn hash_table_mut(&mut self) -> &mut H

Get a mutable reference to the hash table

pub fn num_fields(&self) -> usize

Get the number of fields (columns)

Examples found in repository

examples/write_bcsv.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let lookup_path = Path::new("assets/strings_SMG.txt");
    let hash_table = smg_hash_table_with_lookup(lookup_path)?;

    let csv_path = Path::new("assets/examples/scenariodata.csv");
    let jmap = from_csv(hash_table, csv_path, None)?;

    println!("CSV Info");
    println!("Entries: {}", jmap.len());
    println!("Fields: {}", jmap.num_fields());
    println!();

    to_file(&jmap, "test_output.bcsv", &IoOptions::default())?;
    println!("\nExported to test_output.bcsv");

    Ok(())
}

examples/read_bcsv.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let lookup_path = Path::new("assets/strings_SMG.txt");
    let hash_table = smg_hash_table_with_lookup(lookup_path)?;

    let bcsv_path = Path::new("assets/examples/scenariodata.bcsv");
    let jmap = from_file(hash_table, bcsv_path, &IoOptions::default())?;

    println!("BCSV Info");
    println!("Entries: {}", jmap.len());
    println!("Fields: {}", jmap.num_fields());
    println!();

    println!("Fields");
    for field in jmap.fields() {
        let name = jmap.field_name(field.hash);
        println!("+0x{:X} - {} - {}", field.offset, name, field.field_type);
    }
    println!();

    to_csv(&jmap, "test_output.csv", None)?;
    println!("\nExported to test_output.csv");

    Ok(())
}

pub fn len(&self) -> usize

Get the number of entries (rows)

Examples found in repository

examples/write_bcsv.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let lookup_path = Path::new("assets/strings_SMG.txt");
    let hash_table = smg_hash_table_with_lookup(lookup_path)?;

    let csv_path = Path::new("assets/examples/scenariodata.csv");
    let jmap = from_csv(hash_table, csv_path, None)?;

    println!("CSV Info");
    println!("Entries: {}", jmap.len());
    println!("Fields: {}", jmap.num_fields());
    println!();

    to_file(&jmap, "test_output.bcsv", &IoOptions::default())?;
    println!("\nExported to test_output.bcsv");

    Ok(())
}

examples/read_bcsv.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let lookup_path = Path::new("assets/strings_SMG.txt");
    let hash_table = smg_hash_table_with_lookup(lookup_path)?;

    let bcsv_path = Path::new("assets/examples/scenariodata.bcsv");
    let jmap = from_file(hash_table, bcsv_path, &IoOptions::default())?;

    println!("BCSV Info");
    println!("Entries: {}", jmap.len());
    println!("Fields: {}", jmap.num_fields());
    println!();

    println!("Fields");
    for field in jmap.fields() {
        let name = jmap.field_name(field.hash);
        println!("+0x{:X} - {} - {}", field.offset, name, field.field_type);
    }
    println!();

    to_csv(&jmap, "test_output.csv", None)?;
    println!("\nExported to test_output.csv");

    Ok(())
}

pub fn is_empty(&self) -> bool

Check if entries are empty

pub fn fields(&self) -> impl Iterator<Item = &Field>

Get an iterator over all fields

Examples found in repository

examples/read_bcsv.rs (line 19)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let lookup_path = Path::new("assets/strings_SMG.txt");
    let hash_table = smg_hash_table_with_lookup(lookup_path)?;

    let bcsv_path = Path::new("assets/examples/scenariodata.bcsv");
    let jmap = from_file(hash_table, bcsv_path, &IoOptions::default())?;

    println!("BCSV Info");
    println!("Entries: {}", jmap.len());
    println!("Fields: {}", jmap.num_fields());
    println!();

    println!("Fields");
    for field in jmap.fields() {
        let name = jmap.field_name(field.hash);
        println!("+0x{:X} - {} - {}", field.offset, name, field.field_type);
    }
    println!();

    to_csv(&jmap, "test_output.csv", None)?;
    println!("\nExported to test_output.csv");

    Ok(())
}

pub fn field_hashes(&self) -> impl Iterator<Item = &u32>

Get an iterator over all field hashes

pub fn get_field_by_hash(&self, hash: u32) -> Option<&Field>

Get a field by hash

pub fn get_field(&self, name: &str) -> Option<&Field>

Get a field by name

pub fn contains_field_hash(&self, hash: u32) -> bool

Check if a field exists by hash

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

Check if a field exists by name

pub fn field_name(&self, hash: u32) -> String

Get the name of a field by its hash

Examples found in repository

examples/read_bcsv.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let lookup_path = Path::new("assets/strings_SMG.txt");
    let hash_table = smg_hash_table_with_lookup(lookup_path)?;

    let bcsv_path = Path::new("assets/examples/scenariodata.bcsv");
    let jmap = from_file(hash_table, bcsv_path, &IoOptions::default())?;

    println!("BCSV Info");
    println!("Entries: {}", jmap.len());
    println!("Fields: {}", jmap.num_fields());
    println!();

    println!("Fields");
    for field in jmap.fields() {
        let name = jmap.field_name(field.hash);
        println!("+0x{:X} - {} - {}", field.offset, name, field.field_type);
    }
    println!();

    to_csv(&jmap, "test_output.csv", None)?;
    println!("\nExported to test_output.csv");

    Ok(())
}

pub fn create_field( &mut self, name: &str, field_type: FieldType, default: FieldValue, ) -> Result<()>

Create a new field with the given name and type

Arguments

• name - The name of the field to create
• field_type - The type of the field to create
• default - The default value for the field to create

Errors

• JMapError::TypeMismatch if the default value is not compatible with the field type
• JMapError::FieldAlreadyExists if a field with the same name already exists

Returns

Ok(()) if the field was created successfully, or an error if the field could not be created

pub fn drop_field(&mut self, name: &str) -> Result<()>

Remove a field from the container

Arguments

• name - The name of the field to remove

Errors

• JMapError::FieldNotFound if the field does not exist

Returns

Ok(()) if the field was removed successfully, or an error if the field could not be found

pub fn entries(&self) -> &[Entry]

Get a slice of all entries

pub fn entries_mut(&mut self) -> &mut [Entry]

Get a mutable slice of all entries

pub fn get_entry(&self, index: usize) -> Option<&Entry>

Get an entry by index

pub fn get_entry_mut(&mut self, index: usize) -> Option<&mut Entry>

Get a mutable entry by index

pub fn create_entry(&mut self) -> &mut Entry

Create a new entry with default values for all fields

pub fn remove_entry(&mut self, index: usize) -> Result<Entry>

Remove an entry by index

Arguments

• index - The index of the entry to remove

Errors

• JMapError::EntryIndexOutOfBounds if the index is out of bounds

Returns

Ok(Entry) if the entry was removed successfully, or an error if the index was out of bounds

pub fn clear_entries(&mut self)

Clear all entries but keep the field definitions

pub fn sort_entries_by<F, K>(&mut self, f: F)

where F: FnMut(&Entry) -> K, K: Ord,

Sort entries by a custom key function

Arguments

• f - The key function to sort by

Types

• F - The type of the key function, which must be a function that takes a reference to an Entry and returns a key of type K
• K - The type of the key returned by the key function, which must implement the Ord trait for sorting

pub fn iter(&self) -> impl Iterator<Item = &Entry>

Iterate over entries

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Entry>

Iterate over entries mutably

Trait Implementations

impl<H: Debug + HashTable> Debug for JMapInfo<H>

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

Formats the value using the given formatter.

impl<'a, H: HashTable> IntoIterator for &'a JMapInfo<H>

Implement IntoIterator for references to JMapInfo to allow iterating over entries by reference

Types

• H - The type of the hash table used by the JMapInfo, which must implement the HashTable trait

Lifetime

• 'a - The lifetime of the reference to the JMapInfo

type Item = &'a Entry

The type of the elements being iterated over.

type IntoIter = Iter<'a, Entry>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, H: HashTable> IntoIterator for &'a mut JMapInfo<H>

type Item = &'a mut Entry

The type of the elements being iterated over.

type IntoIter = IterMut<'a, Entry>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<H: HashTable> IntoIterator for JMapInfo<H>

Implement IntoIterator for JMapInfo to allow iterating over entries directly This allows using for entry in jmap syntax to iterate over entries, as well as iterating over references and mutable references to JMapInfo The item type is Entry for owned iteration, &Entry for reference iteration, and &mut Entry for mutable reference iteration

type Item = Entry

The type of the elements being iterated over.

type IntoIter = IntoIter<Entry>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.