Struct sqlx::types::Uuid [−][src]
A Universally Unique Identifier (UUID).
Implementations
impl Uuid
[src]
pub const fn nil() -> Uuid
[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) -> Uuid
[src]
Creates a UUID from a 128bit value in big-endian order.
pub const fn from_u128_le(v: u128) -> Uuid
[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: [u8; 16]) -> 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]
Get a Hyphenated
formatter.
pub const fn to_hyphenated_ref(&self) -> HyphenatedRef<'_>
[src]
Get a borrowed HyphenatedRef
formatter.
pub const fn to_simple(self) -> Simple
[src]
Get a Simple
formatter.
pub const fn to_simple_ref(&self) -> SimpleRef<'_>
[src]
Get a borrowed SimpleRef
formatter.
pub const fn to_urn(self) -> Urn
[src]
Get a Urn
formatter.
pub const fn to_urn_ref(&self) -> UrnRef<'_>
[src]
Get a borrowed UrnRef
formatter.
impl Uuid
[src]
pub const NAMESPACE_DNS: Uuid
[src]
UUID namespace for Domain Name System (DNS).
pub const NAMESPACE_OID: Uuid
[src]
UUID namespace for ISO Object Identifiers (OIDs).
pub const NAMESPACE_URL: Uuid
[src]
UUID namespace for Uniform Resource Locators (URLs).
pub const NAMESPACE_X500: Uuid
[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; fn main() -> Result<(), uuid::Error> { let uuid = Uuid::nil(); assert_eq!(uuid.as_fields(), (0, 0, 0, &[0u8; 8])); let uuid = Uuid::parse_str("936DA01F-9ABD-4D9D-80C7-02AF85C822A8")?; assert_eq!( uuid.as_fields(), ( 0x936DA01F, 0x9ABD, 0x4D9D, b"\x80\xC7\x02\xAF\x85\xC8\x22\xA8" ) ); Ok(()) }
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; fn main() -> Result<(), uuid::Error> { let uuid = Uuid::parse_str("936DA01F-9ABD-4D9D-80C7-02AF85C822A8")?; assert_eq!( uuid.to_fields_le(), ( 0x1FA06D93, 0xBD9A, 0x9D4D, b"\x80\xC7\x02\xAF\x85\xC8\x22\xA8" ) ); Ok(()) }
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
Uuid::as_bytes
method.
Examples
use uuid::Uuid; fn main() -> Result<(), uuid::Error> { let uuid = Uuid::parse_str("936DA01F-9ABD-4D9D-80C7-02AF85C822A8")?; assert_eq!( uuid.as_u128(), 0x936DA01F9ABD4D9D80C702AF85C822A8, ); Ok(()) }
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
Uuid::to_fields_le
, because the entire UUID is reversed, rather
than reversing the individual fields in-place.
Examples
use uuid::Uuid; fn main() -> Result<(), uuid::Error> { let uuid = Uuid::parse_str("936DA01F-9ABD-4D9D-80C7-02AF85C822A8")?; assert_eq!( uuid.to_u128_le(), 0xA822C885AF02C7809D4DBD9A1FA06D93, ); Ok(()) }
pub const fn as_bytes(&self) -> &[u8; 16]
[src]
Returns an array of 16 octets containing the UUID data.
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 Clone for Uuid
[src]
impl Copy for Uuid
[src]
impl Debug for Uuid
[src]
impl<'_> Decode<'_, MySql> for Uuid
[src]
pub fn decode(
value: MySqlValueRef<'_>
) -> Result<Uuid, Box<dyn Error + 'static + Sync + Send, Global>>
[src]
value: MySqlValueRef<'_>
) -> Result<Uuid, Box<dyn Error + 'static + Sync + Send, Global>>
impl<'_> Decode<'_, Postgres> for Uuid
[src]
pub fn decode(
value: PgValueRef<'_>
) -> Result<Uuid, Box<dyn Error + 'static + Sync + Send, Global>>
[src]
value: PgValueRef<'_>
) -> Result<Uuid, Box<dyn Error + 'static + Sync + Send, Global>>
impl<'_> Decode<'_, Sqlite> for Uuid
[src]
pub fn decode(
value: SqliteValueRef<'_>
) -> Result<Uuid, Box<dyn Error + 'static + Sync + Send, Global>>
[src]
value: SqliteValueRef<'_>
) -> Result<Uuid, Box<dyn Error + 'static + Sync + Send, Global>>
impl Default for Uuid
[src]
impl Display for Uuid
[src]
impl<'_> Encode<'_, MySql> for Uuid
[src]
pub fn encode_by_ref(&self, buf: &mut Vec<u8, Global>) -> IsNull
[src]
#[must_use]pub fn encode(
self,
buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer
) -> IsNull
[src]
self,
buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer
) -> IsNull
pub fn produces(&self) -> Option<<DB as Database>::TypeInfo>
[src]
pub fn size_hint(&self) -> usize
[src]
impl<'_> Encode<'_, Postgres> for Uuid
[src]
pub fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> IsNull
[src]
#[must_use]pub fn encode(
self,
buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer
) -> IsNull
[src]
self,
buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer
) -> IsNull
pub fn produces(&self) -> Option<<DB as Database>::TypeInfo>
[src]
pub fn size_hint(&self) -> usize
[src]
impl<'q> Encode<'q, Sqlite> for Uuid
[src]
pub fn encode_by_ref(
&self,
args: &mut Vec<SqliteArgumentValue<'q>, Global>
) -> IsNull
[src]
&self,
args: &mut Vec<SqliteArgumentValue<'q>, Global>
) -> IsNull
#[must_use]pub fn encode(
self,
buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer
) -> IsNull
[src]
self,
buf: &mut <DB as HasArguments<'q>>::ArgumentBuffer
) -> IsNull
pub fn produces(&self) -> Option<<DB as Database>::TypeInfo>
[src]
pub fn size_hint(&self) -> usize
[src]
impl Eq for Uuid
[src]
impl<'a> From<&'a Uuid> for HyphenatedRef<'a>
[src]
pub fn from(f: &'a Uuid) -> HyphenatedRef<'a>
[src]
impl<'a> From<&'a Uuid> for UrnRef<'a>
[src]
impl<'a> From<&'a Uuid> for SimpleRef<'a>
[src]
impl From<Uuid> for Urn
[src]
impl From<Uuid> for Simple
[src]
impl From<Uuid> for Hyphenated
[src]
pub fn from(f: Uuid) -> Hyphenated
[src]
impl FromStr for Uuid
[src]
type Err = Error
The associated error which can be returned from parsing.
pub fn from_str(uuid_str: &str) -> Result<Uuid, <Uuid as FromStr>::Err>
[src]
impl Hash for Uuid
[src]
pub fn hash<__H>(&self, state: &mut __H) where
__H: Hasher,
[src]
__H: Hasher,
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl LowerHex for Uuid
[src]
impl Ord for Uuid
[src]
pub fn cmp(&self, other: &Uuid) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl PartialEq<Uuid> for Uuid
[src]
impl PartialOrd<Uuid> for Uuid
[src]
pub fn partial_cmp(&self, other: &Uuid) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl StructuralEq for Uuid
[src]
impl StructuralPartialEq for Uuid
[src]
impl Type<MySql> for Uuid
[src]
pub fn type_info() -> MySqlTypeInfo
[src]
pub fn compatible(ty: &MySqlTypeInfo) -> bool
[src]
impl Type<Postgres> for Uuid
[src]
pub fn type_info() -> PgTypeInfo
[src]
pub fn compatible(ty: &<DB as Database>::TypeInfo) -> bool
[src]
impl Type<Sqlite> for Uuid
[src]
pub fn type_info() -> SqliteTypeInfo
[src]
pub fn compatible(ty: &SqliteTypeInfo) -> bool
[src]
impl UpperHex for Uuid
[src]
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
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> CallHasher for T where
T: Hash,
T: Hash,
impl<T> CallHasher for T where
T: Hash + ?Sized,
T: Hash + ?Sized,
pub default fn get_hash<H, B>(value: &H, build_hasher: &B) -> u64 where
B: BuildHasher,
H: Hash + ?Sized,
B: BuildHasher,
H: Hash + ?Sized,
impl<T> Conv for T
impl<T> Conv for T
impl<Q, K> Equivalent<K> for Q where
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized,
[src]
K: Borrow<Q> + ?Sized,
Q: Eq + ?Sized,
pub fn equivalent(&self, key: &K) -> bool
[src]
impl<T> FmtForward for T
pub fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Self: Binary,
pub fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Self: Display,
pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Self: LowerExp,
pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Self: LowerHex,
pub fn fmt_octal(self) -> FmtOctal<Self> where
Self: Octal,
Self: Octal,
pub fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Self: Pointer,
pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Self: UpperExp,
pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Self: UpperHex,
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> Pipe for T where
T: ?Sized,
T: ?Sized,
pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_ref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self) -> R
) -> R where
R: 'a,
pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
Self: Borrow<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
R: 'a,
B: 'a + ?Sized,
pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
Self: AsRef<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_as_mut<'a, U, R>(
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut U) -> R
) -> R where
Self: AsMut<U>,
U: 'a + ?Sized,
R: 'a,
pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
Self: Deref<Target = T>,
T: 'a + ?Sized,
R: 'a,
pub fn pipe_deref_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: DerefMut<Target = T> + Deref,
T: 'a + ?Sized,
R: 'a,
impl<T> Pipe for T
impl<T> PipeAsRef for T
pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Self: AsRef<T>,
T: 'a,
R: 'a,
pub fn pipe_as_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: AsMut<T>,
T: 'a,
R: 'a,
impl<T> PipeBorrow for T
pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Self: Borrow<T>,
T: 'a,
R: 'a,
pub fn pipe_borrow_mut<'a, T, R>(
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut T) -> R
) -> R where
Self: BorrowMut<T>,
T: 'a,
R: 'a,
impl<T> PipeDeref for T
pub fn pipe_deref<'a, R>(
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
&'a self,
func: impl FnOnce(&'a Self::Target) -> R
) -> R where
Self: Deref,
R: 'a,
pub fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
impl<T> PipeRef for T
pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
R: 'a,
R: 'a,
pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
R: 'a,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> Tap for T
pub fn tap(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
pub fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Self: Borrow<B>,
B: ?Sized,
pub fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Self: BorrowMut<B>,
B: ?Sized,
pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Self: AsRef<R>,
R: ?Sized,
pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Self: AsMut<R>,
R: ?Sized,
pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
Self: Deref<Target = T>,
T: ?Sized,
Self: Deref<Target = T>,
T: ?Sized,
pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
Self: DerefMut<Target = T> + Deref,
T: ?Sized,
impl<T> Tap for T
pub fn tap<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&Self) -> R,
F: FnOnce(&Self) -> R,
pub fn tap_mut<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
F: FnOnce(&mut Self) -> R,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_ref<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Self: AsRef<T>,
F: FnOnce(&T) -> R,
pub fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
U: ?Sized,
pub fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Self: Borrow<T>,
F: FnOnce(&T) -> R,
pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
impl<T> TapDeref for T
pub fn tap_deref<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Self: Deref,
F: FnOnce(&Self::Target) -> R,
pub fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<T> TryConv for T
impl<T> TryConv for T
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.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
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.
pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,