Struct lattices::DomPair

pub struct DomPair<Key, Val> {
    pub key: Key,
    /* private fields */
}

Dominating pair compound lattice.

When merging if one Key (usually a timestamp) fully dominates (is greater than) the other, then both that Key and corresponding Val are selected. If the Keys are equal or incomparable, then both the Keys and Vals are merged.

Key specifies the key lattice (usually a timestamp), and Val specifies the value lattice.

Note that this is not a proper lattice, it fails associativity. However it will behave like a proper lattice if Key is a totally ordered lattice or a properly formed vector clock lattice. The exact meaning of “properly formed” is still TBD, but each node always incrementing its entry for each operation sent should be sufficient.

Fields

key: Key

The Key of the dominating pair lattice, usually a timestamp.

This field is public as it is always monotonically increasing in its lattice.

Implementations

impl<Key, Val> DomPair<Key, Val>

pub fn new(key: Key, val: Val) -> Self

Create a DomPair from the given Key and Val.

pub fn new_from(key: impl Into<Key>, val: impl Into<Val>) -> Self

Create a DomPair from the given Into<Key> and Into<Val>.

pub fn as_reveal_ref(&self) -> (&Key, &Val)

Reveal the inner value as a shared reference.

pub fn as_reveal_mut(&mut self) -> (&mut Key, &mut Val)

Reveal the inner value as an exclusive reference.

pub fn into_reveal(self) -> (Key, Val)

Gets the inner by value, consuming self.

Trait Implementations

impl<Key: Clone, Val: Clone> Clone for DomPair<Key, Val>

fn clone(&self) -> DomPair<Key, Val>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Key: Debug, Val: Debug> Debug for DomPair<Key, Val>

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

Formats the value using the given formatter.

impl<Key, Val> DeepReveal for DomPair<Key, Val>

where Key: DeepReveal, Val: DeepReveal,

type Revealed = (<Key as DeepReveal>::Revealed, <Val as DeepReveal>::Revealed)

The underlying type when revealed.

fn deep_reveal(self) -> Self::Revealed

Reveals the underlying lattice types recursively.

impl<Key: Default, Val: Default> Default for DomPair<Key, Val>

fn default() -> DomPair<Key, Val>

Returns the “default value” for a type.

impl<'de, Key, Val> Deserialize<'de> for DomPair<Key, Val>

where Key: Deserialize<'de>, Val: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Key, Val> IsBot for DomPair<Key, Val>

where Key: IsBot, Val: IsBot,

fn is_bot(&self) -> bool

Returns if self is lattice bottom (⊥).

impl<Key, Val> IsTop for DomPair<Key, Val>

where Key: IsTop, Val: IsTop,

fn is_top(&self) -> bool

Returns if self is lattice top (⊤).

impl<KeySelf, KeyOther, ValSelf, ValOther> LatticeFrom<DomPair<KeyOther, ValOther>> for DomPair<KeySelf, ValSelf>

where KeySelf: LatticeFrom<KeyOther>, ValSelf: LatticeFrom<ValOther>,

fn lattice_from(other: DomPair<KeyOther, ValOther>) -> Self

Convert from the Other lattice into Self.

impl<KeySelf, KeyOther, ValSelf, ValOther> Merge<DomPair<KeyOther, ValOther>> for DomPair<KeySelf, ValSelf>

where KeySelf: Merge<KeyOther> + LatticeFrom<KeyOther> + PartialOrd<KeyOther>, ValSelf: Merge<ValOther> + LatticeFrom<ValOther>,

fn merge(&mut self, other: DomPair<KeyOther, ValOther>) -> bool

Merge other into the self lattice.

fn merge_owned(this: Self, delta: Other) -> Self

where Self: Sized,

Merge this and delta together, returning the new value.

impl<KeySelf, KeyOther, ValSelf, ValOther> PartialEq<DomPair<KeyOther, ValOther>> for DomPair<KeySelf, ValSelf>

where KeySelf: PartialEq<KeyOther>, ValSelf: PartialEq<ValOther>,

fn eq(&self, other: &DomPair<KeyOther, ValOther>) -> 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<KeySelf, KeyOther, ValSelf, ValOther> PartialOrd<DomPair<KeyOther, ValOther>> for DomPair<KeySelf, ValSelf>

where KeySelf: PartialOrd<KeyOther>, ValSelf: PartialOrd<ValOther>,

fn partial_cmp(&self, other: &DomPair<KeyOther, ValOther>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Key, Val> Serialize for DomPair<Key, Val>

where Key: Serialize, Val: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Key: Copy, Val: Copy> Copy for DomPair<Key, Val>

impl<Key: Eq, Val: Eq> Eq for DomPair<Key, Val>

impl<KeySelf, KeyOther, ValSelf, ValOther> LatticeOrd<DomPair<KeyOther, ValOther>> for DomPair<KeySelf, ValSelf>

where Self: PartialOrd<DomPair<KeyOther, ValOther>>,