Struct uriparse::uri::URIReference [−][src]
pub struct URIReference<'uri> { /* fields omitted */ }
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).
Methods
impl<'uri> URIReference<'uri>
[src]
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>
[src]
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 uriparse::URIReference; let mut builder = URIReference::builder(); builder.scheme(Some("http")).authority(Some("example.com")).path("/my/path"); let reference = builder.build().unwrap(); assert_eq!(reference.to_string(), "http://example.com/my/path");
pub fn can_be_a_base(&self) -> bool
[src]
pub fn can_be_a_base(&self) -> bool
Returns whether or not 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, SchemeType, AuthorityType, PathType, QueryType, FragmentType, SchemeError, AuthorityError, PathError, QueryError, FragmentError>(
scheme: Option<SchemeType>,
authority: Option<AuthorityType>,
path: PathType,
query: Option<QueryType>,
fragment: Option<FragmentType>
) -> Result<URIReference<'new_uri>, InvalidURIReference> where
Scheme<'new_uri>: TryFrom<SchemeType, Error = SchemeError>,
Authority<'new_uri>: TryFrom<AuthorityType, Error = AuthorityError>,
Path<'new_uri>: TryFrom<PathType, Error = PathError>,
Query<'new_uri>: TryFrom<QueryType, Error = QueryError>,
Fragment<'new_uri>: TryFrom<FragmentType, Error = FragmentError>,
InvalidURIReference: From<SchemeError> + From<AuthorityError> + From<PathError> + From<QueryError> + From<FragmentError>,
[src]
pub fn from_parts<'new_uri, SchemeType, AuthorityType, PathType, QueryType, FragmentType, SchemeError, AuthorityError, PathError, QueryError, FragmentError>(
scheme: Option<SchemeType>,
authority: Option<AuthorityType>,
path: PathType,
query: Option<QueryType>,
fragment: Option<FragmentType>
) -> Result<URIReference<'new_uri>, InvalidURIReference> where
Scheme<'new_uri>: TryFrom<SchemeType, Error = SchemeError>,
Authority<'new_uri>: TryFrom<AuthorityType, Error = AuthorityError>,
Path<'new_uri>: TryFrom<PathType, Error = PathError>,
Query<'new_uri>: TryFrom<QueryType, Error = QueryError>,
Fragment<'new_uri>: TryFrom<FragmentType, Error = FragmentError>,
InvalidURIReference: From<SchemeError> + From<AuthorityError> + From<PathError> + From<QueryError> + From<FragmentError>,
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>>
[src]
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");
Returns whether or not 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
[src]
pub fn has_fragment(&self) -> bool
Returns whether or not 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
[src]
pub fn has_password(&self) -> bool
Returns whether or not 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_query(&self) -> bool
[src]
pub fn has_query(&self) -> bool
Returns whether or not 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
[src]
pub fn has_scheme(&self) -> bool
Returns whether or not 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
[src]
pub fn has_username(&self) -> bool
Returns whether or not 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>>
[src]
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>
[src]
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>
[src]
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>>)
[src]
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
[src]
pub fn is_absolute_path_reference(&self) -> bool
Returns whether or not 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
[src]
pub fn is_network_path_reference(&self) -> bool
Returns whether or not 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_relative_path_reference(&self) -> bool
[src]
pub fn is_relative_path_reference(&self) -> bool
Returns whether or not 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
[src]
pub fn is_relative_reference(&self) -> bool
Returns whether or not 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
[src]
pub fn is_uri(&self) -> bool
Returns whether or not 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/");
pub fn map_fragment<Mapper>(
&mut self,
mapper: Mapper
) -> Option<&Fragment<'uri>> where
Mapper: FnOnce(Option<Fragment<'uri>>) -> Option<Fragment<'uri>>,
[src]
pub fn map_fragment<Mapper>(
&mut self,
mapper: Mapper
) -> Option<&Fragment<'uri>> where
Mapper: 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<Mapper>(&mut self, mapper: Mapper) -> &Path<'uri> where
Mapper: FnOnce(Path<'uri>) -> Path<'uri>,
[src]
pub fn map_path<Mapper>(&mut self, mapper: Mapper) -> &Path<'uri> where
Mapper: 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<Mapper>(&mut self, mapper: Mapper) -> Option<&Query<'uri>> where
Mapper: FnOnce(Option<Query<'uri>>) -> Option<Query<'uri>>,
[src]
pub fn map_query<Mapper>(&mut self, mapper: Mapper) -> Option<&Query<'uri>> where
Mapper: 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<Mapper>(&mut self, mapper: Mapper) -> Option<&Scheme<'uri>> where
Mapper: FnOnce(Option<Scheme<'uri>>) -> Option<Scheme<'uri>>,
[src]
pub fn map_scheme<Mapper>(&mut self, mapper: Mapper) -> Option<&Scheme<'uri>> where
Mapper: 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 path(&self) -> &Path<'uri>
[src]
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>>
[src]
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>
[src]
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>>
[src]
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>>
[src]
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");
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<FragmentType, FragmentError>(
&mut self,
fragment: Option<FragmentType>
) -> Result<Option<&Fragment<'uri>>, InvalidURIReference> where
Fragment<'uri>: TryFrom<FragmentType, Error = FragmentError>,
InvalidURIReference: From<FragmentError>,
[src]
pub fn set_fragment<FragmentType, FragmentError>(
&mut self,
fragment: Option<FragmentType>
) -> Result<Option<&Fragment<'uri>>, InvalidURIReference> where
Fragment<'uri>: TryFrom<FragmentType, Error = FragmentError>,
InvalidURIReference: From<FragmentError>,
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<PathType, PathError>(
&mut self,
path: PathType
) -> Result<&Path<'uri>, InvalidURIReference> where
Path<'uri>: TryFrom<PathType, Error = PathError>,
InvalidURIReference: From<PathError>,
[src]
pub fn set_path<PathType, PathError>(
&mut self,
path: PathType
) -> Result<&Path<'uri>, InvalidURIReference> where
Path<'uri>: TryFrom<PathType, Error = PathError>,
InvalidURIReference: From<PathError>,
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 or not 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<QueryType, QueryError>(
&mut self,
query: Option<QueryType>
) -> Result<Option<&Query<'uri>>, InvalidURIReference> where
Query<'uri>: TryFrom<QueryType, Error = QueryError>,
InvalidURIReference: From<QueryError>,
[src]
pub fn set_query<QueryType, QueryError>(
&mut self,
query: Option<QueryType>
) -> Result<Option<&Query<'uri>>, InvalidURIReference> where
Query<'uri>: TryFrom<QueryType, Error = QueryError>,
InvalidURIReference: From<QueryError>,
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<SchemeType, SchemeError>(
&mut self,
scheme: Option<SchemeType>
) -> Result<Option<&Scheme<'uri>>, InvalidURIReference> where
Scheme<'uri>: TryFrom<SchemeType, Error = SchemeError>,
InvalidURIReference: From<SchemeError>,
[src]
pub fn set_scheme<SchemeType, SchemeError>(
&mut self,
scheme: Option<SchemeType>
) -> Result<Option<&Scheme<'uri>>, InvalidURIReference> where
Scheme<'uri>: TryFrom<SchemeType, Error = SchemeError>,
InvalidURIReference: From<SchemeError>,
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>>
[src]
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> TryFrom<URIReference<'uri>> for RelativeReference<'uri>
[src]
impl<'uri> TryFrom<URIReference<'uri>> for RelativeReference<'uri>
type Error = InvalidRelativeReference
try_from
)The type returned in the event of a conversion error.
fn try_from(value: URIReference<'uri>) -> Result<Self, Self::Error>
[src]
fn try_from(value: URIReference<'uri>) -> Result<Self, Self::Error>
try_from
)Performs the conversion.
impl<'uri> TryFrom<URIReference<'uri>> for URI<'uri>
[src]
impl<'uri> TryFrom<URIReference<'uri>> for URI<'uri>
type Error = InvalidURI
try_from
)The type returned in the event of a conversion error.
fn try_from(value: URIReference<'uri>) -> Result<Self, Self::Error>
[src]
fn try_from(value: URIReference<'uri>) -> Result<Self, Self::Error>
try_from
)Performs the conversion.
impl<'uri> Clone for URIReference<'uri>
[src]
impl<'uri> Clone for URIReference<'uri>
fn clone(&self) -> URIReference<'uri>
[src]
fn clone(&self) -> URIReference<'uri>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl<'uri> Debug for URIReference<'uri>
[src]
impl<'uri> Debug for URIReference<'uri>
fn fmt(&self, f: &mut Formatter) -> Result
[src]
fn fmt(&self, f: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl<'uri> Eq for URIReference<'uri>
[src]
impl<'uri> Eq for URIReference<'uri>
impl<'uri> Hash for URIReference<'uri>
[src]
impl<'uri> Hash for URIReference<'uri>
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
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]
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<'uri> PartialEq for URIReference<'uri>
[src]
impl<'uri> PartialEq for URIReference<'uri>
fn eq(&self, other: &URIReference<'uri>) -> bool
[src]
fn eq(&self, other: &URIReference<'uri>) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &URIReference<'uri>) -> bool
[src]
fn ne(&self, other: &URIReference<'uri>) -> bool
This method tests for !=
.
impl<'uri> Display for URIReference<'uri>
[src]
impl<'uri> Display for URIReference<'uri>
fn fmt(&self, formatter: &mut Formatter) -> Result
[src]
fn fmt(&self, formatter: &mut Formatter) -> Result
Formats the value using the given formatter. Read more
impl<'uri> From<RelativeReference<'uri>> for URIReference<'uri>
[src]
impl<'uri> From<RelativeReference<'uri>> for URIReference<'uri>
fn from(value: RelativeReference<'uri>) -> Self
[src]
fn from(value: RelativeReference<'uri>) -> Self
Performs the conversion.
impl<'uri> From<URI<'uri>> for URIReference<'uri>
[src]
impl<'uri> From<URI<'uri>> for URIReference<'uri>
impl<'uri> From<URIReference<'uri>> for String
[src]
impl<'uri> From<URIReference<'uri>> for String
fn from(value: URIReference<'uri>) -> Self
[src]
fn from(value: URIReference<'uri>) -> Self
Performs the conversion.
impl<'uri> TryFrom<&'uri [u8]> for URIReference<'uri>
[src]
impl<'uri> TryFrom<&'uri [u8]> for URIReference<'uri>
type Error = InvalidURIReference
try_from
)The type returned in the event of a conversion error.
fn try_from(value: &'uri [u8]) -> Result<Self, Self::Error>
[src]
fn try_from(value: &'uri [u8]) -> Result<Self, Self::Error>
try_from
)Performs the conversion.
impl<'uri> TryFrom<&'uri str> for URIReference<'uri>
[src]
impl<'uri> TryFrom<&'uri str> for URIReference<'uri>
Auto Trait Implementations
impl<'uri> Send for URIReference<'uri>
impl<'uri> Send for URIReference<'uri>
impl<'uri> Sync for URIReference<'uri>
impl<'uri> Sync for URIReference<'uri>