Struct bidir_map::BidirMap

pub struct BidirMap<Kv1: PartialEq, Kv2: PartialEq> { /* 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>

pub fn new() -> Self

Create a new empty instance of BidirMap

pub fn with_capacity(capacity: usize) -> Self

Create a new empty instance of BidirMap with the specified capacity.

It will be able to hold at least capacity elements without reallocating.

pub 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());

pub 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.

Important traits for Iter<'a, Kv1, Kv2>

impl<'a, Kv1, Kv2> Iterator for Iter<'a, Kv1, Kv2> type Item = (&'a Kv1, &'a Kv2);

pub fn iter(&self) -> Iter<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"));

Important traits for IterMut<'a, Kv1, Kv2>

impl<'a, Kv1, Kv2> Iterator for IterMut<'a, Kv1, Kv2> type Item = (&'a mut Kv1, &'a mut Kv2);

pub fn iter_mut(&mut self) -> IterMut<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;
    }
}

Important traits for FirstColumn<'a, Kv1, Kv2>

impl<'a, Kv1, Kv2> Iterator for FirstColumn<'a, Kv1, Kv2> type Item = &'a Kv1;

pub fn first_col(&self) -> FirstColumn<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]);

Important traits for SecondColumn<'a, Kv1, Kv2>

impl<'a, Kv1, Kv2> Iterator for SecondColumn<'a, Kv1, Kv2> type Item = &'a Kv2;

pub fn second_col(&self) -> SecondColumn<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"]);

pub 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);

pub 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());

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

Returns a 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");
assert_eq!(map.get_by_first(&1), Some(&"a"));
assert_eq!(map.get_by_first(&2), None);

pub fn get_by_second<Q: ?Sized>(&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);

pub fn contains_first_key<Q: ?Sized>(&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);

pub fn contains_second_key<Q: ?Sized>(&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);

pub fn get_mut_by_first<Q: ?Sized>(&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"));

pub fn get_mut_by_second<Q: ?Sized>(&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));

pub fn remove_by_first<Q: ?Sized>(&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);

pub fn remove_by_second<Q: ?Sized>(&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: 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> 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.

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

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

fn default() -> BidirMap<Kv1, Kv2>

Returns the "default value" for a type.

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

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

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

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

This method tests for !=.

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: Hash + PartialEq, Kv2: Hash + PartialEq> Hash for BidirMap<Kv1, Kv2>

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

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

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

Formats the value using the given formatter.

impl<'q, Kv1: PartialEq, Kv2: PartialEq, Q: ?Sized + 'q> Index<ByFirst<'q, Q>> for BidirMap<Kv1, Kv2> where     Kv1: Borrow<Q>,     Q: PartialEq<Kv1>,

type Output = Kv2

The returned type after indexing.

fn index(&self, key: ByFirst<Q>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, 'q, Kv1: PartialEq, Kv2: PartialEq, Q: ?Sized + 'q> Index<&'a ByFirst<'q, Q>> for BidirMap<Kv1, Kv2> where     Kv1: Borrow<Q>,     Q: PartialEq<Kv1>,

type Output = Kv2

The returned type after indexing.

fn index(&self, key: &ByFirst<Q>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'q, Kv1: PartialEq, Kv2: PartialEq, Q: ?Sized + 'q> Index<BySecond<'q, Q>> for BidirMap<Kv1, Kv2> where     Kv2: Borrow<Q>,     Q: PartialEq<Kv2>,

type Output = Kv1

The returned type after indexing.

fn index(&self, key: BySecond<Q>) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, 'q, Kv1: PartialEq, Kv2: PartialEq, Q: ?Sized + 'q> Index<&'a BySecond<'q, Q>> for BidirMap<Kv1, Kv2> where     Kv2: Borrow<Q>,     Q: PartialEq<Kv2>,

type Output = Kv1

The returned type after indexing.

fn index(&self, key: &BySecond<Q>) -> &Self::Output

Performs the indexing (container[index]) operation.

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.