Struct beryl::generator::Generator

pub struct Generator {
    pub id: u16,
    pub epoch: SystemTime,
    // some fields omitted
}

Generates Crystals

Fields

id: u16

The unique ID of this generator within the Beryl scope

epoch: SystemTime

The epoch which timestamps are measured from

Implementations

impl Generator

pub fn new(id: u16, epoch: SystemTime) -> Result<Self, BerylError>

Construct a new generator with the given ID and Epoch

pub fn generate(&mut self) -> Crystal

Generate a Crystal using the recommended blocking method, spinning until the millisecond is over. This may not be the best method for your use case. You should run your own benchmarks if Generator speed is a consideration.

Example

use std::time::SystemTime;

let mut gen = Generator::new(0, SystemTime::UNIX_EPOCH)?;

// Generate a few snowflakes
for _ in 0..2 {
    println!("{:?}", gen.generate());
}

pub fn try_generate(&mut self) -> Result<Crystal, BerylError>

Try to generate a Crystal, returning BerylError::GeneratorExhausted if the Generator has exhausted the set of Crystals which can be generated in that millisecond.

pub fn generate_block_sleep(&mut self) -> Crystal

Generate a Crystal, checking the time every 100ns when the counter is saturated. This wastes a little time if the system has a high-precision sleep call, and a lot if it doesn’t. You should do your own testing if Generator speed is a consideration.

pub fn generate_block_spin(&mut self) -> Crystal

Generate a Crystal, checking the time constantly until the next millisecond when the counter is saturated. This generates many syscalls; however, for use cases where the entire program must block on the generator or on systems which lack high-precision sleep calls, it may be the best option. You should do your own testing if Generator speed is a consideration.

pub fn generate_unchecked(&mut self) -> Crystal

Generate a Crystal without checking to make sure that Crystal hasn’t been generated before.

Warning

Do not use this unless you know what you are doing. If you aren’t absolutely sure you’ll produce less than 1024 Crystals/ms, this will create conflicting Crystals.

Trait Implementations

impl Debug for Generator

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

Formats the value using the given formatter.

impl PartialEq<Generator> for Generator

fn eq(&self, other: &Generator) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Generator) -> bool

This method tests for !=.

impl Eq for Generator

impl StructuralEq for Generator

impl StructuralPartialEq for Generator