#[repr(transparent)]pub struct Uuid(_);
Expand description
A Universally Unique Identifier (UUID).
Examples
Parse a UUID given in the simple format and print it as a urn:
let my_uuid = Uuid::parse_str("a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8")?;
println!("{}", my_uuid.urn());
Create a new random (V4) UUID and print it out in hexadecimal form:
// Note that this requires the `v4` feature enabled in the uuid crate.
let my_uuid = Uuid::new_v4();
println!("{}", my_uuid);
Formatting
A UUID can be formatted in one of a few ways:
simple
:a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8
.hyphenated
:a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8
.urn
:urn:uuid:A1A2A3A4-B1B2-C1C2-D1D2-D3D4D5D6D7D8
.braced
:{a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8}
.
The default representation when formatting a UUID with Display
is
hyphenated:
let my_uuid = Uuid::parse_str("a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8")?;
assert_eq!(
"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8",
my_uuid.to_string(),
);
Other formats can be specified using adapter methods on the UUID:
let my_uuid = Uuid::parse_str("a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8")?;
assert_eq!(
"urn:uuid:a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8",
my_uuid.urn().to_string(),
);
Endianness
The specification for UUIDs encodes the integer fields that make up the
value in big-endian order. This crate assumes integer inputs are already in
the correct order by default, regardless of the endianness of the
environment. Most methods that accept integers have a _le
variant (such as
from_fields_le
) that assumes any integer values will need to have their
bytes flipped, regardless of the endianness of the environment.
Most users won’t need to worry about endianness unless they need to operate on individual fields (such as when converting between Microsoft GUIDs). The important things to remember are:
- The endianness is in terms of the fields of the UUID, not the environment.
- The endianness is assumed to be big-endian when there’s no
_le
suffix somewhere. - Byte-flipping in
_le
methods applies to each integer. - Endianness roundtrips, so if you create a UUID with
from_fields_le
you’ll get the same values back out withto_fields_le
.
ABI
The Uuid
type is always guaranteed to be have the same ABI as Bytes
.
Implementations
sourceimpl Uuid
impl Uuid
sourcepub const fn nil() -> Uuid
pub const fn nil() -> Uuid
The ‘nil UUID’.
The nil UUID is a 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:
let uuid = Uuid::nil();
assert_eq!(
"00000000-0000-0000-0000-000000000000",
uuid.hyphenated().to_string(),
);
sourcepub const fn from_fields(d1: u32, d2: u16, d3: u16, d4: &[u8; 8]) -> Uuid
pub const fn from_fields(d1: u32, d2: u16, d3: u16, d4: &[u8; 8]) -> Uuid
Creates a UUID from four field values.
Examples
Basic usage:
let d1 = 0xa1a2a3a4;
let d2 = 0xb1b2;
let d3 = 0xc1c2;
let d4 = [0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8];
let uuid = Uuid::from_fields(d1, d2, d3, &d4);
assert_eq!(
"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8",
uuid.hyphenated().to_string(),
);
sourcepub const fn from_fields_le(d1: u32, d2: u16, d3: u16, d4: &[u8; 8]) -> Uuid
pub const fn from_fields_le(d1: u32, d2: u16, d3: u16, d4: &[u8; 8]) -> Uuid
Creates a UUID from four field values in little-endian order.
The bytes in the d1
, d2
and d3
fields will be flipped to convert
into big-endian order. This is based on the endianness of the UUID,
rather than the target environment so bytes will be flipped on both
big and little endian machines.
Examples
let d1 = 0xa1a2a3a4;
let d2 = 0xb1b2;
let d3 = 0xc1c2;
let d4 = [0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8];
let uuid = Uuid::from_fields_le(d1, d2, d3, &d4);
assert_eq!(
"a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8",
uuid.hyphenated().to_string(),
);
sourcepub const fn from_u128(v: u128) -> Uuid
pub const fn from_u128(v: u128) -> Uuid
Creates a UUID from a 128bit value.
Examples
Basic usage:
let v = 0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8u128;
let uuid = Uuid::from_u128(v);
assert_eq!(
"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8",
uuid.hyphenated().to_string(),
);
sourcepub const fn from_u128_le(v: u128) -> Uuid
pub const fn from_u128_le(v: u128) -> Uuid
Creates a UUID from a 128bit value in little-endian order.
The entire value will be flipped to convert into big-endian order. This is based on the endianness of the UUID, rather than the target environment so bytes will be flipped on both big and little endian machines.
Examples
Basic usage:
let v = 0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8u128;
let uuid = Uuid::from_u128_le(v);
assert_eq!(
"d8d7d6d5-d4d3-d2d1-c2c1-b2b1a4a3a2a1",
uuid.hyphenated().to_string(),
);
sourcepub const fn from_u64_pair(high_bits: u64, low_bits: u64) -> Uuid
pub const fn from_u64_pair(high_bits: u64, low_bits: u64) -> Uuid
Creates a UUID from two 64bit values.
Examples
Basic usage:
let hi = 0xa1a2a3a4b1b2c1c2u64;
let lo = 0xd1d2d3d4d5d6d7d8u64;
let uuid = Uuid::from_u64_pair(hi, lo);
assert_eq!(
"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8",
uuid.hyphenated().to_string(),
);
sourcepub fn from_slice(b: &[u8]) -> Result<Uuid, Error>
pub fn from_slice(b: &[u8]) -> Result<Uuid, Error>
Creates a UUID using the supplied bytes.
Errors
This function will return an error if b
has any length other than 16.
Examples
Basic usage:
let bytes = [
0xa1, 0xa2, 0xa3, 0xa4,
0xb1, 0xb2,
0xc1, 0xc2,
0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
];
let uuid = Uuid::from_slice(&bytes)?;
assert_eq!(
"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8",
uuid.hyphenated().to_string(),
);
sourcepub fn from_slice_le(b: &[u8]) -> Result<Uuid, Error>
pub fn from_slice_le(b: &[u8]) -> Result<Uuid, Error>
Creates a UUID using the supplied bytes in little endian order.
The individual fields encoded in the buffer will be flipped.
Errors
This function will return an error if b
has any length other than 16.
Examples
Basic usage:
let bytes = [
0xa1, 0xa2, 0xa3, 0xa4,
0xb1, 0xb2,
0xc1, 0xc2,
0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
];
let uuid = Uuid::from_slice_le(&bytes)?;
assert_eq!(
uuid.hyphenated().to_string(),
"a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8"
);
sourcepub const fn from_bytes(bytes: [u8; 16]) -> Uuid
pub const fn from_bytes(bytes: [u8; 16]) -> Uuid
Creates a UUID using the supplied bytes.
Examples
Basic usage:
let bytes = [
0xa1, 0xa2, 0xa3, 0xa4,
0xb1, 0xb2,
0xc1, 0xc2,
0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
];
let uuid = Uuid::from_bytes(bytes);
assert_eq!(
uuid.hyphenated().to_string(),
"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"
);
sourcepub const fn from_bytes_le(b: [u8; 16]) -> Uuid
pub const fn from_bytes_le(b: [u8; 16]) -> Uuid
Creates a UUID using the supplied bytes in little endian order.
The individual fields encoded in the buffer will be flipped.
Examples
Basic usage:
let bytes = [
0xa1, 0xa2, 0xa3, 0xa4,
0xb1, 0xb2,
0xc1, 0xc2,
0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
];
let uuid = Uuid::from_bytes_le(bytes);
assert_eq!(
"a4a3a2a1-b2b1-c2c1-d1d2-d3d4d5d6d7d8",
uuid.hyphenated().to_string(),
);
sourcepub fn from_bytes_ref(bytes: &[u8; 16]) -> &Uuid
pub fn from_bytes_ref(bytes: &[u8; 16]) -> &Uuid
Creates a reference to a UUID from a reference to the supplied bytes.
Examples
Basic usage:
let bytes = [
0xa1, 0xa2, 0xa3, 0xa4,
0xb1, 0xb2,
0xc1, 0xc2,
0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
];
let uuid = Uuid::from_bytes_ref(&bytes);
assert_eq!(
uuid.hyphenated().to_string(),
"a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8"
);
assert!(std::ptr::eq(
uuid as *const Uuid as *const u8,
&bytes as *const [u8; 16] as *const u8,
));
sourceimpl Uuid
impl Uuid
sourcepub fn parse_str(input: &str) -> Result<Uuid, Error>
pub fn parse_str(input: &str) -> Result<Uuid, Error>
Parses a Uuid
from a string of hexadecimal digits with optional
hyphens.
Any of the formats generated by this module (simple, hyphenated, urn, Microsoft GUID) are supported by this parsing function.
Prefer try_parse
unless you need detailed user-facing diagnostics.
This method will be eventually deprecated in favor of try_parse
.
Examples
Parse a hyphenated UUID:
let uuid = Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000")?;
assert_eq!(Some(Version::Random), uuid.get_version());
assert_eq!(Variant::RFC4122, uuid.get_variant());
sourcepub const fn try_parse(input: &str) -> Result<Uuid, Error>
pub const fn try_parse(input: &str) -> Result<Uuid, Error>
Parses a Uuid
from a string of hexadecimal digits with optional
hyphens.
This function is similar to parse_str
, in fact parse_str
shares
the same underlying parser. The difference is that if try_parse
fails, it won’t generate very useful error messages. The parse_str
function will eventually be deprecated in favor or try_parse
.
To parse a UUID from a byte stream instead of a UTF8 string, see
try_parse_ascii
.
Examples
Parse a hyphenated UUID:
let uuid = Uuid::try_parse("550e8400-e29b-41d4-a716-446655440000")?;
assert_eq!(Some(Version::Random), uuid.get_version());
assert_eq!(Variant::RFC4122, uuid.get_variant());
sourcepub const fn try_parse_ascii(input: &[u8]) -> Result<Uuid, Error>
pub const fn try_parse_ascii(input: &[u8]) -> Result<Uuid, Error>
Parses a Uuid
from a string of hexadecimal digits with optional
hyphens.
The input is expected to be a string of ASCII characters. This method
can be more convenient than try_parse
if the UUID is being
parsed from a byte stream instead of from a UTF8 string.
Examples
Parse a hyphenated UUID:
let uuid = Uuid::try_parse_ascii(b"550e8400-e29b-41d4-a716-446655440000")?;
assert_eq!(Some(Version::Random), uuid.get_version());
assert_eq!(Variant::RFC4122, uuid.get_variant());
sourceimpl Uuid
impl Uuid
sourcepub const fn hyphenated(self) -> Hyphenated
pub const fn hyphenated(self) -> Hyphenated
Get a Hyphenated
formatter.
sourcepub fn as_hyphenated(&self) -> &Hyphenated
pub fn as_hyphenated(&self) -> &Hyphenated
Get a borrowed Hyphenated
formatter.
sourceimpl Uuid
impl Uuid
sourcepub const NAMESPACE_DNS: Uuid = Uuid([107, 167, 184, 16, 157, 173, 17, 209, 128, 180, 0, 192, 79, 212, 48,
200])
pub const NAMESPACE_DNS: Uuid = Uuid([107, 167, 184, 16, 157, 173, 17, 209, 128, 180, 0, 192, 79, 212, 48, 200])
UUID namespace for Domain Name System (DNS).
sourcepub const NAMESPACE_OID: Uuid = Uuid([107, 167, 184, 18, 157, 173, 17, 209, 128, 180, 0, 192, 79, 212, 48,
200])
pub const NAMESPACE_OID: Uuid = Uuid([107, 167, 184, 18, 157, 173, 17, 209, 128, 180, 0, 192, 79, 212, 48, 200])
UUID namespace for ISO Object Identifiers (OIDs).
sourcepub const NAMESPACE_URL: Uuid = Uuid([107, 167, 184, 17, 157, 173, 17, 209, 128, 180, 0, 192, 79, 212, 48,
200])
pub const NAMESPACE_URL: Uuid = Uuid([107, 167, 184, 17, 157, 173, 17, 209, 128, 180, 0, 192, 79, 212, 48, 200])
UUID namespace for Uniform Resource Locators (URLs).
sourcepub const NAMESPACE_X500: Uuid = Uuid([107, 167, 184, 20, 157, 173, 17, 209, 128, 180, 0, 192, 79, 212, 48,
200])
pub const NAMESPACE_X500: Uuid = Uuid([107, 167, 184, 20, 157, 173, 17, 209, 128, 180, 0, 192, 79, 212, 48, 200])
UUID namespace for X.500 Distinguished Names (DNs).
sourcepub const fn get_variant(&self) -> Variant
pub const fn get_variant(&self) -> Variant
Returns the variant of the UUID structure.
This determines the interpretation of the structure of the UUID. This method simply reads the value of the variant byte. It doesn’t validate the rest of the UUID as conforming to that variant.
Examples
Basic usage:
let my_uuid = Uuid::parse_str("02f09a3f-1624-3b1d-8409-44eff7708208")?;
assert_eq!(Variant::RFC4122, my_uuid.get_variant());
References
sourcepub const fn get_version_num(&self) -> usize
pub const fn get_version_num(&self) -> usize
Returns the version number of the UUID.
This represents the algorithm used to generate the value.
This method is the future-proof alternative to Uuid::get_version
.
Examples
Basic usage:
let my_uuid = Uuid::parse_str("02f09a3f-1624-3b1d-8409-44eff7708208")?;
assert_eq!(3, my_uuid.get_version_num());
References
sourcepub const fn get_version(&self) -> Option<Version>
pub const fn get_version(&self) -> Option<Version>
Returns the version of the UUID.
This represents the algorithm used to generate the value.
If the version field doesn’t contain a recognized version then None
is returned. If you’re trying to read the version for a future extension
you can also use Uuid::get_version_num
to unconditionally return a
number. Future extensions may start to return Some
once they’re
standardized and supported.
Examples
Basic usage:
let my_uuid = Uuid::parse_str("02f09a3f-1624-3b1d-8409-44eff7708208")?;
assert_eq!(Some(Version::Md5), my_uuid.get_version());
References
sourcepub fn as_fields(&self) -> (u32, u16, u16, &[u8; 8])
pub fn as_fields(&self) -> (u32, u16, u16, &[u8; 8])
Returns the four field values of the UUID.
These values can be passed to the Uuid::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
let uuid = Uuid::nil();
assert_eq!(uuid.as_fields(), (0, 0, 0, &[0u8; 8]));
let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;
assert_eq!(
uuid.as_fields(),
(
0xa1a2a3a4,
0xb1b2,
0xc1c2,
&[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8],
)
);
sourcepub fn to_fields_le(&self) -> (u32, u16, u16, &[u8; 8])
pub fn to_fields_le(&self) -> (u32, u16, u16, &[u8; 8])
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. This is based on the endianness of the UUID, rather than the target environment so bytes will be flipped on both big and little endian machines.
Examples
use uuid::Uuid;
let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;
assert_eq!(
uuid.to_fields_le(),
(
0xa4a3a2a1,
0xb2b1,
0xc2c1,
&[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8],
)
);
sourcepub const fn as_u128(&self) -> u128
pub const fn as_u128(&self) -> u128
Returns a 128bit value containing the value.
The bytes in the UUID will be packed directly into a u128
.
Examples
let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;
assert_eq!(
uuid.as_u128(),
0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8,
);
sourcepub const fn to_u128_le(&self) -> u128
pub const fn to_u128_le(&self) -> u128
Returns a 128bit little-endian value containing the value.
The bytes in the u128
will be flipped to convert into big-endian
order. This is based on the endianness of the UUID, rather than the
target environment so bytes will be flipped on both big and little
endian machines.
Note that this will produce a different result than
Uuid::to_fields_le
, because the entire UUID is reversed, rather
than reversing the individual fields in-place.
Examples
let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;
assert_eq!(
uuid.to_u128_le(),
0xd8d7d6d5d4d3d2d1c2c1b2b1a4a3a2a1,
);
sourcepub const fn as_u64_pair(&self) -> (u64, u64)
pub const fn as_u64_pair(&self) -> (u64, u64)
Returns two 64bit values containing the value.
The bytes in the UUID will be split into two u64
.
The first u64 represents the 64 most significant bits,
the second one represents the 64 least significant.
Examples
let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;
assert_eq!(
uuid.as_u64_pair(),
(0xa1a2a3a4b1b2c1c2, 0xd1d2d3d4d5d6d7d8),
);
sourcepub const fn as_bytes(&self) -> &[u8; 16]
pub const fn as_bytes(&self) -> &[u8; 16]
Returns a slice of 16 octets containing the value.
This method borrows the underlying byte value of the UUID.
Examples
let bytes1 = [
0xa1, 0xa2, 0xa3, 0xa4,
0xb1, 0xb2,
0xc1, 0xc2,
0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
];
let uuid1 = Uuid::from_bytes_ref(&bytes1);
let bytes2 = uuid1.as_bytes();
let uuid2 = Uuid::from_bytes_ref(bytes2);
assert_eq!(uuid1, uuid2);
assert!(std::ptr::eq(
uuid2 as *const Uuid as *const u8,
&bytes1 as *const [u8; 16] as *const u8,
));
sourcepub const fn into_bytes(self) -> [u8; 16]
pub const fn into_bytes(self) -> [u8; 16]
Consumes self and returns the underlying byte value of the UUID.
Examples
let bytes = [
0xa1, 0xa2, 0xa3, 0xa4,
0xb1, 0xb2,
0xc1, 0xc2,
0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
];
let uuid = Uuid::from_bytes(bytes);
assert_eq!(bytes, uuid.into_bytes());
sourcepub const fn to_bytes_le(&self) -> [u8; 16]
pub const fn to_bytes_le(&self) -> [u8; 16]
Returns the bytes of the UUID in little-endian order.
The bytes will be flipped to convert into little-endian order. This is based on the endianness of the UUID, rather than the target environment so bytes will be flipped on both big and little endian machines.
Examples
use uuid::Uuid;
let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;
assert_eq!(
uuid.to_bytes_le(),
([
0xa4, 0xa3, 0xa2, 0xa1, 0xb2, 0xb1, 0xc2, 0xc1, 0xd1, 0xd2,
0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8
])
);
sourcepub const fn encode_buffer() -> [u8; 45]
pub const fn encode_buffer() -> [u8; 45]
A buffer that can be used for encode_...
calls, that is
guaranteed to be long enough for any of the format adapters.
Examples
let uuid = Uuid::nil();
assert_eq!(
uuid.simple().encode_lower(&mut Uuid::encode_buffer()),
"00000000000000000000000000000000"
);
assert_eq!(
uuid.hyphenated()
.encode_lower(&mut Uuid::encode_buffer()),
"00000000-0000-0000-0000-000000000000"
);
assert_eq!(
uuid.urn().encode_lower(&mut Uuid::encode_buffer()),
"urn:uuid:00000000-0000-0000-0000-000000000000"
);
Trait Implementations
sourceimpl AsRef<Uuid> for Hyphenated
impl AsRef<Uuid> for Hyphenated
sourceimpl Borrow<Uuid> for Hyphenated
impl Borrow<Uuid> for Hyphenated
sourceimpl Encode<'_, MySql> for Uuid
impl Encode<'_, MySql> for Uuid
sourcefn encode_by_ref(&self, buf: &mut Vec<u8, Global>) -> IsNull
fn encode_by_ref(&self, buf: &mut Vec<u8, Global>) -> IsNull
Writes the value of self
into buf
without moving self
. Read more
sourcefn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
Writes the value of self
into buf
in the expected format for the database.
fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
sourceimpl Encode<'_, Postgres> for Uuid
impl Encode<'_, Postgres> for Uuid
sourcefn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> IsNull
fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> IsNull
Writes the value of self
into buf
without moving self
. Read more
sourcefn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
Writes the value of self
into buf
in the expected format for the database.
fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
sourceimpl<'q> Encode<'q, Sqlite> for Uuid
impl<'q> Encode<'q, Sqlite> for Uuid
sourcefn encode_by_ref(
&self,
args: &mut Vec<SqliteArgumentValue<'q>, Global>
) -> IsNull
fn encode_by_ref(
&self,
args: &mut Vec<SqliteArgumentValue<'q>, Global>
) -> IsNull
Writes the value of self
into buf
without moving self
. Read more
sourcefn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
fn encode(self, buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer) -> IsNull
Writes the value of self
into buf
in the expected format for the database.
fn produces(&self) -> Option<<DB as Database>::TypeInfo>
fn size_hint(&self) -> usize
sourceimpl From<Hyphenated> for Uuid
impl From<Hyphenated> for Uuid
sourcefn from(f: Hyphenated) -> Uuid
fn from(f: Hyphenated) -> Uuid
Converts to this type from the input type.
sourceimpl From<Uuid> for Hyphenated
impl From<Uuid> for Hyphenated
sourcefn from(f: Uuid) -> Hyphenated
fn from(f: Uuid) -> Hyphenated
Converts to this type from the input type.
sourceimpl Ord for Uuid
impl Ord for Uuid
1.21.0 · sourcefn max(self, other: Self) -> Self
fn max(self, other: Self) -> Self
Compares and returns the maximum of two values. Read more
1.21.0 · sourcefn min(self, other: Self) -> Self
fn min(self, other: Self) -> Self
Compares and returns the minimum of two values. Read more
1.50.0 · sourcefn clamp(self, min: Self, max: Self) -> Self where
Self: PartialOrd<Self>,
fn clamp(self, min: Self, max: Self) -> Self where
Self: PartialOrd<Self>,
Restrict a value to a certain interval. Read more
sourceimpl PartialOrd<Uuid> for Uuid
impl PartialOrd<Uuid> for Uuid
sourcefn partial_cmp(&self, other: &Uuid) -> Option<Ordering>
fn partial_cmp(&self, other: &Uuid) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PgHasArrayType for Uuid
impl PgHasArrayType for Uuid
fn array_type_info() -> PgTypeInfo
fn array_compatible(ty: &PgTypeInfo) -> bool
sourceimpl Type<MySql> for Uuid
impl Type<MySql> for Uuid
sourcefn type_info() -> MySqlTypeInfo
fn type_info() -> MySqlTypeInfo
Returns the canonical SQL type for this Rust type. Read more
sourcefn compatible(ty: &MySqlTypeInfo) -> bool
fn compatible(ty: &MySqlTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
sourceimpl Type<Postgres> for Uuid
impl Type<Postgres> for Uuid
sourcefn type_info() -> PgTypeInfo
fn type_info() -> PgTypeInfo
Returns the canonical SQL type for this Rust type. Read more
sourceimpl Type<Sqlite> for Uuid
impl Type<Sqlite> for Uuid
sourcefn type_info() -> SqliteTypeInfo
fn type_info() -> SqliteTypeInfo
Returns the canonical SQL type for this Rust type. Read more
sourcefn compatible(ty: &SqliteTypeInfo) -> bool
fn compatible(ty: &SqliteTypeInfo) -> bool
Determines if this Rust type is compatible with the given SQL type. Read more
impl Copy for Uuid
impl Eq for Uuid
impl StructuralEq for Uuid
impl StructuralPartialEq for Uuid
Auto Trait Implementations
impl RefUnwindSafe for Uuid
impl Send for Uuid
impl Sync for Uuid
impl Unpin for Uuid
impl UnwindSafe for Uuid
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
sourcefn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
Compare self to key
and return true
if they are equal.
sourceimpl<T> ToHex for T where
T: AsRef<[u8]>,
impl<T> ToHex for T where
T: AsRef<[u8]>,
sourcefn encode_hex<U>(&self) -> U where
U: FromIterator<char>,
fn encode_hex<U>(&self) -> U where
U: FromIterator<char>,
Encode the hex strict representing self
into the result. Lower case
letters are used (e.g. f9b4ca
) Read more
sourcefn encode_hex_upper<U>(&self) -> U where
U: FromIterator<char>,
fn encode_hex_upper<U>(&self) -> U where
U: FromIterator<char>,
Encode the hex strict representing self
into the result. Upper case
letters are used (e.g. F9B4CA
) Read more