[−][src]Struct rusty_ulid::Ulid
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]
R: Rng,
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]
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
.
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]
previous_ulid: Option<Self>,
timestamp: u64,
rng: &mut R,
postprocessor: Option<&dyn Fn(Self) -> Self>
) -> Self where
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
.
pub fn next_strictly_monotonic_from_timestamp_with_rng<R>(
previous_ulid: Self,
timestamp: u64,
rng: &mut R
) -> Option<Self> where
R: Rng,
[src]
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
.
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]
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
.
#[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]
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
[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<Ulid> for [u8; 16]
[src]
#[must_use]fn from(ulid: Ulid) -> Self
[src]
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);
impl From<Ulid> for (u64, u64)
[src]
#[must_use]fn from(ulid: Ulid) -> Self
[src]
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);
impl From<Ulid> for u128
[src]
#[must_use]fn from(ulid: Ulid) -> Self
[src]
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);
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.
fn from_str(s: &str) -> Result<Self, Self::Err>
[src]
impl Hash for Ulid
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl Ord for Ulid
[src]
fn cmp(&self, other: &Ulid) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl PartialEq<Ulid> for Ulid
[src]
impl PartialOrd<Ulid> for Ulid
[src]
fn partial_cmp(&self, other: &Ulid) -> Option<Ordering>
[src]
fn lt(&self, other: &Ulid) -> bool
[src]
fn le(&self, other: &Ulid) -> bool
[src]
fn gt(&self, other: &Ulid) -> bool
[src]
fn ge(&self, other: &Ulid) -> bool
[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
impl RefUnwindSafe for Ulid
impl Send for Ulid
impl Sync for Ulid
impl Unpin for Ulid
impl UnwindSafe for Ulid
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> DeserializeOwned for T where
T: for<'de> Deserialize<'de>,
[src]
T: for<'de> Deserialize<'de>,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,