Struct tarantool::vclock::Vclock

pub struct Vclock(/* private fields */);

Tarantool vector clock.

Find the explanation of the concept in the module documentation.

Vclock is a mapping (HashMap) of replica id (usize) to its LSN (u64).

Unlike in Tarantool, Vclock doesn’t impose any restrictions on the replica ids (in Tarantool its valid range is 0..32).

Vclock supports equality comparison (Eq) and partial ordering (PartialOrd). Two vclocks are said to be a => b if and only if for every component i it’s true that a[i] => b[i]. Missing components are treated as 0.

use tarantool::vclock::Vclock;

let vc1 = Vclock::from([1, 9, 88]);
let vc2 = Vclock::from([1, 10, 100]);
assert!(vc1 < vc2);

Since vclocks do not form a total order some vclock instances might be incomparible, leading to both >= and <= returning false. Such situations can be detected by directly calling partial_cmp and checking if it returns None.

use tarantool::vclock::Vclock;
use std::cmp::PartialOrd;

let vc1 = Vclock::from([0, 100]);
let vc2 = Vclock::from([100, 0]);
assert_eq!(vc1 <= vc2, false);
assert_eq!(vc1 >= vc2, false);
assert!(vc1.partial_cmp(&vc2).is_none());

Implementations

impl Vclock

pub fn current() -> Self

Obtains current vclock from Tarantool box.info.vclock API.

Example

dbg!(Vclock::current());

Example output:

Vclock({0: 2, 1: 101})

Panics

If box.cfg{ .. } was not called yet.

pub fn try_current() -> Result<Self, LuaError>

Obtains current vclock from Tarantool box.info.vclock API.

Returns an error if box.cfg{ .. } was not called yet.

pub fn ignore_zero(self) -> Self

Sets zero component to 0. It’s used for tracking local updates that aren’t replicated so it should be excluded from comparison of vclocks of different replicas.

Example

let vc = Vclock::from([100, 1]);
assert_eq!(vc.ignore_zero(), Vclock::from([0, 1]));

pub fn into_inner(self) -> HashMap<usize, Lsn>

Consumes the Vclock, returning underlying HashMap.

Example

let vc = Vclock::from([0, 0, 200]);
assert_eq!(vc.into_inner(), HashMap::from([(2, 200)]))

pub fn get(&self, index: usize) -> Lsn

Returns an Lsn at index or zero if it is not present.

Example

let vc = Vclock::from([0, 10]);
assert_eq!(vc.get(0), 0);
assert_eq!(vc.get(1), 10);
assert_eq!(vc.get(2), 0);

pub fn cmp(&self, other: &Self, ignore_zero: bool) -> Option<Ordering>

Does a component-wise comparison of self against other.

If ignore_zero is true, the component at index 0 is ignored. This is useful for comparing vclocks from different replicas, because the zeroth component only tracks local updates.

pub fn cmp_ignore_zero(&self, other: &Self) -> Option<Ordering>

Does a component-wise comparison of self against other.

Ignores the components at index 0.

See also Self::cmp.

Trait Implementations

impl Clone for Vclock

fn clone(&self) -> Vclock

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Vclock

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Vclock

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: usize> From<[u64; N]> for Vclock

fn from(from: [Lsn; N]) -> Self

Converts an array [Lsn; N] into a Vclock, skipping components with LSN equal to 0.

Primarily used for testing. It has no meaningful application in the real world.

impl<L> LuaRead<L> for Vclock

where L: AsLua,

fn lua_read_at_position(lua: L, index: NonZeroI32) -> ReadResult<Self, L>

Reads the data from Lua at a given position.

fn n_values_expected() -> i32

fn lua_read(lua: L) -> Result<Self, (L, WrongType)>

Reads the data from Lua.

fn lua_read_at_maybe_zero_position( lua: L, index: i32 ) -> Result<Self, (L, WrongType)>

where L: AsLua,

impl PartialEq for Vclock

fn eq(&self, other: &Vclock) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Vclock

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

Does a component-wise comparison of self against other.

Includes the components at index 0 in the comparison, so it’s probably not suitable for comparing vclocks from different replicas.

See also Self::cmp_ignore_zero.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<L: AsLua> Push<L> for Vclock

type Err = Void

Error that can happen when pushing a value.

fn push_to_lua(&self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

Pushes the value on the top of the stack.

fn push_no_err(&self, lua: L) -> PushGuard<L>

where Self::Err: Into<Void>,

Same as push_to_lua but can only succeed and is only available if Err implements Into<Void>.

impl<L: AsLua> PushInto<L> for Vclock

type Err = Void

fn push_into_lua(self, lua: L) -> Result<PushGuard<L>, (Self::Err, L)>

Push the value into lua by value

fn push_into_no_err(self, lua: L) -> PushGuard<L>

where Self: Sized, Self::Err: Into<Void>,

Same as push_into_lua but can only succeed and is only available if Err implements Into<Void>.

impl Serialize for Vclock

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 Vclock

impl<L: AsLua> PushOne<L> for Vclock

impl<L: AsLua> PushOneInto<L> for Vclock

impl StructuralEq for Vclock

impl StructuralPartialEq for Vclock