[−][src]Struct uuid::Uuid
A Universally Unique Identifier (UUID).
Methods
impl Uuid
[src]
pub const fn nil() -> Self
[src]
The 'nil UUID'.
The nil UUID is special form of UUID that is specified to have all 128 bits set to zero, as defined in IETF RFC 4122 Section 4.1.7.
Examples
Basic usage:
use uuid::Uuid; let uuid = Uuid::nil(); assert_eq!( uuid.to_hyphenated().to_string(), "00000000-0000-0000-0000-000000000000" );
pub fn from_fields(d1: u32, d2: u16, d3: u16, d4: &[u8]) -> Result<Uuid, Error>
[src]
Creates a Uuid
from four field values in big-endian order.
Errors
This function will return an error if d4
's length is not 8 bytes.
Examples
Basic usage:
use uuid::Uuid; let d4 = [12, 3, 9, 56, 54, 43, 8, 9]; let uuid = Uuid::from_fields(42, 12, 5, &d4); let uuid = uuid.map(|uuid| uuid.to_hyphenated().to_string()); let expected_uuid = Ok(String::from("0000002a-000c-0005-0c03-0938362b0809")); assert_eq!(expected_uuid, uuid);
pub fn from_fields_le(
d1: u32,
d2: u16,
d3: u16,
d4: &[u8]
) -> Result<Uuid, Error>
[src]
d1: u32,
d2: u16,
d3: u16,
d4: &[u8]
) -> Result<Uuid, Error>
Creates a Uuid
from four field values in little-endian order.
The bytes in the d1
, d2
and d3
fields will
be converted into big-endian order.
Examples
use uuid::Uuid; let d1 = 0xAB3F1097u32; let d2 = 0x501Eu16; let d3 = 0xB736u16; let d4 = [12, 3, 9, 56, 54, 43, 8, 9]; let uuid = Uuid::from_fields_le(d1, d2, d3, &d4); let uuid = uuid.map(|uuid| uuid.to_hyphenated().to_string()); let expected_uuid = Ok(String::from("97103fab-1e50-36b7-0c03-0938362b0809")); assert_eq!(expected_uuid, uuid);
pub const fn from_u128(v: u128) -> Self
[src]
Creates a Uuid
from a 128bit value in big-endian order.
pub const fn from_u128_le(v: u128) -> Self
[src]
Creates a Uuid
from a 128bit value in little-endian order.
pub fn from_slice(b: &[u8]) -> Result<Uuid, Error>
[src]
Creates a Uuid
using the supplied big-endian bytes.
Errors
This function will return an error if b
has any length other than 16.
Examples
Basic usage:
use uuid::Uuid; let bytes = [4, 54, 67, 12, 43, 2, 98, 76, 32, 50, 87, 5, 1, 33, 43, 87]; let uuid = Uuid::from_slice(&bytes); let uuid = uuid.map(|uuid| uuid.to_hyphenated().to_string()); let expected_uuid = Ok(String::from("0436430c-2b02-624c-2032-570501212b57")); assert_eq!(expected_uuid, uuid);
An incorrect number of bytes:
use uuid::Uuid; let bytes = [4, 54, 67, 12, 43, 2, 98, 76]; let uuid = Uuid::from_slice(&bytes); assert!(uuid.is_err());
pub const fn from_bytes(bytes: Bytes) -> Uuid
[src]
Creates a Uuid
using the supplied big-endian bytes.
impl Uuid
[src]
pub fn parse_str(input: &str) -> Result<Uuid, Error>
[src]
Parses a Uuid
from a string of hexadecimal digits with optional
hyphens.
Any of the formats generated by this module (simple, hyphenated, urn) are supported by this parsing function.
impl Uuid
[src]
pub const fn to_hyphenated(self) -> Hyphenated
[src]
Creates a Hyphenated
instance from a Uuid
.
pub const fn to_hyphenated_ref(&self) -> HyphenatedRef
[src]
Creates a HyphenatedRef
instance from a Uuid
reference.
pub const fn to_simple(self) -> Simple
[src]
pub const fn to_simple_ref(&self) -> SimpleRef
[src]
pub const fn to_urn(self) -> Urn
[src]
pub const fn to_urn_ref(&self) -> UrnRef
[src]
impl Uuid
[src]
pub fn new_v1(ts: Timestamp, node_id: &[u8]) -> Result<Self, Error>
[src]
Create a new Uuid
(version 1) using a time value + sequence +
NodeId.
When generating Timestamp
s using a ClockSequence
, this function
is only guaranteed to produce unique values if the following conditions
hold:
- The NodeId is unique for this process,
- The Context is shared across all threads which are generating v1
Uuid
s, - The
ClockSequence
implementation reliably returns unique clock sequences (this crate providesContext
for this purpose. However you can create your ownClockSequence
implementation, ifContext
does not meet your needs).
The NodeID must be exactly 6 bytes long. If the NodeID is not a valid
length this will return a ParseError
::InvalidLength
.
Note that usage of this method requires the v1
feature of this crate
to be enabled.
Examples
A Uuid
can be created from a unix Timestamp
with a
ClockSequence
:
use uuid::v1::{Timestamp, Context}; use uuid::Uuid; let context = Context::new(42); let ts = Timestamp::from_unix(&context, 1497624119, 1234); let uuid = Uuid::new_v1(ts, &[1, 2, 3, 4, 5, 6]).expect("failed to generate UUID"); assert_eq!( uuid.to_hyphenated().to_string(), "f3b4958c-52a1-11e7-802a-010203040506" );
The timestamp can also be created manually as per RFC4122:
use uuid::v1::{Timestamp, Context}; use uuid::Uuid; let context = Context::new(42); let ts = Timestamp::from_rfc4122(1497624119, 0); let uuid = Uuid::new_v1(ts, &[1, 2, 3, 4, 5, 6]).expect("failed to generate UUID"); assert_eq!( uuid.to_hyphenated().to_string(), "5943ee37-0000-1000-8000-010203040506" );
pub fn to_timestamp(&self) -> Option<Timestamp>
[src]
Returns an optional Timestamp
storing the timestamp and
counter portion parsed from a V1 UUID.
Returns None
if the supplied UUID is not V1.
The V1 timestamp format defined in RFC4122 specifies a 60-bit integer representing the number of 100-nanosecond intervals since 00:00:00.00, 15 Oct 1582.
Timestamp
offers several options for converting the raw RFC4122
value into more commonly-used formats, such as a unix timestamp.
impl Uuid
[src]
pub fn new_v3(namespace: &Uuid, name: &[u8]) -> Uuid
[src]
Creates a Uuid
using a name from a namespace, based on the MD5
hash.
A number of namespaces are available as constants in this crate:
Note that usage of this method requires the v3
feature of this crate
to be enabled.
impl Uuid
[src]
pub fn new_v4() -> Self
[src]
Creates a random Uuid
.
This uses the rand
crate's default task RNG as the source of random
numbers. If you'd like to use a custom generator, don't use this
method: use the rand::Rand trait
's rand()
method instead.
Note that usage of this method requires the v4
feature of this crate
to be enabled.
Examples
Basic usage:
use uuid::Uuid; let uuid = Uuid::new_v4();
impl Uuid
[src]
pub fn new_v5(namespace: &Uuid, name: &[u8]) -> Uuid
[src]
Creates a UUID using a name from a namespace, based on the SHA-1 hash.
A number of namespaces are available as constants in this crate:
Note that usage of this method requires the v5
feature of this crate
to be enabled.
impl Uuid
[src]
pub fn from_guid(guid: GUID) -> Result<Uuid, Error>
[src]
Attempts to create a Uuid
from a little endian winapi GUID
pub fn to_guid(&self) -> GUID
[src]
Converts a Uuid
into a little endian winapi GUID
impl Uuid
[src]
pub const NAMESPACE_DNS: Self
[src]
Uuid
namespace for Domain Name System (DNS).
pub const NAMESPACE_OID: Self
[src]
Uuid
namespace for ISO Object Identifiers (OIDs).
pub const NAMESPACE_URL: Self
[src]
Uuid
namespace for Uniform Resource Locators (URLs).
pub const NAMESPACE_X500: Self
[src]
Uuid
namespace for X.500 Distinguished Names (DNs).
pub fn get_variant(&self) -> Option<Variant>
[src]
Returns the variant of the Uuid
structure.
This determines the interpretation of the structure of the UUID. Currently only the RFC4122 variant is generated by this module.
pub const fn get_version_num(&self) -> usize
[src]
Returns the version number of the Uuid
.
This represents the algorithm used to generate the contents.
Currently only the Random (V4) algorithm is supported by this module. There are security and privacy implications for using older versions - see Wikipedia: Universally Unique Identifier for details.
pub fn get_version(&self) -> Option<Version>
[src]
Returns the version of the Uuid
.
This represents the algorithm used to generate the contents
pub fn as_fields(&self) -> (u32, u16, u16, &[u8; 8])
[src]
Returns the four field values of the UUID in big-endian order.
These values can be passed to the from_fields()
method to get the
original Uuid
back.
- The first field value represents the first group of (eight) hex
digits, taken as a big-endian
u32
value. For V1 UUIDs, this field represents the low 32 bits of the timestamp. - The second field value represents the second group of (four) hex
digits, taken as a big-endian
u16
value. For V1 UUIDs, this field represents the middle 16 bits of the timestamp. - The third field value represents the third group of (four) hex digits,
taken as a big-endian
u16
value. The 4 most significant bits give the UUID version, and for V1 UUIDs, the last 12 bits represent the high 12 bits of the timestamp. - The last field value represents the last two groups of four and twelve hex digits, taken in order. The first 1-3 bits of this indicate the UUID variant, and for V1 UUIDs, the next 13-15 bits indicate the clock sequence and the last 48 bits indicate the node ID.
Examples
use uuid::Uuid; let uuid = Uuid::nil(); assert_eq!(uuid.as_fields(), (0, 0, 0, &[0u8; 8])); let uuid = Uuid::parse_str("936DA01F-9ABD-4D9D-80C7-02AF85C822A8").unwrap(); assert_eq!( uuid.as_fields(), ( 0x936DA01F, 0x9ABD, 0x4D9D, b"\x80\xC7\x02\xAF\x85\xC8\x22\xA8" ) );
pub fn to_fields_le(&self) -> (u32, u16, u16, &[u8; 8])
[src]
Returns the four field values of the UUID in little-endian order.
The bytes in the returned integer fields will be converted from big-endian order.
Examples
use uuid::Uuid; let uuid = Uuid::parse_str("936DA01F-9ABD-4D9D-80C7-02AF85C822A8").unwrap(); assert_eq!( uuid.to_fields_le(), ( 0x1FA06D93, 0xBD9A, 0x9D4D, b"\x80\xC7\x02\xAF\x85\xC8\x22\xA8" ) );
pub fn as_u128(&self) -> u128
[src]
Returns a 128bit value containing the UUID data.
The bytes in the UUID will be packed into a u128
, like the as_bytes
method.
Examples
use uuid::Uuid; let uuid = Uuid::parse_str("936DA01F-9ABD-4D9D-80C7-02AF85C822A8").unwrap(); assert_eq!( uuid.as_u128(), 0x936DA01F9ABD4D9D80C702AF85C822A8, )
pub fn to_u128_le(&self) -> u128
[src]
Returns a 128bit little-endian value containing the UUID data.
The bytes in the UUID will be reversed and packed into a u128
.
Note that this will produce a different result than to_fields_le
,
because the entire UUID is reversed, rather than reversing the
individual fields in-place.
Examples
use uuid::Uuid; let uuid = Uuid::parse_str("936DA01F-9ABD-4D9D-80C7-02AF85C822A8").unwrap(); assert_eq!( uuid.to_u128_le(), 0xA822C885AF02C7809D4DBD9A1FA06D93, )
pub const fn as_bytes(&self) -> &Bytes
[src]
Returns an array of 16 octets containing the UUID data.
This method wraps Uuid::as_bytes
pub fn is_nil(&self) -> bool
[src]
Tests if the UUID is nil
pub const fn encode_buffer() -> [u8; 45]
[src]
A buffer that can be used for encode_...
calls, that is
guaranteed to be long enough for any of the adapters.
Examples
use uuid::Uuid; let uuid = Uuid::nil(); assert_eq!( uuid.to_simple().encode_lower(&mut Uuid::encode_buffer()), "00000000000000000000000000000000" ); assert_eq!( uuid.to_hyphenated() .encode_lower(&mut Uuid::encode_buffer()), "00000000-0000-0000-0000-000000000000" ); assert_eq!( uuid.to_urn().encode_lower(&mut Uuid::encode_buffer()), "urn:uuid:00000000-0000-0000-0000-000000000000" );
Trait Implementations
impl From<Uuid> for Hyphenated
[src]
impl<'a> From<&'a Uuid> for HyphenatedRef<'a>
[src]
impl From<Uuid> for Simple
[src]
impl<'a> From<&'a Uuid> for SimpleRef<'a>
[src]
impl From<Uuid> for Urn
[src]
impl<'a> From<&'a Uuid> for UrnRef<'a>
[src]
impl Display for Uuid
[src]
impl Debug for Uuid
[src]
impl PartialEq<Uuid> for Uuid
[src]
impl Eq for Uuid
[src]
impl Ord for Uuid
[src]
fn cmp(&self, other: &Uuid) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl PartialOrd<Uuid> for Uuid
[src]
fn partial_cmp(&self, other: &Uuid) -> Option<Ordering>
[src]
fn lt(&self, other: &Uuid) -> bool
[src]
fn le(&self, other: &Uuid) -> bool
[src]
fn gt(&self, other: &Uuid) -> bool
[src]
fn ge(&self, other: &Uuid) -> bool
[src]
impl FromStr for Uuid
[src]
type Err = Error
The associated error which can be returned from parsing.
fn from_str(uuid_str: &str) -> Result<Self, Self::Err>
[src]
impl Hash for Uuid
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl Copy for Uuid
[src]
impl LowerHex for Uuid
[src]
impl UpperHex for Uuid
[src]
impl Clone for Uuid
[src]
impl Default for Uuid
[src]
impl Serialize for Uuid
[src]
impl<'de> Deserialize<'de> for Uuid
[src]
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
[src]
impl Value for Uuid
[src]
Auto Trait Implementations
impl Unpin for Uuid
impl Send for Uuid
impl Sync for Uuid
impl UnwindSafe for Uuid
impl RefUnwindSafe for Uuid
Blanket Implementations
impl<T> From<T> for T
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T> DeserializeOwned for T where
T: Deserialize<'de>,
[src]
T: Deserialize<'de>,
impl<T> SendSyncUnwindSafe for T where
T: Send + Sync + UnwindSafe + ?Sized,
T: Send + Sync + UnwindSafe + ?Sized,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,