[][src]Struct rusty_ulid::Ulid

pub struct Ulid { /* fields omitted */ }

The ULID data type.

Implementations

impl Ulid[src]

#[must_use]pub fn generate() -> Self[src]

Creates a new ULID.

Examples

use rusty_ulid::Ulid;

let ulid = Ulid::generate();

assert_ne!(0, ulid.timestamp());

let ulid_string = ulid.to_string();
// every ulid has exactly 26 characters
assert_eq!(ulid_string.len(), 26);

Panics

Panics if called after +10889-08-02T05:31:50.655Z.

#[must_use]pub fn next_monotonic(previous_ulid: Self) -> Self[src]

Creates the next monotonic ULID for the given previous_ulid.

If the random part of previous_ulid would overflow, this function returns a ULID with the random part set to zero.

Examples

use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0);
let ulid = Ulid::next_monotonic(previous_ulid);

assert_ne!(0, ulid.timestamp());

Panics

Panics if called after +10889-08-02T05:31:50.655Z.

#[must_use]pub fn next_strictly_monotonic(previous_ulid: Self) -> Option<Self>[src]

Creates the next strictly monotonic ULID for the given previous_ulid.

If the random part of previous_ulid would overflow, this function returns None.

Examples

use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0);
let ulid = Ulid::next_strictly_monotonic(previous_ulid);

if let Some(ulid) = ulid {
    assert_ne!(0, ulid.timestamp());
}

Panics

Panics if called after +10889-08-02T05:31:50.655Z.

pub fn from_timestamp_with_rng<R>(timestamp: u64, rng: &mut R) -> Self where
    R: Rng
[src]

Creates a new ULID with the given timestamp obtaining randomness from rng.

Examples

use rusty_ulid::Ulid;

let ulid = Ulid::from_timestamp_with_rng(0, &mut rand::thread_rng());

let timestamp = ulid.timestamp();

assert_eq!(timestamp, 0);

Panics

Panics if timestamp is larger than 0xFFFF_FFFF_FFFF.

pub fn next_monotonic_from_timestamp_with_rng<R>(
    previous_ulid: Self,
    timestamp: u64,
    rng: &mut R
) -> Self where
    R: Rng
[src]

Creates the next monotonic ULID with the given previous_ulid, timestamp obtaining randomness from rng.

If the random part of previous_ulid would overflow, this function returns a ULID with the random part set to zero.

Examples

use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0);
let ulid = Ulid::next_monotonic_from_timestamp_with_rng(previous_ulid, 0, &mut rand::thread_rng());

assert_eq!(ulid, Ulid::from(1));
use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFE);
let ulid = Ulid::next_monotonic_from_timestamp_with_rng(previous_ulid, 0, &mut rand::thread_rng());

assert_eq!(ulid, Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF));
use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF);
let ulid = Ulid::next_monotonic_from_timestamp_with_rng(previous_ulid, 0, &mut rand::thread_rng());

// overflow results in zero random part
assert_eq!(ulid, Ulid::from(0));

Panics

Panics if timestamp is larger than 0xFFFF_FFFF_FFFF.

pub fn next_monotonic_from_timestamp_with_rng_and_postprocessor<R>(
    previous_ulid: Option<Self>,
    timestamp: u64,
    rng: &mut R,
    postprocessor: Option<&dyn Fn(Self) -> Self>
) -> Self where
    R: Rng
[src]

Creates the next monotonic ULID with the given previous_ulid, timestamp obtaining randomness from rng. If a new ULID is created instead of simply incrementing the previous ULID, then postprocessor is used (if available) to transform the new ULID before returning it.

If the random part of previous_ulid would overflow, this function returns a ULID with the random part set to zero.

Examples

use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0);
let ulid = Ulid::next_monotonic_from_timestamp_with_rng_and_postprocessor(Some(previous_ulid), 0, &mut rand::thread_rng(), None);

assert_eq!(ulid, Ulid::from(1));
use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFE);
let ulid = Ulid::next_monotonic_from_timestamp_with_rng_and_postprocessor(Some(previous_ulid), 0, &mut rand::thread_rng(), None);

assert_eq!(ulid, Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF));
use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF);
let ulid = Ulid::next_monotonic_from_timestamp_with_rng_and_postprocessor(Some(previous_ulid), 0, &mut rand::thread_rng(), None);

// overflow results in zero random part
assert_eq!(ulid, Ulid::from(0));
use rusty_ulid::Ulid;

fn postprocessor_fn(ulid: Ulid) -> Ulid {
    // zero out lowest 32 bits
    Ulid::from(u128::from(ulid) & 0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_0000_0000)
}

let previous_ulid = Ulid::from(0);
let ulid = Ulid::next_monotonic_from_timestamp_with_rng_and_postprocessor(
    Some(previous_ulid),
    1,
    &mut rand::thread_rng(),
    Some(&postprocessor_fn),
);

assert_eq!(0, u128::from(ulid) & 0xFFFF_FFFF);

let ulid = Ulid::next_monotonic_from_timestamp_with_rng_and_postprocessor(
    None,
    1,
    &mut rand::thread_rng(),
    Some(&postprocessor_fn),
);

