Struct CausalReplica 

pub struct CausalReplica<S: Lattice + Clone> {
    durable: DurableState<S>,
    volatile: VolatileState<S>,
    pending: HashMap<ReplicaId, VecDeque<DeltaInterval<S>>>,
}

A causal δ-CRDT replica implementing Algorithm 2

Provides causal consistency guarantees by:

1. Tracking per-peer delta intervals
2. Only accepting deltas in causal order
3. Supporting crash recovery via durable state

Fields

durable: DurableState<S>

Durable state (survives crashes)

volatile: VolatileState<S>

Volatile state (lost on crash)

pending: HashMap<ReplicaId, VecDeque<DeltaInterval<S>>>

Pending deltas waiting for causal predecessors

Implementations

impl<S: Lattice + Clone> CausalReplica<S>

pub fn new(id: impl Into<ReplicaId>) -> Self

Create a new causal replica

pub fn restore(durable: DurableState<S>) -> Self

Restore from durable state (after crash)

pub fn id(&self) -> &ReplicaId

Get the replica ID

pub fn state(&self) -> &S

Get current state (read-only)

pub fn counter(&self) -> SeqNo

Get the durable counter (sequence number)

pub fn durable_state(&self) -> &DurableState<S>

Get durable state for persistence

pub fn register_peer(&mut self, peer_id: ReplicaId)

Register a peer for causal anti-entropy

pub fn mutate<F>(&mut self, mutator: F) -> S

where F: FnOnce(&S) -> S,

Apply a local mutation

Algorithm 2, step 1:

cᵢ := cᵢ + 1
d := mδ(Xᵢ)
Xᵢ := Xᵢ ⊔ d
∀j: Dᵢ[j] := Dᵢ[j] ⊔ d

Returns the computed delta

pub fn prepare_interval(&mut self, peer_id: &str) -> Option<DeltaInterval<S>>

Prepare a delta-interval to send to a peer

Returns Some(DeltaInterval) if there are pending deltas for this peer, or None if the buffer is empty.

fn is_causally_ready(&self, interval: &DeltaInterval<S>) -> bool

Check if a delta-interval is causally ready

A delta-interval is ready if its from_seq matches our last acked seq from that peer

pub fn receive_interval( &mut self, interval: DeltaInterval<S>, ) -> Option<IntervalAck>

Receive a delta-interval from a peer

Algorithm 2, step 3:

if n = Aᵢ[j] + 1 then        // causally ready
    Xᵢ := Xᵢ ⊔ d
    Aᵢ[j] := m
    send ack(m) to j
else
    buffer for later

Returns Some(IntervalAck) if the interval was applied (causally ready), or None if it was buffered for later.

fn try_apply_pending(&mut self, peer_id: &str) -> Vec<IntervalAck>

Try to apply pending intervals that are now causally ready

pub fn receive_ack(&mut self, ack: &IntervalAck)

Process an acknowledgment from a peer

Algorithm 2, step 4:

Dᵢ[j] := ⊥   // clear delta buffer for j

pub fn snapshot(&self) -> (S, SeqNo)

Get a full state snapshot for bootstrapping

pub fn apply_snapshot(&mut self, state: S, seq: SeqNo, from: &str)

Apply a snapshot from another replica (for bootstrapping)

pub fn peers(&self) -> impl Iterator<Item = &ReplicaId>

Get all registered peer IDs

pub fn has_pending_deltas(&self) -> bool

Check if we have pending deltas for any peer

pub fn pending_count(&self) -> usize

Count of pending out-of-order intervals

Trait Implementations

impl<S: Clone + Lattice + Clone> Clone for CausalReplica<S>

fn clone(&self) -> CausalReplica<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Lattice + Clone> Debug for CausalReplica<S>

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

Formats the value using the given formatter.