Struct Generator 

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

simple 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.

if you want to wait for the next available id without calling the function again check out blocking_next_id_mut 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::Generator<MyFlake>;

const START_TIME: u64 = 1679587200000;

let mut 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> Generator<F>

where F: FromIdGenerator + Sized,

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

where I: Into<F::IdSegType>,

returns a new Generator

will return an error if the primary id is invalid, the timestamp is invalid, it failes 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(&mut 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 Generator<F>

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

fn clone(&self) -> Generator<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F> IdGeneratorMut for Generator<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<<Generator<F> as IdGeneratorMut>::Id, <Generator<F> as IdGeneratorMut>::Error>

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

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

mutating call to get the next available id