Enum IdGenStatus

pub enum IdGenStatus<T: Snowflake> {
    Ready {
        id: T,
    },
    Pending {
        yield_until: T::Ty,
    },
}

Represents the result of attempting to generate a new Snowflake ID.

This type models the outcome of SnowflakeGenerator::try_next_id():

• IdGenStatus::Ready indicates a new ID was successfully generated.
• IdGenStatus::Pending means the generator is throttled and cannot produce a new ID until the clock advances past yield_until.

This allows non-blocking generation loops and clean backoff strategies.

Example

use ferroid::{Snowflake, BasicSnowflakeGenerator, SnowflakeTwitterId, IdGenStatus};

struct FixedTime;
impl ferroid::TimeSource<u64> for FixedTime {
    fn current_millis(&self) -> u64 {
        1
    }
}

let mut generator = BasicSnowflakeGenerator::<_, SnowflakeTwitterId>::from_components(0, 1, SnowflakeTwitterId::max_sequence(), FixedTime);
match generator.next_id() {
    IdGenStatus::Ready { id } => println!("ID: {}", id.timestamp()),
    IdGenStatus::Pending { yield_until } => println!("Back off until: {yield_until}"),
}

Variants

Ready

A unique ID was generated and is ready to use.

Fields

id: T

The generated Snowflake ID.

Pending

No ID could be generated because the sequence has been exhausted for the current tick.

You should wait until the clock reaches or exceeds yield_until before attempting to generate a new ID again.

Fields

yield_until: T::Ty

The next timestamp (inclusive) at which you may resume generating IDs.

Trait Implementations

impl<T: Clone + Snowflake> Clone for IdGenStatus<T>

where T::Ty: Clone,

fn clone(&self) -> IdGenStatus<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Snowflake> Debug for IdGenStatus<T>

where T::Ty: Debug,

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

Formats the value using the given formatter.

impl<T: PartialEq + Snowflake> PartialEq for IdGenStatus<T>

where T::Ty: PartialEq,

fn eq(&self, other: &IdGenStatus<T>) -> 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<T: Copy + Snowflake> Copy for IdGenStatus<T>

where T::Ty: Copy,

impl<T: Eq + Snowflake> Eq for IdGenStatus<T>

where T::Ty: Eq,

impl<T: Snowflake> StructuralPartialEq for IdGenStatus<T>