Struct Generator 

pub struct Generator { /* private fields */ }

A Ulid generator that provides monotonically increasing Ulids

Implementations

impl Generator

pub const 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( &mut self, datetime: SystemTime, ) -> 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 std::time::SystemTime;

let dt = SystemTime::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 + ?Sized,

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 std::time::SystemTime;
use rand::prelude::*;

let mut rng = StdRng::from_os_rng();
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<R>( &mut self, datetime: SystemTime, source: &mut R, ) -> Result<Ulid, MonotonicError>

where R: Rng + ?Sized,

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 std::time::SystemTime;
use rand::prelude::*;

let dt = SystemTime::now();
let mut rng = StdRng::from_os_rng();
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.