Struct bidir_map::BidirMap

pub struct BidirMap<Kv1: PartialEq, Kv2: PartialEq> {
    // some fields omitted
}

A bidirectional map.

Bidirectional maps allow for mapping from and to both types.

The interface is based on that of BTreeMap, except, that for all functions, where one would supply a key, there are two functions, each treating one of the types as keys (get() -> get_by_{first,second}()).

Performance: O(n), mostly.

Methods

impl<Kv1: PartialEq, Kv2: PartialEq> BidirMap<Kv1, Kv2>

fn new() -> Self

Create a new empty instance of BidirMap

fn clear(&mut self)

Clears the map, removing all entries.

Examples

use bidir_map::BidirMap;

let mut a = BidirMap::new();
a.insert(1, "a");
a.clear();
assert!(a.is_empty());

fn insert(&mut self, kv1: Kv1, kv2: Kv2) -> Option<(Kv1, Kv2)>

Inserts a K/V-K/V pair into the map.

If the map did not have this K/V-K/V pair present, None is returned.

If the map did have this K/V-K/V pair present, it's updated and the old K/V-K/V pair is returned.

fn iter<'s>(&'s self) -> Iter<'s, Kv1, Kv2>

Gets an iterator over the entries of the map.

Examples

use bidir_map::BidirMap;

let mut map = BidirMap::new();
map.insert(1, "a");
map.insert(2, "b");
map.insert(3, "c");

for kv in map.iter() {
    println!("{}: {}", kv.0, kv.1);
}

let first = map.iter().next().unwrap();
assert_eq!(*first, (1, "a"));

fn iter_mut<'s>(&'s mut self) -> IterMut<'s, Kv1, Kv2>

Gets a mutable iterator over the entries of the map.

Examples

use bidir_map::BidirMap;

let mut map = BidirMap::new();
map.insert("a", 1);
map.insert("b", 2);
map.insert("c", 3);

// add 10 to the value if the key isn't "a"
for kv in map.iter_mut() {
    if &kv.0 != &"a" {
        kv.1 += 10;
    }
}

fn first_col<'s>(&'s self) -> FirstColumn<'s, Kv1, Kv2>

Gets an iterator over the first K/V of the map.

Examples

use bidir_map::BidirMap;

let mut a = BidirMap::new();
a.insert(1, "a");
a.insert(2, "b");

let keys: Vec<_> = a.first_col().cloned().collect();
assert_eq!(keys, [1, 2]);

fn second_col<'s>(&'s self) -> SecondColumn<'s, Kv1, Kv2>

Gets an iterator over the second K/V of the map.

Examples

use bidir_map::BidirMap;

let mut a = BidirMap::new();
a.insert(1, "a");
a.insert(2, "b");

let keys: Vec<_> = a.second_col().cloned().collect();
assert_eq!(keys, ["a", "b"]);

fn len(&self) -> usize

Returns the number of elements in the map.

Examples

use bidir_map::BidirMap;

let mut a = BidirMap::new();
assert_eq!(a.len(), 0);
a.insert(1, "a");
assert_eq!(a.len(), 1);

fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

use bidir_map::BidirMap;

let mut a = BidirMap::new();
assert!(a.is_empty());
a.insert(1, "a");
assert!(!a.is_empty());

fn get_by_first<Q>(&self, key: &Q) -> Option<&Kv2> where Kv1: Borrow<Q>, Q: PartialEq<Kv1>

Returns a reference to the first K/V corresponding to the second K/V.

Examples

use bidir_map::BidirMap;

let mut map = BidirMap::new();
map.insert(1, "a");
assert_eq!(map.get_by_first(&1), Some(&"a"));
assert_eq!(map.get_by_first(&2), None);

fn get_by_second<Q>(&self, key: &Q) -> Option<&Kv1> where Kv2: Borrow<Q>, Q: PartialEq<Kv2>

Returns a reference to the first K/V corresponding to the second K/V.

Examples

use bidir_map::BidirMap;

let mut map = BidirMap::new();
map.insert(1, "a");
assert_eq!(map.get_by_second(&"a"), Some(&1));
assert_eq!(map.get_by_second(&"b"), None);

fn contains_first_key<Q>(&self, key: &Q) -> bool where Kv1: Borrow<Q>, Q: PartialEq<Kv1>

Check if the map contains the first K/V

Examples

use bidir_map::BidirMap;

let mut map = BidirMap::new();
map.insert(1, "a");
assert_eq!(map.contains_first_key(&1), true);
assert_eq!(map.contains_first_key(&2), false);

