Struct uguid::Guid

#[repr(C)]
pub struct Guid { /* private fields */ }

Globally-unique identifier.

The format is defined in RFC 4122. However, unlike “normal” UUIDs (such as those provided by the uuid crate), the first three fields are little-endian. See also Appendix A of the UEFI Specification.

This type is 4-byte aligned. The UEFI Specification says the GUID type should be 8-byte aligned, but most C implementations have 4-byte alignment, so we do the same here for compatibility.

Implementations

impl Guid

pub const ZERO: Self = _

GUID with all fields set to zero.

pub const fn new( time_low: [u8; 4], time_mid: [u8; 2], time_high_and_version: [u8; 2], clock_seq_high_and_reserved: u8, clock_seq_low: u8, node: [u8; 6] ) -> Self

Create a new GUID.

pub const fn from_random_bytes(random_bytes: [u8; 16]) -> Self

Create a version 4 GUID from provided random bytes.

See RFC 4122 section 4.4 for the definition of a version 4 GUID.

This constructor does not itself generate random bytes, but instead expects the caller to provide suitably random bytes.

Example

use uguid::{Guid, Variant};

let guid = Guid::from_random_bytes([
    104, 192, 95, 215, 120, 33, 249, 1, 102, 21, 171, 84, 233, 204, 68, 176,
]);
assert_eq!(guid.variant(), Variant::Rfc4122);
assert_eq!(guid.version(), 4);

pub const fn is_zero(self) -> bool

True if all bits are zero, false otherwise.

Example

use uguid::guid;

assert!(guid!("00000000-0000-0000-0000-000000000000").is_zero());
assert!(!guid!("308bbc16-a308-47e8-8977-5e5646c5291f").is_zero());

pub const fn time_low(self) -> [u8; 4]

The little-endian low field of the timestamp.

pub const fn time_mid(self) -> [u8; 2]

The little-endian middle field of the timestamp.

pub const fn time_high_and_version(self) -> [u8; 2]

The little-endian high field of the timestamp multiplexed with the version number.

pub const fn clock_seq_high_and_reserved(self) -> u8

The high field of the clock sequence multiplexed with the variant.

pub const fn clock_seq_low(self) -> u8

The low field of the clock sequence.

pub const fn node(self) -> [u8; 6]

The spatially unique node identifier.

pub const fn variant(self) -> Variant

Get the GUID variant.

Example

use uguid::{guid, Variant};

assert_eq!(
    guid!("308bbc16-a308-47e8-8977-5e5646c5291f").variant(),
    Variant::Rfc4122
);

pub const fn version(self) -> u8

Get the GUID version. This is a sub-type of the variant as defined in RFC4122.

Example

use uguid::guid;

assert_eq!(guid!("308bbc16-a308-47e8-8977-5e5646c5291f").version(), 4);

pub const fn try_parse(s: &str) -> Result<Self, GuidFromStrError>

Parse a GUID from a string.

This is functionally the same as Self::from_str, but is exposed separately to provide a const method for parsing.

pub const fn parse_or_panic(s: &str) -> Self

Parse a GUID from a string, panicking on failure.

The input must be in “xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx” format, where each x is a hex digit (any of 0-9, a-f, or A-F).

This function is marked track_caller so that error messages point directly to the invalid GUID string.

Panics

This function will panic if the input is not in the format shown above. In particular, it will panic if the input is not exactly 36 bytes long, or if the input does not have separators at the expected positions, or if any of the remaining characters are not valid hex digits.

pub const fn from_bytes(bytes: [u8; 16]) -> Self

Create a GUID from a 16-byte array. No changes to byte order are made.

pub const fn to_bytes(self) -> [u8; 16]

Convert to a 16-byte array.

pub const fn to_ascii_hex_lower(self) -> [u8; 36]

Convert to a lower-case hex ASCII string.

The output is in “xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx” format.

Trait Implementations

impl Clone for Guid

fn clone(&self) -> Guid

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Guid

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

Formats the value using the given formatter.

impl Default for Guid

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Guid

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Guid

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

Formats the value using the given formatter.

impl FromStr for Guid

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

Parse a GUID from a string, panicking on failure.

The input must be in “xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx” format, where each x is a hex digit (any of 0-9, a-f, or A-F).

type Err = GuidFromStrError

The associated error which can be returned from parsing.

impl Hash for Guid

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl Ord for Guid

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Guid

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Guid

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

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

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

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

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

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

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

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

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 Serialize for Guid

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl Zeroable for Guid

fn zeroed() -> Self

Calls zeroed.

impl Copy for Guid

impl Eq for Guid

impl Pod for Guid

impl StructuralEq for Guid

impl StructuralPartialEq for Guid