Struct bidir_map::BidirMap
[−]
[src]
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>
[src]
fn new() -> Self
[src]
Create a new empty instance of BidirMap
fn with_capacity(capacity: usize) -> Self
[src]
Create a new empty instance of BidirMap
with the specified capacity.
It will be able to hold at least capacity
elements without reallocating.
fn clear(&mut self)
[src]
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)>
[src]
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(&self) -> Iter<Kv1, Kv2>
[src]
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(&mut self) -> IterMut<Kv1, Kv2>
[src]
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(&self) -> FirstColumn<Kv1, Kv2>
[src]
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(&self) -> SecondColumn<Kv1, Kv2>
[src]
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
[src]
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
[src]
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: ?Sized>(&self, key: &Q) -> Option<&Kv2> where
Kv1: Borrow<Q>,
Q: PartialEq<Kv1>,
[src]
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);
fn get_by_second<Q: ?Sized>(&self, key: &Q) -> Option<&Kv1> where
Kv2: Borrow<Q>,
Q: PartialEq<Kv2>,
[src]
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: ?Sized>(&self, key: &Q) -> bool where
Kv1: Borrow<Q>,
Q: PartialEq<Kv1>,
[src]
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: ?Sized>(&self, key: &Q) -> bool where
Kv2: Borrow<Q>,
Q: PartialEq<Kv2>,
[src]
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: ?Sized>(&mut self, key: &Q) -> Option<&mut Kv2> where
Kv1: Borrow<Q>,
Q: PartialEq<Kv1>,
[src]
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: ?Sized>(&mut self, key: &Q) -> Option<&mut Kv1> where
Kv2: Borrow<Q>,
Q: PartialEq<Kv2>,
[src]
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: ?Sized>(&mut self, key: &Q) -> Option<(Kv1, Kv2)> where
Kv1: Borrow<Q>,
Q: PartialEq<Kv1>,
[src]
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: ?Sized>(&mut self, key: &Q) -> Option<(Kv1, Kv2)> where
Kv2: Borrow<Q>,
Q: PartialEq<Kv2>,
[src]
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: Default + PartialEq, Kv2: Default + PartialEq> Default for BidirMap<Kv1, Kv2>
[src]
impl<Kv1: Clone + PartialEq, Kv2: Clone + PartialEq> Clone for BidirMap<Kv1, Kv2>
[src]
fn clone(&self) -> BidirMap<Kv1, Kv2>
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<Kv1: Debug + PartialEq, Kv2: Debug + PartialEq> Debug for BidirMap<Kv1, Kv2>
[src]
impl<Kv1: Hash + PartialEq, Kv2: Hash + PartialEq> Hash for BidirMap<Kv1, Kv2>
[src]
fn hash<__HKv1Kv2: Hasher>(&self, __arg_0: &mut __HKv1Kv2)
[src]
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<Kv1: PartialEq + PartialEq, Kv2: PartialEq + PartialEq> PartialEq for BidirMap<Kv1, Kv2>
[src]
fn eq(&self, __arg_0: &BidirMap<Kv1, Kv2>) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, __arg_0: &BidirMap<Kv1, Kv2>) -> bool
[src]
This method tests for !=
.
impl<Kv1: Eq + PartialEq, Kv2: Eq + PartialEq> Eq for BidirMap<Kv1, Kv2>
[src]
impl<Kv1: PartialEq, Kv2: PartialEq> IntoIterator for BidirMap<Kv1, Kv2>
[src]
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
[src]
Creates an iterator from a value. Read more
impl<Kv1: PartialEq, Kv2: PartialEq> FromIterator<(Kv1, Kv2)> for BidirMap<Kv1, Kv2>
[src]
fn from_iter<T: IntoIterator<Item = (Kv1, Kv2)>>(iter: T) -> Self
[src]
Creates a value from an iterator. Read more
impl<Kv1: PartialEq, Kv2: PartialEq> Extend<(Kv1, Kv2)> for BidirMap<Kv1, Kv2>
[src]
fn extend<T: IntoIterator<Item = (Kv1, Kv2)>>(&mut self, iter: T)
[src]
Extends a collection with the contents of an iterator. Read more
impl<'q, Kv1: PartialEq, Kv2: PartialEq, Q: ?Sized + 'q> Index<ByFirst<'q, Q>> for BidirMap<Kv1, Kv2> where
Kv1: Borrow<Q>,
Q: PartialEq<Kv1>,
[src]
Kv1: Borrow<Q>,
Q: PartialEq<Kv1>,
type Output = Kv2
The returned type after indexing.
fn index(&self, key: ByFirst<Q>) -> &Self::Output
[src]
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>,
[src]
Kv1: Borrow<Q>,
Q: PartialEq<Kv1>,
type Output = Kv2
The returned type after indexing.
fn index(&self, key: &ByFirst<Q>) -> &Self::Output
[src]
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>,
[src]
Kv2: Borrow<Q>,
Q: PartialEq<Kv2>,
type Output = Kv1
The returned type after indexing.
fn index(&self, key: BySecond<Q>) -> &Self::Output
[src]
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>,
[src]
Kv2: Borrow<Q>,
Q: PartialEq<Kv2>,