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.

Implementations

impl LangFile

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};
use std::convert::TryFrom;

let mut lang_file = LangFile::new();
assert!(lang_file.is_empty());
lang_file.insert(StringKey::try_from(0).unwrap(), 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};
use std::convert::TryFrom;

let mut lang_file = LangFile::new();
assert_eq!(0, lang_file.len());
lang_file.insert(StringKey::try_from(0).unwrap(), 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};
use std::convert::TryFrom;

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::try_from(0).unwrap(), 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};
use std::convert::TryFrom;

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

for (k, v) in lang_file.drain().take(1) {
    assert!(k == StringKey::try_from(0).unwrap() || k == StringKey::try_from(1).unwrap());
    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};
use std::convert::TryFrom;

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

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

Returns a reference to the value corresponding to the key.

Examples

use genie_lang::{LangFile, StringKey};
use std::convert::TryFrom;

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

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};
use std::convert::TryFrom;

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::try_from(0).unwrap(), String::from("a"));
if let Some(s) = lang_file.get_mut(&StringKey::try_from(0).unwrap()) { s.push('A'); }
assert_eq!("aA", lang_file.get(&StringKey::try_from(0).unwrap()).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};
use std::convert::TryFrom;

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::try_from(0).unwrap(), String::from("a"));
let s0 = lang_file.entry(StringKey::try_from(0).unwrap())
                  .or_insert(String::from("Hello"));
s0.push('A');
let s1 = lang_file.entry(StringKey::try_from(1).unwrap())
                  .or_insert(String::from("Hello"));
s1.push('A');
assert_eq!("aA", lang_file.get(&StringKey::try_from(0).unwrap()).unwrap());
assert_eq!("HelloA", lang_file.get(&StringKey::try_from(1).unwrap()).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};
use std::convert::TryFrom;

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

lang_file.insert(StringKey::try_from(0).unwrap(), String::from("b"));
assert_eq!(Some(String::from("b")),
           lang_file.insert(StringKey::try_from(0).unwrap(), 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};
use std::convert::TryFrom;

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

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};
use std::convert::TryFrom;

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::try_from(0).unwrap(), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::try_from(1).unwrap(), 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};
use std::convert::TryFrom;

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::try_from(0).unwrap(), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::try_from(1).unwrap(), 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};
use std::convert::TryFrom;

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::try_from(0).unwrap(), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::try_from(1).unwrap(), 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};
use std::convert::TryFrom;

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::try_from(0).unwrap(), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::try_from(1).unwrap(), 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};
use std::convert::TryFrom;

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::try_from(0).unwrap(), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::try_from(1).unwrap(), 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};
use std::convert::TryFrom;

let mut lang_file = LangFile::new();
lang_file.insert(StringKey::try_from(0).unwrap(), String::from("zero"));
lang_file.insert(StringKey::from("a"), String::from("a"));
lang_file.insert(StringKey::try_from(1).unwrap(), 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 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 Debug for LangFile

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

Formats the value using the given formatter.

impl Default for LangFile

fn default() -> LangFile

Returns the "default value" for a type.

impl Display for LangFile

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

Formats the value using the given formatter.

impl Eq for LangFile

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 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<'_> 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 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<'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 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 StructuralEq for LangFile

impl StructuralPartialEq for LangFile