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>

pub fn authority(&self) -> Option<&Authority<'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>

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

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,

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");

pub fn fragment(&self) -> Option<&Fragment<'uri>>

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");

pub fn has_authority(&self) -> bool

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

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

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());

pub fn has_port(&self) -> bool

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());

pub fn has_query(&self) -> bool

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

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

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());

pub fn host(&self) -> Option<&Host<'uri>>

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>

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>

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.

pub fn into_parts(
    self
) -> (Option<Scheme<'uri>>, Option<Authority<'uri>>, Path<'uri>, Option<Query<'uri>>, Option<Fragment<'uri>>)

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

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

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

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

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

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());

pub fn is_uri(&self) -> bool

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());

pub fn map_authority<TMapper>(
    &mut self, 
    mapper: TMapper
) -> Option<&Authority<'uri>> where
    TMapper: FnOnce(Option<Authority<'uri>>) -> Option<Authority<'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/");

pub fn map_fragment<TMapper>(
    &mut self, 
    mapper: TMapper
) -> Option<&Fragment<'uri>> where
    TMapper: FnOnce(Option<Fragment<'uri>>) -> Option<Fragment<'uri>>,

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");

pub fn map_path<TMapper>(&mut self, mapper: TMapper) -> &Path<'uri> where
    TMapper: FnOnce(Path<'uri>) -> Path<'uri>,

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");

pub fn map_query<TMapper>(&mut self, mapper: TMapper) -> Option<&Query<'uri>> where
    TMapper: FnOnce(Option<Query<'uri>>) -> Option<Query<'uri>>,

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");

pub fn map_scheme<TMapper>(&mut self, mapper: TMapper) -> Option<&Scheme<'uri>> where
    TMapper: FnOnce(Option<Scheme<'uri>>) -> Option<Scheme<'uri>>,

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)

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");

pub fn path(&self) -> &Path<'uri>

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");

pub fn password(&self) -> Option<&Password<'uri>>

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");

pub fn port(&self) -> Option<u16>

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);

pub fn query(&self) -> Option<&Query<'uri>>

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");

pub fn scheme(&self) -> Option<&Scheme<'uri>>

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");

pub fn set_authority<TAuthority, TAuthorityError>(
    &mut self, 
    authority: Option<TAuthority>
) -> Result<Option<&Authority<'uri>>, URIReferenceError> where
    Authority<'uri>: TryFrom<TAuthority>,
    URIReferenceError: From<TAuthorityError>,
    <Authority<'uri> as TryFrom<TAuthority>>::Error == TAuthorityError,

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,

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");

pub fn set_path<TPath, TPathError>(
    &mut self, 
    path: TPath
) -> Result<&Path<'uri>, URIReferenceError> where
    Path<'uri>: TryFrom<TPath>,
    URIReferenceError: From<TPathError>,
    <Path<'uri> as TryFrom<TPath>>::Error == TPathError,

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");

pub fn set_query<TQuery, TQueryError>(
    &mut self, 
    query: Option<TQuery>
) -> Result<Option<&Query<'uri>>, URIReferenceError> where
    Query<'uri>: TryFrom<TQuery>,
    URIReferenceError: From<TQueryError>,
    <Query<'uri> as TryFrom<TQuery>>::Error == TQueryError,

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,

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/");

pub fn username(&self) -> Option<&Username<'uri>>

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>

pub fn clone(&self) -> URIReference<'uri>

Returns a copy of the value. Read more

fn clone_from(&mut self, source: &Self)1.0.0 [src]

Performs copy-assignment from source. Read more

impl<'uri> Debug for URIReference<'uri>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

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>,

Deserialize this value from the given Serde deserializer. Read more

impl<'_> Display for URIReference<'_>

pub fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

impl<'uri> From<RelativeReference<'uri>> for URIReference<'uri>

pub fn from(value: RelativeReference<'uri>) -> URIReference<'uri>

Performs the conversion.

impl<'uri> From<URI<'uri>> for URIReference<'uri>

pub fn from(value: URI<'uri>) -> URIReference<'uri>

Performs the conversion.

impl<'a> From<URIReference<'a>> for LinkData<'a>[src]

pub fn from(uri_ref: URIReference<'a>) -> LinkData<'a>[src]

Performs the conversion.

impl<'a> From<URIReference<'a>> for Description<'a>[src]

pub fn from(uri_ref: URIReference<'a>) -> Description<'a>[src]

Performs the conversion.

impl<'uri> Hash for URIReference<'uri>

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher,

Feeds this value into the given Hasher. Read more

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher,

1.3.0 [src]

Feeds a slice of this type into the given Hasher. Read more

impl<'uri> PartialEq<URIReference<'uri>> for URIReference<'uri>

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

This method tests for !=.

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,

Serialize this value into the given Serde serializer. Read more

impl<'uri> TryFrom<&'uri [u8]> for URIReference<'uri>

type Error = URIReferenceError

The type returned in the event of a conversion error.

pub fn try_from(
    value: &'uri [u8]
) -> Result<URIReference<'uri>, <URIReference<'uri> as TryFrom<&'uri [u8]>>::Error>

Performs the conversion.

impl<'uri> TryFrom<&'uri str> for URIReference<'uri>

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>

Performs the conversion.

impl<'a> TryFrom<Span<'a>> for URIReference<'a>[src]

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]

Performs the conversion.

impl<'uri> TryFrom<URIReference<'uri>> for RelativeReference<'uri>

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>

Performs the conversion.

impl<'uri> TryFrom<URIReference<'uri>> for URI<'uri>

type Error = URIError

The type returned in the event of a conversion 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

impl<T> Any for T where
    T: 'static + ?Sized,

[src]

pub fn type_id(&self) -> TypeId[src]

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
    T: ?Sized,

[src]

pub fn borrow(&self) -> &T[src]

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
    T: ?Sized,

[src]

pub fn borrow_mut(&mut self) -> &mut T[src]

Mutably borrows from an owned value. Read more

impl<T> Conv for T

fn conv<T>(self) -> T where
    Self: Into<T>,

Converts self into T using Into<T>. Read more

impl<T> Conv for T

fn conv<T>(self) -> T where
    Self: Into<T>,

Converts self into a target type. Read more

impl<T> FmtForward for T

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,

Causes self to use its Display implementation when Debug-formatted. Read more

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,

Causes self to use its LowerHex implementation when Debug-formatted. Read more

fn fmt_octal(self) -> FmtOctal<Self> where
    Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.

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,

Causes self to use its UpperExp implementation when Debug-formatted. Read more

fn fmt_upper_hex(self) -> FmtUpperHex<Self> where
    Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted. Read more

impl<T> From<T> for T[src]

pub fn from(t: T) -> T[src]

Performs the conversion.

impl<T, U> Into<U> for T where
    U: From<T>,

[src]

pub fn into(self) -> U[src]

Performs the conversion.

impl<T> Pipe for T where
    T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R

Pipes by value. This is generally the method you want to use. Read more

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
    R: 'a,

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,

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,

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,

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,

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,

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,

Borrows self, then passes self.deref() into the pipe function.

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,

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

impl<T> Pipe for T

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

impl<T> PipeAsRef for T

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,

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

impl<T> PipeBorrow for T

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,

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

impl<T> PipeDeref for T

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,

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

impl<T> PipeRef for T

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where
    R: 'a,

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where
    R: 'a,

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

impl<T> Tap for T

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where
    Self: Borrow<B>,
    B: ?Sized,

Immutable access to the Borrow of a value. Read more

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where
    Self: BorrowMut<B>,
    B: ?Sized,

Mutable access to the BorrowMut of a value. Read more

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where
    Self: AsRef<R>,
    R: ?Sized,

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,

Mutable access to the AsMut<R> view of a value. Read more

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where
    Self: Deref<Target = T>,
    T: ?Sized,

Immutable access to the Deref::Target of a value. Read more

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where
    Self: DerefMut<Target = T> + Deref,
    T: ?Sized,

Mutable access to the Deref::Target of a value. Read more

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.

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,

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,

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,

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,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where
    Self: Deref<Target = T>,
    T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where
    Self: DerefMut<Target = T> + Deref,
    T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

impl<T> Tap for T

fn tap<F, R>(self, func: F) -> Self where
    F: FnOnce(&Self) -> R,

Provides immutable access for inspection. Read more

fn tap_dbg<F, R>(self, func: F) -> Self where
    F: FnOnce(&Self) -> R,

Calls tap in debug builds, and does nothing in release builds.

fn tap_mut<F, R>(self, func: F) -> Self where
    F: FnOnce(&mut Self) -> R,

Provides mutable access for modification. Read more

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,

fn tap_ref<F, R>(self, func: F) -> Self where
    Self: AsRef<T>,
    F: FnOnce(&T) -> R,

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,

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,

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,

Calls tap_ref_mut in debug builds, and does nothing in release builds.

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,

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,

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,

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,

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

impl<T> TapDeref for T

fn tap_deref<F, R>(self, func: F) -> Self where
    Self: Deref,
    F: FnOnce(&Self::Target) -> R,

Immutably dereferences self for inspection.

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,

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,

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

impl<T> ToOwned for T where
    T: Clone,

[src]

type Owned = T

The resulting type after obtaining ownership.

pub fn to_owned(&self) -> T[src]

Creates owned data from borrowed data, usually by cloning. Read more

pub fn clone_into(&self, target: &mut T)[src]

🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T> ToString for T where
    T: Display + ?Sized,

[src]

pub default fn to_string(&self) -> String[src]

Converts the given value to a String. Read more

impl<T> TryConv for T

fn try_conv<T>(self) -> Result<T, Self::Error> where
    Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more

impl<T> TryConv for T

fn try_conv<T>(self) -> Result<T, Self::Error> where
    Self: TryInto<T>,

Attempts to convert self into a target type. Read more

impl<T, U> TryFrom<U> for T where
    U: Into<T>,

[src]

type Error = Infallible

The type returned in the event of a conversion error.

pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>[src]

Performs the conversion.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>,

[src]

type Error = >::Error

The type returned in the event of a conversion error.

pub fn try_into(self) -> Result<U, >::Error>[src]

Performs the conversion.

impl<T> DeserializeOwned for T where
    T: for<'de> Deserialize<'de>,

[src]