Struct uefi_raw::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: Guid = _

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], ) -> Guid

Create a new GUID.

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

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<Guid, 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) -> Guid

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]) -> Guid

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<(), Error>

Formats the value using the given formatter.

impl Default for Guid

fn default() -> Guid

Returns the “default value” for a type.

impl Display for Guid

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

Formats the value using the given formatter.

impl FromStr for Guid

fn from_str(s: &str) -> Result<Guid, <Guid as FromStr>::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>(&self, state: &mut __H)

where __H: Hasher,

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) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Guid

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Copy for Guid

impl Eq for Guid

impl StructuralPartialEq for Guid