Struct ContextV7 

pub struct ContextV7 { /* private fields */ }

An unsynchronized, reseeding counter that produces 42-bit values for version 7 UUIDs.

This type is:

• Reseeding: The counter is reseeded on each time interval (1ms) with a random 41-bit value. The 42nd bit is left unset so the counter can safely increment over the millisecond.
• Adjusting: The timestamp is incremented when the counter wraps within a time interval (1ms). All subsequent timestamps in that same interval will also be incremented until it changes and the counter is reseeded.
• Non-thread-safe: The underlying counter uses unsynchronized cells, so needs to be wrapped in a mutex to share.

The counter can use additional sub-millisecond precision from the timestamp to better synchronize UUID sorting in distributed systems. In these cases, the additional precision is masked into the left-most 12 bits of the counter. The counter is still reseeded on each new millisecond, and incremented within the millisecond. This behavior may change in the future. The only guarantee is monotonicity.

This type can be used when constructing version 7 UUIDs. When used to construct a version 7 UUID, the 42-bit counter will be padded with random data. This type can be used to maintain ordering of UUIDs within the same millisecond.

This type should not be used when constructing version 1 or version 6 UUIDs. When used to construct a version 1 or version 6 UUID, only the 14 least significant bits of the counter will be used.

Implementations

impl ContextV7

pub const fn new() -> ContextV7

Construct a new context that will reseed its counter on the first non-zero timestamp it receives.

pub fn with_adjust_by_millis(self, millis: u32) -> ContextV7

Specify an amount to shift timestamps by to obfuscate their actual generation time.

pub fn with_additional_precision(self) -> ContextV7

Use the leftmost 12 bits of the counter for additional timestamp precision.

This method can provide better sorting for distributed applications that generate frequent UUIDs by trading a small amount of entropy for better counter synchronization. Note that the counter will still be reseeded on millisecond boundaries, even though some of its storage will be dedicated to the timestamp.

Trait Implementations

impl ClockSequence for ContextV7

type Output = u64

The type of sequence returned by this counter.

fn generate_sequence( &self, seconds: u64, subsec_nanos: u32, ) -> <ContextV7 as ClockSequence>::Output

Get the next value in the sequence to feed into a timestamp.

fn generate_timestamp_sequence( &self, seconds: u64, subsec_nanos: u32, ) -> (<ContextV7 as ClockSequence>::Output, u64, u32)

Get the next value in the sequence, potentially also adjusting the timestamp.

fn usable_bits(&self) -> usize

The number of usable bits from the least significant bit in the result of ClockSequence::generate_sequence or ClockSequence::generate_timestamp_sequence.

impl Debug for ContextV7

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

Formats the value using the given formatter.

impl RefUnwindSafe for ContextV7