Struct Uuid 

pub struct Uuid(/* private fields */);

Available on crate feature net only.

A UUID.

This type provides type-safe UUIDs with RFC 4122 validation. It uses the newtype pattern with #[repr(transparent)] for zero-cost abstraction.

Invariants

• Exactly 16 bytes (128 bits)

Examples

use bare_types::net::Uuid;

// Create a UUID from bytes
let uuid = Uuid::new([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                       0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);

// Access the string representation
assert_eq!(uuid.as_str(), "00112233-4455-6677-8899-aabbccddeeff");

// Check if it's nil
assert!(!uuid.is_nil());

// Get the bytes
assert_eq!(uuid.bytes(), [0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);

// Parse from string
let uuid: Uuid = "00112233-4455-6677-8899-aabbccddeeff".parse()?;

Implementations

impl Uuid

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

Creates a new UUID from an array of 16 bytes.

Examples

use bare_types::net::Uuid;

let uuid = Uuid::new([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                       0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
assert_eq!(uuid.as_str(), "00112233-4455-6677-8899-aabbccddeeff");

pub fn from_bytes(bytes: &[u8]) -> Result<Self, UuidError>

Creates a new UUID from a slice of bytes.

Errors

Returns UuidError if the slice is not exactly 16 bytes.

Examples

use bare_types::net::Uuid;

let bytes = vec![0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
               0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff];
let uuid = Uuid::from_bytes(&bytes)?;
assert_eq!(uuid.as_str(), "00112233-4455-6677-8899-aabbccddeeff");

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

Creates a new UUID from a string.

Errors

Returns UuidError if string is not in a valid format.

Panics

Panics if a hex character is invalid (this should never happen due to prior validation).

Examples

use bare_types::net::Uuid;

let uuid = Uuid::from_str("00112233-4455-6677-8899-aabbccddeeff")?;
assert_eq!(uuid.as_str(), "00112233-4455-6677-8899-aabbccddeeff");

pub const fn nil() -> Self

Returns the nil UUID.

The nil UUID is 00000000-0000-0000-0000-000000000000.

Examples

use bare_types::net::Uuid;

let uuid = Uuid::nil();
assert!(uuid.is_nil());
assert_eq!(uuid.as_str(), "00000000-0000-0000-0000-000000000000");

pub fn as_str(&self) -> String

Returns the UUID as a string in standard format.

Examples

use bare_types::net::Uuid;

let uuid = Uuid::new([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                       0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
assert_eq!(uuid.as_str(), "00112233-4455-6677-8899-aabbccddeeff");

pub fn as_str_upper(&self) -> String

Returns the UUID as a string in uppercase format.

Examples

use bare_types::net::Uuid;

let uuid = Uuid::new([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                       0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
assert_eq!(uuid.as_str_upper(), "00112233-4455-6677-8899-AABBCCDDEEFF");

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

Returns a reference to the underlying array of 16 bytes.

Examples

use bare_types::net::Uuid;

let uuid = Uuid::new([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                       0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
let bytes: &[u8; 16] = uuid.as_inner();
assert_eq!(bytes, &[0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                      0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);

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

Consumes this UUID and returns the underlying array of 16 bytes.

Examples

use bare_types::net::Uuid;

let uuid = Uuid::new([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                       0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
let bytes = uuid.into_inner();
assert_eq!(bytes, [0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);

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

Returns the bytes of the UUID.

Examples

use bare_types::net::Uuid;

let uuid = Uuid::new([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                       0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
assert_eq!(uuid.bytes(), [0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                         0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);

pub fn is_nil(&self) -> bool

Returns true if this is a nil UUID.

The nil UUID is 00000000-0000-0000-0000-000000000000.

Examples

use bare_types::net::Uuid;

assert!(Uuid::nil().is_nil());

pub fn version(&self) -> Option<u8>

Returns the version of the UUID.

Returns None if the UUID is not a valid RFC 4122 UUID.

Examples

use bare_types::net::Uuid;

let uuid = Uuid::new([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                       0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
assert_eq!(uuid.version(), None);

pub const fn variant(&self) -> Option<UuidVariant>

Returns the variant of the UUID.

Returns None if the UUID is not a valid RFC 4122 UUID.

Examples

use bare_types::net::{Uuid, UuidVariant};

let uuid = Uuid::new([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                       0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);
assert_eq!(uuid.variant(), Some(UuidVariant::Rfc4122));

Trait Implementations

impl<'a> Arbitrary<'a> for Uuid

Available on crate feature arbitrary only.

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl Clone for Uuid

fn clone(&self) -> Uuid

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Uuid

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Uuid

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Uuid

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

Formats the value using the given formatter.

impl From<[u8; 16]> for Uuid

fn from(bytes: [u8; 16]) -> Self

Converts to this type from the input type.

impl From<Uuid> for [u8; 16]

fn from(uuid: Uuid) -> Self

Converts to this type from the input type.

impl FromStr for Uuid

type Err = UuidError

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.

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 Uuid

fn cmp(&self, other: &Uuid) -> 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,

Restrict a value to a certain interval.

impl PartialEq for Uuid

fn eq(&self, other: &Uuid) -> 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 Uuid

fn partial_cmp(&self, other: &Uuid) -> 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 Serialize for Uuid

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&[u8]> for Uuid

type Error = UuidError

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&str> for Uuid

type Error = UuidError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl Zeroize for Uuid

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Copy for Uuid

impl Eq for Uuid

impl StructuralPartialEq for Uuid