Struct ORSet 

pub struct ORSet<T: Ord + Clone> { /* private fields */ }

An observed-remove set (OR-Set), also known as an add-wins set.

Unlike the 2P-Set, elements can be freely added and removed, and re-added after removal. Each add operation generates a unique tag. Remove only removes the tags that the remover has observed, so concurrent adds are preserved.

Example

use crdt_kit::prelude::*;

let mut s1 = ORSet::new("node-1");
s1.insert("apple");
s1.insert("banana");
s1.remove(&"banana");

let mut s2 = ORSet::new("node-2");
s2.insert("banana"); // concurrent add

s1.merge(&s2);
// banana is present because s2's add was concurrent with s1's remove
assert!(s1.contains(&"banana"));
assert!(s1.contains(&"apple"));

Implementations

impl<T: Ord + Clone> ORSet<T>

pub fn new(actor: impl Into<String>) -> Self

Create a new empty OR-Set for the given actor.

pub fn insert(&mut self, value: T)

Insert an element into the set.

Generates a unique tag for this insertion. Even if the element was previously removed, this new tag allows it to be re-added.

pub fn remove(&mut self, value: &T) -> bool

Remove an element from the set.

Only removes the tags that this replica has observed. Concurrent adds on other replicas will survive the merge.

Returns true if the element was present and removed.

pub fn contains(&self, value: &T) -> bool

Check if the set contains an element.

pub fn len(&self) -> usize

Get the number of distinct elements in the set.

pub fn is_empty(&self) -> bool

Check if the set is empty.

pub fn iter(&self) -> impl Iterator<Item = &T>

Iterate over the elements in the set.

pub fn actor(&self) -> &str

Get this replica’s actor ID.

Trait Implementations

impl<T: Clone + Ord + Clone> Clone for ORSet<T>

fn clone(&self) -> ORSet<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Ord + Clone> Crdt for ORSet<T>

fn merge(&mut self, other: &Self)

Merge another replica’s state into this one.

impl<T: Debug + Ord + Clone> Debug for ORSet<T>

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

Formats the value using the given formatter.

impl<T: PartialEq + Ord + Clone> PartialEq for ORSet<T>

fn eq(&self, other: &ORSet<T>) -> 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<T: Eq + Ord + Clone> Eq for ORSet<T>

impl<T: Ord + Clone> StructuralPartialEq for ORSet<T>