Struct MutexGenerator 

pub struct MutexGenerator<F>
where
    F: FromIdGenerator,
{ /* private fields */ }

thread safe snowflake generator

generates a given snowflake with the provided epoch and id value. epoch is a specified date that can be in the future of UNIX_EPOCH but not in the future of now. the sequence value will always start at 1 when created.

this guards the previous time and sequence count behind an Arc Mutex. the critical section is small and will not block if its unable to get a valid snowflake.

if you want to wait for the next available id without calling the function again check out blocking_next_id or other waiting methods depending on how you want to wait for the next available id.

type MyFlake = snowcloud::i64::SingleIdFlake<43, 8, 12>;
type MyCloud = snowcloud::sync::MutexGenerator<MyFlake>;

const START_TIME: u64 = 1679587200000;

let cloud = MyCloud::new(START_TIME, 1)
    .expect("failed to create MyCloud");

println!("epoch: {:?}", cloud.epoch());
println!("ids: {}", cloud.ids());

println!("{:?}", cloud.next_id());

Implementations

impl<F> MutexGenerator<F>

where F: FromIdGenerator,

pub fn new<I>(epoch: u64, ids: I) -> Result<Self, Error>

where I: Into<F::IdSegType>,

returns a new MutexGenerator

will return an error if ids is invalid, the timestamp is invalid, it fails to retrieve the current timestamp, or if the epoch is ahead of the current timestamp

pub fn epoch(&self) -> &SystemTime

returns epoch

pub fn ids(&self) -> &F::IdSegType

returns ids

type is determined by the provided snowflake

pub fn next_id(&self) -> Result<F, Error>

retrieves the next available id

if the current timestamp reaches max, the max sequence value is reached, or if it fails to get the current timestamp this will return an error.

Trait Implementations

impl<F> Clone for MutexGenerator<F>

where F: FromIdGenerator, F::IdSegType: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F> IdGenerator for MutexGenerator<F>

where F: FromIdGenerator,

type Error = Error

the potential error that could be returned from next_id

type Id = F

the actual Id type that is returned from next_id

type Output = Result<<MutexGenerator<F> as IdGenerator>::Id, <MutexGenerator<F> as IdGenerator>::Error>

to help with allowing for different situations, Output can what ever is needed. a Result or if used in an async context then an impl of Future

fn next_id(&self) -> Self::Output

call to get the next available id