Struct VectorClock 

pub struct VectorClock {
    pub entries: HashMap<String, u64>,
}

A logical clock that tracks causality per node.

Each node maintains a counter that is incremented whenever the node produces a new event. The happened-before relation (→) is defined by Lamport/Mattern vector clock rules.

Fields

entries: HashMap<String, u64>

Map from node_id to that node’s logical counter.

Implementations

impl VectorClock

pub fn new() -> Self

Create a new, zeroed vector clock.

pub fn increment(&mut self, node_id: &str)

Increment the counter for node_id by one.

pub fn merge(&self, other: &VectorClock) -> VectorClock

Element-wise maximum of self and other.

The result is the smallest vector clock that dominates both inputs, i.e. self.merge(other).dominates(self) && self.merge(other).dominates(other).

pub fn happens_before(&self, other: &VectorClock) -> bool

self → other: every component of self is ≤ the corresponding component of other, and at least one is strictly less.

pub fn concurrent_with(&self, other: &VectorClock) -> bool

Two clocks are concurrent when neither happens-before the other.

pub fn dominates(&self, other: &VectorClock) -> bool

self dominates other: every component of self is ≥ the corresponding component of other (i.e. other → self or other == self).

Note: this is not strict; equal clocks both dominate each other.

pub fn max_value(&self) -> u64

The maximum counter value across all nodes, or 0 if the clock is empty.

pub fn get(&self, node_id: &str) -> u64

Return the counter for node_id, or 0 if not present.

Trait Implementations

impl Clone for VectorClock

fn clone(&self) -> VectorClock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VectorClock

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

Formats the value using the given formatter.

impl Default for VectorClock

fn default() -> VectorClock

Returns the “default value” for a type.

impl Eq for VectorClock

impl PartialEq for VectorClock

fn eq(&self, other: &VectorClock) -> 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 StructuralPartialEq for VectorClock