[−][src]Struct bimap::hash::BiHashMap
A bimap backed by two HashMap
s.
See the module-level documentation for more details and examples.
Implementations
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);
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); }
pub fn left_values(&self) -> LeftValues<'_, L, R>ⓘNotable traits for LeftValues<'a, L, R>
impl<'a, L, R> Iterator for LeftValues<'a, L, R> type Item = &'a L;
[src]
Notable traits for LeftValues<'a, L, R>
impl<'a, L, R> Iterator for LeftValues<'a, L, R> type Item = &'a L;
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); }
pub fn right_values(&self) -> RightValues<'_, L, R>ⓘNotable traits for RightValues<'a, L, R>
impl<'a, L, R> Iterator for RightValues<'a, L, R> type Item = &'a R;
[src]
Notable traits for RightValues<'a, L, R>
impl<'a, L, R> Iterator for RightValues<'a, L, R> type Item = &'a R;
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<Q: ?Sized>(&self, left: &Q) -> Option<&R> where
L: Borrow<Q>,
Q: Eq + Hash,
[src]
L: Borrow<Q>,
Q: Eq + Hash,
Returns a reference to the right value corresponding to the given left value.
The input may be any borrowed form of the bimap's left type, but Eq
and Hash
on the borrowed form must match those for the left type.
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<Q: ?Sized>(&self, right: &Q) -> Option<&L> where
R: Borrow<Q>,
Q: Eq + Hash,
[src]
R: Borrow<Q>,
Q: Eq + Hash,
Returns a reference to the left value corresponding to the given right value.
The input may be any borrowed form of the bimap's right type, but Eq
and Hash
on the borrowed form must match those for the right type.
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<Q: ?Sized>(&self, left: &Q) -> bool where
L: Borrow<Q>,
Q: Eq + Hash,
[src]
L: Borrow<Q>,
Q: Eq + Hash,
Returns true
if the bimap contains the given left value and false
otherwise.
The input may be any borrowed form of the bimap's left type, but Eq
and Hash
on the borrowed form must match those for the left type.
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<Q: ?Sized>(&self, right: &Q) -> bool where
R: Borrow<Q>,
Q: Eq + Hash,
[src]
R: Borrow<Q>,
Q: Eq + Hash,
Returns true
if the map contains the given right value and false
otherwise.
The input may be any borrowed form of the bimap's right type, but Eq
and Hash
on the borrowed form must match those for the right type.
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<Q: ?Sized>(&mut self, left: &Q) -> Option<(L, R)> where
L: Borrow<Q>,
Q: Eq + Hash,
[src]
L: Borrow<Q>,
Q: Eq + Hash,
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.
The input may be any borrowed form of the bimap's left type, but Eq
and Hash
on the borrowed form must match those for the left type.
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<Q: ?Sized>(&mut self, right: &Q) -> Option<(L, R)> where
R: Borrow<Q>,
Q: Eq + Hash,
[src]
R: Borrow<Q>,
Q: Eq + Hash,
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.
The input may be any borrowed form of the bimap's right type, but Eq
and Hash
on the borrowed form must match those for the right type.
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,
pub fn clone(&self) -> BiHashMap<L, R, LS, RS>
[src]
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<L, R, LS, RS> Debug for BiHashMap<L, R, LS, RS> where
L: Debug,
R: Debug,
[src]
L: Debug,
R: Debug,
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<'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
pub fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Self, D::Error>
[src]
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> Extend<(L, R)> 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,
pub fn extend<T: IntoIterator<Item = (L, R)>>(&mut self, iter: T)
[src]
pub fn extend_one(&mut self, item: A)
[src]
pub fn extend_reserve(&mut self, additional: usize)
[src]
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<'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?
pub 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?
pub 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,
pub fn eq(&self, other: &Self) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
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> 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<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,
Auto Trait Implementations
impl<L, R, LS = RandomState, RS = RandomState> !RefUnwindSafe for BiHashMap<L, R, LS, RS>
[src]
impl<L, R, LS, RS> Unpin for BiHashMap<L, R, LS, RS> where
LS: Unpin,
RS: Unpin,
[src]
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,
[src]
L: RefUnwindSafe,
LS: UnwindSafe,
R: RefUnwindSafe,
RS: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> DeserializeOwned for T where
T: for<'de> Deserialize<'de>,
[src]
T: for<'de> Deserialize<'de>,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
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.
pub 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>,