Struct noosphere_core::data::Orswot

pub struct Orswot<M, A>where
    M: Hash + Eq,
    A: Ord + Hash,{ /* private fields */ }

Orswot is an add-biased or-set without tombstones ported from the riak_dt CRDT library.

Implementations

impl<M, A> Orswot<M, A>where
    M: Hash + Clone + Eq,
    A: Ord + Hash + Clone,

pub fn new() -> Orswot<M, A>

Returns a new Orswot instance.

pub fn clock(&self) -> VClock<A>

Return a snapshot of the ORSWOT clock

pub fn add(&self, member: M, ctx: AddCtx<A>) -> Op<M, A>

Add a single element.

pub fn add_all<I>(&self, members: I, ctx: AddCtx<A>) -> Op<M, A>where
    I: IntoIterator<Item = M>,

Add multiple elements.

pub fn rm(&self, member: M, ctx: RmCtx<A>) -> Op<M, A>

Remove a member with a witnessing ctx.

pub fn rm_all<I>(&self, members: I, ctx: RmCtx<A>) -> Op<M, A>where
    I: IntoIterator<Item = M>,

Remove members with a witnessing ctx.

pub fn contains(&self, member: &M) -> ReadCtx<bool, A>

Check if the set contains a member

pub fn iter(&self) -> impl Iterator<Item = ReadCtx<&M, A>>

Gets an iterator over the entries of the Map.

Examples

use crdts::{Orswot, CmRDT};

let actor = "actor";

let mut set: Orswot<u8, &'static str> = Default::default();

let add_ctx = set.read_ctx().derive_add_ctx(actor);
set.apply(set.add(100, add_ctx));

let add_ctx = set.read_ctx().derive_add_ctx(actor);
set.apply(set.add(50, add_ctx));

let mut items: Vec<_> = set
    .iter()
    .map(|item_ctx| *item_ctx.val)
    .collect();

items.sort();

assert_eq!(items, &[50, 100]);

pub fn read(&self) -> ReadCtx<HashSet<M, RandomState>, A>

Retrieve the current members.

pub fn read_ctx(&self) -> ReadCtx<(), A>

Retrieve the current read context

Trait Implementations

impl<M, A> Clone for Orswot<M, A>where
    M: Clone + Hash + Eq,
    A: Clone + Ord + Hash,

fn clone(&self) -> Orswot<M, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M, A> CmRDT for Orswot<M, A>where
    M: Hash + Clone + Eq,
    A: Ord + Hash + Clone + Debug,

type Op = Op<M, A>

Op defines a mutation to the CRDT. As long as Op’s from one actor are replayed in exactly the same order they were generated by that actor, the CRDT will converge. In other words, we must have a total ordering on each actors operations, while requiring only a partial order over all ops. E.g.

type Validation = <VClock<A> as CmRDT>::Validation

The validation error returned by validate_op.

fn validate_op(
    &self,
    op: &<Orswot<M, A> as CmRDT>::Op
) -> Result<(), <Orswot<M, A> as CmRDT>::Validation>

Some CRDT’s have stricter requirements on how they must be used. To avoid violating these requirements, CRDT’s provide an interface to optionally validate op’s before they are applied.

fn apply(&mut self, op: <Orswot<M, A> as CmRDT>::Op)

Apply an Op to the CRDT

impl<M, A> CvRDT for Orswot<M, A>where
    M: Hash + Eq + Clone + Debug,
    A: Ord + Hash + Clone + Debug,

fn merge(&mut self, other: Orswot<M, A>)

Merge combines another Orswot with this one.

type Validation = Validation<M, A>

The validation error returned by validate_merge.

fn validate_merge(
    &self,
    other: &Orswot<M, A>
) -> Result<(), <Orswot<M, A> as CvRDT>::Validation>

Some CRDT’s have stricter requirements on how they must be used. To avoid violating these requirements, CRDT’s provide an interface to optionally validate merge compatibility before attempting to merge.

impl<M, A> Debug for Orswot<M, A>where
    M: Debug + Hash + Eq,
    A: Debug + Ord + Hash,

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

Formats the value using the given formatter.

impl<M, A> Default for Orswot<M, A>where
    M: Hash + Eq,
    A: Ord + Hash,

fn default() -> Orswot<M, A>

Returns the “default value” for a type.

impl<'de, M, A> Deserialize<'de> for Orswot<M, A>where
    M: Hash + Eq + Deserialize<'de>,
    A: Ord + Hash + Deserialize<'de>,

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Orswot<M, A>, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<M, A> PartialEq<Orswot<M, A>> for Orswot<M, A>where
    M: PartialEq<M> + Hash + Eq,
    A: PartialEq<A> + Ord + Hash,

fn eq(&self, other: &Orswot<M, A>) -> 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<M, A> ResetRemove<A> for Orswot<M, A>where
    M: Hash + Clone + Eq,
    A: Ord + Hash,

fn reset_remove(&mut self, clock: &VClock<A>)

Remove data that is strictly smaller than this clock

impl<M, A> Serialize for Orswot<M, A>where
    M: Hash + Eq + Serialize,
    A: Ord + Hash + Serialize,

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

Serialize this value into the given Serde serializer.

impl<M, A> Eq for Orswot<M, A>where
    M: Eq + Hash,
    A: Eq + Ord + Hash,

impl<M, A> StructuralEq for Orswot<M, A>where
    M: Hash + Eq,
    A: Ord + Hash,

impl<M, A> StructuralPartialEq for Orswot<M, A>where
    M: Hash + Eq,
    A: Ord + Hash,