Struct OrSet 

pub struct OrSet<T: Hash + Eq> {
    pub elements: HashSet<(T, Timestamp)>,
    pub tombstone: HashSet<(T, Timestamp)>,
}

Observed-Remove Set (Add-Wins)

Fields

elements: HashSet<(T, Timestamp)>

tombstone: HashSet<(T, Timestamp)>

Implementations

impl<T: Hash + Eq + Clone> OrSet<T>

pub fn new() -> Self

Create a new empty OR-Set.

pub fn add(&mut self, value: T, tag: Timestamp)

Add an element to the set with a unique tag.

The tag (timestamp) must be unique across all operations to ensure correct causality tracking. In bones, this is guaranteed by the event hash or ITC stamp.

pub fn remove(&mut self, value: &T) -> Vec<Timestamp>

where T: Eq + Hash,

Remove an element from the set.

This tombstones all currently-observed tags for the given element. Any tags added concurrently (not yet observed) will survive, implementing add-wins semantics.

Returns the tags that were tombstoned (empty if element was not present).

pub fn remove_specific(&mut self, value: &T, tags: &[Timestamp])

where T: Eq + Hash,

Remove specific tags for an element.

Tombstones only the provided tags.

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

Check if an element is present in the set.

An element is present if it has at least one add-tag that is not covered by a corresponding tombstone.

pub fn values(&self) -> HashSet<&T>

Return all currently-present values in the set.

An element is present if it has at least one un-tombstoned add-tag.

pub fn len(&self) -> usize

Return the number of distinct present values.

pub fn is_empty(&self) -> bool

Return true if no values are present.

pub fn active_tags(&self, value: &T) -> Vec<&Timestamp>

Return all active (un-tombstoned) tags for a given value.

pub fn apply(&mut self, op: OrSetOp<T>)

Apply an operation to the OR-Set.

Trait Implementations

impl<T: Clone + Hash + Eq> 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: Debug + Hash + Eq> Debug for OrSet<T>

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

Formats the value using the given formatter.

impl<T: Hash + Eq + Clone> Default for OrSet<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for OrSet<T>

where T: Deserialize<'de> + Hash + Eq,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Eq + Hash + Clone> Merge for OrSet<T>

Merge implementation for OR-Set.

The merge is a union of both the element sets and the tombstone sets. This satisfies semilattice laws because set union is commutative, associative, and idempotent.

After merge, an element is present iff it has at least one add-tag not covered by a tombstone entry.

fn merge(&mut self, other: Self)

impl<T: PartialEq + Hash + Eq> 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> Serialize for OrSet<T>

where T: Serialize + Hash + Eq,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq + Hash + Eq> Eq for OrSet<T>

impl<T: Hash + Eq> StructuralPartialEq for OrSet<T>