Struct mas_data_model::Ulid
source · pub struct Ulid(pub u128);
Expand description
A Ulid is a unique 128-bit lexicographically sortable identifier
Canonically, it is represented as a 26 character Crockford Base32 encoded string.
Of the 128-bits, the first 48 are a unix timestamp in milliseconds. The remaining 80 are random. The first 48 provide for lexicographic sorting and the remaining 80 ensure that the identifier is unique.
Tuple Fields§
§0: u128
Implementations§
source§impl Ulid
impl Ulid
sourcepub fn new() -> Ulid
pub fn new() -> Ulid
Creates a new Ulid with the current time (UTC)
Using this function to generate Ulids will not guarantee monotonic sort order. See [ulid::Generator] for a monotonic sort order.
§Example
use ulid::Ulid;
let my_ulid = Ulid::new();
sourcepub fn with_source<R>(source: &mut R) -> Ulidwhere
R: Rng,
pub fn with_source<R>(source: &mut R) -> Ulidwhere
R: Rng,
Creates a new Ulid using data from the given random number generator
§Example
use rand::prelude::*;
use ulid::Ulid;
let mut rng = StdRng::from_entropy();
let ulid = Ulid::with_source(&mut rng);
sourcepub fn from_datetime(datetime: SystemTime) -> Ulid
pub fn from_datetime(datetime: SystemTime) -> Ulid
Creates a new Ulid with the given datetime
This can be useful when migrating data to use Ulid identifiers.
This will take the maximum of the [SystemTime]
argument and [SystemTime::UNIX_EPOCH]
as earlier times are not valid for a Ulid timestamp
§Example
use std::time::{SystemTime, Duration};
use ulid::Ulid;
let ulid = Ulid::from_datetime(SystemTime::now());
sourcepub fn from_datetime_with_source<R>(
datetime: SystemTime,
source: &mut R,
) -> Ulid
pub fn from_datetime_with_source<R>( datetime: SystemTime, source: &mut R, ) -> Ulid
Creates a new Ulid with the given datetime and random number generator
This will take the maximum of the [SystemTime]
argument and [SystemTime::UNIX_EPOCH]
as earlier times are not valid for a Ulid timestamp
§Example
use std::time::{SystemTime, Duration};
use rand::prelude::*;
use ulid::Ulid;
let mut rng = StdRng::from_entropy();
let ulid = Ulid::from_datetime_with_source(SystemTime::now(), &mut rng);
sourcepub fn datetime(&self) -> SystemTime
pub fn datetime(&self) -> SystemTime
Gets the datetime of when this Ulid was created accurate to 1ms
§Example
use std::time::{SystemTime, Duration};
use ulid::Ulid;
let dt = SystemTime::now();
let ulid = Ulid::from_datetime(dt);
assert!(
dt + Duration::from_millis(1) >= ulid.datetime()
&& dt - Duration::from_millis(1) <= ulid.datetime()
);
source§impl Ulid
impl Ulid
sourcepub const fn from_parts(timestamp_ms: u64, random: u128) -> Ulid
pub const fn from_parts(timestamp_ms: u64, random: u128) -> Ulid
Create a Ulid from separated parts.
NOTE: Any overflow bits in the given args are discarded
§Example
use ulid::Ulid;
let ulid = Ulid::from_string("01D39ZY06FGSCTVN4T2V9PKHFZ").unwrap();
let ulid2 = Ulid::from_parts(ulid.timestamp_ms(), ulid.random());
assert_eq!(ulid, ulid2);
sourcepub const fn from_string(encoded: &str) -> Result<Ulid, DecodeError>
pub const fn from_string(encoded: &str) -> Result<Ulid, DecodeError>
Creates a Ulid from a Crockford Base32 encoded string
An DecodeError will be returned when the given string is not formatted properly.
§Example
use ulid::Ulid;
let text = "01D39ZY06FGSCTVN4T2V9PKHFZ";
let result = Ulid::from_string(text);
assert!(result.is_ok());
assert_eq!(&result.unwrap().to_string(), text);
sourcepub const fn nil() -> Ulid
pub const fn nil() -> Ulid
The ‘nil Ulid’.
The nil Ulid is special form of Ulid that is specified to have all 128 bits set to zero.
§Example
use ulid::Ulid;
let ulid = Ulid::nil();
assert_eq!(
ulid.to_string(),
"00000000000000000000000000"
);
sourcepub const fn timestamp_ms(&self) -> u64
pub const fn timestamp_ms(&self) -> u64
Gets the timestamp section of this ulid
§Example
use std::time::{SystemTime, Duration};
use ulid::Ulid;
let dt = SystemTime::now();
let ulid = Ulid::from_datetime(dt);
assert_eq!(u128::from(ulid.timestamp_ms()), dt.duration_since(SystemTime::UNIX_EPOCH).unwrap_or(Duration::ZERO).as_millis());
sourcepub const fn random(&self) -> u128
pub const fn random(&self) -> u128
Gets the random section of this ulid
§Example
use ulid::Ulid;
let text = "01D39ZY06FGSCTVN4T2V9PKHFZ";
let ulid = Ulid::from_string(text).unwrap();
let ulid_next = ulid.increment().unwrap();
assert_eq!(ulid.random() + 1, ulid_next.random());
sourcepub fn to_str<'buf>(
&self,
buf: &'buf mut [u8],
) -> Result<&'buf mut str, EncodeError>
👎Deprecated since 1.2.0: Use the infallible array_to_str
instead.
pub fn to_str<'buf>( &self, buf: &'buf mut [u8], ) -> Result<&'buf mut str, EncodeError>
array_to_str
instead.Creates a Crockford Base32 encoded string that represents this Ulid
§Example
use ulid::Ulid;
let text = "01D39ZY06FGSCTVN4T2V9PKHFZ";
let ulid = Ulid::from_string(text).unwrap();
let mut buf = [0; ulid::ULID_LEN];
let new_text = ulid.to_str(&mut buf).unwrap();
assert_eq!(new_text, text);
sourcepub fn array_to_str<'buf>(&self, buf: &'buf mut [u8; 26]) -> &'buf mut str
pub fn array_to_str<'buf>(&self, buf: &'buf mut [u8; 26]) -> &'buf mut str
Creates a Crockford Base32 encoded string that represents this Ulid
§Example
use ulid::Ulid;
let text = "01D39ZY06FGSCTVN4T2V9PKHFZ";
let ulid = Ulid::from_string(text).unwrap();
let mut buf = [0; ulid::ULID_LEN];
let new_text = ulid.array_to_str(&mut buf);
assert_eq!(new_text, text);
sourcepub fn to_string(&self) -> String
pub fn to_string(&self) -> String
Creates a Crockford Base32 encoded string that represents this Ulid
§Example
use ulid::Ulid;
let text = "01D39ZY06FGSCTVN4T2V9PKHFZ";
let ulid = Ulid::from_string(text).unwrap();
assert_eq!(&ulid.to_string(), text);
sourcepub const fn is_nil(&self) -> bool
pub const fn is_nil(&self) -> bool
Test if the Ulid is nil
§Example
use ulid::Ulid;
let ulid = Ulid::new();
assert!(!ulid.is_nil());
let nil = Ulid::nil();
assert!(nil.is_nil());
sourcepub const fn increment(&self) -> Option<Ulid>
pub const fn increment(&self) -> Option<Ulid>
Increment the random number, make sure that the ts millis stays the same
Trait Implementations§
source§impl<'de> Deserialize<'de> for Ulid
impl<'de> Deserialize<'de> for Ulid
source§fn deserialize<D>(
deserializer: D,
) -> Result<Ulid, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
fn deserialize<D>(
deserializer: D,
) -> Result<Ulid, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,
source§impl Ord for Ulid
impl Ord for Ulid
source§impl PartialOrd for Ulid
impl PartialOrd for Ulid
source§impl Serialize for Ulid
impl Serialize for Ulid
source§fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
fn serialize<S>(
&self,
serializer: S,
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,
impl Copy for Ulid
impl Eq for Ulid
impl StructuralPartialEq for Ulid
Auto Trait Implementations§
impl Freeze for Ulid
impl RefUnwindSafe for Ulid
impl Send for Ulid
impl Sync for Ulid
impl Unpin for Ulid
impl UnwindSafe for Ulid
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.source§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
source§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more