Struct Ulid 

pub struct Ulid(/* private fields */);

A ULID: 128 bits made of a 48-bit millisecond timestamp and 80 random bits, written as 26 characters of Crockford’s base32 (01ARYZ6S41TSV4RRFFQ69G5FAV).

Ulids sort by creation time, both as numbers and as text, and are shorter than a UUID. Time and randomness are parameters of from_parts; with the random-entropy feature, new takes them from the system. Ids made in the same millisecond are not ordered among themselves (there is no monotonic counter).

Examples

use helpers4::id::Ulid;

let id = Ulid::from_parts(1_469_918_176_385, [0; 10]);
assert_eq!(id.to_string(), "01ARYZ6S410000000000000000");
assert_eq!(id.timestamp_millis(), 1_469_918_176_385);
assert_eq!(Ulid::parse("01ARYZ6S41TSV4RRFFQ69G5FAV").map(|u| u.timestamp_millis()), Ok(1_469_918_176_385));

Implementations

impl Ulid

pub const fn from_parts(unix_millis: u64, random: [u8; 10]) -> Self

Builds a ULID from a timestamp and 80 random bits. Only the low 48 bits of unix_millis are kept, enough until the year 10889.

Arguments

• unix_millis - Milliseconds since 1970-01-01 UTC.
• random - 10 random bytes, from a secure source for an id that must be unpredictable.

Returns

The ULID.

Examples

use helpers4::id::Ulid;

assert_eq!(Ulid::from_parts(0, [0xff; 10]).to_string(), "0000000000ZZZZZZZZZZZZZZZZ");

pub const fn from_u128(value: u128) -> Self

Wraps a 128-bit value as it is.

Arguments

• value - The 128 bits: the timestamp in the top 48, then the random part.

Returns

The ULID.

Examples

use helpers4::id::Ulid;

assert_eq!(Ulid::from_u128(1).to_string(), "00000000000000000000000001");

pub const fn as_u128(&self) -> u128

The ULID as a 128-bit number.

Returns

The timestamp in the top 48 bits, then the random part.

Examples

use helpers4::id::Ulid;

assert_eq!(Ulid::from_parts(0, [0, 0, 0, 0, 0, 0, 0, 0, 0, 7]).as_u128(), 7);

pub const fn timestamp_millis(&self) -> u64

The creation time stored in the ULID.

Returns

Milliseconds since 1970-01-01 UTC.

Examples

use helpers4::id::Ulid;

assert_eq!(Ulid::from_parts(1234, [9; 10]).timestamp_millis(), 1234);

pub fn parse(text: &str) -> Result<Self, ParseUlidError>

Reads a ULID from its 26-character form, in upper or lower case. Only the 32 symbols of Crockford’s base32 are accepted (I, L, O and U are not).

Arguments

• text - The text to read.

Returns

The ULID.

Errors

Returns a ParseUlidError for a length other than 26, a character outside the alphabet, or a first character above 7 (the value would not fit in 128 bits).

Examples

use helpers4::id::Ulid;

let id = Ulid::parse("01aryz6s41tsv4rrffq69g5fav")?;
assert_eq!(id.to_string(), "01ARYZ6S41TSV4RRFFQ69G5FAV");

Trait Implementations

impl Clone for Ulid

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Ulid

impl Debug for Ulid

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

Formats the value using the given formatter.

impl Display for Ulid

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

Formats the value using the given formatter.

impl Eq for Ulid

impl FromStr for Ulid

type Err = ParseUlidError

The associated error which can be returned from parsing.

fn from_str(text: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Ulid

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Ulid

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Ulid

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Ulid

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Ulid