Struct BiMap

pub struct BiMap<L, R> { /* private fields */ }

A bidirectional map.

Example

use rust_dsa::BiMap;

// First, we create a new map.
let mut map = BiMap::new();

// Then we insert values.
map.insert(1, 'a');
map.insert(2, 'b');
map.insert(3, 'c');

assert_eq!(map.len(), 3);
assert!(map.contains_left(&1));
assert!(map.contains_right(&'c'));

// We can get values.
assert_eq!(map.get_by_left(&1), Some(&'a'));
assert_eq!(map.get_by_left(&2), Some(&'b'));
assert_eq!(map.get_by_right(&'c'), Some(&3));
assert_eq!(map.get_by_left(&99), None);
assert_eq!(map.get_by_right(&'z'), None);

use rust_dsa::Removed;

// Inserting returns the old elements.
let removed = map.insert(3, 'z');
assert_eq!(removed, Removed::Single((3, 'c')));

// (1, 'z') touches two pairs ((1, 'a') and (3, 'z'))
let removed = map.insert(1, 'z');
assert_eq!(removed, Removed::Double((1, 'a'), (3, 'z')));

// (5, 'm') touches nothing
let removed = map.insert(5, 'm');
assert_eq!(removed, Removed::Nothing);

assert_eq!(map.len(), 3);

// We can also remove items.
assert_eq!(map.remove_by_left(&1), Some((1, 'z')));
assert_eq!(map.remove_by_right(&'b'), Some((2, 'b')));
assert_eq!(map.remove_by_right(&'m'), Some((5, 'm')));
assert_eq!(map.remove_by_left(&99), None);

assert!(map.is_empty());

Implementations

impl<L, R> BiMap<L, R>

pub fn new() -> BiMap<L, R>

Creates a new map.

pub fn with_capacity(capacity: usize) -> BiMap<L, R>

Creates a new map with the given capacity.

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

where L: Hash + Eq, R: Hash + Eq,

Inserts a pair into the map. Returns the removed items.

Example

use rust_dsa::{BiMap, Removed};

let mut map = BiMap::new();

let removed = map.insert(1, 2);
assert_eq!(removed, Removed::Nothing);
let removed = map.insert(3, 4);
assert_eq!(removed, Removed::Nothing);

let removed = map.insert(1, 3);
assert_eq!(removed, Removed::Single((1, 2)));

let removed = map.insert(1, 4);
assert_eq!(removed, Removed::Double((1, 3), (3, 4)));

let removed = map.insert(1, 4);
assert_eq!(removed, Removed::Single((1, 4)));

pub fn get_by_left(&self, left: &L) -> Option<&R>

where L: Hash + Eq,

Returns a reference to the right value based on the left value.

Example

use rust_dsa::BiMap;

let map = BiMap::from([(1, 'a'), (2, 'b')]);

assert_eq!(map.get_by_left(&1), Some(&'a'));
assert_eq!(map.get_by_left(&2), Some(&'b'));
assert_eq!(map.get_by_left(&3), None);

pub fn get_by_right(&self, right: &R) -> Option<&L>

where R: Hash + Eq,

Returns a reference to the left value based on the right value.

Example

use rust_dsa::BiMap;

let map = BiMap::from([(1, 'a'), (2, 'b')]);

assert_eq!(map.get_by_right(&'a'), Some(&1));
assert_eq!(map.get_by_right(&'b'), Some(&2));
assert_eq!(map.get_by_right(&'c'), None);

pub fn remove_by_left(&mut self, left: &L) -> Option<(L, R)>

where L: Hash + Eq, R: Hash + Eq,

Removes a pair from the map based on the left value.

Example

use rust_dsa::BiMap;

let mut map = BiMap::from([(1, 'a'), (2, 'b')]);

assert_eq!(map.remove_by_left(&1), Some((1, 'a')));
assert_eq!(map.remove_by_left(&2), Some((2, 'b')));
assert_eq!(map.remove_by_left(&1), None);

