[−][src]Struct bimap::hash::BiHashMap
A bimap backed by two HashMap
s.
See the module-level documentation for more details and examples.
Methods
impl<L, R> BiHashMap<L, R, RandomState, RandomState> where
L: Eq + Hash,
R: Eq + Hash,
[src]
L: Eq + Hash,
R: Eq + Hash,
pub fn new() -> Self
[src]
Creates an empty BiHashMap
.
Examples
use bimap::BiHashMap; let bimap = BiHashMap::<char, i32>::new();
pub fn with_capacity(capacity: usize) -> Self
[src]
Creates a new empty BiHashMap
with the given capacity.
Examples
use bimap::BiHashMap; let bimap = BiHashMap::<char, i32>::with_capacity(10); assert!(bimap.capacity() >= 10);
impl<L, R, LS, RS> BiHashMap<L, R, LS, RS> where
L: Eq + Hash,
R: Eq + Hash,
[src]
L: Eq + Hash,
R: Eq + Hash,
pub fn len(&self) -> usize
[src]
Returns the number of left-right pairs in the bimap.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); bimap.insert('b', 2); bimap.insert('c', 3); assert_eq!(bimap.len(), 3);
pub fn is_empty(&self) -> bool
[src]
Returns true
if the bimap contains no left-right pairs, and false
otherwise.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); assert!(bimap.is_empty()); bimap.insert('a', 1); assert!(!bimap.is_empty()); bimap.remove_by_right(&1); assert!(bimap.is_empty());
pub fn capacity(&self) -> usize
[src]
Returns a lower bound on the number of left-right pairs the BiHashMap
can store without
reallocating memory.
Examples
use bimap::BiHashMap; let bimap = BiHashMap::<char, i32>::with_capacity(10); assert!(bimap.capacity() >= 10);
pub fn clear(&mut self)
[src]
Removes all left-right pairs from the bimap.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); bimap.insert('b', 2); bimap.insert('c', 3); bimap.clear(); assert!(bimap.len() == 0);
ⓘImportant traits for Iter<'a, L, R>pub fn iter(&self) -> Iter<L, R>
[src]
Creates an iterator over the left-right pairs in the bimap in arbitrary order.
The iterator element type is (&L, &R)
.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); bimap.insert('b', 2); bimap.insert('c', 3); for (left, right) in bimap.iter() { println!("({}, {})", left, right); }
ⓘImportant traits for LeftValues<'a, L, R>pub fn left_values(&self) -> LeftValues<L, R>
[src]
Creates an iterator over the left values in the bimap in arbitrary order.
The iterator element type is &L
.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); bimap.insert('b', 2); bimap.insert('c', 3); for char_value in bimap.left_values() { println!("{}", char_value); }
ⓘImportant traits for RightValues<'a, L, R>pub fn right_values(&self) -> RightValues<L, R>
[src]
Creates an iterator over the right values in the bimap in arbitrary order.
The iterator element type is &R
.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); bimap.insert('b', 2); bimap.insert('c', 3); for int_value in bimap.right_values() { println!("{}", int_value); }
impl<L, R, LS, RS> BiHashMap<L, R, LS, RS> where
L: Eq + Hash,
R: Eq + Hash,
LS: BuildHasher,
RS: BuildHasher,
[src]
L: Eq + Hash,
R: Eq + Hash,
LS: BuildHasher,
RS: BuildHasher,
pub fn with_hashers(hash_builder_left: LS, hash_builder_right: RS) -> Self
[src]
Creates a new empty BiHashMap
using hash_builder_left
to hash left values and
hash_builder_right
to hash right values.
Examples
use std::collections::hash_map::RandomState; use bimap::BiHashMap; let s_left = RandomState::new(); let s_right = RandomState::new(); let mut bimap = BiHashMap::<char, i32>::with_hashers(s_left, s_right); bimap.insert('a', 42);
pub fn with_capacity_and_hashers(
capacity: usize,
hash_builder_left: LS,
hash_builder_right: RS
) -> Self
[src]
capacity: usize,
hash_builder_left: LS,
hash_builder_right: RS
) -> Self
Creates a new empty BiHashMap
with the given capacity, using hash_builder_left
to hash left values and hash_builder_right
to hash right values.
Examples
use std::collections::hash_map::RandomState; use bimap::BiHashMap; let s_left = RandomState::new(); let s_right = RandomState::new(); let bimap = BiHashMap::<char, i32>::with_capacity_and_hashers(10, s_left, s_right); assert!(bimap.capacity() >= 10);
pub fn get_by_left(&self, left: &L) -> Option<&R>
[src]
Returns a reference to the right value corresponding to the given left value.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); assert_eq!(bimap.get_by_left(&'a'), Some(&1)); assert_eq!(bimap.get_by_left(&'z'), None);
pub fn get_by_right(&self, right: &R) -> Option<&L>
[src]
Returns a reference to the left value corresponding to the given right value.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); assert_eq!(bimap.get_by_right(&1), Some(&'a')); assert_eq!(bimap.get_by_right(&2), None);
pub fn contains_left(&self, left: &L) -> bool
[src]
Returns true
if the bimap contains the given left value and false
otherwise.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); assert!(bimap.contains_left(&'a')); assert!(!bimap.contains_left(&'b'));
pub fn contains_right(&self, right: &R) -> bool
[src]
Returns true
if the map contains the given right value and false
otherwise.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); assert!(bimap.contains_right(&1)); assert!(!bimap.contains_right(&2));
pub fn remove_by_left(&mut self, left: &L) -> Option<(L, R)>
[src]
Removes the left-right pair corresponding to the given left value.
Returns the previous left-right pair if the map contained the left value and None
otherwise.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); bimap.insert('b', 2); bimap.insert('c', 3); assert_eq!(bimap.remove_by_left(&'b'), Some(('b', 2))); assert_eq!(bimap.remove_by_left(&'b'), None);
pub fn remove_by_right(&mut self, right: &R) -> Option<(L, R)>
[src]
Removes the left-right pair corresponding to the given right value.
Returns the previous left-right pair if the map contained the right value and None
otherwise.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); bimap.insert('b', 2); bimap.insert('c', 3); assert_eq!(bimap.remove_by_right(&2), Some(('b', 2))); assert_eq!(bimap.remove_by_right(&2), None);
pub fn insert(&mut self, left: L, right: R) -> Overwritten<L, R>
[src]
Inserts the given left-right pair into the bimap.
Returns an enum Overwritten
representing any left-right pairs that were overwritten by
the call to insert
. The example below details all possible enum variants that can be
returned.
Warnings
Somewhat paradoxically, calling insert()
can actually reduce the size of the bimap! This
is because of the invariant that each left value maps to exactly one right value and vice
versa.
Examples
use bimap::{BiHashMap, Overwritten}; let mut bimap = BiHashMap::new(); assert_eq!(bimap.len(), 0); // {} // no values are overwritten. assert_eq!(bimap.insert('a', 1), Overwritten::Neither); assert_eq!(bimap.len(), 1); // {'a' <> 1} // no values are overwritten. assert_eq!(bimap.insert('b', 2), Overwritten::Neither); assert_eq!(bimap.len(), 2); // {'a' <> 1, 'b' <> 2} // ('a', 1) already exists, so inserting ('a', 4) overwrites 'a', the left value. // the previous left-right pair ('a', 1) is returned. assert_eq!(bimap.insert('a', 4), Overwritten::Left('a', 1)); assert_eq!(bimap.len(), 2); // {'a' <> 4, 'b' <> 2} // ('b', 2) already exists, so inserting ('c', 2) overwrites 2, the right value. // the previous left-right pair ('b', 2) is returned. assert_eq!(bimap.insert('c', 2), Overwritten::Right('b', 2)); assert_eq!(bimap.len(), 2); // {'a' <> 1, 'c' <> 2} // both ('a', 4) and ('c', 2) already exist, so inserting ('a', 2) overwrites both. // ('a', 4) has the overwritten left value ('a'), so it's the first tuple returned. // ('c', 2) has the overwritten right value (2), so it's the second tuple returned. assert_eq!(bimap.insert('a', 2), Overwritten::Both(('a', 4), ('c', 2))); assert_eq!(bimap.len(), 1); // {'a' <> 2} // bimap is smaller than before! // ('a', 2) already exists, so inserting ('a', 2) overwrites the pair. // the previous left-right pair ('a', 2) is returned. assert_eq!(bimap.insert('a', 2), Overwritten::Pair('a', 2)); assert_eq!(bimap.len(), 1); // {'a' <> 2}
pub fn insert_no_overwrite(&mut self, left: L, right: R) -> Result<(), (L, R)>
[src]
Inserts the given left-right pair into the bimap without overwriting any existing values.
Returns Ok(())
if the pair was successfully inserted into the bimap. If either value
exists in the map, Err((left, right)
is returned with the attempted left-right pair and
the map is unchanged.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); assert_eq!(bimap.insert_no_overwrite('a', 1), Ok(())); assert_eq!(bimap.insert_no_overwrite('b', 2), Ok(())); assert_eq!(bimap.insert_no_overwrite('a', 3), Err(('a', 3))); assert_eq!(bimap.insert_no_overwrite('c', 2), Err(('c', 2)));
pub fn retain<F>(&mut self, f: F) where
F: FnMut(&L, &R) -> bool,
[src]
F: FnMut(&L, &R) -> bool,
Retains only the elements specified by the predicate.
In other words, remove all left-right pairs (l, r)
such that f(&l, &r)
returns false
.
Examples
use bimap::BiHashMap; let mut bimap = BiHashMap::new(); bimap.insert('a', 1); bimap.insert('b', 2); bimap.insert('c', 3); bimap.retain(|&l, &r| r >= 2); assert_eq!(bimap.len(), 2); assert_eq!(bimap.get_by_left(&'b'), Some(&2)); assert_eq!(bimap.get_by_left(&'c'), Some(&3)); assert_eq!(bimap.get_by_left(&'a'), None);
Trait Implementations
impl<L, R, LS, RS> Clone for BiHashMap<L, R, LS, RS> where
L: Clone + Eq + Hash,
R: Clone + Eq + Hash,
LS: BuildHasher + Clone,
RS: BuildHasher + Clone,
[src]
L: Clone + Eq + Hash,
R: Clone + Eq + Hash,
LS: BuildHasher + Clone,
RS: BuildHasher + Clone,
fn clone(&self) -> BiHashMap<L, R, LS, RS>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<L, R, LS, RS> Default for BiHashMap<L, R, LS, RS> where
L: Eq + Hash,
R: Eq + Hash,
LS: BuildHasher + Default,
RS: BuildHasher + Default,
[src]
L: Eq + Hash,
R: Eq + Hash,
LS: BuildHasher + Default,
RS: BuildHasher + Default,
impl<'a, L, R, LS, RS> IntoIterator for &'a BiHashMap<L, R, LS, RS> where
L: Eq + Hash,
R: Eq + Hash,
[src]
L: Eq + Hash,
R: Eq + Hash,
type Item = (&'a L, &'a R)
The type of the elements being iterated over.
type IntoIter = Iter<'a, L, R>
Which kind of iterator are we turning this into?
ⓘImportant traits for Iter<'a, L, R>fn into_iter(self) -> Iter<'a, L, R>
[src]
impl<L, R, LS, RS> IntoIterator for BiHashMap<L, R, LS, RS> where
L: Eq + Hash,
R: Eq + Hash,
[src]
L: Eq + Hash,
R: Eq + Hash,
type Item = (L, R)
The type of the elements being iterated over.
type IntoIter = IntoIter<L, R>
Which kind of iterator are we turning this into?
ⓘImportant traits for IntoIter<L, R>fn into_iter(self) -> IntoIter<L, R>
[src]
impl<L, R, LS, RS> PartialEq<BiHashMap<L, R, LS, RS>> for BiHashMap<L, R, LS, RS> where
L: Eq + Hash,
R: Eq + Hash,
LS: BuildHasher,
RS: BuildHasher,
[src]
L: Eq + Hash,
R: Eq + Hash,
LS: BuildHasher,
RS: BuildHasher,
fn eq(&self, other: &Self) -> bool
[src]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<L, R, LS, RS> Sync for BiHashMap<L, R, LS, RS> where
L: Sync,
R: Sync,
LS: Sync,
RS: Sync,
[src]
L: Sync,
R: Sync,
LS: Sync,
RS: Sync,
impl<L, R, LS, RS> Send for BiHashMap<L, R, LS, RS> where
L: Send,
R: Send,
LS: Send,
RS: Send,
[src]
L: Send,
R: Send,
LS: Send,
RS: Send,
impl<L, R, LS, RS> Eq for BiHashMap<L, R, LS, RS> where
L: Eq + Hash,
R: Eq + Hash,
LS: BuildHasher,
RS: BuildHasher,
[src]
L: Eq + Hash,
R: Eq + Hash,
LS: BuildHasher,
RS: BuildHasher,
impl<L, R, LS, RS> Debug for BiHashMap<L, R, LS, RS> where
L: Debug + Eq + Hash,
R: Debug + Eq + Hash,
[src]
L: Debug + Eq + Hash,
R: Debug + Eq + Hash,
impl<L, R, LS, RS> FromIterator<(L, R)> for BiHashMap<L, R, LS, RS> where
L: Eq + Hash,
R: Eq + Hash,
LS: BuildHasher + Default,
RS: BuildHasher + Default,
[src]
L: Eq + Hash,
R: Eq + Hash,
LS: BuildHasher + Default,
RS: BuildHasher + Default,
impl<L, R> Serialize for BiHashMap<L, R> where
L: Serialize + Eq + Hash,
R: Serialize + Eq + Hash,
[src]
L: Serialize + Eq + Hash,
R: Serialize + Eq + Hash,
Serializer for BiHashMap
impl<'de, L, R> Deserialize<'de> for BiHashMap<L, R> where
L: Deserialize<'de> + Eq + Hash,
R: Deserialize<'de> + Eq + Hash,
[src]
L: Deserialize<'de> + Eq + Hash,
R: Deserialize<'de> + Eq + Hash,
Deserializer for BiHashMap
fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Self, D::Error>
[src]
Auto Trait Implementations
impl<L, R, LS, RS> Unpin for BiHashMap<L, R, LS, RS> where
LS: Unpin,
RS: Unpin,
LS: Unpin,
RS: Unpin,
impl<L, R, LS, RS> UnwindSafe for BiHashMap<L, R, LS, RS> where
L: RefUnwindSafe,
LS: UnwindSafe,
R: RefUnwindSafe,
RS: UnwindSafe,
L: RefUnwindSafe,
LS: UnwindSafe,
R: RefUnwindSafe,
RS: UnwindSafe,
impl<L, R, LS = RandomState, RS = RandomState> !RefUnwindSafe for BiHashMap<L, R, LS, RS>
Blanket Implementations
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> From<T> for T
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> DeserializeOwned for T where
T: Deserialize<'de>,
[src]
T: Deserialize<'de>,