Struct bimap::btree::BiBTreeMap

source ·
pub struct BiBTreeMap<L, R> { /* private fields */ }
Expand description

A bimap backed by two BTreeMaps.

See the module-level documentation for more details and examples.

Implementations§

source§

impl<L, R> BiBTreeMap<L, R>
where L: Ord, R: Ord,

source

pub fn new() -> Self

Creates an empty BiBTreeMap.

§Examples
use bimap::BiBTreeMap;

let bimap = BiBTreeMap::<char, i32>::new();
source

pub fn len(&self) -> usize

Returns the number of left-right pairs in the bimap.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
bimap.insert('b', 2);
bimap.insert('c', 3);
assert_eq!(bimap.len(), 3);
source

pub fn is_empty(&self) -> bool

Returns true if the bimap contains no left-right pairs, and false otherwise.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
assert!(bimap.is_empty());
bimap.insert('a', 1);
assert!(!bimap.is_empty());
bimap.remove_by_right(&1);
assert!(bimap.is_empty());
source

pub fn clear(&mut self)

Removes all left-right pairs from the bimap.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
bimap.insert('b', 2);
bimap.insert('c', 3);
bimap.clear();
assert!(bimap.len() == 0);
source

pub fn iter(&self) -> Iter<'_, L, R>

Creates an iterator over the left-right pairs in the bimap in ascending order by left value.

The iterator element type is (&L, &R).

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
bimap.insert('b', 2);
bimap.insert('c', 3);

for (left, right) in bimap.iter() {
    println!("({}, {})", left, right);
}
source

pub fn left_values(&self) -> LeftValues<'_, L, R>

Creates an iterator over the left values in the bimap in ascending order.

The iterator element type is &L.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
bimap.insert('b', 2);
bimap.insert('c', 3);

for char_value in bimap.left_values() {
    println!("{}", char_value);
}
source

pub fn right_values(&self) -> RightValues<'_, L, R>

Creates an iterator over the right values in the bimap in ascending order.

The iterator element type is &R.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
bimap.insert('b', 2);
bimap.insert('c', 3);

for int_value in bimap.right_values() {
    println!("{}", int_value);
}
source

pub fn get_by_left<Q>(&self, left: &Q) -> Option<&R>
where L: Borrow<Q>, Q: Ord + ?Sized,

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 the ordering on the borrowed form must match the ordering on the left type.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
assert_eq!(bimap.get_by_left(&'a'), Some(&1));
assert_eq!(bimap.get_by_left(&'z'), None);
source

pub fn get_by_right<Q>(&self, right: &Q) -> Option<&L>
where R: Borrow<Q>, Q: Ord + ?Sized,

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 the ordering on the borrowed form must match the ordering on the right type.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
assert_eq!(bimap.get_by_right(&1), Some(&'a'));
assert_eq!(bimap.get_by_right(&2), None);
source

pub fn contains_left<Q>(&self, left: &Q) -> bool
where L: Borrow<Q>, Q: Ord + ?Sized,

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 the ordering on the borrowed form must match the ordering on the left type.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
assert!(bimap.contains_left(&'a'));
assert!(!bimap.contains_left(&'b'));
source

pub fn contains_right<Q>(&self, right: &Q) -> bool
where R: Borrow<Q>, Q: Ord + ?Sized,

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 the ordering on the borrowed form must match the ordering on the right type.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
assert!(bimap.contains_right(&1));
assert!(!bimap.contains_right(&2));
source

pub fn remove_by_left<Q>(&mut self, left: &Q) -> Option<(L, R)>
where L: Borrow<Q>, Q: Ord + ?Sized,

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 the ordering on the borrowed form must match the ordering on the left type.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::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);
source

pub fn remove_by_right<Q>(&mut self, right: &Q) -> Option<(L, R)>
where R: Borrow<Q>, Q: Ord + ?Sized,

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 the ordering on the borrowed form must match the ordering on the right type.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::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);
source

pub fn retain<F>(&mut self, f: F)
where F: FnMut(&L, &R) -> bool,

Retains only elements specified by a predicate

In other words, remove all left-right pairs (l, r) such that f(&l, &r) returns false.

§Example
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
bimap.insert('b', 2);
bimap.insert('c', 3);

bimap.retain(|&l, _| l != 'b');
assert_eq!(bimap.len(), 2);
assert_eq!(bimap.get_by_right(&1), Some(&'a'));
assert_eq!(bimap.get_by_right(&2), None);
assert_eq!(bimap.get_by_right(&3), Some(&'c'));
source

pub fn insert(&mut self, left: L, right: R) -> Overwritten<L, R>

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::{BiBTreeMap, Overwritten};

