Struct rusty_ulid::Ulid
source · [−]pub struct Ulid { /* private fields */ }
Expand description
The ULID data type.
Implementations
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
.
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 next_monotonic_from_timestamp_with_rng<R>(
previous_ulid: Self,
timestamp: u64,
rng: &mut R
) -> Self where
R: Rng,
pub fn next_monotonic_from_timestamp_with_rng<R>(
previous_ulid: Self,
timestamp: u64,
rng: &mut R
) -> Self where
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
.
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
.
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
.
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
.
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);
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");
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));
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
Deserialize this value from the given Serde deserializer. Read more
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);
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);
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);
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);
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);
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);
This method returns an ordering between self
and other
values if one exists. Read more
This method tests less than (for self
and other
) and is used by the <
operator. Read more
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
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))
type Error = DecodingError
type Error = DecodingError
The type returned in the event of a conversion error.
Auto Trait Implementations
impl RefUnwindSafe for Ulid
impl UnwindSafe for Ulid
Blanket Implementations
Mutably borrows from an owned value. Read more