assert_eq!(0, u128::from(ulid) & 0xFFFF_FFFF);
assert_ne!(0, u128::from(ulid));

Panics

Panics if timestamp is larger than 0xFFFF_FFFF_FFFF.

pub fn next_strictly_monotonic_from_timestamp_with_rng<R>(
    previous_ulid: Self,
    timestamp: u64,
    rng: &mut R
) -> Option<Self> where
    R: Rng
[src]

Creates the next strictly monotonic ULID with the given previous_ulid, timestamp obtaining randomness from rng.

If the random part of previous_ulid would overflow, this function returns None.

Examples

use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0);
let ulid = Ulid::next_strictly_monotonic_from_timestamp_with_rng(previous_ulid, 0, &mut rand::thread_rng());

assert_eq!(ulid, Some(Ulid::from(1)));
use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFE);
let ulid = Ulid::next_strictly_monotonic_from_timestamp_with_rng(previous_ulid, 0, &mut rand::thread_rng());

assert_eq!(ulid, Some(Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF)));
use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF);
let ulid = Ulid::next_strictly_monotonic_from_timestamp_with_rng(previous_ulid, 0, &mut rand::thread_rng());

// overflow results in None
assert_eq!(ulid, None);

Panics

Panics if timestamp is larger than 0xFFFF_FFFF_FFFF.

pub fn next_strictly_monotonic_from_timestamp_with_rng_and_postprocessor<R>(
    previous_ulid: Option<Self>,
    timestamp: u64,
    rng: &mut R,
    postprocessor: Option<&dyn Fn(Self) -> Self>
) -> Option<Self> where
    R: Rng
[src]

Creates the next strictly monotonic ULID with the given previous_ulid, timestamp obtaining randomness from rng.

If the random part of previous_ulid would overflow, this function returns None.

Examples

use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0);
let ulid = Ulid::next_strictly_monotonic_from_timestamp_with_rng_and_postprocessor(
    Some(previous_ulid),
    0,
    &mut rand::thread_rng(),
    None,
);

assert_eq!(ulid, Some(Ulid::from(1)));
use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFE);
let ulid = Ulid::next_strictly_monotonic_from_timestamp_with_rng_and_postprocessor(
    Some(previous_ulid),
    0,
    &mut rand::thread_rng(),
    None,
);

assert_eq!(
    ulid,
    Some(Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF))
);
use rusty_ulid::Ulid;

let previous_ulid = Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF);
let ulid = Ulid::next_strictly_monotonic_from_timestamp_with_rng_and_postprocessor(
    Some(previous_ulid),
    0,
    &mut rand::thread_rng(),
    None,
);

// overflow results in None
assert_eq!(ulid, None);
use rusty_ulid::Ulid;

fn postprocessor_fn(ulid: Ulid) -> Ulid {
    // zero out lowest 32 bits
    Ulid::from(u128::from(ulid) & 0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_0000_0000)
}

let previous_ulid = Ulid::from(0);
let ulid = Ulid::next_strictly_monotonic_from_timestamp_with_rng_and_postprocessor(
    Some(previous_ulid),
    1,
    &mut rand::thread_rng(),
    Some(&postprocessor_fn),
);
let ulid = ulid.unwrap();

assert_eq!(0, u128::from(ulid) & 0xFFFF_FFFF);

let ulid = Ulid::next_strictly_monotonic_from_timestamp_with_rng_and_postprocessor(
    None,
    1,
    &mut rand::thread_rng(),
    Some(&postprocessor_fn),
);
let ulid = ulid.unwrap();

assert_eq!(0, u128::from(ulid) & 0xFFFF_FFFF);
assert_ne!(0, u128::from(ulid));

Panics

Panics if timestamp is larger than 0xFFFF_FFFF_FFFF.

#[must_use]pub fn timestamp(&self) -> u64[src]

Returns the timestamp of this ULID as number of non-leap milliseconds since January 1, 1970 0:00:00 UTC (aka "UNIX timestamp").

Examples

use rusty_ulid::Ulid;
use std::str::FromStr;

let ulid = Ulid::from_str("01CAH7NXGRDJNE9B1NY7PQGYV7")?;
let timestamp = ulid.timestamp();

assert_eq!(timestamp, 1523144390168);

#[must_use]pub fn datetime(&self) -> DateTime<Utc>[src]

Returns the timestamp of this ULID as a DateTime<Utc>.

Examples

use rusty_ulid::Ulid;
use std::str::FromStr;

let ulid = Ulid::from_str("01CAH7NXGRDJNE9B1NY7PQGYV7")?;
let datetime = ulid.datetime();

assert_eq!(datetime.to_string(), "2018-04-07 23:39:50.168 UTC");

#[must_use]pub fn increment(self) -> Self[src]

Returns a new ULID with the random part incremented by one.

Overflowing the random part resets it to zero without influencing the timestamp.

Examples

use rusty_ulid::Ulid;

let ulid = Ulid::from(0);
let incremented = ulid.increment();

