Struct bones_framework::prelude::Ulid
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§
§impl Ulid
impl Ulid
pub 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();
pub 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);
pub 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());
pub 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);
pub 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()
);
§impl Ulid
impl Ulid
pub 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);
pub 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);
pub 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"
);
pub 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());
pub 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());
pub 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);
pub 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);
pub 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);
pub 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());
pub 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
pub const fn from_bytes(bytes: [u8; 16]) -> Ulid
pub const fn from_bytes(bytes: [u8; 16]) -> Ulid
Creates a Ulid using the provided bytes array.
§Example
use ulid::Ulid;
let bytes = [0xFF; 16];
let ulid = Ulid::from_bytes(bytes);
assert_eq!(
ulid.to_string(),
"7ZZZZZZZZZZZZZZZZZZZZZZZZZ"
);
Trait Implementations§
§impl Ord for Ulid
impl Ord for Ulid
§impl PartialOrd for Ulid
impl PartialOrd for Ulid
§fn partial_cmp(&self, other: &Ulid) -> Option<Ordering>
fn partial_cmp(&self, other: &Ulid) -> Option<Ordering>
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 moreimpl 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§
§impl<T> AnyEq for T
impl<T> AnyEq for T
§impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
§impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
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: Copy,
impl<T> CloneToUninit for Twhere
T: Copy,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)§impl<Q, K> Comparable<K> for Q
impl<Q, K> Comparable<K> for Q
§impl<T> Conv for T
impl<T> Conv for T
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
fn equivalent(&self, key: &K) -> bool
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
§impl<Q, K> Equivalent<K> for Q
impl<Q, K> Equivalent<K> for Q
§fn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
key
and return true
if they are equal.§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<S> FromSample<S> for S
impl<S> FromSample<S> for S
fn from_sample_(s: S) -> S
source§impl<T> FromWorld for Twhere
T: Default,
impl<T> FromWorld for Twhere
T: Default,
source§fn from_world(_world: &World) -> T
fn from_world(_world: &World) -> T
Self
using data from the given World
.§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
fn into_sample(self) -> T
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.source§impl<T> RawDefault for Twhere
T: Default,
impl<T> RawDefault for Twhere
T: Default,
§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.