fn contains_second_key<Q>(&self, key: &Q) -> bool where Kv2: Borrow<Q>, Q: PartialEq<Kv2>

Check if the map contains the second K/V

Examples

use bidir_map::BidirMap;

let mut map = BidirMap::new();
map.insert(1, "a");
assert_eq!(map.contains_second_key(&"a"), true);
assert_eq!(map.contains_second_key(&"b"), false);

fn get_mut_by_first<Q>(&mut self, key: &Q) -> Option<&mut Kv2> where Kv1: Borrow<Q>, Q: PartialEq<Kv1>

Returns a mutable reference to the second K/V corresponding to the first K/V.

Examples

use bidir_map::BidirMap;

let mut map = BidirMap::new();
map.insert(1, "a");
if let Some(x) = map.get_mut_by_first(&1) {
    *x = "b";
}
assert_eq!(map.get_by_first(&1), Some(&"b"));

fn get_mut_by_second<Q>(&mut self, key: &Q) -> Option<&mut Kv1> where Kv2: Borrow<Q>, Q: PartialEq<Kv2>

Returns a mutable reference to the first K/V corresponding to the second K/V.

Examples

use bidir_map::BidirMap;

let mut map = BidirMap::new();
map.insert(1, "a");
if let Some(x) = map.get_mut_by_second(&"a") {
    *x = 2;
}
assert_eq!(map.get_by_second(&"a"), Some(&2));

fn remove_by_first<Q>(&mut self, key: &Q) -> Option<(Kv1, Kv2)> where Kv1: Borrow<Q>, Q: PartialEq<Kv1>

Removes the pair corresponding to the first K/V from the map, returning it if the key was previously in the map.

Examples

use bidir_map::BidirMap;

let mut map = BidirMap::new();
map.insert(1, "a");
assert_eq!(map.remove_by_first(&1), Some((1, "a")));
assert_eq!(map.remove_by_first(&1), None);

fn remove_by_second<Q>(&mut self, key: &Q) -> Option<(Kv1, Kv2)> where Kv2: Borrow<Q>, Q: PartialEq<Kv2>

Removes the pair corresponding to the first K/V from the map, returning it if the key was previously in the map.

Examples

use bidir_map::BidirMap;

let mut map = BidirMap::new();
map.insert(1, "a");
assert_eq!(map.remove_by_second(&"a"), Some((1, "a")));
assert_eq!(map.remove_by_second(&"b"), None);

Trait Implementations

impl<Kv1: Eq + PartialEq, Kv2: Eq + PartialEq> Eq for BidirMap<Kv1, Kv2>

impl<Kv1: PartialEq + PartialEq, Kv2: PartialEq + PartialEq> PartialEq for BidirMap<Kv1, Kv2>

fn eq(&self, __arg_0: &BidirMap<Kv1, Kv2>) -> bool

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

fn ne(&self, __arg_0: &BidirMap<Kv1, Kv2>) -> bool

This method tests for !=.

impl<Kv1: Hash + PartialEq, Kv2: Hash + PartialEq> Hash for BidirMap<Kv1, Kv2>

fn hash<__HKv1Kv2: Hasher>(&self, __arg_0: &mut __HKv1Kv2)

Feeds this value into the state given, updating the hasher as necessary.

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher

Feeds a slice of this type into the state provided.

impl<Kv1: Debug + PartialEq, Kv2: Debug + PartialEq> Debug for BidirMap<Kv1, Kv2>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<Kv1: Clone + PartialEq, Kv2: Clone + PartialEq> Clone for BidirMap<Kv1, Kv2>

fn clone(&self) -> BidirMap<Kv1, Kv2>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Kv1: PartialEq, Kv2: PartialEq> IntoIterator for BidirMap<Kv1, Kv2>

type Item = (Kv1, Kv2)

The type of the elements being iterated over.

type IntoIter = IntoIter<Self::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<Kv1: PartialEq, Kv2: PartialEq> FromIterator<(Kv1, Kv2)> for BidirMap<Kv1, Kv2>

fn from_iter<T: IntoIterator<Item=(Kv1, Kv2)>>(iter: T) -> Self

Creates a value from an iterator.

impl<Kv1: PartialEq, Kv2: PartialEq> Extend<(Kv1, Kv2)> for BidirMap<Kv1, Kv2>

fn extend<T: IntoIterator<Item=(Kv1, Kv2)>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.