Enum UUID

pub enum UUID {
    Name {
        name: u64,
        scope: u64,
    },
    Number {
        value1: u64,
        value2: u64,
    },
    Event {
        timestamp: u64,
        origin: u64,
    },
    Derived {
        timestamp: u64,
        origin: u64,
    },
}

UUIDs are used by RON to identify types, objects, events, etc.

There are different kinds of UUIDs: Name, number, event and derived.

Any UUID has four parts, two related to its content, and two related to its type.

The type of an UUID is a 2-bit number called the scheme. The subtype of an UUID is a 4-bit number called the variety (currently unsupported). Together, the scheme and variety specify the kind of UUID.

Two other fields describe the actual content of the UUID. Both are 60-bit numbers that can be represented as ten-digit Base64 characters.

That leaves 2 bits to make up a 128-bit number. These 2 bits are always 0 and are provided for backwards compatibility with RFC4122 (variant field).

Variants

Name

Name UUIDs are often used to encode short string atoms, such as types (e.g. lww). The string is read as a Base64-literal to determine the actual (numeric) UUID component. Name UUIDs can be global (e.g. lww = lww$0) or scoped (e.g. dbtest$client1)

Fields

name: u64

Local name.

scope: u64

Global namespace/node ID.

Number

Number UUIDs encode numbers (e.g. indices into a matrix) and hash values. The meaning of the two values is context-dependent.

Fields

value1: u64

First value.

value2: u64

Second value.

Event

Event UUIDs are Lamport-timestamps that are used to identify operations and objects. The timestamp is clock-dependent, while the origin is a replica ID.

Fields

timestamp: u64

Local timestamp.

origin: u64

Global namespace/node ID.

Derived

Derived UUIDs refer to an event ID, without being the event ID.

Fields

timestamp: u64

Local timestamp.

origin: u64

Global namespace/node ID.

Implementations

impl UUID

pub fn set_node_id(val: u64)

Sets the default UUID origin. s must not be longer than 10 characters and only consist of [0-9a-zA-Z~_].

pub fn node_id() -> u64

The current default UUID origin. Initially “0”.

pub fn now() -> Self

New UUID with the default origin (see node_id and set_node_id) and the current time. Ignoring leap seconds and other events that mess with the system time all calls to this functions return unique UUID (duh).

pub fn zero() -> Self

Creates a new 0 UUID

pub fn is_name(&self) -> bool

Return true if and only if this is a name UUID.

pub fn is_number(&self) -> bool

Return true if and only if this is a number UUID.

pub fn is_event(&self) -> bool

Return true if and only if this is an event UUID.

pub fn is_derived(&self) -> bool

Return true if and only if this is a derived UUID.

pub fn is_zero(&self) -> bool

Returns true if high() = low() = 0.

pub fn weak_cmp(a: &UUID, b: &UUID) -> Ordering

Compares a and b while ignoring the scheme.

pub fn parse<'a>( input: &'a str, context: Option<(&UUID, &UUID)>, ) -> Option<(UUID, &'a str)>

Parse a single UUID and return the remaining string. The context argument is the pair previous column UUID / previous row UUID or None.

pub fn compress(&self, context: Option<(&UUID, &UUID)>) -> String

Serialize this UUID the text optionally compressing it against (previous column UUID / previous row UUID) if context is not None.

Trait Implementations

impl Arbitrary for UUID

fn arbitrary<G: Gen>(g: &mut G) -> Self

fn shrink(&self) -> Box<dyn Iterator<Item = Self>>

impl Clone for UUID

fn clone(&self) -> UUID

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UUID

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

Formats the value using the given formatter.

impl Default for UUID

fn default() -> Self

Returns the “default value” for a type.

impl Display for UUID

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

Formats the value using the given formatter.

impl FromStr for UUID

type Err = ()

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for UUID

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for UUID

fn cmp(&self, other: &UUID) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for UUID

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

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

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for UUID

impl Eq for UUID

impl StructuralPartialEq for UUID