Spracherkennung für: .rs vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen]
// Copyright
2013-
2014 The Rust Project Developers.
// Copyright
2018 The Uuid Project Developers.
//
// See the COPYRIGHT file at the top-level directory of this distribution.
//
// Licensed under the Apache License, Version
2.
0 <LICENSE-APACHE or
//
http://www.apache.org/licenses/LICENSE-2.
0> or the MIT license
// <LICENSE-MIT or
http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//! Adapters for alternative string formats.
use crate::{
std::{borrow::Borrow, fmt, ptr, str},
Uuid, Variant,
};
impl std::fmt::Debug for Uuid {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::LowerHex::fmt(self, f)
}
}
impl fmt::Display for Uuid {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::LowerHex::fmt(self, f)
}
}
impl fmt::Display for Variant {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Variant::NCS => write!(f, "NCS"),
Variant::RFC4122 => write!(f, "RFC4122"),
Variant::Microsoft => write!(f, "Microsoft"),
Variant::Future => write!(f, "Future"),
}
}
}
impl fmt::LowerHex for Uuid {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::LowerHex::fmt(self.as_hyphenated(), f)
}
}
impl fmt::UpperHex for Uuid {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::UpperHex::fmt(self.as_hyphenated(), f)
}
}
/// Format a [`Uuid`] as a hyphenated string, like
/// `
67e55044-
10b1-
426f-
9247-bb680e5fe0c8`.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(transparent)]
pub struct Hyphenated(Uuid);
/// Format a [`Uuid`] as a simple string, like
/// `
67e5504410b1426f9247bb680e5fe0c8`.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(transparent)]
pub struct Simple(Uuid);
/// Format a [`Uuid`] as a URN string, like
/// `urn:uuid:
67e55044-
10b1-
426f-
9247-bb680e5fe0c8`.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(transparent)]
pub struct Urn(Uuid);
/// Format a [`Uuid`] as a braced hyphenated string, like
/// `{
67e55044-
10b1-
426f-
9247-bb680e5fe0c8}`.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(transparent)]
pub struct Braced(Uuid);
impl Uuid {
/// Get a [`Hyphenated`] formatter.
#[inline]
pub const fn hyphenated(self) -> Hyphenated {
Hyphenated(self)
}
/// Get a borrowed [`Hyphenated`] formatter.
#[inline]
pub fn as_hyphenated(&self) -> &Hyphenated {
// SAFETY: `Uuid` and `Hyphenated` have the same ABI
unsafe { &*(self as *const Uuid as *const Hyphenated) }
}
/// Get a [`Simple`] formatter.
#[inline]
pub const fn simple(self) -> Simple {
Simple(self)
}
/// Get a borrowed [`Simple`] formatter.
#[inline]
pub fn as_simple(&self) -> &Simple {
// SAFETY: `Uuid` and `Simple` have the same ABI
unsafe { &*(self as *const Uuid as *const Simple) }
}
/// Get a [`Urn`] formatter.
#[inline]
pub const fn urn(self) -> Urn {
Urn(self)
}
/// Get a borrowed [`Urn`] formatter.
#[inline]
pub fn as_urn(&self) -> &Urn {
// SAFETY: `Uuid` and `Urn` have the same ABI
unsafe { &*(self as *const Uuid as *const Urn) }
}
/// Get a [`Braced`] formatter.
#[inline]
pub const fn braced(self) -> Braced {
Braced(self)
}
/// Get a borrowed [`Braced`] formatter.
#[inline]
pub fn as_braced(&self) -> &Braced {
// SAFETY: `Uuid` and `Braced` have the same ABI
unsafe { &*(self as *const Uuid as *const Braced) }
}
}
const UPPER: [u8;
16] = [
b'
0', b'
1', b'
2', b'
3', b'
4', b'
5', b'
6', b'
7', b'
8', b'
9', b'A', b'B', b'C', b'D', b'E', b'F',
];
const LOWER: [u8;
16] = [
b'
0', b'
1', b'
2', b'
3', b'
4', b'
5', b'
6', b'
7', b'
8', b'
9', b'a', b'b', b'c', b'd', b'e', b'f',
];
#[inline]
const fn format_simple(src: &[u8;
16], upper: bool) -> [u8;
32] {
let lut = if upper { &UPPER } else { &LOWER };
let mut dst = [
0;
32];
let mut i =
0;
while i <
16 {
let x = src[i];
dst[i *
2] = lut[(x >>
4) as usize];
dst[i *
2 +
1] = lut[(x &
0x0f) as usize];
i +=
1;
}
dst
}
#[inline]
const fn format_hyphenated(src: &[u8;
16], upper: bool) -> [u8;
36] {
let lut = if upper { &UPPER } else { &LOWER };
let groups = [(
0,
8), (
9,
13), (
14,
18), (
19,
23), (
24,
36)];
let mut dst = [
0;
36];
let mut group_idx =
0;
let mut i =
0;
while group_idx <
5 {
let (start, end) = groups[group_idx];
let mut j = start;
while j < end {
let x = src[i];
i +=
1;
dst[j] = lut[(x >>
4) as usize];
dst[j +
1] = lut[(x &
0x0f) as usize];
j +=
2;
}
if group_idx <
4 {
dst[end] = b'-';
}
group_idx +=
1;
}
dst
}
#[inline]
fn encode_simple<'b>(src: &[u8;
16], buffer: &'b mut [u8], upper: bool) -> &'b mut str {
let buf = &mut buffer[..Simple::LENGTH];
let dst = buf.as_mut_ptr();
// SAFETY: `buf` is guaranteed to be at least `LEN` bytes
// SAFETY: The encoded buffer is ASCII encoded
unsafe {
ptr::write(dst.cast(), format_simple(src, upper));
str::from_utf8_unchecked_mut(buf)
}
}
#[inline]
fn encode_hyphenated<'b>(src: &[u8;
16], buffer: &'b mut [u8], upper: bool) -> &'b mut str {
let buf = &mut buffer[..Hyphenated::LENGTH];
let dst = buf.as_mut_ptr();
// SAFETY: `buf` is guaranteed to be at least `LEN` bytes
// SAFETY: The encoded buffer is ASCII encoded
unsafe {
ptr::write(dst.cast(), format_hyphenated(src, upper));
str::from_utf8_unchecked_mut(buf)
}
}
#[inline]
fn encode_braced<'b>(src: &[u8;
16], buffer: &'b mut [u8], upper: bool) -> &'b mut str {
let buf = &mut buffer[..Braced::LENGTH];
buf[
0] = b'{';
buf[Braced::LENGTH -
1] = b'}';
// SAFETY: `buf` is guaranteed to be at least `LEN` bytes
// SAFETY: The encoded buffer is ASCII encoded
unsafe {
let dst = buf.as_mut_ptr().add(
1);
ptr::write(dst.cast(), format_hyphenated(src, upper));
str::from_utf8_unchecked_mut(buf)
}
}
#[inline]
fn encode_urn<'b>(src: &[u8;
16], buffer: &'b mut [u8], upper: bool) -> &'b mut str {
let buf = &mut buffer[..Urn::LENGTH];
buf[..
9].copy_from_slice(b"urn:uuid:");
// SAFETY: `buf` is guaranteed to be at least `LEN` bytes
// SAFETY: The encoded buffer is ASCII encoded
unsafe {
let dst = buf.as_mut_ptr().add(
9);
ptr::write(dst.cast(), format_hyphenated(src, upper));
str::from_utf8_unchecked_mut(buf)
}
}
impl Hyphenated {
/// The length of a hyphenated [`Uuid`] string.
///
/// [`Uuid`]: ../struct.Uuid.html
pub const LENGTH: usize =
36;
/// Creates a [`Hyphenated`] from a [`Uuid`].
///
/// [`Uuid`]: ../struct.Uuid.html
/// [`Hyphenated`]: struct.Hyphenated.html
pub const fn from_uuid(uuid: Uuid) -> Self {
Hyphenated(uuid)
}
/// Writes the [`Uuid`] as a lower-case hyphenated string to
/// `buffer`, and returns the subslice of the buffer that contains the
/// encoded UUID.
///
/// This is slightly more efficient than using the formatting
/// infrastructure as it avoids virtual calls, and may avoid
/// double buffering.
///
/// [`Uuid`]: ../struct.Uuid.html
///
/// # Panics
///
/// Panics if the buffer is not large enough: it must have length at least
/// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
/// sufficiently-large temporary buffer.
///
/// [`LENGTH`]: #associatedconstant.LENGTH
/// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// fn main() -> Result<(), uuid::Error> {
/// let uuid = Uuid::parse_str("
936DA01f9abd4d9d80c702af85c822a8")?;
///
/// // the encoded portion is returned
/// assert_eq!(
/// uuid.hyphenated()
/// .encode_lower(&mut Uuid::encode_buffer()),
/// "
936da01f-
9abd-
4d9d-
80c7-
02af85c822a8"
/// );
///
/// // the buffer is mutated directly, and trailing contents remains
/// let mut buf = [b'!';
40];
/// uuid.hyphenated().encode_lower(&mut buf);
/// assert_eq!(
/// &buf as &[_],
/// b"
936da01f-
9abd-
4d9d-
80c7-
02af85c822a8!!!!" as &[_]
/// );
///
/// Ok(())
/// }
/// ```
/// */
#[inline]
pub fn encode_lower<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str {
encode_hyphenated(self.
0.as_bytes(), buffer, false)
}
/// Writes the [`Uuid`] as an upper-case hyphenated string to
/// `buffer`, and returns the subslice of the buffer that contains the
/// encoded UUID.
///
/// This is slightly more efficient than using the formatting
/// infrastructure as it avoids virtual calls, and may avoid
/// double buffering.
///
/// [`Uuid`]: ../struct.Uuid.html
///
/// # Panics
///
/// Panics if the buffer is not large enough: it must have length at least
/// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
/// sufficiently-large temporary buffer.
///
/// [`LENGTH`]: #associatedconstant.LENGTH
/// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// fn main() -> Result<(), uuid::Error> {
/// let uuid = Uuid::parse_str("
936da01f9abd4d9d80c702af85c822a8")?;
///
/// // the encoded portion is returned
/// assert_eq!(
/// uuid.hyphenated()
/// .encode_upper(&mut Uuid::encode_buffer()),
/// "
936DA01F-
9ABD-
4D9D-
80C7-
02AF85C822A8"
/// );
///
/// // the buffer is mutated directly, and trailing contents remains
/// let mut buf = [b'!';
40];
/// uuid.hyphenated().encode_upper(&mut buf);
/// assert_eq!(
/// &buf as &[_],
/// b"
936DA01F-
9ABD-
4D9D-
80C7-
02AF85C822A8!!!!" as &[_]
/// );
///
/// Ok(())
/// }
/// ```
/// */
#[inline]
pub fn encode_upper<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str {
encode_hyphenated(self.
0.as_bytes(), buffer, true)
}
/// Get a reference to the underlying [`Uuid`].
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// let hyphenated = Uuid::nil().hyphenated();
/// assert_eq!(*hyphenated.as_uuid(), Uuid::nil());
/// ```
pub const fn as_uuid(&self) -> &Uuid {
&self.
0
}
/// Consumes the [`Hyphenated`], returning the underlying [`Uuid`].
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// let hyphenated = Uuid::nil().hyphenated();
/// assert_eq!(hyphenated.into_uuid(), Uuid::nil());
/// ```
pub const fn into_uuid(self) -> Uuid {
self.
0
}
}
impl Braced {
/// The length of a braced [`Uuid`] string.
///
/// [`Uuid`]: ../struct.Uuid.html
pub const LENGTH: usize =
38;
/// Creates a [`Braced`] from a [`Uuid`].
///
/// [`Uuid`]: ../struct.Uuid.html
/// [`Braced`]: struct.Braced.html
pub const fn from_uuid(uuid: Uuid) -> Self {
Braced(uuid)
}
/// Writes the [`Uuid`] as a lower-case hyphenated string surrounded by
/// braces to `buffer`, and returns the subslice of the buffer that contains
/// the encoded UUID.
///
/// This is slightly more efficient than using the formatting
/// infrastructure as it avoids virtual calls, and may avoid
/// double buffering.
///
/// [`Uuid`]: ../struct.Uuid.html
///
/// # Panics
///
/// Panics if the buffer is not large enough: it must have length at least
/// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
/// sufficiently-large temporary buffer.
///
/// [`LENGTH`]: #associatedconstant.LENGTH
/// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// fn main() -> Result<(), uuid::Error> {
/// let uuid = Uuid::parse_str("
936DA01f9abd4d9d80c702af85c822a8")?;
///
/// // the encoded portion is returned
/// assert_eq!(
/// uuid.braced()
/// .encode_lower(&mut Uuid::encode_buffer()),
/// "{
936da01f-
9abd-
4d9d-
80c7-
02af85c822a8}"
/// );
///
/// // the buffer is mutated directly, and trailing contents remains
/// let mut buf = [b'!';
40];
/// uuid.braced().encode_lower(&mut buf);
/// assert_eq!(
/// &buf as &[_],
/// b"{
936da01f-
9abd-
4d9d-
80c7-
02af85c822a8}!!" as &[_]
/// );
///
/// Ok(())
/// }
/// ```
/// */
#[inline]
pub fn encode_lower<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str {
encode_braced(self.
0.as_bytes(), buffer, false)
}
/// Writes the [`Uuid`] as an upper-case hyphenated string surrounded by
/// braces to `buffer`, and returns the subslice of the buffer that contains
/// the encoded UUID.
///
/// This is slightly more efficient than using the formatting
/// infrastructure as it avoids virtual calls, and may avoid
/// double buffering.
///
/// [`Uuid`]: ../struct.Uuid.html
///
/// # Panics
///
/// Panics if the buffer is not large enough: it must have length at least
/// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
/// sufficiently-large temporary buffer.
///
/// [`LENGTH`]: #associatedconstant.LENGTH
/// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// fn main() -> Result<(), uuid::Error> {
/// let uuid = Uuid::parse_str("
936da01f9abd4d9d80c702af85c822a8")?;
///
/// // the encoded portion is returned
/// assert_eq!(
/// uuid.braced()
/// .encode_upper(&mut Uuid::encode_buffer()),
/// "{
936DA01F-
9ABD-
4D9D-
80C7-
02AF85C822A8}"
/// );
///
/// // the buffer is mutated directly, and trailing contents remains
/// let mut buf = [b'!';
40];
/// uuid.braced().encode_upper(&mut buf);
/// assert_eq!(
/// &buf as &[_],
/// b"{
936DA01F-
9ABD-
4D9D-
80C7-
02AF85C822A8}!!" as &[_]
/// );
///
/// Ok(())
/// }
/// ```
/// */
#[inline]
pub fn encode_upper<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str {
encode_braced(self.
0.as_bytes(), buffer, true)
}
/// Get a reference to the underlying [`Uuid`].
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// let braced = Uuid::nil().braced();
/// assert_eq!(*braced.as_uuid(), Uuid::nil());
/// ```
pub const fn as_uuid(&self) -> &Uuid {
&self.
0
}
/// Consumes the [`Braced`], returning the underlying [`Uuid`].
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// let braced = Uuid::nil().braced();
/// assert_eq!(braced.into_uuid(), Uuid::nil());
/// ```
pub const fn into_uuid(self) -> Uuid {
self.
0
}
}
impl Simple {
/// The length of a simple [`Uuid`] string.
///
/// [`Uuid`]: ../struct.Uuid.html
pub const LENGTH: usize =
32;
/// Creates a [`Simple`] from a [`Uuid`].
///
/// [`Uuid`]: ../struct.Uuid.html
/// [`Simple`]: struct.Simple.html
pub const fn from_uuid(uuid: Uuid) -> Self {
Simple(uuid)
}
/// Writes the [`Uuid`] as a lower-case simple string to `buffer`,
/// and returns the subslice of the buffer that contains the encoded UUID.
///
/// This is slightly more efficient than using the formatting
/// infrastructure as it avoids virtual calls, and may avoid
/// double buffering.
///
/// [`Uuid`]: ../struct.Uuid.html
///
/// # Panics
///
/// Panics if the buffer is not large enough: it must have length at least
/// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
/// sufficiently-large temporary buffer.
///
/// [`LENGTH`]: #associatedconstant.LENGTH
/// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// fn main() -> Result<(), uuid::Error> {
/// let uuid = Uuid::parse_str("
936DA01f9abd4d9d80c702af85c822a8")?;
///
/// // the encoded portion is returned
/// assert_eq!(
/// uuid.simple().encode_lower(&mut Uuid::encode_buffer()),
/// "
936da01f9abd4d9d80c702af85c822a8"
/// );
///
/// // the buffer is mutated directly, and trailing contents remains
/// let mut buf = [b'!';
36];
/// assert_eq!(
/// uuid.simple().encode_lower(&mut buf),
/// "
936da01f9abd4d9d80c702af85c822a8"
/// );
/// assert_eq!(
/// &buf as &[_],
/// b"
936da01f9abd4d9d80c702af85c822a8!!!!" as &[_]
/// );
///
/// Ok(())
/// }
/// ```
/// */
#[inline]
pub fn encode_lower<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str {
encode_simple(self.
0.as_bytes(), buffer, false)
}
/// Writes the [`Uuid`] as an upper-case simple string to `buffer`,
/// and returns the subslice of the buffer that contains the encoded UUID.
///
/// [`Uuid`]: ../struct.Uuid.html
///
/// # Panics
///
/// Panics if the buffer is not large enough: it must have length at least
/// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
/// sufficiently-large temporary buffer.
///
/// [`LENGTH`]: #associatedconstant.LENGTH
/// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// fn main() -> Result<(), uuid::Error> {
/// let uuid = Uuid::parse_str("
936da01f9abd4d9d80c702af85c822a8")?;
///
/// // the encoded portion is returned
/// assert_eq!(
/// uuid.simple().encode_upper(&mut Uuid::encode_buffer()),
/// "
936DA01F9ABD4D9D80C702AF85C822A8"
/// );
///
/// // the buffer is mutated directly, and trailing contents remains
/// let mut buf = [b'!';
36];
/// assert_eq!(
/// uuid.simple().encode_upper(&mut buf),
/// "
936DA01F9ABD4D9D80C702AF85C822A8"
/// );
/// assert_eq!(
/// &buf as &[_],
/// b"
936DA01F9ABD4D9D80C702AF85C822A8!!!!" as &[_]
/// );
///
/// Ok(())
/// }
/// ```
/// */
#[inline]
pub fn encode_upper<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str {
encode_simple(self.
0.as_bytes(), buffer, true)
}
/// Get a reference to the underlying [`Uuid`].
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// let simple = Uuid::nil().simple();
/// assert_eq!(*simple.as_uuid(), Uuid::nil());
/// ```
pub const fn as_uuid(&self) -> &Uuid {
&self.
0
}
/// Consumes the [`Simple`], returning the underlying [`Uuid`].
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// let simple = Uuid::nil().simple();
/// assert_eq!(simple.into_uuid(), Uuid::nil());
/// ```
pub const fn into_uuid(self) -> Uuid {
self.
0
}
}
impl Urn {
/// The length of a URN [`Uuid`] string.
///
/// [`Uuid`]: ../struct.Uuid.html
pub const LENGTH: usize =
45;
/// Creates a [`Urn`] from a [`Uuid`].
///
/// [`Uuid`]: ../struct.Uuid.html
/// [`Urn`]: struct.Urn.html
pub const fn from_uuid(uuid: Uuid) -> Self {
Urn(uuid)
}
/// Writes the [`Uuid`] as a lower-case URN string to
/// `buffer`, and returns the subslice of the buffer that contains the
/// encoded UUID.
///
/// This is slightly more efficient than using the formatting
/// infrastructure as it avoids virtual calls, and may avoid
/// double buffering.
///
/// [`Uuid`]: ../struct.Uuid.html
///
/// # Panics
///
/// Panics if the buffer is not large enough: it must have length at least
/// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
/// sufficiently-large temporary buffer.
///
/// [`LENGTH`]: #associatedconstant.LENGTH
/// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// fn main() -> Result<(), uuid::Error> {
/// let uuid = Uuid::parse_str("
936DA01f9abd4d9d80c702af85c822a8")?;
///
/// // the encoded portion is returned
/// assert_eq!(
/// uuid.urn().encode_lower(&mut Uuid::encode_buffer()),
/// "urn:uuid:
936da01f-
9abd-
4d9d-
80c7-
02af85c822a8"
/// );
///
/// // the buffer is mutated directly, and trailing contents remains
/// let mut buf = [b'!';
49];
/// uuid.urn().encode_lower(&mut buf);
/// assert_eq!(
/// uuid.urn().encode_lower(&mut buf),
/// "urn:uuid:
936da01f-
9abd-
4d9d-
80c7-
02af85c822a8"
/// );
/// assert_eq!(
/// &buf as &[_],
/// b"urn:uuid:
936da01f-
9abd-
4d9d-
80c7-
02af85c822a8!!!!" as &[_]
/// );
///
/// Ok(())
/// }
/// ```
/// */
#[inline]
pub fn encode_lower<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str {
encode_urn(self.
0.as_bytes(), buffer, false)
}
/// Writes the [`Uuid`] as an upper-case URN string to
/// `buffer`, and returns the subslice of the buffer that contains the
/// encoded UUID.
///
/// This is slightly more efficient than using the formatting
/// infrastructure as it avoids virtual calls, and may avoid
/// double buffering.
///
/// [`Uuid`]: ../struct.Uuid.html
///
/// # Panics
///
/// Panics if the buffer is not large enough: it must have length at least
/// [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
/// sufficiently-large temporary buffer.
///
/// [`LENGTH`]: #associatedconstant.LENGTH
/// [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// fn main() -> Result<(), uuid::Error> {
/// let uuid = Uuid::parse_str("
936da01f9abd4d9d80c702af85c822a8")?;
///
/// // the encoded portion is returned
/// assert_eq!(
/// uuid.urn().encode_upper(&mut Uuid::encode_buffer()),
/// "urn:uuid:
936DA01F-
9ABD-
4D9D-
80C7-
02AF85C822A8"
/// );
///
/// // the buffer is mutated directly, and trailing contents remains
/// let mut buf = [b'!';
49];
/// assert_eq!(
/// uuid.urn().encode_upper(&mut buf),
/// "urn:uuid:
936DA01F-
9ABD-
4D9D-
80C7-
02AF85C822A8"
/// );
/// assert_eq!(
/// &buf as &[_],
/// b"urn:uuid:
936DA01F-
9ABD-
4D9D-
80C7-
02AF85C822A8!!!!" as &[_]
/// );
///
/// Ok(())
/// }
/// ```
/// */
#[inline]
pub fn encode_upper<'buf>(&self, buffer: &'buf mut [u8]) -> &'buf mut str {
encode_urn(self.
0.as_bytes(), buffer, true)
}
/// Get a reference to the underlying [`Uuid`].
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// let urn = Uuid::nil().urn();
/// assert_eq!(*urn.as_uuid(), Uuid::nil());
/// ```
pub const fn as_uuid(&self) -> &Uuid {
&self.
0
}
/// Consumes the [`Urn`], returning the underlying [`Uuid`].
///
/// # Examples
///
/// ```rust
/// use uuid::Uuid;
///
/// let urn = Uuid::nil().urn();
/// assert_eq!(urn.into_uuid(), Uuid::nil());
/// ```
pub const fn into_uuid(self) -> Uuid {
self.
0
}
}
macro_rules! impl_fmt_traits {
($($T:ident<$($a:lifetime),*>),+) => {$(
impl<$($a),*> fmt::Display for $T<$($a),*> {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::LowerHex::fmt(self, f)
}
}
impl<$($a),*> fmt::LowerHex for $T<$($a),*> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.encode_lower(&mut [
0; Self::LENGTH]))
}
}
impl<$($a),*> fmt::UpperHex for $T<$($a),*> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.encode_upper(&mut [
0; Self::LENGTH]))
}
}
impl_fmt_from!($T<$($a),*>);
)+}
}
macro_rules! impl_fmt_from {
($T:ident<>) => {
impl From<Uuid> for $T {
#[inline]
fn from(f: Uuid) -> Self {
$T(f)
}
}
impl From<$T> for Uuid {
#[inline]
fn from(f: $T) -> Self {
f.into_uuid()
}
}
impl AsRef<Uuid> for $T {
#[inline]
fn as_ref(&self) -> &Uuid {
&self.
0
}
}
impl Borrow<Uuid> for $T {
#[inline]
fn borrow(&self) -> &Uuid {
&self.
0
}
}
};
($T:ident<$a:lifetime>) => {
impl<$a> From<&$a Uuid> for $T<$a> {
#[inline]
fn from(f: &$a Uuid) -> Self {
$T::from_uuid_ref(f)
}
}
impl<$a> From<$T<$a>> for &$a Uuid {
#[inline]
fn from(f: $T<$a>) -> &$a Uuid {
f.
0
}
}
impl<$a> AsRef<Uuid> for $T<$a> {
#[inline]
fn as_ref(&self) -> &Uuid {
self.
0
}
}
impl<$a> Borrow<Uuid> for $T<$a> {
#[inline]
fn borrow(&self) -> &Uuid {
self.
0
}
}
};
}
impl_fmt_traits! {
Hyphenated<>,
Simple<>,
Urn<>,
Braced<>
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn hyphenated_trailing() {
let mut buf = [b'x';
100];
let len = Uuid::nil().hyphenated().encode_lower(&mut buf).len();
assert_eq!(len, super::Hyphenated::LENGTH);
assert!(buf[len..].iter().all(|x| *x == b'x'));
}
#[test]
fn hyphenated_ref_trailing() {
let mut buf = [b'x';
100];
let len = Uuid::nil().as_hyphenated().encode_lower(&mut buf).len();
assert_eq!(len, super::Hyphenated::LENGTH);
assert!(buf[len..].iter().all(|x| *x == b'x'));
}
#[test]
fn simple_trailing() {
let mut buf = [b'x';
100];
let len = Uuid::nil().simple().encode_lower(&mut buf).len();
assert_eq!(len, super::Simple::LENGTH);
assert!(buf[len..].iter().all(|x| *x == b'x'));
}
#[test]
fn simple_ref_trailing() {
let mut buf = [b'x';
100];
let len = Uuid::nil().as_simple().encode_lower(&mut buf).len();
assert_eq!(len, super::Simple::LENGTH);
assert!(buf[len..].iter().all(|x| *x == b'x'));
}
#[test]
fn urn_trailing() {
let mut buf = [b'x';
100];
let len = Uuid::nil().urn().encode_lower(&mut buf).len();
assert_eq!(len, super::Urn::LENGTH);
assert!(buf[len..].iter().all(|x| *x == b'x'));
}
#[test]
fn urn_ref_trailing() {
let mut buf = [b'x';
100];
let len = Uuid::nil().as_urn().encode_lower(&mut buf).len();
assert_eq!(len, super::Urn::LENGTH);
assert!(buf[len..].iter().all(|x| *x == b'x'));
}
#[test]
fn braced_trailing() {
let mut buf = [b'x';
100];
let len = Uuid::nil().braced().encode_lower(&mut buf).len();
assert_eq!(len, super::Braced::LENGTH);
assert!(buf[len..].iter().all(|x| *x == b'x'));
}
#[test]
fn braced_ref_trailing() {
let mut buf = [b'x';
100];
let len = Uuid::nil().as_braced().encode_lower(&mut buf).len();
assert_eq!(len, super::Braced::LENGTH);
assert!(buf[len..].iter().all(|x| *x == b'x'));
}
#[test]
#[should_panic]
fn hyphenated_too_small() {
Uuid::nil().hyphenated().encode_lower(&mut [
0;
35]);
}
#[test]
#[should_panic]
fn simple_too_small() {
Uuid::nil().simple().encode_lower(&mut [
0;
31]);
}
#[test]
#[should_panic]
fn urn_too_small() {
Uuid::nil().urn().encode_lower(&mut [
0;
44]);
}
#[test]
#[should_panic]
fn braced_too_small() {
Uuid::nil().braced().encode_lower(&mut [
0;
37]);
}
#[test]
fn hyphenated_to_inner() {
let hyphenated = Uuid::nil().hyphenated();
assert_eq!(Uuid::from(hyphenated), Uuid::nil());
}
#[test]
fn simple_to_inner() {
let simple = Uuid::nil().simple();
assert_eq!(Uuid::from(simple), Uuid::nil());
}
#[test]
fn urn_to_inner() {
let urn = Uuid::nil().urn();
assert_eq!(Uuid::from(urn), Uuid::nil());
}
#[test]
fn braced_to_inner() {
let braced = Uuid::nil().braced();
assert_eq!(Uuid::from(braced), Uuid::nil());
}
}
