Struct ulid::Generator

pub struct Generator { /* fields omitted */ }

A Ulid generator that provides monotonically increasing Ulids

Implementations

impl Generator

pub fn new() -> Generator

Create a new ulid generator for monotonically ordered ulids

Example

use ulid::Generator;

let mut gen = Generator::new();

let ulid1 = gen.generate().unwrap();
let ulid2 = gen.generate().unwrap();

assert!(ulid1 < ulid2);

pub fn generate(&mut self) -> Result<Ulid, MonotonicError>

Generate a new Ulid. Each call is guaranteed to provide a Ulid with a larger value than the last call. If the random bits would overflow, this method will return an error.

use ulid::Generator;
let mut gen = Generator::new();

let ulid1 = gen.generate().unwrap();
let ulid2 = gen.generate().unwrap();

assert!(ulid1 < ulid2);

pub fn generate_from_datetime<T: TimeZone>(
    &mut self,
    datetime: DateTime<T>
) -> Result<Ulid, MonotonicError>

Generate a new Ulid matching the given DateTime. Each call is guaranteed to provide a Ulid with a larger value than the last call. If the random bits would overflow, this method will return an error.

Example

use ulid::Generator;
use chrono::Utc;

let dt = Utc::now();
let mut gen = Generator::new();

let ulid1 = gen.generate_from_datetime(dt).unwrap();
let ulid2 = gen.generate_from_datetime(dt).unwrap();

assert_eq!(ulid1.datetime(), ulid2.datetime());
assert!(ulid1 < ulid2);

pub fn generate_with_source<R>(
    &mut self,
    source: &mut R
) -> Result<Ulid, MonotonicError> where
    R: Rng, 

Generate a new monotonic increasing Ulid with the given source Each call is guaranteed to provide a Ulid with a larger value than the last call. If the random bits would overflow, this method will return an error.

Example

use ulid::Generator;
use ulid::Ulid;
use chrono::Utc;
use rand::FromEntropy;
use rand::rngs::SmallRng;

let mut rng = SmallRng::from_entropy();
let mut gen = Generator::new();

let ulid1 = gen.generate_with_source(&mut rng).unwrap();
let ulid2 = gen.generate_with_source(&mut rng).unwrap();

assert!(ulid1 < ulid2);

pub fn generate_from_datetime_with_source<T, R>(
    &mut self,
    datetime: DateTime<T>,
    source: &mut R
) -> Result<Ulid, MonotonicError> where
    T: TimeZone,
    R: Rng, 

Generate a new monotonic increasing Ulid with the given source matching the given DateTime Each call is guaranteed to provide a Ulid with a larger value than the last call. If the random bits would overflow, this method will return an error.

Example

use ulid::Generator;
use chrono::Utc;
use rand::FromEntropy;
use rand::rngs::SmallRng;

let dt = Utc::now();
let mut rng = SmallRng::from_entropy();
let mut gen = Generator::new();

let ulid1 = gen.generate_from_datetime_with_source(dt, &mut rng).unwrap();
let ulid2 = gen.generate_from_datetime_with_source(dt, &mut rng).unwrap();

assert_eq!(ulid1.datetime(), ulid2.datetime());
assert!(ulid1 < ulid2);

Trait Implementations

impl Default for Generator

fn default() -> Self

Returns the "default value" for a type.