assert!(map.is_empty());

pub fn remove_by_right(&mut self, right: &R) -> Option<(L, R)>

where L: Hash + Eq, R: Hash + Eq,

Removes a pair from the map based on the right value.

Example

use rust_dsa::BiMap;

let mut map = BiMap::from([(1, 'a'), (2, 'b')]);

assert_eq!(map.remove_by_right(&'a'), Some((1, 'a')));
assert_eq!(map.remove_by_right(&'b'), Some((2, 'b')));
assert_eq!(map.remove_by_right(&'a'), None);

assert!(map.is_empty());

pub fn contains_left(&self, left: &L) -> bool

where L: Hash + Eq,

Returns true if the map contains the left value.

Example

use rust_dsa::BiMap;

let map = BiMap::from([(1, 'a'), (2, 'b')]);

assert!(map.contains_left(&1));
assert!(map.contains_left(&2));
assert!(!map.contains_left(&3));

pub fn contains_right(&self, right: &R) -> bool

where R: Hash + Eq,

Returns true if the map contains the right value.

Example

use rust_dsa::BiMap;

let map = BiMap::from([(1, 'a'), (2, 'b')]);

assert!(map.contains_right(&'a'));
assert!(map.contains_right(&'b'));
assert!(!map.contains_right(&'c'));

pub fn len(&self) -> usize

Returns the number of pairs in the map.

Example

use rust_dsa::BiMap;

let mut map = BiMap::from([(1, 'a'), (2, 'b'), (3, 'c')]);

assert_eq!(map.len(), 3);

map.remove_by_left(&1);

assert_eq!(map.len(), 2);

pub fn is_empty(&self) -> bool

Returns true if the map is empty.

Example

use rust_dsa::BiMap;

let mut map = BiMap::from([(1, 'a'), (2, 'b'), (3, 'c')]);

assert!(!map.is_empty());

map.clear();

assert!(map.is_empty());

pub fn clear(&mut self)

Clears the map.

Example

use rust_dsa::BiMap;

let mut map = BiMap::from([(1, 'a'), (2, 'b'), (3, 'c')]);

assert!(!map.is_empty());

map.clear();

assert!(map.is_empty());

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

Returns an iterator over the items in the map.

pub fn lefts(&self) -> Vec<&L>

Returns the left values in the map.

pub fn into_lefts(self) -> Vec<L>

Returns the left values in the map.

pub fn rights(&self) -> Vec<&R>

Returns right values in the map.

pub fn into_rights(self) -> Vec<R>

Returns right values in the map.

Trait Implementations

impl<L, R> Clone for BiMap<L, R>

where L: Clone + Hash + Eq, R: Clone + Hash + Eq,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L, R> Debug for BiMap<L, R>

where L: Debug, R: Debug,

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

Formats the value using the given formatter.

impl<L, R> Default for BiMap<L, R>

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

Returns the “default value” for a type.

impl<L, R, const N: usize> From<[(L, R); N]> for BiMap<L, R>

where L: Hash + Eq, R: Hash + Eq,

fn from(array: [(L, R); N]) -> BiMap<L, R>

Converts to this type from the input type.

impl<L, R> FromIterator<(L, R)> for BiMap<L, R>

where L: Hash + Eq, R: Hash + Eq,

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

Creates a value from an iterator.

impl<'a, L, R> IntoIterator for &'a BiMap<L, R>

type IntoIter = Iter<'a, L, R>

Which kind of iterator are we turning this into?

type Item = (&'a L, &'a R)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<L, R> IntoIterator for BiMap<L, R>

type IntoIter = IntoIter<L, R>

Which kind of iterator are we turning this into?

type Item = (L, R)

The type of the elements being iterated over.

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<L, R> PartialEq for BiMap<L, R>

where L: Hash + Eq, R: Hash + Eq,

fn eq(&self, other: &BiMap<L, R>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<L, R> Eq for BiMap<L, R>

where L: Hash + Eq, R: Hash + Eq,