Struct DotFunMap 

pub struct DotFunMap<V> { /* private fields */ }

A map from Dot to V: DotStore, whose computed dots is the union of the dots of its values.

Quoth the DSON paper:

We combine the DotMap and DotFun to get a dot store which maps dots to dot stores. The join operation keeps keys that have not been deleted (as in the DotFun), or the values themselves haven’t been deleted (as in the DotMap).

Note that this is called CompDotFun in the DSON paper (section 5.1), but DotFunMap in their prototype implementation.

Implementations

impl<V> DotFunMap<V>

pub fn with_capacity(capacity: usize) -> Self

Constructs a DotFunMap with the given initial capacity.

pub fn iter(&self) -> impl ExactSizeIterator<Item = (Dot, &V)>

Produces an iterator over the map’s keys and values.

pub fn keys(&self) -> impl ExactSizeIterator<Item = Dot> + '_

Produces an iterator over the map’s keys.

pub fn values(&self) -> impl ExactSizeIterator<Item = &V>

Produces an iterator over the map’s values.

pub fn len(&self) -> usize

Returns the number of keys in the map.

pub fn is_empty(&self) -> bool

Returns true if the map is empty.

impl<V> DotFunMap<V>

pub fn get(&self, dot: &Dot) -> Option<&V>

Retrieves the associated value, if any, for the given Dot.

pub fn get_mut(&mut self, dot: &Dot) -> Option<&mut V>

Retrieves a mutable reference to the associated value, if any, for the given Dot.

pub fn has(&self, dot: &Dot) -> bool

Returns true if the given Dot has a value in this map.

pub fn set(&mut self, dot: Dot, value: V) -> Option<V>

Associates the value with the given Dot.

Returns the previous value if any.

Trait Implementations

impl<V: Clone> Clone for DotFunMap<V>

fn clone(&self) -> DotFunMap<V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug> Debug for DotFunMap<V>

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

Formats the value using the given formatter.

impl<V> Default for DotFunMap<V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, V> Deserialize<'de> for DotFunMap<V>

where V: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<V> DotStore for DotFunMap<V>

where V: DotStore + Debug,

fn add_dots_to(&self, other: &mut CausalContext)

Add the set of event identifiers (ie, dots) currently stored in the dot store to other.

fn is_bottom(&self) -> bool

Returns true if this dot store is ⊥ (ie, empty).

fn subset_for_inflation_from(&self, frontier: &CausalContext) -> Self

Returns a subset-CRDT derived from self that allows inflating state at the vector time frontier to what’s in self.

fn dots(&self) -> CausalContext

Queries the set of event identifiers (ie, dots) currently stored in the dot store.

impl<V, S> DotStoreJoin<S> for DotFunMap<V>

where V: DotStoreJoin<S> + Debug + Default, S: Visit<Dot> + KeySentinel,

fn join( (m1, cc1): (Self, &CausalContext), (m2, cc2): (Self, &CausalContext), on_dot_change: &mut dyn FnMut(DotChange), sentinel: &mut S, ) -> Result<Self, S::Error>

where S: Sentinel,

Formally (Equation 7):

(𝑚, 𝑐) ⊔ (𝑚′, 𝑐′) = ( {𝑑 ↦ 𝑣(𝑑) | 𝑑 ∈ dom 𝑚 ∩ dom 𝑚′ ∧ 𝑣(𝑑) ≠ ⊥} ∪ {(𝑑, 𝑣) ∈ 𝑚 | 𝑑 ∉ 𝑐′} ∪ {(𝑑, 𝑣) ∈ 𝑚′ | 𝑑 ∉ 𝑐} , 𝑐 ∪ 𝑐′ ) where 𝑣(𝑑) = fst((𝑚(𝑑), 𝑐) ⊔ (𝑚′(𝑑), 𝑐′))

Informally:

• for dots in both stores, join the values and keep non-bottoms
• for dots in store 1 that haven’t beeen observed by store 2, keep the value
• for dots in store 2 that haven’t beeen observed by store 1, keep the value
• don’t keep other dots
• the resulting causal context is the union of the provided causal contexts

fn dry_join( (m1, cc1): (&Self, &CausalContext), (m2, cc2): (&Self, &CausalContext), sentinel: &mut S, ) -> Result<DryJoinOutput, S::Error>

where S: Sentinel,

Simulates a DotStoreJoin::join without constructing the output of the join.

impl<V> FromIterator<(Dot, V)> for DotFunMap<V>

fn from_iter<T: IntoIterator<Item = (Dot, V)>>(iter: T) -> Self

Creates a value from an iterator.

impl<V: PartialEq> PartialEq for DotFunMap<V>

fn eq(&self, other: &DotFunMap<V>) -> 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<V> Serialize for DotFunMap<V>

where V: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<V: Eq> Eq for DotFunMap<V>

impl<V> StructuralPartialEq for DotFunMap<V>