Struct rusty_ulid::Ulid
source · pub struct Ulid { /* private fields */ }
Expand description
The ULID data type.
Implementations§
source§impl Ulid
impl Ulid
sourcepub fn next_monotonic(previous_ulid: Self) -> Self
pub fn next_monotonic(previous_ulid: Self) -> Self
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
.
sourcepub fn next_strictly_monotonic(previous_ulid: Self) -> Option<Self>
pub fn next_strictly_monotonic(previous_ulid: Self) -> Option<Self>
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
.
sourcepub fn from_timestamp_with_rng<R>(timestamp: u64, rng: &mut R) -> Selfwhere
R: Rng,
pub fn from_timestamp_with_rng<R>(timestamp: u64, rng: &mut R) -> Selfwhere
R: Rng,
sourcepub fn next_monotonic_from_timestamp_with_rng<R>(
previous_ulid: Self,
timestamp: u64,
rng: &mut R
) -> Selfwhere
R: Rng,
pub fn next_monotonic_from_timestamp_with_rng<R>(
previous_ulid: Self,
timestamp: u64,
rng: &mut R
) -> Selfwhere
R: Rng,
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
.
sourcepub 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>
) -> Selfwhere
R: Rng,
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>
) -> Selfwhere
R: Rng,
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
.
sourcepub fn next_strictly_monotonic_from_timestamp_with_rng<R>(
previous_ulid: Self,
timestamp: u64,
rng: &mut R
) -> Option<Self>where
R: Rng,
pub fn next_strictly_monotonic_from_timestamp_with_rng<R>(
previous_ulid: Self,
timestamp: u64,
rng: &mut R
) -> Option<Self>where
R: Rng,
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
.
sourcepub 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,
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,
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
.
sourcepub fn timestamp(&self) -> u64
pub fn timestamp(&self) -> u64
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);
sourcepub fn offsetdatetime(&self) -> OffsetDateTime
pub fn offsetdatetime(&self) -> OffsetDateTime
Returns the timestamp of this ULID as a OffsetDateTime
.
Examples
use rusty_ulid::Ulid;
use std::str::FromStr;
let ulid = Ulid::from_str("01CAH7NXGRDJNE9B1NY7PQGYV7")?;
let datetime = ulid.offsetdatetime();
assert_eq!(datetime.to_string(), "2018-04-07 23:39:50.168 +00:00:00");
sourcepub fn increment(self) -> Self
pub fn increment(self) -> Self
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));
sourcepub fn to_string(&self) -> String
pub fn to_string(&self) -> String
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§
source§impl<'de> Deserialize<'de> for Ulid
impl<'de> Deserialize<'de> for Ulid
source§fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
source§impl From<[u8; 16]> for Ulid
impl From<[u8; 16]> for Ulid
source§fn from(bytes: [u8; 16]) -> Self
fn from(bytes: [u8; 16]) -> Self
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);
source§impl From<(u64, u64)> for Ulid
impl From<(u64, u64)> for Ulid
source§fn from(value: (u64, u64)) -> Self
fn from(value: (u64, u64)) -> Self
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);
source§impl From<Ulid> for [u8; 16]
impl From<Ulid> for [u8; 16]
source§fn from(ulid: Ulid) -> Self
fn from(ulid: Ulid) -> Self
Examples
use rusty_ulid::Ulid;
let ulid = Ulid::from(0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F);
let bytes = <[u8; 16]>::from(ulid);
let expected_bytes: [u8; 16] = [
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xF0, 0x0F,
];
assert_eq!(bytes, expected_bytes);
use rusty_ulid::Ulid;
let ulid = Ulid::from(0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F);
let bytes: [u8; 16] = ulid.into();
let expected_bytes: [u8; 16] = [
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88,
0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xF0, 0x0F,
];
assert_eq!(bytes, expected_bytes);
source§impl From<Ulid> for (u64, u64)
impl From<Ulid> for (u64, u64)
source§fn from(ulid: Ulid) -> Self
fn from(ulid: Ulid) -> Self
Examples
use rusty_ulid::Ulid;
let ulid = Ulid::from(0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F);
let tuple = <(u64, u64)>::from(ulid);
let expected_tuple = (0x1122_3344_5566_7788, 0x99AA_BBCC_DDEE_F00F);
assert_eq!(tuple, expected_tuple);
use rusty_ulid::Ulid;
let ulid = Ulid::from(0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F);
let tuple : (u64, u64) = ulid.into();
let expected_tuple = (0x1122_3344_5566_7788, 0x99AA_BBCC_DDEE_F00F);
assert_eq!(tuple, expected_tuple);
source§impl From<Ulid> for u128
impl From<Ulid> for u128
source§fn from(ulid: Ulid) -> Self
fn from(ulid: Ulid) -> Self
Examples
use rusty_ulid::Ulid;
let ulid = Ulid::from((0x1122_3344_5566_7788, 0x99AA_BBCC_DDEE_F00F));
let value = <u128>::from(ulid);
let expected_value = 0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F;
assert_eq!(value, expected_value);
use rusty_ulid::Ulid;
let ulid = Ulid::from((0x1122_3344_5566_7788, 0x99AA_BBCC_DDEE_F00F));
let value : u128 = ulid.into();
let expected_value = 0x1122_3344_5566_7788_99AA_BBCC_DDEE_F00F;
assert_eq!(value, expected_value);
source§impl From<u128> for Ulid
impl From<u128> for Ulid
source§fn from(value: u128) -> Self
fn from(value: u128) -> Self
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);
source§impl Ord for Ulid
impl Ord for Ulid
source§impl PartialEq<Ulid> for Ulid
impl PartialEq<Ulid> for Ulid
source§impl PartialOrd<Ulid> for Ulid
impl PartialOrd<Ulid> for Ulid
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl TryFrom<&[u8]> for Ulid
impl TryFrom<&[u8]> for Ulid
source§fn try_from(bytes: &[u8]) -> Result<Self, DecodingError>
fn try_from(bytes: &[u8]) -> Result<Self, DecodingError>
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))