Struct nuuid::Uuid

#[repr(transparent)]
pub struct Uuid(_);

Universally Unique Identifier, or UUID.

This type is repr(transparent) and guaranteed to have the same layout as [u8; 16].

The various methods on Uuid assume each field is laid out Most Significant Byte First/MSB/Big-Endian/Network Endian.

This type is also serde(transparent), when serde is enabled.

Implementations

impl Uuid

pub const fn nil() -> Self

The special Nil UUID, where all bits are set to zero.

pub const fn from_bytes(bytes: Bytes) -> Self

Create a UUID from bytes.

pub const fn to_bytes(self) -> Bytes

Return the UUID as it’s bytes.

pub fn from_bytes_me(bytes: Bytes) -> Self

Create a UUID from mixed-endian bytes.

Note

This is primarily for compatibility with version 2 UUID’s, which use a mixed-endian format where the first three fields are little-endian.

Common modern use of this format is found in Microsoft GUID’s and UEFI UUID’s.

pub fn to_bytes_me(self) -> Bytes

Return the UUID as mixed-endian bytes.

See Uuid::from_bytes_me for details.

pub fn is_nil(self) -> bool

Returns true if the UUID is nil.

pub fn variant(self) -> Variant

The UUID Variant

Warning

Many UUIDs out in the wild are incorrectly generated, so this value can’t be relied upon.

pub fn version(self) -> Version

The UUID Version

Warning

Many UUIDs out in the wild are incorrectly generated, so this value can’t be relied upon.

pub fn to_str(self, buf: &mut [u8; 36]) -> &mut str

Write UUID as a lowercase ASCII string into buf, and returns it as a string.

Examples

With an array

let mut buf = [0u8; 36];
uuid.to_str(&mut buf);

With a slice

let mut buf = [0u8; 50];

let buf: &mut [u8] = &mut buf;
uuid.to_str((&mut buf[..36]).try_into().unwrap());

With a slice, incorrectly.

let mut buf = [0u8; 50];

let buf: &mut [u8] = &mut buf;
uuid.to_str(buf.try_into().unwrap());

pub fn to_urn(self, buf: &mut [u8; 45]) -> &mut str

Write a UUID as a lowercase ASCII string into buf, and return it as a string.

For usage examples see Uuid::to_str.

pub fn to_str_upper(self, buf: &mut [u8; 36]) -> &mut str

Uuid::to_str, but uppercase.

pub fn to_urn_upper(self, buf: &mut [u8; 45]) -> &mut str

Uuid::to_urn, but the UUID is uppercase.

impl Uuid

pub fn parse(s: &str) -> Result<Self, ParseUuidError>

Parse a Uuid from a string

Case insensitive and supports “urn:uuid:”

Example

Uuid::parse("662aa7c7-7598-4d56-8bcc-a72c30f998a2").unwrap();
Uuid::parse("662AA7C7-7598-4D56-8BCC-A72C30F998A2").unwrap();

Uuid::parse("urn:uuid:662aa7c7-7598-4d56-8bcc-a72c30f998a2").unwrap();
Uuid::parse("urn:uuid:662AA7C7-7598-4D56-8BCC-A72C30F998A2").unwrap();

pub fn new_v4() -> Self

This is supported on crate feature getrandom only.

Create a new Version 4(Random) UUID.

This requires the getrandom feature.

If generating a lot of UUID’s very quickly, prefer Uuid::new_v4_rng.

Example

let uuid = Uuid::new_v4();

pub fn new_v4_rng(rng: &mut Rng) -> Self

Create a new Version 4(Random) UUID, using the provided Rng

This method is useful if you need to generate a lot of UUID’s very quickly, since it won’t create and seed a new RNG each time.

Providing a good seed is left to you, however. If a bad seed is used, the resulting UUIDs may not be sufficiently random or unique.

Example

let mut rng = Rng::from_seed(seed);
for _ in 0..10 {
    let uuid = Uuid::new_v4_rng(&mut rng);
}

pub fn new_v3(namespace: Uuid, name: &[u8]) -> Self

Create a new Version 3 UUID with the provided name and namespace.

Note

Version 3 UUID’s use the obsolete MD5 algorithm, Uuid::new_v5 should be preferred.

Example

let uuid = Uuid::new_v3(NAMESPACE_DNS, b"example.com");

pub fn new_v5(namespace: Uuid, name: &[u8]) -> Self

Create a new Version 5 UUID with the provided name and namespace.

Example

let uuid = Uuid::new_v5(NAMESPACE_DNS, b"example.com");

Trait Implementations

impl AsRef<[u8; 16]> for Uuid

fn as_ref(&self) -> &[u8; 16]

Performs the conversion.

impl AsRef<[u8]> for Uuid

fn as_ref(&self) -> &[u8]

Performs the conversion.

impl Clone for Uuid

fn clone(&self) -> Uuid

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Uuid

impl Debug for Uuid

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Uuid

fn default() -> Uuid

Returns the “default value” for a type.

impl Display for Uuid

Display the Uuid in uppercase hex.

Example

let uuid = Uuid::parse("662aa7c7-7598-4d56-8bcc-a72c30f998a2").unwrap();
assert_eq!(format!("{}", uuid), "662AA7C7-7598-4D56-8BCC-A72C30F998A2");

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Uuid

impl FromStr for Uuid

See Uuid::parse for details.

type Err = ParseUuidError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Uuid

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl LowerHex for Uuid

Display the Uuid in lowercase

The alternate(#) flag can be used to get a URN.

Example

let uuid = Uuid::parse("662aa7c7-7598-4d56-8bcc-a72c30f998a2").unwrap();
assert_eq!(format!("{:x}", uuid), "662aa7c7-7598-4d56-8bcc-a72c30f998a2");
assert_eq!(format!("{:#x}", uuid), "urn:uuid:662aa7c7-7598-4d56-8bcc-a72c30f998a2");

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Ord for Uuid

fn cmp(&self, other: &Uuid) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]

pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]

pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Uuid> for Uuid

fn eq(&self, other: &Uuid) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Uuid) -> bool

This method tests for !=.

impl PartialOrd<Uuid> for Uuid

fn partial_cmp(&self, other: &Uuid) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

#[must_use]

pub fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

pub fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

#[must_use]

pub fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

pub fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralEq for Uuid

impl StructuralPartialEq for Uuid

impl UpperHex for Uuid

Display the Uuid in uppercase

The alternate(#) flag can be used to get a URN.

Example

let uuid = Uuid::parse("662aa7c7-7598-4d56-8bcc-a72c30f998a2").unwrap();
assert_eq!(format!("{:X}", uuid), "662AA7C7-7598-4D56-8BCC-A72C30F998A2");
assert_eq!(format!("{:#X}", uuid), "urn:uuid:662AA7C7-7598-4D56-8BCC-A72C30F998A2");

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.