Struct vimwiki::vendor::uriparse::uri_reference::URIReference [−]
pub struct URIReference<'uri> { /* fields omitted */ }
Expand description
A URI reference as defined in [RFC3986, Section 4.1].
Specifically, a URI reference is either a URI or a relative reference (a schemeless URI).
Implementations
impl<'uri> URIReference<'uri>
impl<'uri> URIReference<'uri>
Returns the authority, if present, of the URI reference.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("//example.com/my/path").unwrap(); assert_eq!(reference.authority().unwrap().to_string(), "example.com");
pub fn builder<'new_uri>() -> URIReferenceBuilder<'new_uri>
pub fn builder<'new_uri>() -> URIReferenceBuilder<'new_uri>
Constructs a default builder for a URI reference.
This provides an alternative means of constructing a URI reference besides parsing and
URIReference::from_parts
.
Examples
use std::convert::TryFrom; use uriparse::{Authority, Path, Scheme, URIReference}; let reference = URIReference::builder() .with_scheme(Some(Scheme::HTTP)) .with_authority(Some(Authority::try_from("example.com").unwrap())) .with_path(Path::try_from("/my/path").unwrap()) .build() .unwrap(); assert_eq!(reference.to_string(), "http://example.com/my/path");
pub fn can_be_a_base(&self) -> bool
pub fn can_be_a_base(&self) -> bool
Returns whether the URI reference can act as a base URI.
A URI can be a base if it is absolute (i.e. it has no fragment component).
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://example.com/my/path").unwrap(); assert!(reference.can_be_a_base()); let reference = URIReference::try_from("ftp://127.0.0.1#fragment").unwrap(); assert!(!reference.can_be_a_base());
pub fn from_parts<'new_uri, TScheme, TAuthority, TPath, TQuery, TFragment, TSchemeError, TAuthorityError, TPathError, TQueryError, TFragmentError>(
scheme: Option<TScheme>,
authority: Option<TAuthority>,
path: TPath,
query: Option<TQuery>,
fragment: Option<TFragment>
) -> Result<URIReference<'new_uri>, URIReferenceError> where
Scheme<'new_uri>: TryFrom<TScheme>,
Authority<'new_uri>: TryFrom<TAuthority>,
Path<'new_uri>: TryFrom<TPath>,
Query<'new_uri>: TryFrom<TQuery>,
Fragment<'new_uri>: TryFrom<TFragment>,
URIReferenceError: From<TSchemeError>,
URIReferenceError: From<TAuthorityError>,
URIReferenceError: From<TPathError>,
URIReferenceError: From<TQueryError>,
URIReferenceError: From<TFragmentError>,
<Scheme<'new_uri> as TryFrom<TScheme>>::Error == TSchemeError,
<Authority<'new_uri> as TryFrom<TAuthority>>::Error == TAuthorityError,
<Path<'new_uri> as TryFrom<TPath>>::Error == TPathError,
<Query<'new_uri> as TryFrom<TQuery>>::Error == TQueryError,
<Fragment<'new_uri> as TryFrom<TFragment>>::Error == TFragmentError,
pub fn from_parts<'new_uri, TScheme, TAuthority, TPath, TQuery, TFragment, TSchemeError, TAuthorityError, TPathError, TQueryError, TFragmentError>(
scheme: Option<TScheme>,
authority: Option<TAuthority>,
path: TPath,
query: Option<TQuery>,
fragment: Option<TFragment>
) -> Result<URIReference<'new_uri>, URIReferenceError> where
Scheme<'new_uri>: TryFrom<TScheme>,
Authority<'new_uri>: TryFrom<TAuthority>,
Path<'new_uri>: TryFrom<TPath>,
Query<'new_uri>: TryFrom<TQuery>,
Fragment<'new_uri>: TryFrom<TFragment>,
URIReferenceError: From<TSchemeError>,
URIReferenceError: From<TAuthorityError>,
URIReferenceError: From<TPathError>,
URIReferenceError: From<TQueryError>,
URIReferenceError: From<TFragmentError>,
<Scheme<'new_uri> as TryFrom<TScheme>>::Error == TSchemeError,
<Authority<'new_uri> as TryFrom<TAuthority>>::Error == TAuthorityError,
<Path<'new_uri> as TryFrom<TPath>>::Error == TPathError,
<Query<'new_uri> as TryFrom<TQuery>>::Error == TQueryError,
<Fragment<'new_uri> as TryFrom<TFragment>>::Error == TFragmentError,
Constructs a new URIReference
from the individual parts: scheme, authority, path, query,
and fragment.
The lifetime used by the resulting value will be the lifetime of the part that is most restricted in scope.
Examples
use std::convert::TryFrom; use uriparse::{Scheme, URIReference}; let reference = URIReference::from_parts( None::<Scheme>, Some("example.com"), "/my/path", Some("query"), Some("fragment") ).unwrap(); assert_eq!(reference.to_string(), "//example.com/my/path?query#fragment");
Returns the fragment, if present, of the URI reference.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://example.com#fragment").unwrap(); assert_eq!(reference.fragment().unwrap(), "fragment");
Returns whether the URI reference has an authority component.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://example.com").unwrap(); assert!(reference.has_authority()); let reference = URIReference::try_from("").unwrap(); assert!(!reference.has_authority());
pub fn has_fragment(&self) -> bool
pub fn has_fragment(&self) -> bool
Returns whether the URI reference has a fragment component.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("#test").unwrap(); assert!(reference.has_fragment()); let reference = URIReference::try_from("http://example.com").unwrap(); assert!(!reference.has_fragment());
pub fn has_password(&self) -> bool
pub fn has_password(&self) -> bool
Returns whether the URI reference has a password component.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://user:pass@127.0.0.1").unwrap(); assert!(reference.has_password()); let reference = URIReference::try_from("http://user@127.0.0.1").unwrap(); assert!(!reference.has_password());
Returns whether the URI reference has a port.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://127.0.0.1:8080").unwrap(); assert!(reference.has_port()); let reference = URIReference::try_from("http://127.0.0.1").unwrap(); assert!(!reference.has_port());
Returns whether the URI reference has a query component.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("/?my=query").unwrap(); assert!(reference.has_query()); let reference = URIReference::try_from("http://example.com/my/path").unwrap(); assert!(!reference.has_query());
pub fn has_scheme(&self) -> bool
pub fn has_scheme(&self) -> bool
Returns whether the URI reference has a scheme component.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://example.com?my=query").unwrap(); assert!(reference.has_scheme()); let reference = URIReference::try_from("/my/path").unwrap(); assert!(!reference.has_scheme());
pub fn has_username(&self) -> bool
pub fn has_username(&self) -> bool
Returns whether the URI reference has a username component.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("//username@example.com").unwrap(); assert!(reference.has_username()); let reference = URIReference::try_from("http://example.com").unwrap(); assert!(!reference.has_username());
Returns the host, if present, of the URI reference.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://username@example.com").unwrap(); assert_eq!(reference.host().unwrap().to_string(), "example.com");
pub fn into_builder(self) -> URIReferenceBuilder<'uri>
pub fn into_builder(self) -> URIReferenceBuilder<'uri>
Consumes the URI reference and converts it into a builder with the same values.
Examples
use std::convert::TryFrom; use uriparse::{Fragment, Query, URIReference}; let reference = URIReference::try_from("//example.com/path?query#fragment").unwrap(); let mut builder = reference.into_builder(); builder.query(None::<Query>).fragment(None::<Fragment>); let reference = builder.build().unwrap(); assert_eq!(reference.to_string(), "//example.com/path");
pub fn into_owned(self) -> URIReference<'static>
pub fn into_owned(self) -> URIReference<'static>
Converts the URIReference
into an owned copy.
If you construct the URI reference from a source with a non-static lifetime, you may run into lifetime problems due to the way the struct is designed. Calling this function will ensure that the returned value has a static lifetime.
This is different from just cloning. Cloning the URI reference will just copy the references, and thus the lifetime will remain the same.
Consumes the URIReference
and returns its parts: scheme, authority, path, query, and
fragment.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from( "http://username:password@example.com:80/my/path?my=query#fragment", ).unwrap(); let (scheme, authority, path, query, fragment) = reference.into_parts(); assert_eq!(scheme.unwrap(), "http"); assert_eq!(authority.unwrap().to_string(), "username:password@example.com:80"); assert_eq!(path, "/my/path"); assert_eq!(query.unwrap(), "my=query"); assert_eq!(fragment.unwrap(), "fragment");
pub fn is_absolute_path_reference(&self) -> bool
pub fn is_absolute_path_reference(&self) -> bool
Returns whether the URI reference is an absolute path reference.
A URI reference is an absolute path reference if it is a relative reference that begins with
a single '/'
.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("/my/path").unwrap(); assert!(reference.is_absolute_path_reference());
pub fn is_network_path_reference(&self) -> bool
pub fn is_network_path_reference(&self) -> bool
Returns whether the URI reference is a network path reference.
A URI reference is a network path reference if it is a relative reference that begins with
two '/'
.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("//example.com").unwrap(); assert!(reference.is_network_path_reference());
pub fn is_normalized(&self) -> bool
pub fn is_normalized(&self) -> bool
Returns whether the URI reference is normalized.
A normalized URI reference will have all of its components normalized.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://example.com/?a=b").unwrap(); assert!(reference.is_normalized()); let mut reference = URIReference::try_from("http://EXAMPLE.com/?a=b").unwrap(); assert!(!reference.is_normalized()); reference.normalize(); assert!(reference.is_normalized());
pub fn is_relative_path_reference(&self) -> bool
pub fn is_relative_path_reference(&self) -> bool
Returns whether the URI reference is a relative path reference.
A URI reference is a relative path reference if it is a relative reference that does not
begin with a '/'
.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("my/path").unwrap(); assert!(reference.is_relative_path_reference());
pub fn is_relative_reference(&self) -> bool
pub fn is_relative_reference(&self) -> bool
Returns whether the URI reference is a relative reference.
A URI reference is a relative reference if it has no scheme.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("/my/path").unwrap(); assert!(reference.is_relative_reference());
Returns whether the URI reference is a URI.
A URI reference is a URI if it has a scheme.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://example.com").unwrap(); assert!(reference.is_uri());
Maps the authority using the given map function.
This function will panic if, as a result of the authority change, the URI reference becomes invalid.
Examples
use std::convert::TryFrom; use uriparse::{Authority, URIReference}; let mut reference = URIReference::try_from("http://example.com").unwrap(); reference.map_authority(|_| Some(Authority::try_from("127.0.0.1").unwrap())); assert_eq!(reference.to_string(), "http://127.0.0.1/");
Maps the fragment using the given map function.
Examples
use std::convert::TryFrom; use uriparse::{Fragment, URIReference}; let mut reference = URIReference::try_from("http://example.com").unwrap(); reference.map_fragment(|_| Some(Fragment::try_from("fragment").unwrap())); assert_eq!(reference.to_string(), "http://example.com/#fragment");
Maps the path using the given map function.
This function will panic if, as a result of the path change, the URI reference becomes invalid.
Examples
use std::convert::TryFrom; use uriparse::{Authority, URIReference}; let mut reference = URIReference::try_from("http://example.com").unwrap(); reference.map_path(|mut path| { path.push("test").unwrap(); path.push("path").unwrap(); path }); assert_eq!(reference.to_string(), "http://example.com/test/path");
Maps the query using the given map function.
Examples
use std::convert::TryFrom; use uriparse::{Query, URIReference}; let mut reference = URIReference::try_from("http://example.com").unwrap(); reference.map_query(|_| Some(Query::try_from("query").unwrap())); assert_eq!(reference.to_string(), "http://example.com/?query");
Maps the scheme using the given map function.
This function will panic if, as a result of the scheme change, the URI reference becomes invalid.
Examples
use std::convert::TryFrom; use uriparse::{Scheme, URIReference}; let mut reference = URIReference::try_from("http://example.com").unwrap(); reference.map_scheme(|_| Some(Scheme::try_from("https").unwrap())); assert_eq!(reference.to_string(), "https://example.com/");
pub fn normalize(&mut self)
pub fn normalize(&mut self)
Normalizes the URI reference.
A normalized URI reference will have all of its components normalized.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let mut reference = URIReference::try_from("http://example.com/?a=b").unwrap(); reference.normalize(); assert_eq!(reference.to_string(), "http://example.com/?a=b"); let mut reference = URIReference::try_from("http://EXAMPLE.com/?a=b").unwrap(); assert_eq!(reference.to_string(), "http://EXAMPLE.com/?a=b"); reference.normalize(); assert_eq!(reference.to_string(), "http://example.com/?a=b");
Returns the path of the URI reference.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://127.0.0.1/my/path").unwrap(); assert_eq!(reference.path(), "/my/path");
Returns the password, if present, of the URI reference.
Usage of a password in URI and URI references is deprecated.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://user:pass@example.com").unwrap(); assert_eq!(reference.password().unwrap(), "pass");
Returns the port, if present, of the URI reference.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://example.com:8080/").unwrap(); assert_eq!(reference.port().unwrap(), 8080);
Returns the query, if present, of the URI reference.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://127.0.0.1?my=query").unwrap(); assert_eq!(reference.query().unwrap(), "my=query");
Returns the scheme, if present, of the URI reference.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://127.0.0.1/").unwrap(); assert_eq!(reference.scheme().unwrap(), "http");
Sets the authority of the URI reference.
An error will be returned if the conversion to an Authority
fails.
The existing path will be set to absolute (i.e. starts with a '/'
).
Examples
use std::convert::TryFrom; use uriparse::URIReference; let mut reference = URIReference::try_from("http://example.com").unwrap(); reference.set_authority(Some("user@example.com:80")); assert_eq!(reference.to_string(), "http://user@example.com:80/");
pub fn set_fragment<TFragment, TFragmentError>(
&mut self,
fragment: Option<TFragment>
) -> Result<Option<&Fragment<'uri>>, URIReferenceError> where
Fragment<'uri>: TryFrom<TFragment>,
URIReferenceError: From<TFragmentError>,
<Fragment<'uri> as TryFrom<TFragment>>::Error == TFragmentError,
pub fn set_fragment<TFragment, TFragmentError>(
&mut self,
fragment: Option<TFragment>
) -> Result<Option<&Fragment<'uri>>, URIReferenceError> where
Fragment<'uri>: TryFrom<TFragment>,
URIReferenceError: From<TFragmentError>,
<Fragment<'uri> as TryFrom<TFragment>>::Error == TFragmentError,
Sets the fragment of the URI reference.
An error will be returned if the conversion to a Fragment
fails.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let mut reference = URIReference::try_from("http://example.com").unwrap(); reference.set_fragment(Some("fragment")); assert_eq!(reference.to_string(), "http://example.com/#fragment");
Sets the path of the URI reference.
An error will be returned in one of two cases:
- The conversion to
Path
failed. - The path was set to a value that resulted in an invalid URI reference.
Regardless of whether the given path was set as absolute or relative, if the URI reference currently has an authority, the path will be forced to be absolute.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let mut reference = URIReference::try_from("http://example.com").unwrap(); reference.set_path("my/path"); assert_eq!(reference.to_string(), "http://example.com/my/path");
Sets the query of the URI reference.
An error will be returned if the conversion to a Query
fails.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let mut reference = URIReference::try_from("http://example.com").unwrap(); reference.set_query(Some("myquery")); assert_eq!(reference.to_string(), "http://example.com/?myquery");
pub fn set_scheme<TScheme, TSchemeError>(
&mut self,
scheme: Option<TScheme>
) -> Result<Option<&Scheme<'uri>>, URIReferenceError> where
Scheme<'uri>: TryFrom<TScheme>,
URIReferenceError: From<TSchemeError>,
<Scheme<'uri> as TryFrom<TScheme>>::Error == TSchemeError,
pub fn set_scheme<TScheme, TSchemeError>(
&mut self,
scheme: Option<TScheme>
) -> Result<Option<&Scheme<'uri>>, URIReferenceError> where
Scheme<'uri>: TryFrom<TScheme>,
URIReferenceError: From<TSchemeError>,
<Scheme<'uri> as TryFrom<TScheme>>::Error == TSchemeError,
Sets the scheme of the URI reference.
An error will be returned in one of two cases:
- The conversion to
Scheme
failed. - The scheme was set to
None
, but the resulting URI reference has an invalid schemeless path.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let mut reference = URIReference::try_from("http://example.com").unwrap(); reference.set_scheme(Some("https")); assert_eq!(reference.to_string(), "https://example.com/");
Returns the username, if present, of the URI reference.
Examples
use std::convert::TryFrom; use uriparse::URIReference; let reference = URIReference::try_from("http://username@example.com").unwrap(); assert_eq!(reference.username().unwrap(), "username");
Trait Implementations
impl<'uri> Clone for URIReference<'uri>
impl<'uri> Clone for URIReference<'uri>
pub fn clone(&self) -> URIReference<'uri>
pub fn clone(&self) -> URIReference<'uri>
Returns a copy of the value. Read more
Performs copy-assignment from source
. Read more
impl<'uri> Debug for URIReference<'uri>
impl<'uri> Debug for URIReference<'uri>
impl<'de, 'uri> Deserialize<'de> for URIReference<'uri>
impl<'de, 'uri> Deserialize<'de> for URIReference<'uri>
pub fn deserialize<__D>(
__deserializer: __D
) -> Result<URIReference<'uri>, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
pub fn deserialize<__D>(
__deserializer: __D
) -> Result<URIReference<'uri>, <__D as Deserializer<'de>>::Error> where
__D: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more
impl<'_> Display for URIReference<'_>
impl<'_> Display for URIReference<'_>
impl<'uri> From<RelativeReference<'uri>> for URIReference<'uri>
impl<'uri> From<RelativeReference<'uri>> for URIReference<'uri>
pub fn from(value: RelativeReference<'uri>) -> URIReference<'uri>
pub fn from(value: RelativeReference<'uri>) -> URIReference<'uri>
Performs the conversion.
impl<'uri> From<URI<'uri>> for URIReference<'uri>
impl<'uri> From<URI<'uri>> for URIReference<'uri>
pub fn from(value: URI<'uri>) -> URIReference<'uri>
pub fn from(value: URI<'uri>) -> URIReference<'uri>
Performs the conversion.
Performs the conversion.
Performs the conversion.
impl<'uri> Hash for URIReference<'uri>
impl<'uri> Hash for URIReference<'uri>
impl<'uri> PartialEq<URIReference<'uri>> for URIReference<'uri>
impl<'uri> PartialEq<URIReference<'uri>> for URIReference<'uri>
pub fn eq(&self, other: &URIReference<'uri>) -> bool
pub fn eq(&self, other: &URIReference<'uri>) -> bool
This method tests for self
and other
values to be equal, and is used
by ==
. Read more
pub fn ne(&self, other: &URIReference<'uri>) -> bool
pub fn ne(&self, other: &URIReference<'uri>) -> bool
This method tests for !=
.
impl<'uri> Serialize for URIReference<'uri>
impl<'uri> Serialize for URIReference<'uri>
pub fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
pub fn serialize<__S>(
&self,
__serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
__S: Serializer,
Serialize this value into the given Serde serializer. Read more
impl<'uri> TryFrom<&'uri [u8]> for URIReference<'uri>
impl<'uri> TryFrom<&'uri [u8]> for URIReference<'uri>
type Error = URIReferenceError
type Error = URIReferenceError
The type returned in the event of a conversion error.
impl<'uri> TryFrom<&'uri str> for URIReference<'uri>
impl<'uri> TryFrom<&'uri str> for URIReference<'uri>
type Error = URIReferenceError
type Error = URIReferenceError
The type returned in the event of a conversion error.
pub fn try_from(
value: &'uri str
) -> Result<URIReference<'uri>, <URIReference<'uri> as TryFrom<&'uri str>>::Error>
pub fn try_from(
value: &'uri str
) -> Result<URIReference<'uri>, <URIReference<'uri> as TryFrom<&'uri str>>::Error>
Performs the conversion.
type Error = URIReferenceError
type Error = URIReferenceError
The type returned in the event of a conversion error.
pub fn try_from(
span: Span<'a>
) -> Result<URIReference<'a>, <URIReference<'a> as TryFrom<Span<'a>>>::Error>
[src]
pub fn try_from(
span: Span<'a>
) -> Result<URIReference<'a>, <URIReference<'a> as TryFrom<Span<'a>>>::Error>
[src]Performs the conversion.
impl<'uri> TryFrom<URIReference<'uri>> for RelativeReference<'uri>
impl<'uri> TryFrom<URIReference<'uri>> for RelativeReference<'uri>
type Error = RelativeReferenceError
type Error = RelativeReferenceError
The type returned in the event of a conversion error.
pub fn try_from(
value: URIReference<'uri>
) -> Result<RelativeReference<'uri>, <RelativeReference<'uri> as TryFrom<URIReference<'uri>>>::Error>
pub fn try_from(
value: URIReference<'uri>
) -> Result<RelativeReference<'uri>, <RelativeReference<'uri> as TryFrom<URIReference<'uri>>>::Error>
Performs the conversion.
impl<'uri> TryFrom<URIReference<'uri>> for URI<'uri>
impl<'uri> TryFrom<URIReference<'uri>> for URI<'uri>
pub fn try_from(
value: URIReference<'uri>
) -> Result<URI<'uri>, <URI<'uri> as TryFrom<URIReference<'uri>>>::Error>
pub fn try_from(
value: URIReference<'uri>
) -> Result<URI<'uri>, <URI<'uri> as TryFrom<URIReference<'uri>>>::Error>
Performs the conversion.
impl<'uri> Eq for URIReference<'uri>
impl<'uri> StructuralEq for URIReference<'uri>
impl<'uri> StructuralPartialEq for URIReference<'uri>
Auto Trait Implementations
impl<'uri> RefUnwindSafe for URIReference<'uri>
impl<'uri> Send for URIReference<'uri>
impl<'uri> Sync for URIReference<'uri>
impl<'uri> Unpin for URIReference<'uri>
impl<'uri> UnwindSafe for URIReference<'uri>
Blanket Implementations
Mutably borrows from an owned value. Read more
fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self> where
Self: Binary,
Causes self
to use its Binary
implementation when Debug
-formatted.
fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self> where
Self: Display,
Causes self
to use its Display
implementation when
Debug
-formatted. Read more
fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self> where
Self: LowerExp,
Causes self
to use its LowerExp
implementation when
Debug
-formatted. Read more
fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self> where
Self: LowerHex,
Causes self
to use its LowerHex
implementation when
Debug
-formatted. Read more
Causes self
to use its Octal
implementation when Debug
-formatted.
fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self> where
Self: Pointer,
Causes self
to use its Pointer
implementation when
Debug
-formatted. Read more
fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self> where
Self: UpperExp,
Causes self
to use its UpperExp
implementation when
Debug
-formatted. Read more
fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
Self: UpperHex,
Causes self
to use its UpperHex
implementation when
Debug
-formatted. Read more
impl<T> Pipe for T where
T: ?Sized,
impl<T> Pipe for T where
T: ?Sized,
Pipes by value. This is generally the method you want to use. Read more
Borrows self
and passes that borrow into the pipe function. Read more
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
R: 'a,
Mutably borrows self
and passes that borrow into the pipe function. Read more
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where
Self: Borrow<B>,
B: 'a + ?Sized,
R: 'a,
Borrows self
, then passes self.borrow()
into the pipe function. Read more
fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,
fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R
) -> R where
Self: BorrowMut<B>,
B: 'a + ?Sized,
R: 'a,
Mutably borrows self
, then passes self.borrow_mut()
into the pipe
function. Read more
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
R: 'a,
U: 'a + ?Sized,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where
Self: AsRef<U>,
R: 'a,
U: 'a + ?Sized,
Borrows self
, then passes self.as_ref()
into the pipe function.
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
R: 'a,
U: 'a + ?Sized,
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R where
Self: AsMut<U>,
R: 'a,
U: 'a + ?Sized,
Mutably borrows self
, then passes self.as_mut()
into the pipe
function. Read more
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,
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,
Borrows self
, then passes self.deref()
into the pipe function.
fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: AsRef<T>,
T: 'a,
R: 'a,
Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more
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,
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,
Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where
Self: Borrow<T>,
T: 'a,
R: 'a,
Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more
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,
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,
Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more
fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,
fn pipe_deref<'a, R>(&'a self, func: impl FnOnce(&'a Self::Target) -> R) -> R where
Self: Deref,
R: 'a,
Pipes a dereference into a function that cannot normally be called in suffix position. Read more
fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
fn pipe_deref_mut<'a, R>(
&'a mut self,
func: impl FnOnce(&'a mut Self::Target) -> R
) -> R where
Self: DerefMut,
R: 'a,
Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more
Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Immutable access to the Borrow<B>
of a value. Read more
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Mutable access to the BorrowMut<B>
of a value. Read more
Immutable access to the AsRef<R>
view of a value. Read more
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Mutable access to the AsMut<R>
view of a value. Read more
Immutable access to the Deref::Target
of a value. Read more
Mutable access to the Deref::Target
of a value. Read more
Calls .tap()
only in debug builds, and is erased in release builds.
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls .tap_mut()
only in debug builds, and is erased in release
builds. Read more
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where
Self: Borrow<B>,
B: ?Sized,
Calls .tap_borrow()
only in debug builds, and is erased in release
builds. Read more
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where
Self: BorrowMut<B>,
B: ?Sized,
Calls .tap_borrow_mut()
only in debug builds, and is erased in release
builds. Read more
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where
Self: AsRef<R>,
R: ?Sized,
Calls .tap_ref()
only in debug builds, and is erased in release
builds. Read more
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where
Self: AsMut<R>,
R: ?Sized,
Calls .tap_ref_mut()
only in debug builds, and is erased in release
builds. Read more
Provides immutable access for inspection. Read more
Calls tap
in debug builds, and does nothing in release builds.
Provides mutable access for modification. Read more
fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
fn tap_mut_dbg<F, R>(self, func: F) -> Self where
F: FnOnce(&mut Self) -> R,
Calls tap_mut
in debug builds, and does nothing in release builds.
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
impl<T, U> TapAsRef<U> for T where
U: ?Sized,
Provides immutable access to the reference for inspection.
fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
fn tap_ref_dbg<F, R>(self, func: F) -> Self where
Self: AsRef<T>,
F: FnOnce(&T) -> R,
Calls tap_ref
in debug builds, and does nothing in release builds.
fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_ref_mut<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Provides mutable access to the reference for modification.
fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where
Self: AsMut<T>,
F: FnOnce(&mut T) -> R,
Calls tap_ref_mut
in debug builds, and does nothing in release builds.
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
impl<T, U> TapBorrow<U> for T where
U: ?Sized,
fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
fn tap_borrow<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Provides immutable access to the borrow for inspection. Read more
fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
fn tap_borrow_dbg<F, R>(self, func: F) -> Self where
Self: Borrow<T>,
F: FnOnce(&T) -> R,
Calls tap_borrow
in debug builds, and does nothing in release builds.
fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_borrow_mut<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Provides mutable access to the borrow for modification.
fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where
Self: BorrowMut<T>,
F: FnOnce(&mut T) -> R,
Calls tap_borrow_mut
in debug builds, and does nothing in release
builds. Read more
Immutably dereferences self
for inspection.
fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
fn tap_deref_dbg<F, R>(self, func: F) -> Self where
Self: Deref,
F: FnOnce(&Self::Target) -> R,
Calls tap_deref
in debug builds, and does nothing in release builds.
fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
fn tap_deref_mut<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Mutably dereferences self
for modification.
fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where
Self: DerefMut,
F: FnOnce(&mut Self::Target) -> R,
Calls tap_deref_mut
in debug builds, and does nothing in release
builds. Read more