Struct VectorClock 

pub struct VectorClock { /* private fields */ }

Vector clock for tracking causality in distributed systems

A vector clock is a data structure used for determining the partial ordering of events in a distributed system and detecting causality violations.

Implementations

impl VectorClock

pub fn new(device_id: DeviceId) -> Self

Creates a new vector clock for the given device

Arguments

• device_id - The identifier of the device owning this clock

Example

use oxigdal_sync::vector_clock::VectorClock;

let clock = VectorClock::new("device-1".to_string());

pub fn from_version_vector(device_id: DeviceId, clock: VersionVector) -> Self

Creates a vector clock from an existing version vector

Arguments

• device_id - The device ID
• clock - Existing version vector

pub fn tick(&mut self) -> Timestamp

Increments the clock for this device

This should be called when a new event occurs on this device.

Example

use oxigdal_sync::vector_clock::VectorClock;

let mut clock = VectorClock::new("device-1".to_string());
clock.tick();
assert_eq!(clock.get_time(&"device-1".to_string()), Some(1));

pub fn get_time(&self, device_id: &DeviceId) -> Option<Timestamp>

Gets the timestamp for a specific device

Arguments

• device_id - The device to query

Returns

The timestamp for the device, or None if the device is not in the clock

pub fn current_time(&self) -> Timestamp

Gets the current timestamp for this device

pub fn merge(&mut self, other: &VectorClock)

Merges another vector clock into this one

Takes the maximum timestamp for each device. This is used when receiving an event from another device.

Arguments

• other - The clock to merge

Example

use oxigdal_sync::vector_clock::VectorClock;

let mut clock1 = VectorClock::new("device-1".to_string());
let mut clock2 = VectorClock::new("device-2".to_string());

clock1.tick();
clock2.tick();

clock1.merge(&clock2);
assert_eq!(clock1.get_time(&"device-2".to_string()), Some(1));

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

Compares this clock with another to determine causal ordering

Arguments

• other - The clock to compare with

Returns

The ordering relationship between the clocks

Example

use oxigdal_sync::vector_clock::{VectorClock, ClockOrdering};

let mut clock1 = VectorClock::new("device-1".to_string());
let mut clock2 = VectorClock::new("device-1".to_string());

clock2.tick();

assert_eq!(clock1.compare(&clock2), ClockOrdering::Before);
assert_eq!(clock2.compare(&clock1), ClockOrdering::After);

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

Checks if this clock happened before the other

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

Checks if this clock happened after the other

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

Checks if clocks are concurrent (causally independent)

pub fn device_id(&self) -> &DeviceId

Gets the device ID associated with this clock

pub fn as_version_vector(&self) -> &VersionVector

Gets a reference to the underlying version vector

pub fn into_version_vector(self) -> VersionVector

Converts the clock into a version vector

pub fn with_device_id(&self, device_id: DeviceId) -> Self

Creates a clone with a new device ID

pub fn update(&mut self, device_id: DeviceId, timestamp: Timestamp)

Updates the timestamp for a specific device

Arguments

• device_id - The device to update
• timestamp - The new timestamp

pub fn sum(&self) -> Timestamp

Gets the sum of all timestamps (useful for debugging)

pub fn is_empty(&self) -> bool

Checks if the clock is empty (no devices)

pub fn len(&self) -> usize

Gets the number of devices in the clock

pub fn devices(&self) -> Vec<DeviceId>

Gets all device IDs in the clock

Trait Implementations

impl CausalOrdering for VectorClock

fn precedes(&self, other: &Self) -> bool

Checks if this event causally precedes another

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

Checks if this event is concurrent with another

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() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for VectorClock

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 Serialize for VectorClock

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for VectorClock

impl StructuralPartialEq for VectorClock