Struct genie::LangFile

pub struct LangFile(_);

A mapping of StringKey key to String values.

May be read from or written to one of the three file formats for Aoe2 language files.

Methods

impl LangFile

pub fn read_dll<impl Read>(&mut self, input: impl Read) -> Result<(), LoadError> where
    impl Read: Read, 

Reads a language file from a .DLL. This function eagerly loads all the strings into memory.

Returns Err(e) where e is a LoadError if an error occurs while loading the file.

pub fn write_to_ini<W>(&self, output: &mut W) -> Result<(), Error> where
    W: Write, 

Writes this language file to an output writer using the ini format.

pub fn write_to_keyval<W>(&self, output: &mut W) -> Result<(), Error> where
    W: Write, 

Writes this language file to an output writer using the key-value format.

pub fn new() -> LangFile

Creates an empty language file.

Examples

use genie_lang::LangFile;

let lang_file = LangFile::new();

pub fn is_empty(&self) -> bool

Returns true if this language file contains no key-value pairs, false otherwise.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
assert!(lang_file.is_empty());
lang_file.insert(StringKey::from(0), String::from(""));
assert!(!lang_file.is_empty());

pub fn len(&self) -> usize

Returns the number of key-value pairs in this language file.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
assert_eq!(0, lang_file.len());
lang_file.insert(StringKey::from(0), String::from(""));
assert_eq!(1, lang_file.len());

pub fn clear(&mut self)

Removes all key-value pairs from this Language file.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from(""));
lang_file.clear();
assert!(lang_file.is_empty());

pub fn drain(&mut self) -> Drain<StringKey, String>

Clears this Language file, returning all key-value pairs as an iterator.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from("a"));
lang_file.insert(StringKey::from(1), String::from("b"));

for (k, v) in lang_file.drain().take(1) {
    assert!(k == StringKey::from(0) || k == StringKey::from(1));
    assert!(v == "a" || v == "b");
}
assert!(lang_file.is_empty());

pub fn contains_key(&self, k: &StringKey) -> bool

Returns true if the map contains a value for key k, false if not.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from(""));
assert!(lang_file.contains_key(&StringKey::from(0)));
assert!(!lang_file.contains_key(&StringKey::from(1)));

pub fn get(&self, k: &StringKey) -> Option<&String>

Returns a reference to the value corresponding to the key.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from(""));
assert_eq!(Some(&String::from("")), lang_file.get(&StringKey::from(0)));
assert_eq!(None, lang_file.get(&StringKey::from(1)));

pub fn get_mut(&mut self, k: &StringKey) -> Option<&mut String>

Returns a mutable reference to the value corresponding to the key.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from("a"));
if let Some(s) = lang_file.get_mut(&StringKey::from(0)) { s.push('A'); }
assert_eq!("aA", lang_file.get(&StringKey::from(0)).unwrap());

pub fn entry(&mut self, key: StringKey) -> Entry<StringKey, String>

Returns the given key's corresponding entry in the language file.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from("a"));
let s0 = lang_file.entry(StringKey::from(0))
                  .or_insert(String::from("Hello"));
s0.push('A');
let s1 = lang_file.entry(StringKey::from(1))
                  .or_insert(String::from("Hello"));
s1.push('A');
assert_eq!("aA", lang_file.get(&StringKey::from(0)).unwrap());
assert_eq!("HelloA", lang_file.get(&StringKey::from(1)).unwrap());

pub fn insert(&mut self, k: StringKey, v: String) -> Option<String>

Inserts a key-value pair into this language file.

Returns None. if the language file did not have the key present.

If the key was present, the value is updated, and the old value is returned.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from("a"));
assert!(!lang_file.is_empty());

lang_file.insert(StringKey::from(0), String::from("b"));
assert_eq!(Some(String::from("b")),
           lang_file.insert(StringKey::from(0), String::from("c")));

pub fn remove(&mut self, k: &StringKey) -> Option<String>

Removes a key-value pair from the map, returning the value at the key if the key was previously in the map. Returns None if the key was not in the map.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from(""));
assert_eq!(Some(String::from("")),
           lang_file.remove(&StringKey::from(0)));
