Struct Dictionary 

pub struct Dictionary<D> { /* private fields */ }

a list of Datapairs

Implementations

impl<D> Dictionary<D>

pub fn new() -> Self

create a new Dictionary for D

Return

Dictionary<D>

Examples

let dictonary:Dictionary<String> = Dictionary::new();

Coution

The type for the data has to be set. Wrong example:

let dictionary = Dictionary::new();

This gives an error, because the type for the data is not clear.

pub fn add(&mut self, k: String, d: D)

add data to the Dictionary

Params

p: Datapair<D>

Example

dictionary.add(String::from("Lola"),String::from("Sky"));

pub fn add_pair(&mut self, p: Datapair<D>)

add a pair to the Dictionary

Params

k: String // the key
d: D // the data

Example

let pair: Datapair<String> = Datapair::new(String::from("Marie"),String::from("Karate"))
dictionary.add_pair(pair);   

pub fn remove(&mut self, k: String)

removes a pair from the Dictionary

Params

k: String // the key

Example

dictionary.remove(String::from("Lola"));

pub fn change_data(&mut self, k: String, d: D)

changes the data for the given key

Params

k:String // the key
d:D // the new data

Example

dictionary.change_data(String::from("Maxime"),String::from("Swimming"));

pub fn change_key(&mut self, ok: String, nk: String)

changes the key for the given old key

Params

ok:String // the old key
nk:String // the new key

Example

dictionary.change_key(String::from("Anna"),String::from("Anna-Lena"));

pub fn get_pair(&self, k: String) -> &Datapair<D>

get a specific Datapair for the given key

Params

k:String // the key

Return

&Dictonary<D>

Example

let pair:Datapair<String> = dictionary.get_pair(String::from("Anna"));

pub fn get_data(&self, k: String) -> &D

get the data for the given key

Params

k:String // the key

Return

&D

Example

let hobby = dictionary.get_data(String::from("Anna"));

pub fn clear(&mut self)

clears the Dictionary

Example

dictionary.clear();

pub fn size(&self) -> usize

gives you how many pairs are in the Dictionary

Returns

usize

Example

let size:usize = dictionary.size();

Trait Implementations

impl<D: Clone> Clone for Dictionary<D>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<D: Display + Clone> Display for Dictionary<D>

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

Formats the value using the given formatter.

impl<D: PartialEq> PartialEq for Dictionary<D>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.