Enum bimap::Overwritten

pub enum Overwritten<L, R> {
    Neither,
    Left(L, R),
    Right(L, R),
    Pair(L, R),
    Both((L, R), (L, R)),
}

The previous left-right pairs, if any, that were overwritten by a call to the insert method of a bimap.

Variants

Neither

Neither the left nor the right value previously existed in the bimap.

Left(L, R)

The left value existed in the bimap, and the previous left-right pair is returned.

Right(L, R)

The right value existed in the bimap, and the previous left-right pair is returned.

Pair(L, R)

The left-right pair already existed in the bimap, and the previous left-right pair is returned.

Both((L, R), (L, R))

Both the left and the right value existed in the bimap, but as part of separate pairs. The first tuple is the left-right pair of the previous left value, and the second is the left-right pair of the previous right value.

Implementations

impl<L, R> Overwritten<L, R>

pub fn did_overwrite(&self) -> bool

Returns a boolean indicating if the Overwritten variant implies any values were overwritten.

This method is true for all variants other than Neither.

Examples

use bimap::{BiMap, Overwritten};

let mut bimap = BiMap::new();
assert!(!bimap.insert('a', 1).did_overwrite());
assert!(bimap.insert('a', 2).did_overwrite());

Trait Implementations

impl<L: Clone, R: Clone> Clone for Overwritten<L, R>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<L: Debug, R: Debug> Debug for Overwritten<L, R>

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

Formats the value using the given formatter.

impl<L: Hash, R: Hash> Hash for Overwritten<L, R>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<L: PartialEq, R: PartialEq> PartialEq for Overwritten<L, R>

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

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

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.

impl<L: Copy, R: Copy> Copy for Overwritten<L, R>

impl<L: Eq, R: Eq> Eq for Overwritten<L, R>

impl<L, R> StructuralPartialEq for Overwritten<L, R>