assert_eq!(incremented, Ulid::from(1));
use rusty_ulid::Ulid;

let ulid = Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFE);
let incremented = ulid.increment();

assert_eq!(incremented, Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF));
use rusty_ulid::Ulid;

let ulid = Ulid::from(0x0000_0000_0000_FFFF_FFFF_FFFF_FFFF_FFFF);
let incremented = ulid.increment();

assert_eq!(incremented, Ulid::from(0));

#[must_use]pub fn to_string(&self) -> String[src]

Returns the string representaton of this ULID.

Examples

use rusty_ulid::Ulid;

let ulid = Ulid::from(0);

assert_eq!(ulid.to_string(), "00000000000000000000000000");
use rusty_ulid::Ulid;

let ulid = Ulid::from(0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF);

assert_eq!(ulid.to_string(), "7ZZZZZZZZZZZZZZZZZZZZZZZZZ");

Trait Implementations

impl Clone for Ulid[src]

impl Copy for Ulid[src]

impl Debug for Ulid[src]

impl<'de> Deserialize<'de> for Ulid[src]

impl Display for Ulid[src]

impl Eq for Ulid[src]

impl From<[u8; 16]> for Ulid[src]

#[must_use]fn from(bytes: [u8; 16]) -> Self[src]

Examples

use rusty_ulid::Ulid;

let bytes: [u8; 16] = [
    0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
    0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xF0, 0x0F,
];

let ulid = Ulid::from(bytes);

let expected_ulid = Ulid::from(0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F);

assert_eq!(ulid, expected_ulid);
use rusty_ulid::Ulid;

let bytes: [u8; 16] = [
    0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
    0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xF0, 0x0F,
];

let ulid : Ulid = bytes.into();

let expected_ulid = Ulid::from(0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F);

assert_eq!(ulid, expected_ulid);

impl From<(u64, u64)> for Ulid[src]

#[must_use]fn from(value: (u64, u64)) -> Self[src]

Examples

use rusty_ulid::Ulid;

let tuple = (0x1122_3344_5566_7788, 0x99AA_BBCC_DDEE_F00F);

let ulid = Ulid::from(tuple);

let expected_ulid = Ulid::from(0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F);

assert_eq!(ulid, expected_ulid);
use rusty_ulid::Ulid;

let tuple = (0x1122_3344_5566_7788, 0x99AA_BBCC_DDEE_F00F);

let ulid : Ulid = tuple.into();

let expected_ulid = Ulid::from(0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F);

assert_eq!(ulid, expected_ulid);

impl From<u128> for Ulid[src]

#[must_use]fn from(value: u128) -> Self[src]

Examples

use rusty_ulid::Ulid;

let value = 0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F;

let ulid = Ulid::from(value);

let expected_ulid = Ulid::from((0x1122_3344_5566_7788, 0x99AA_BBCC_DDEE_F00F));

assert_eq!(ulid, expected_ulid);
use rusty_ulid::Ulid;

let value = 0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F;

let ulid : Ulid = value.into();

let expected_ulid = Ulid::from((0x1122_3344_5566_7788, 0x99AA_BBCC_DDEE_F00F));

assert_eq!(ulid, expected_ulid);

impl FromStr for Ulid[src]

type Err = DecodingError

The associated error which can be returned from parsing.

impl Hash for Ulid[src]

impl Ord for Ulid[src]

impl PartialEq<Ulid> for Ulid[src]

impl PartialOrd<Ulid> for Ulid[src]

impl Serialize for Ulid[src]

impl StructuralEq for Ulid[src]

impl StructuralPartialEq for Ulid[src]

impl TryFrom<&'_ [u8]> for Ulid[src]

type Error = DecodingError

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Self, DecodingError>[src]

Returns a ULID for the given slice of bytes or DecodingError::InvalidLength if the slice does not contain exactly 16 bytes.

Examples

use rusty_ulid::Ulid;
use std::convert::TryFrom;
use std::convert::TryInto;

let bytes: [u8; 18] = [
    0x00,
    0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
    0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xF0, 0x0F,
    0x00,
];

let ulid : Ulid = Ulid::try_from(&bytes[1..17])?;

let expected_ulid = Ulid::from(0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F);

assert_eq!(ulid, expected_ulid);

let ulid : Ulid = (&bytes[1..17]).try_into()?;

let expected_ulid = Ulid::from(0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F);

assert_eq!(ulid, expected_ulid);
use rusty_ulid::Ulid;
use rusty_ulid::DecodingError;
use std::convert::TryFrom;

let mut bytes: [u8; 17] = [0; 17];
let result = Ulid::try_from(&bytes[0..]);

assert_eq!(result, Err(DecodingError::InvalidLength))
use rusty_ulid::Ulid;
use rusty_ulid::DecodingError;
use std::convert::TryFrom;

let mut bytes: [u8; 15] = [0; 15];
let result = Ulid::try_from(&bytes[0..]);

assert_eq!(result, Err(DecodingError::InvalidLength))

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> DeserializeOwned for T where
    T: for<'de> Deserialize<'de>, 
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,