Struct BiMultiMapStreams 

pub struct BiMultiMapStreams<L: Clone + Hash + Eq, R: Clone + Hash + Eq, St: Stream + Unpin> { /* private fields */ }

This is a BiMultiMap structure that associates (LeftKey, RightKey) pairs with a stream. Bi - This is a two-way mapping; each kind of key is mapped to keys of the other kind (and streams) Multi - Each key can have associations with multiple keys of the other kind.

The result is a structure that can be indexed with either a left key or a right key to obtain a set of keys of the other kind, and a set of streams, or can be indexed with a (left, right) key pair to obtain at most one stream.

Implementations

impl<L: Clone + Hash + Eq, R: Clone + Hash + Eq, St: Stream + Unpin> BiMultiMapStreams<L, R, St>

pub fn new() -> Self

Create a new mapping.

pub fn insert(&mut self, left: L, right: R, stream: St) -> bool

Insert a new (left, right, stream) associations. Returns true if another stream was not removed to make room for the provided stream.

pub fn insert_pin(&mut self, left: L, right: R, stream: St) -> Option<St>

where St: Unpin,

Insert a new (left, right, stream) associations. Returns Some(fut) if a stream was evicted to make room for this association.

pub fn contains(&self, left: &L, right: &R) -> bool

Check if there exists a (left, right) association.

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

Check if there exists any associations with the provided left key.

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

Check if there exists any associations with the provided right key.

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

where St: Unpin,

Remove and return the corresponding stream, if one exists.

pub fn cancel(&mut self, left: &L, right: &R) -> bool

Remove and drop the corresponding stream. Returns true if a stream was cancelled.

pub fn get_mut(&mut self, left: &L, right: &R) -> Option<StMut<'_, (L, R), St>>

where St: Unpin,

Get a mutable reference to the corresponding stream.

pub fn get_right_mut<'a>(&'a mut self, left: &L) -> RightIterMut<'a, L, R, St>

where St: Unpin,

Get an iterator of mutable references to the streams and right keys that are associated with the provided left key.

pub fn get_left_mut<'a>(&'a mut self, right: &R) -> LeftIterMut<'a, L, R, St>

where St: Unpin,

Get an iterator of mutable references to the streams and left keys that are associated with the provided right key.

pub fn left_cancel(&mut self, left: &L) -> Vec<R>

Remove and drop all streams corresponding to the provided left key. Returns the right keys of all streams that were dropped.

pub fn right_cancel(&mut self, right: &R) -> Vec<L>

Remove and drop all streams corresponding to the provided right key. Returns the left keys of all streams that were dropped.

pub fn left_remove(&mut self, left: &L) -> Vec<(R, St)>

where St: Unpin,

Remove and return the corresponding streams and their right keys.

pub fn right_remove(&mut self, right: &R) -> Vec<(L, St)>

where St: Unpin,

Remove and return the corresponding streams and their left keys.

pub fn right_len(&self) -> usize

The number of unique right keys.

pub fn left_len(&self) -> usize

The number of unique left keys.

pub fn len(&self) -> usize

The number of streams contained in the mapping.

pub fn is_empty(&self) -> bool

Returns true of no streams are contained.

pub fn clear(&mut self)

Empties the structure.

pub fn collect_keys(&mut self) -> Vec<(L, R)>

Returns a vector of all the (left, right) associations contained in the structure (not including the streams).

Trait Implementations

impl<L: Clone + Hash + Eq, R: Clone + Hash + Eq, St: Stream + Unpin> Stream for BiMultiMapStreams<L, R, St>

type Item = (L, R, Option<<St as Stream>::Item>)

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.