Struct validators::prelude::validators_prelude::Ipv6Addr 1.0.0[−][src]
pub struct Ipv6Addr { /* fields omitted */ }
An IPv6 address.
IPv6 addresses are defined as 128-bit integers in IETF RFC 4291. They are usually represented as eight 16-bit segments.
See IpAddr
for a type encompassing both IPv4 and IPv6 addresses.
The size of an Ipv6Addr
struct may vary depending on the target operating
system.
Textual representation
Ipv6Addr
provides a FromStr
implementation. There are many ways to represent
an IPv6 address in text, but in general, each segments is written in hexadecimal
notation, and segments are separated by :
. For more information, see
IETF RFC 5952.
Examples
use std::net::Ipv6Addr; let localhost = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1); assert_eq!("::1".parse(), Ok(localhost)); assert_eq!(localhost.is_loopback(), true);
Implementations
impl Ipv6Addr
[src]
pub const fn new(
a: u16,
b: u16,
c: u16,
d: u16,
e: u16,
f: u16,
g: u16,
h: u16
) -> Ipv6Addr
1.0.0 (const: 1.32.0)[src]
a: u16,
b: u16,
c: u16,
d: u16,
e: u16,
f: u16,
g: u16,
h: u16
) -> Ipv6Addr
Creates a new IPv6 address from eight 16-bit segments.
The result will represent the IP address a:b:c:d:e:f:g:h
.
Examples
use std::net::Ipv6Addr; let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);
pub const LOCALHOST: Ipv6Addr
1.30.0[src]
An IPv6 address representing localhost: ::1
.
Examples
use std::net::Ipv6Addr; let addr = Ipv6Addr::LOCALHOST; assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
pub const UNSPECIFIED: Ipv6Addr
1.30.0[src]
An IPv6 address representing the unspecified address: ::
Examples
use std::net::Ipv6Addr; let addr = Ipv6Addr::UNSPECIFIED; assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));
pub const fn segments(&self) -> [u16; 8]
1.0.0 (const: 1.50.0)[src]
Returns the eight 16-bit segments that make up this address.
Examples
use std::net::Ipv6Addr; assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).segments(), [0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff]);
pub const fn is_unspecified(&self) -> bool
1.7.0 (const: 1.50.0)[src]
Returns true
for the special ‘unspecified’ address (::).
This property is defined in IETF RFC 4291.
Examples
use std::net::Ipv6Addr; assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unspecified(), false); assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0).is_unspecified(), true);
pub const fn is_loopback(&self) -> bool
1.7.0 (const: 1.50.0)[src]
Returns true
if this is a loopback address (::1).
This property is defined in IETF RFC 4291.
Examples
use std::net::Ipv6Addr; assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_loopback(), false); assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1).is_loopback(), true);
pub const fn is_global(&self) -> bool
[src]
🔬 This is a nightly-only experimental API. (ip
)
extra functionality has not been scrutinized to the level that it should be to be stable
Returns true
if the address appears to be globally routable.
The following return false
:
- the loopback address
- link-local and unique local unicast addresses
- interface-, link-, realm-, admin- and site-local multicast addresses
Examples
#![feature(ip)] use std::net::Ipv6Addr; assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_global(), true); assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1).is_global(), false); assert_eq!(Ipv6Addr::new(0, 0, 0x1c9, 0, 0, 0xafc8, 0, 0x1).is_global(), true);
pub const fn is_unique_local(&self) -> bool
[src]
🔬 This is a nightly-only experimental API. (ip
)
extra functionality has not been scrutinized to the level that it should be to be stable
Returns true
if this is a unique local address (fc00::/7
).
This property is defined in IETF RFC 4193.
Examples
#![feature(ip)] use std::net::Ipv6Addr; assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unique_local(), false); assert_eq!(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 0).is_unique_local(), true);
pub const fn is_unicast_link_local_strict(&self) -> bool
[src]
🔬 This is a nightly-only experimental API. (ip
)
extra functionality has not been scrutinized to the level that it should be to be stable
Returns true
if the address is a unicast link-local address (fe80::/64
).
A common misconception is to think that “unicast link-local addresses start with
fe80::
”, but IETF RFC 4291 actually defines a stricter format for these addresses:
| 10 |
| bits | 54 bits | 64 bits |
+----------+-------------------------+----------------------------+
|1111111010| 0 | interface ID |
+----------+-------------------------+----------------------------+
This method validates the format defined in the RFC and won’t recognize addresses
like fe80:0:0:1::
or fe81::
as unicast link-local addresses.
If you need a less strict validation, use Ipv6Addr::is_unicast_link_local()
instead.
Examples
#![feature(ip)] use std::net::Ipv6Addr; let ip = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0); assert!(ip.is_unicast_link_local_strict()); let ip = Ipv6Addr::new(0xfe80, 0, 0, 0, 0xffff, 0xffff, 0xffff, 0xffff); assert!(ip.is_unicast_link_local_strict()); let ip = Ipv6Addr::new(0xfe80, 0, 0, 1, 0, 0, 0, 0); assert!(!ip.is_unicast_link_local_strict()); assert!(ip.is_unicast_link_local()); let ip = Ipv6Addr::new(0xfe81, 0, 0, 0, 0, 0, 0, 0); assert!(!ip.is_unicast_link_local_strict()); assert!(ip.is_unicast_link_local());
See also
- IETF RFC 4291 section 2.5.6
- RFC 4291 errata 4406 (which has been rejected but provides useful insight)
Ipv6Addr::is_unicast_link_local()
pub const fn is_unicast_link_local(&self) -> bool
[src]
🔬 This is a nightly-only experimental API. (ip
)
extra functionality has not been scrutinized to the level that it should be to be stable
Returns true
if the address is a unicast link-local address (fe80::/10
).
This method returns true
for addresses in the range reserved by [RFC 4291 section 2.4],
i.e. addresses with the following format:
| 10 |
| bits | 54 bits | 64 bits |
+----------+-------------------------+----------------------------+
|1111111010| arbitratry value | interface ID |
+----------+-------------------------+----------------------------+
As a result, this method considers addresses such as fe80:0:0:1::
or fe81::
to be
unicast link-local addresses, whereas Ipv6Addr::is_unicast_link_local_strict()
does not.
If you need a strict validation fully compliant with the RFC, use
Ipv6Addr::is_unicast_link_local_strict()
instead.
Examples
#![feature(ip)] use std::net::Ipv6Addr; let ip = Ipv6Addr::new(0xfe80, 0, 0, 0, 0, 0, 0, 0); assert!(ip.is_unicast_link_local()); let ip = Ipv6Addr::new(0xfe80, 0, 0, 0, 0xffff, 0xffff, 0xffff, 0xffff); assert!(ip.is_unicast_link_local()); let ip = Ipv6Addr::new(0xfe80, 0, 0, 1, 0, 0, 0, 0); assert!(ip.is_unicast_link_local()); assert!(!ip.is_unicast_link_local_strict()); let ip = Ipv6Addr::new(0xfe81, 0, 0, 0, 0, 0, 0, 0); assert!(ip.is_unicast_link_local()); assert!(!ip.is_unicast_link_local_strict());
See also
- IETF RFC 4291 section 2.4
- RFC 4291 errata 4406 (which has been rejected but provides useful insight)
pub const fn is_unicast_site_local(&self) -> bool
[src]
🔬 This is a nightly-only experimental API. (ip
)
extra functionality has not been scrutinized to the level that it should be to be stable
Returns true
if this is a deprecated unicast site-local address (fec0::/10). The
unicast site-local address format is defined in RFC 4291 section 2.5.7 as:
| 10 |
| bits | 54 bits | 64 bits |
+----------+-------------------------+----------------------------+
|1111111011| subnet ID | interface ID |
+----------+-------------------------+----------------------------+
Examples
#![feature(ip)] use std::net::Ipv6Addr; assert_eq!( Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unicast_site_local(), false ); assert_eq!(Ipv6Addr::new(0xfec2, 0, 0, 0, 0, 0, 0, 0).is_unicast_site_local(), true);
Warning
As per RFC 3879, the whole FEC0::/10
prefix is
deprecated. New software must not support site-local
addresses.
pub const fn is_documentation(&self) -> bool
[src]
🔬 This is a nightly-only experimental API. (ip
)
extra functionality has not been scrutinized to the level that it should be to be stable
Returns true
if this is an address reserved for documentation
(2001:db8::/32
).
This property is defined in IETF RFC 3849.
Examples
#![feature(ip)] use std::net::Ipv6Addr; assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_documentation(), false); assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_documentation(), true);
pub const fn is_unicast_global(&self) -> bool
[src]
🔬 This is a nightly-only experimental API. (ip
)
extra functionality has not been scrutinized to the level that it should be to be stable
Returns true
if the address is a globally routable unicast address.
The following return false:
- the loopback address
- the link-local addresses
- unique local addresses
- the unspecified address
- the address range reserved for documentation
This method returns true
for site-local addresses as per RFC 4291 section 2.5.7
The special behavior of [the site-local unicast] prefix defined in [RFC3513] must no longer
be supported in new implementations (i.e., new implementations must treat this prefix as
Global Unicast).
Examples
#![feature(ip)] use std::net::Ipv6Addr; assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast_global(), false); assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unicast_global(), true);
pub const fn multicast_scope(&self) -> Option<Ipv6MulticastScope>
[src]
🔬 This is a nightly-only experimental API. (ip
)
extra functionality has not been scrutinized to the level that it should be to be stable
Returns the address’s multicast scope if the address is multicast.
Examples
#![feature(ip)] use std::net::{Ipv6Addr, Ipv6MulticastScope}; assert_eq!( Ipv6Addr::new(0xff0e, 0, 0, 0, 0, 0, 0, 0).multicast_scope(), Some(Ipv6MulticastScope::Global) ); assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).multicast_scope(), None);
pub const fn is_multicast(&self) -> bool
1.7.0 (const: 1.50.0)[src]
Returns true
if this is a multicast address (ff00::/8).
This property is defined by IETF RFC 4291.
Examples
use std::net::Ipv6Addr; assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).is_multicast(), true); assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_multicast(), false);
pub const fn to_ipv4_mapped(&self) -> Option<Ipv4Addr>
[src]
🔬 This is a nightly-only experimental API. (ip
)
extra functionality has not been scrutinized to the level that it should be to be stable
Converts this address to an IPv4
address if it’s an “IPv4-mapped IPv6 address”
defined in IETF RFC 4291 section 2.5.5.2, otherwise returns None
.
::ffff:a.b.c.d
becomes a.b.c.d
.
All addresses not starting with ::ffff
will return None
.
Examples
#![feature(ip)] use std::net::{Ipv4Addr, Ipv6Addr}; assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).to_ipv4_mapped(), None); assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).to_ipv4_mapped(), Some(Ipv4Addr::new(192, 10, 2, 255))); assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_ipv4_mapped(), None);
pub const fn to_ipv4(&self) -> Option<Ipv4Addr>
1.0.0 (const: 1.50.0)[src]
Converts this address to an IPv4
address. Returns None
if this address is
neither IPv4-compatible or IPv4-mapped.
::a.b.c.d and ::ffff:a.b.c.d become a.b.c.d
Examples
use std::net::{Ipv4Addr, Ipv6Addr}; assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).to_ipv4(), None); assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).to_ipv4(), Some(Ipv4Addr::new(192, 10, 2, 255))); assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_ipv4(), Some(Ipv4Addr::new(0, 0, 0, 1)));
pub const fn octets(&self) -> [u8; 16]
1.12.0 (const: 1.32.0)[src]
Returns the sixteen eight-bit integers the IPv6 address consists of.
use std::net::Ipv6Addr; assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).octets(), [255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
Trait Implementations
impl Clone for Ipv6Addr
[src]
impl Copy for Ipv6Addr
[src]
impl Debug for Ipv6Addr
[src]
impl<'de> Deserialize<'de> for Ipv6Addr
[src]
pub fn deserialize<D>(
deserializer: D
) -> Result<Ipv6Addr, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
[src]
deserializer: D
) -> Result<Ipv6Addr, <D as Deserializer<'de>>::Error> where
D: Deserializer<'de>,
impl Display for Ipv6Addr
[src]
Write an Ipv6Addr, conforming to the canonical style described by RFC 5952.
impl Eq for Ipv6Addr
[src]
impl From<[u16; 8]> for Ipv6Addr
1.16.0[src]
pub fn from(segments: [u16; 8]) -> Ipv6Addr
[src]
Creates an Ipv6Addr
from an eight element 16-bit array.
Examples
use std::net::Ipv6Addr; let addr = Ipv6Addr::from([ 525u16, 524u16, 523u16, 522u16, 521u16, 520u16, 519u16, 518u16, ]); assert_eq!( Ipv6Addr::new( 0x20d, 0x20c, 0x20b, 0x20a, 0x209, 0x208, 0x207, 0x206 ), addr );
impl From<[u8; 16]> for Ipv6Addr
1.9.0[src]
pub fn from(octets: [u8; 16]) -> Ipv6Addr
[src]
Creates an Ipv6Addr
from a sixteen element byte array.
Examples
use std::net::Ipv6Addr; let addr = Ipv6Addr::from([ 25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8, 17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8, ]); assert_eq!( Ipv6Addr::new( 0x1918, 0x1716, 0x1514, 0x1312, 0x1110, 0x0f0e, 0x0d0c, 0x0b0a ), addr );
impl From<Ipv6Addr> for IpAddr
1.16.0[src]
pub fn from(ipv6: Ipv6Addr) -> IpAddr
[src]
Copies this address to a new IpAddr::V6
.
Examples
use std::net::{IpAddr, Ipv6Addr}; let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff); assert_eq!( IpAddr::V6(addr), IpAddr::from(addr) );
impl From<u128> for Ipv6Addr
1.26.0[src]
pub fn from(ip: u128) -> Ipv6Addr
[src]
Convert a host byte order u128
into an Ipv6Addr
.
Examples
use std::net::Ipv6Addr; let addr = Ipv6Addr::from(0x102030405060708090A0B0C0D0E0F00D_u128); assert_eq!( Ipv6Addr::new( 0x1020, 0x3040, 0x5060, 0x7080, 0x90A0, 0xB0C0, 0xD0E0, 0xF00D, ), addr);
impl<'v> FromFormValue<'v> for Ipv6Addr
[src]
type Error = &'v RawStr
The associated error which can be returned from parsing. It is a good
idea to have the return type be or contain an &'v str
so that the
unparseable string can be examined after a bad parse. Read more
pub fn from_form_value(
v: &'v RawStr
) -> Result<Ipv6Addr, <Ipv6Addr as FromFormValue<'v>>::Error>
[src]
v: &'v RawStr
) -> Result<Ipv6Addr, <Ipv6Addr as FromFormValue<'v>>::Error>
pub fn default() -> Option<Self>
[src]
impl<'a> FromParam<'a> for Ipv6Addr
[src]
type Error = &'a RawStr
The associated error to be returned if parsing/validation fails.
pub fn from_param(
param: &'a RawStr
) -> Result<Ipv6Addr, <Ipv6Addr as FromParam<'a>>::Error>
[src]
param: &'a RawStr
) -> Result<Ipv6Addr, <Ipv6Addr as FromParam<'a>>::Error>
impl FromStr for Ipv6Addr
[src]
type Err = AddrParseError
The associated error which can be returned from parsing.
pub fn from_str(s: &str) -> Result<Ipv6Addr, AddrParseError>
[src]
impl<'x, P> FromUriParam<P, &'x Ipv6Addr> for Ipv6Addr where
P: UriPart,
P: UriPart,
type Target = &'x Ipv6Addr
The resulting type of this conversion.
pub fn from_uri_param(param: &'x Ipv6Addr) -> &'x Ipv6Addr
impl<'x, P> FromUriParam<P, &'x mut Ipv6Addr> for Ipv6Addr where
P: UriPart,
P: UriPart,
type Target = &'x mut Ipv6Addr
The resulting type of this conversion.
pub fn from_uri_param(param: &'x mut Ipv6Addr) -> &'x mut Ipv6Addr
impl<P> FromUriParam<P, Ipv6Addr> for Ipv6Addr where
P: UriPart,
P: UriPart,
type Target = Ipv6Addr
The resulting type of this conversion.
pub fn from_uri_param(param: Ipv6Addr) -> Ipv6Addr
impl Hash for Ipv6Addr
[src]
pub fn hash<H>(&self, s: &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 Ord for Ipv6Addr
[src]
pub fn cmp(&self, other: &Ipv6Addr) -> 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<IpAddr> for Ipv6Addr
1.16.0[src]
impl PartialEq<Ipv6Addr> for IpAddr
1.16.0[src]
pub fn eq(&self, other: &Ipv6Addr) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl PartialEq<Ipv6Addr> for Ipv6Addr
[src]
pub fn eq(&self, other: &Ipv6Addr) -> bool
[src]
#[must_use]pub fn ne(&self, other: &Rhs) -> bool
[src]
impl PartialOrd<IpAddr> for Ipv6Addr
1.16.0[src]
pub fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl PartialOrd<Ipv6Addr> for Ipv6Addr
[src]
pub fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl PartialOrd<Ipv6Addr> for IpAddr
1.16.0[src]
pub fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering>
[src]
#[must_use]pub fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]pub fn ge(&self, other: &Rhs) -> bool
[src]
impl Serialize for Ipv6Addr
[src]
pub fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
[src]
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
S: Serializer,
impl<P> UriDisplay<P> for Ipv6Addr where
P: UriPart,
P: UriPart,
This implementation is identical to the Display
implementation.
Auto Trait Implementations
impl RefUnwindSafe for Ipv6Addr
impl Send for Ipv6Addr
impl Sync for Ipv6Addr
impl Unpin for Ipv6Addr
impl UnwindSafe for Ipv6Addr
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T, I> AsResult<T, I> for T where
I: Input,
I: Input,
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> DeserializeOwned for T where
T: for<'de> Deserialize<'de>,
[src]
T: for<'de> Deserialize<'de>,
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> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> IntoCollection<T> for T
pub fn into_collection<A>(self) -> SmallVec<A> where
A: Array<Item = T>,
A: Array<Item = T>,
pub fn mapped<U, F, A>(self, f: F) -> SmallVec<A> where
A: Array<Item = U>,
F: FnMut(T) -> U,
A: Array<Item = U>,
F: FnMut(T) -> U,
impl<T> RuleType for T where
T: Copy + Debug + Eq + Hash + Ord,
[src]
T: Copy + Debug + Eq + Hash + Ord,
impl<T> Same<T> for T
type Output = T
Should always be Self
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, 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<T> Typeable for T where
T: Any,
T: Any,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,