Struct DeterministicUuidFactory 

pub struct DeterministicUuidFactory { /* private fields */ }

A factory for generating deterministic UUIDs that are guaranteed unique across different generator types within the same seed.

UUID Structure (16 bytes)

Bytes 0-5:   Seed (lower 48 bits)
Byte  6:     Generator type discriminator
Byte  7:     Version nibble (0x4_) | Sub-discriminator
Bytes 8-15:  Counter (64-bit, with variant bits set)

Thread Safety

The counter uses AtomicU64 for thread-safe increments, allowing concurrent UUID generation from multiple threads.

Implementations

impl DeterministicUuidFactory

pub fn new(seed: u64, generator_type: GeneratorType) -> Self

Create a new UUID factory for a specific generator type.

Arguments

• seed - The global seed for deterministic generation
• generator_type - The type of generator using this factory

Example

use datasynth_core::uuid_factory::{DeterministicUuidFactory, GeneratorType};

let factory = DeterministicUuidFactory::new(12345, GeneratorType::JournalEntry);
let uuid = factory.next();

pub fn with_sub_discriminator( seed: u64, generator_type: GeneratorType, sub_discriminator: u8, ) -> Self

Create a factory with a sub-discriminator for additional namespace separation.

Useful when the same generator type needs multiple independent UUID streams.

pub fn with_counter( seed: u64, generator_type: GeneratorType, start_counter: u64, ) -> Self

Create a factory starting from a specific counter value.

Useful for resuming generation from a checkpoint or for partitioned parallel generation where each thread gets a non-overlapping counter range.

pub fn for_partition( seed: u64, generator_type: GeneratorType, partition_index: u8, ) -> Self

Create a factory for a specific partition in parallel generation.

Each partition gets a unique sub-discriminator so that counters starting from 0 in each partition still produce globally unique UUIDs. This avoids atomic contention between threads since each partition has its own factory.

pub fn next(&self) -> Uuid

Generate the next UUID in the sequence.

This method is thread-safe and can be called from multiple threads.

pub fn generate_at(&self, counter: u64) -> Uuid

Generate a UUID for a specific counter value without incrementing.

Useful for deterministic regeneration of specific UUIDs.

pub fn current_counter(&self) -> u64

Get the current counter value.

pub fn reset(&self)

Reset the counter to zero.

pub fn set_counter(&self, value: u64)

Set the counter to a specific value.

Trait Implementations

impl Clone for DeterministicUuidFactory

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DeterministicUuidFactory

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

Formats the value using the given formatter.