assert_eq!(None, lang_file.remove(&StringKey::from(0)));

pub fn retain<F>(&mut self, f: F) where
    F: FnMut(&StringKey, &mut String) -> bool, 

Retains only the elements specified by the predicate.

In other words, removes all pairs (k, v) such that f(&k, &mut v) returns false.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::from(1), String::from("one"));
lang_file.insert(StringKey::from("2"), String::from("two"));
lang_file.retain(|k, _| match k {
    StringKey::Num(_) => true,
    StringKey::Name(_) => false,
});
assert_eq!(3, lang_file.len());

pub fn iter(&self) -> Iter<StringKey, String>

An iterator visiting all key-value pairs in an arbitrary order. The iterator element type is (&'a StringKey, &'a String).

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::from(1), String::from("one"));
lang_file.insert(StringKey::from("2"), String::from("two"));

for (k, v) in lang_file.iter() { println!("key: {}, val: {}", k, v); }

pub fn iter_mut(&mut self) -> IterMut<StringKey, String>

Returns an iterator that visits all key-values pairs in an arbitrary order, with mutable references to the values. The iterator element type is (&'a StringKey, &'a mut String).

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::from(1), String::from("one"));
lang_file.insert(StringKey::from("2"), String::from("two"));

for (_, v) in lang_file.iter_mut() { v.push('A'); }
for (k, v) in &lang_file { println!("key: {}, val: {}", k, v); }

pub fn keys(&self) -> Keys<StringKey, String>

Returns an iterator that visits all keys in arbitrary order. The iterator element type is &'a StringKey.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::from(1), String::from("one"));
lang_file.insert(StringKey::from("2"), String::from("two"));

for k in lang_file.keys() { println!("key: {}", k); }

pub fn values(&self) -> Values<StringKey, String>

Returns an iterator that visits all values in arbitrary order. The iterator element type is &'a String.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::from(1), String::from("one"));
lang_file.insert(StringKey::from("2"), String::from("two"));

for v in lang_file.values() { println!("value: {}", v); }

pub fn values_mut(&mut self) -> ValuesMut<StringKey, String>

Returns an iterator visiting all values mutable in arbitrary order. The iterator element type is &'a mut String.

Examples

use genie_lang::{LangFile, StringKey};

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::from(0), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::from(1), String::from("one"));
lang_file.insert(StringKey::from("2"), String::from("two"));

for v in lang_file.values_mut() { v.push('A'); }
for v in lang_file.values() { println!("{}", v); }

Trait Implementations

impl PartialEq<LangFile> for LangFile

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Default for LangFile

fn default() -> LangFile

Returns the "default value" for a type.

impl<'_> Index<&'_ StringKey> for LangFile

type Output = String

The returned type after indexing.

fn index(&self, key: &StringKey) -> &String

Performs the indexing (container[index]) operation.

impl Debug for LangFile

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

Formats the value using the given formatter.

impl Extend<(StringKey, String)> for LangFile

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = (StringKey, String)>, 

Extends a collection with the contents of an iterator.

impl Clone for LangFile

fn clone(&self) -> LangFile

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> IntoIterator for &'a LangFile

type Item = (&'a StringKey, &'a String)

The type of the elements being iterated over.

type IntoIter = Iter<'a, StringKey, String>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a LangFile as IntoIterator>::IntoIter

Creates an iterator from a value.

impl IntoIterator for LangFile

type Item = (StringKey, String)

The type of the elements being iterated over.

type IntoIter = IntoIter<StringKey, String>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <LangFile as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a mut LangFile

type Item = (&'a StringKey, &'a mut String)

The type of the elements being iterated over.

type IntoIter = IterMut<'a, StringKey, String>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut LangFile as IntoIterator>::IntoIter

Creates an iterator from a value.

impl Eq for LangFile

impl FromIterator<(StringKey, String)> for LangFile

fn from_iter<T>(iter: T) -> LangFile where
    T: IntoIterator<Item = (StringKey, String)>, 

Creates a value from an iterator.

impl Display for LangFile

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

Formats the value using the given formatter.