keylist

Keylist

Map like wrapper around a list with tuple pairs. Inspired by Elixir's Keyword lists.

Because it is just a list with tuples, keys can be anything that can be put in a tuple. Also means that getting a value is not efficient.

For something more usefull and quite similar take a look at: https://docs.rs/multimap ```rust use keylist::Keylist;

let mut keylist = Keylist::from(vec![("a", 5), ("b", 2), ("a", 1)]);

assert_eq!(keylist.get(&"a"), Some(&5));

keylist.sortbyvalue();

assert_eq!(keylist.get(&"a"), Some(&1));

keylist.push("z", 26);

assert_eq!(keylist.get(&"z"), Some(&26));

keylist.insert(1, "z", 2);

assert_eq!(keylist.get(&"z"), Some(&2));

asserteq!(keylist.getall(&"z"), vec![&2, &26]);

asserteq!(keylist.getkey_value(&"b"), Some(&("b", 2)));

let mut swappedkeylist = keylist.intoswapped();

asserteq!(swappedkeylist.get(&2), Some(&"z"));

asserteq!(swappedkeylist.get_all(&2), vec![&"z", &"b"]);

swapped_keylist.sort();

asserteq!(swappedkeylist.get_all(&2), vec![&"b", &"z"]);

swapped_keylist.extend(vec![(3, "b"), (2, "g")]);

asserteq!(swappedkeylist.get_all(&2), vec![&"b", &"z", &"g"]);

```

Convert keylist to map and back: ```rust use std::collections::HashMap; use std::iter::FromIterator; use keylist::Keylist;

let keylist = Keylist::from(vec![("a", 5), ("b", 2), ("c", 1)]);

let mut map = HashMap::new(); map.extend(vec![("a", 5), ("b", 2), ("c", 1)]);

let mapfromkeylist = HashMap::fromiter(keylist.clone()); let mut keylistfrommap = Keylist::fromiter(map.clone()); keylistfrommap.sort();

asserteq!(map, mapfromkeylist); asserteq!(keylist, keylistfrommap); ```

Arbitrary example: ```rust use keylist::Keylist;

let mut keylist = Keylist::new(); keylist.push(vec![3.12, 0.12], "a"); keylist.push(vec![0.1235, 34.121551], "c");

assert_eq!(keylist.get(&vec![0.1235, 34.121551]), Some(&"c"));

```

HashKeylist

There is also a more efficient implemetation, backend by a hashmap, therefore the keys should be hashable. ```rust use keylist::HashKeylist; use std::collections::HashMap; use std::iter::FromIterator;

let mut map = HashMap::new(); map.insert("one", 1); map.insert("two", 2); map.insert("three", 3); map.insert("four", 4);

let mut keylist = HashKeylist::fromiter(map); // sorts keys alphabetically keylist.sortby_key();

keylist.push("one", 11); keylist.push("five", 5); keylist.push("five", 1);

assert_eq!( vec![ (&"four", &4), (&"one", &1), (&"three", &3), (&"two", &2), (&"one", &11), (&"five", &5), (&"five", &1), ], keylist.iter().collect::>() );

keylist.insert(2, "five", 12);

assert_eq!( vec![ (&"four", &4), (&"one", &1), (&"five", &12), (&"three", &3), (&"two", &2), (&"one", &11), (&"five", &5), (&"five", &1), ], keylist.iter().collect::>() );

assert_eq!(Some(("five", 1)), keylist.pop());

assert_eq!( vec![ (&"four", &4), (&"one", &1), (&"five", &12), (&"three", &3), (&"two", &2), (&"one", &11), (&"five", &5), ], keylist.iter().collect::>() );

assert_eq!(("two", 2), keylist.remove(4));

assert_eq!( vec![ (&"four", &4), (&"one", &1), (&"five", &12), (&"three", &3), (&"one", &11), (&"five", &5), ], keylist.iter().collect::>() );

assert_eq!( vec![&"four", &"one", &"five", &"three", &"one", &"five"], keylist.keys().collect::>() );

assert_eq!( vec![&4, &1, &12, &3, &11, &5], keylist.values().collect::>() );

assert_eq!( vec![ ("four", 4), ("one", 1), ("five", 12), ("three", 3), ("one", 11), ("five", 5), ], Vec::from(keylist) ) ```

License: Unlicense