let mut bimap = BiBTreeMap::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}
source

pub fn insert_no_overwrite(&mut self, left: L, right: R) -> Result<(), (L, R)>

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::BiBTreeMap;

let mut bimap = BiBTreeMap::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)));
source

pub fn left_range<T, A>(&self, range: A) -> LeftRange<'_, L, R>
where L: Borrow<T>, A: RangeBounds<T>, T: Ord + ?Sized,

Creates an iterator over the left-right pairs lying within a range of left values in the bimap in ascending order by left.

The iterator element type is (&L, &R).

The range bounds may be any borrowed form of the bimap’s left type, but the ordering on the borrowed form must match the ordering on the left type.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
bimap.insert('b', 2);
bimap.insert('c', 3);
bimap.insert('d', 4);

for (left, right) in bimap.left_range('b'..'d') {
    println!("({}, {})", left, right);
}
source

pub fn right_range<T, A>(&self, range: A) -> RightRange<'_, L, R>
where R: Borrow<T>, A: RangeBounds<T>, T: Ord + ?Sized,

Creates an iterator over the left-right pairs lying within a range of right values in the bimap in ascending order by right.

The iterator element type is (&L, &R).

The range bounds may be any borrowed form of the bimap’s right type, but the ordering on the borrowed form must match the ordering on the right type.

§Examples
use bimap::BiBTreeMap;

let mut bimap = BiBTreeMap::new();
bimap.insert('a', 1);
bimap.insert('b', 2);
bimap.insert('c', 3);
bimap.insert('d', 4);

for (left, right) in bimap.right_range(2..4) {
    println!("({}, {})", left, right);
}

Trait Implementations§

source§

impl<L, R> Clone for BiBTreeMap<L, R>
where L: Clone + Ord, R: Clone + Ord,

source§

fn clone(&self) -> BiBTreeMap<L, R>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<L, R> Debug for BiBTreeMap<L, R>
where L: Debug + Ord, R: Debug + Ord,

source§

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

Formats the value using the given formatter. Read more
source§

impl<L, R> Default for BiBTreeMap<L, R>
where L: Ord, R: Ord,

source§

fn default() -> BiBTreeMap<L, R>

Returns the “default value” for a type. Read more
source§

impl<L, R> Extend<(L, R)> for BiBTreeMap<L, R>
where L: Ord, R: Ord,

source§

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

Extends a collection with the contents of an iterator. Read more
source§

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)
Extends a collection with exactly one element.
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)
Reserves capacity in a collection for the given number of additional elements. Read more
source§

impl<L, R> FromIterator<(L, R)> for BiBTreeMap<L, R>
where L: Ord, R: Ord,

source§

fn from_iter<I>(iter: I) -> BiBTreeMap<L, R>
where I: IntoIterator<Item = (L, R)>,

Creates a value from an iterator. Read more
source§

impl<L, R> Hash for BiBTreeMap<L, R>
where L: Hash, R: Hash,

source§

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

Feeds this value into the given Hasher. Read more
1.3.0 · source§

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

Feeds a slice of this type into the given Hasher. Read more
source§

impl<'a, L, R> IntoIterator for &'a BiBTreeMap<L, R>
where L: Ord, R: Ord,

§

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?
source§

fn into_iter(self) -> Iter<'a, L, R>

Creates an iterator from a value. Read more
source§

impl<L, R> IntoIterator for BiBTreeMap<L, R>
where L: Ord, R: Ord,

§

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?
source§

fn into_iter(self) -> IntoIter<L, R>

Creates an iterator from a value. Read more
source§

impl<L, R> Ord for BiBTreeMap<L, R>
where L: Ord, R: Ord,

source§

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

impl<L, R> PartialEq for BiBTreeMap<L, R>
where L: Ord, R: Ord,

source§

fn eq(&self, other: &Self) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<L, R> PartialOrd for BiBTreeMap<L, R>
where L: Ord, R: Ord,

source§

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more
source§

impl<L, R> Eq for BiBTreeMap<L, R>
where L: Ord, R: Ord,

source§

impl<L, R> Send for BiBTreeMap<L, R>
where L: Send, R: Send,

source§

impl<L, R> Sync for BiBTreeMap<L, R>
where L: Sync, R: Sync,

Auto Trait Implementations§

§

impl<L, R> Freeze for BiBTreeMap<L, R>

§

impl<L, R> RefUnwindSafe for BiBTreeMap<L, R>

§

impl<L, R> Unpin for BiBTreeMap<L, R>

§

impl<L, R> UnwindSafe for BiBTreeMap<L, R>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.