Struct RiReferenceString

struct RiReferenceString<S> { ... }

An owned string of an absolute IRI possibly with fragment part.

This corresponds to IRI-reference rule in RFC 3987 (and URI-reference rule in RFC 3986). The rule for IRI-reference is IRI / irelative-ref. In other words, this is union of RiString and RiRelativeString.

For details, see the document for RiReferenceStr.

Enabled by alloc or std feature.

Implementations

impl RiReferenceString<IriSpec>

fn encode_to_uri_inline(self: &mut Self)

Percent-encodes the IRI into a valid URI that identifies the equivalent resource.

After the encode, the IRI is also a valid URI.

If you want a new URI string rather than modifying the IRI string, or if you need more precise control over memory allocation and buffer handling, use [encode_to_uri]IriReferenceStr::encode_to_uri method.

Panics

Panics if the memory allocation failed.

Examples

# use iri_string::validate::Error;
#[cfg(feature = "alloc")] {
use iri_string::types::IriReferenceString;

let mut iri = IriReferenceString::try_from("http://example.com/?alpha=\u{03B1}")?;
iri.encode_to_uri_inline();
assert_eq!(iri, "http://example.com/?alpha=%CE%B1");
# }
# Ok::<_, Error>(())

fn try_encode_to_uri_inline(self: &mut Self) -> Result<(), TryReserveError>

Percent-encodes the IRI into a valid URI that identifies the equivalent resource.

After the encode, the IRI is also a valid URI.

If you want a new URI string rather than modifying the IRI string, or if you need more precise control over memory allocation and buffer handling, use [encode_to_uri]IriReferenceStr::encode_to_uri method.

Examples

# use iri_string::validate::Error;
#[cfg(feature = "alloc")] {
use iri_string::types::IriReferenceString;

let mut iri = IriReferenceString::try_from("http://example.com/?alpha=\u{03B1}")?;
iri.try_encode_to_uri_inline()
    .expect("failed to allocate memory");
assert_eq!(iri, "http://example.com/?alpha=%CE%B1");
# }
# Ok::<_, Error>(())

fn encode_into_uri(self: Self) -> UriReferenceString

Percent-encodes the IRI into a valid URI that identifies the equivalent resource.

If you want a new URI string rather than modifying the IRI string, or if you need more precise control over memory allocation and buffer handling, use [encode_to_uri]IriReferenceStr::encode_to_uri method.

Examples

# use iri_string::validate::Error;
#[cfg(feature = "alloc")] {
use iri_string::types::{IriReferenceString, UriReferenceString};

let iri = IriReferenceString::try_from("http://example.com/?alpha=\u{03B1}")?;
// Type annotation here is not necessary.
let uri: UriReferenceString = iri.encode_into_uri();
assert_eq!(uri, "http://example.com/?alpha=%CE%B1");
# }
# Ok::<_, Error>(())

fn try_encode_into_uri(self: Self) -> Result<UriReferenceString, TryReserveError>

Percent-encodes the IRI into a valid URI that identifies the equivalent resource.

If you want a new URI string rather than modifying the IRI string, or if you need more precise control over memory allocation and buffer handling, use [encode_to_uri]IriReferenceStr::encode_to_uri method.

Examples

# use iri_string::validate::Error;
#[cfg(feature = "alloc")] {
use iri_string::types::{IriReferenceString, UriReferenceString};

let iri = IriReferenceString::try_from("http://example.com/?alpha=\u{03B1}")?;
// Type annotation here is not necessary.
let uri: UriReferenceString = iri.try_encode_into_uri()
    .expect("failed to allocate memory");
assert_eq!(uri, "http://example.com/?alpha=%CE%B1");
# }
# Ok::<_, Error>(())

fn try_into_uri(self: Self) -> Result<UriReferenceString, IriReferenceString>

Converts an IRI into a URI without modification, if possible.

Examples

# use iri_string::validate::Error;
use iri_string::types::{IriReferenceString, UriReferenceString};

let ascii_iri = IriReferenceString::try_from("http://example.com/?alpha=%CE%B1")?;
assert_eq!(
    ascii_iri.try_into_uri().map(|uri| uri.to_string()),
    Ok("http://example.com/?alpha=%CE%B1".to_string())
);

let nonascii_iri = IriReferenceString::try_from("http://example.com/?alpha=\u{03B1}")?;
assert_eq!(
    nonascii_iri.try_into_uri().map_err(|iri| iri.to_string()),
    Err("http://example.com/?alpha=\u{03B1}".to_string())
);
# Ok::<_, Error>(())

impl<S: Spec> RiReferenceString<S>

fn into_iri(self: Self) -> Result<RiString<S>, RiRelativeString<S>>

Returns the string as RiString, if it is valid as an IRI.

If it is not an IRI, then RiRelativeString is returned as Err(_).

fn into_relative_iri(self: Self) -> Result<RiRelativeString<S>, RiString<S>>

Returns the string as RiRelativeString, if it is valid as an IRI.

If it is not an IRI, then RiString is returned as Err(_).

fn set_fragment(self: &mut Self, fragment: Option<&RiFragmentStr<S>>)

Sets the fragment part to the given string.

Removes fragment part (and following # character) if None is given.

fn remove_password_inline(self: &mut Self)

Removes the password completely (including separator colon) from self even if it is empty.

Examples

# use iri_string::validate::Error;
# #[cfg(feature = "alloc")] {
use iri_string::types::IriReferenceString;

let mut iri = IriReferenceString::try_from("http://user:password@example.com/path?query")?;
iri.remove_password_inline();
assert_eq!(iri, "http://user@example.com/path?query");
# }
# Ok::<_, Error>(())

Even if the password is empty, the password and separator will be removed.

# use iri_string::validate::Error;
# #[cfg(feature = "alloc")] {
use iri_string::types::IriReferenceString;

let mut iri = IriReferenceString::try_from("http://user:@example.com/path?query")?;
iri.remove_password_inline();
assert_eq!(iri, "http://user@example.com/path?query");
# }
# Ok::<_, Error>(())

fn remove_nonempty_password_inline(self: &mut Self)

Replaces the non-empty password in self to the empty password.

This leaves the separator colon if the password part was available.

Examples

# use iri_string::validate::Error;
# #[cfg(feature = "alloc")] {
use iri_string::types::IriReferenceString;

let mut iri = IriReferenceString::try_from("http://user:password@example.com/path?query")?;
iri.remove_nonempty_password_inline();
assert_eq!(iri, "http://user:@example.com/path?query");
# }
# Ok::<_, Error>(())

If the password is empty, it is left as is.

# use iri_string::validate::Error;
# #[cfg(feature = "alloc")] {
use iri_string::types::IriReferenceString;

let mut iri = IriReferenceString::try_from("http://user:@example.com/path?query")?;
iri.remove_nonempty_password_inline();
assert_eq!(iri, "http://user:@example.com/path?query");
# }
# Ok::<_, Error>(())

impl<S: crate::spec::Spec> RiReferenceString<S>

unsafe fn new_unchecked(s: String) -> Self

Creates a new string without validation.

This does not validate the given string, so it is caller's responsibility to ensure the given string is valid.

Safety

The given string must be syntactically valid as Self type. If not, any use of the returned value or the call of this function itself may result in undefined behavior.

fn shrink_to_fit(self: &mut Self)

Shrinks the capacity of the inner buffer to match its length.

fn capacity(self: &Self) -> usize

Returns the internal buffer capacity in bytes.

fn as_slice(self: &Self) -> &RiReferenceStr<S>

Returns the borrowed IRI string slice.

This is equivalent to &*self.

impl<P, T> Receiver for RiReferenceString<S>

impl<S> Freeze for RiReferenceString<S>

impl<S> RefUnwindSafe for RiReferenceString<S>

impl<S> Send for RiReferenceString<S>

impl<S> Sync for RiReferenceString<S>

impl<S> Unpin for RiReferenceString<S>

impl<S> UnsafeUnpin for RiReferenceString<S>

impl<S> UnwindSafe for RiReferenceString<S>

impl<S: Spec> From for RiReferenceString<S>

fn from(builder: Built<'_, RiReferenceStr<S>>) -> Self

impl<S: Spec> From for RiReferenceString<S>

fn from(builder: &Built<'_, RiReferenceStr<S>>) -> Self

impl<S: Spec, C: Context> TryFrom for RiReferenceString<S>

fn try_from(v: Expanded<'_, S, C>) -> Result<Self, <Self as >::Error>

impl<S: crate::spec::Spec> AsRef for RiReferenceString<S>

fn as_ref(self: &Self) -> &str

impl<S: crate::spec::Spec> AsRef for RiReferenceString<S>

fn as_ref(self: &Self) -> &RiReferenceStr<S>

impl<S: crate::spec::Spec> Borrow for RiReferenceString<S>

fn borrow(self: &Self) -> &str

impl<S: crate::spec::Spec> Borrow for RiReferenceString<S>

fn borrow(self: &Self) -> &RiReferenceStr<S>

impl<S: crate::spec::Spec> Clone for RiReferenceString<S>

fn clone(self: &Self) -> Self

impl<S: crate::spec::Spec> Debug for RiReferenceString<S>

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

impl<S: crate::spec::Spec> Deref for RiReferenceString<S>

fn deref(self: &Self) -> &RiReferenceStr<S>

impl<S: crate::spec::Spec> Display for RiReferenceString<S>

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

impl<S: crate::spec::Spec> Eq for RiReferenceString<S>

impl<S: crate::spec::Spec> From for RiReferenceString<S>

fn from(s: RiString<S>) -> RiReferenceString<S>

impl<S: crate::spec::Spec> From for RiReferenceString<S>

fn from(s: RiRelativeString<S>) -> RiReferenceString<S>

impl<S: crate::spec::Spec> From for RiReferenceString<S>

fn from(s: RiAbsoluteString<S>) -> RiReferenceString<S>

impl<S: crate::spec::Spec> From for RiReferenceString<S>

fn from(s: &RiReferenceStr<S>) -> Self

impl<S: crate::spec::Spec> FromStr for RiReferenceString<S>

fn from_str(s: &str) -> Result<Self, <Self as >::Err>

impl<S: crate::spec::Spec> Hash for RiReferenceString<S>

fn hash<H: core::hash::Hasher>(self: &Self, state: &mut H)

impl<S: crate::spec::Spec> Ord for RiReferenceString<S>

fn cmp(self: &Self, other: &Self) -> Ordering

impl<S: crate::spec::Spec> PartialEq for RiReferenceString<S>

fn eq(self: &Self, o: &String) -> bool

impl<S: crate::spec::Spec> PartialEq for RiReferenceString<S>

fn eq(self: &Self, o: &Cow<'_, str>) -> bool

impl<S: crate::spec::Spec> PartialEq for RiReferenceString<S>

fn eq(self: &Self, o: &&str) -> bool

impl<S: crate::spec::Spec> PartialEq for RiReferenceString<S>

fn eq(self: &Self, o: &str) -> bool

impl<S: crate::spec::Spec> PartialOrd for RiReferenceString<S>

fn partial_cmp(self: &Self, o: &str) -> Option<Ordering>

impl<S: crate::spec::Spec> PartialOrd for RiReferenceString<S>

fn partial_cmp(self: &Self, o: &String) -> Option<Ordering>

impl<S: crate::spec::Spec> PartialOrd for RiReferenceString<S>

fn partial_cmp(self: &Self, o: &Cow<'_, str>) -> Option<Ordering>

impl<S: crate::spec::Spec> PartialOrd for RiReferenceString<S>

fn partial_cmp(self: &Self, o: &&str) -> Option<Ordering>

impl<S: crate::spec::Spec> TryFrom for RiReferenceString<S>

fn try_from(s: &str) -> Result<Self, <Self as >::Error>

impl<S: crate::spec::Spec> TryFrom for RiReferenceString<S>

fn try_from(bytes: &[u8]) -> Result<Self, <Self as >::Error>

impl<S: crate::spec::Spec> TryFrom for RiReferenceString<S>

fn try_from(s: String) -> Result<Self, <Self as >::Error>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<S>

fn eq(self: &Self, other: &RiReferenceString<T>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &RiStr<S>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &&RiReferenceStr<S>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &RiReferenceStr<S>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &Cow<'_, RiStr<S>>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &Cow<'_, RiAbsoluteStr<S>>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &Cow<'_, RiReferenceStr<S>>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &RiString<S>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &RiRelativeString<S>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &RiAbsoluteString<S>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &Cow<'_, RiRelativeStr<S>>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &&RiRelativeStr<S>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &RiRelativeStr<S>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &&RiAbsoluteStr<S>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &&RiStr<S>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialEq for RiReferenceString<T>

fn eq(self: &Self, o: &RiAbsoluteStr<S>) -> bool

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<S>

fn partial_cmp(self: &Self, other: &RiReferenceString<T>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &RiRelativeString<S>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &RiAbsoluteString<S>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &Cow<'_, RiRelativeStr<S>>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &&RiRelativeStr<S>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &RiRelativeStr<S>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &&RiAbsoluteStr<S>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &&RiStr<S>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &RiAbsoluteStr<S>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &RiStr<S>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &&RiReferenceStr<S>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &RiReferenceStr<S>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &Cow<'_, RiStr<S>>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &Cow<'_, RiAbsoluteStr<S>>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &Cow<'_, RiReferenceStr<S>>) -> Option<Ordering>

impl<S: crate::spec::Spec, T: crate::spec::Spec> PartialOrd for RiReferenceString<T>

fn partial_cmp(self: &Self, o: &RiString<S>) -> Option<Ordering>

impl<T> Any for RiReferenceString<S>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for RiReferenceString<S>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for RiReferenceString<S>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for RiReferenceString<S>

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for RiReferenceString<S>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for RiReferenceString<S>

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

impl<T> ToString for RiReferenceString<S>

fn to_string(self: &Self) -> String

impl<T> ToStringFallible for RiReferenceString<S>

fn try_to_string(self: &Self) -> Result<String, TryReserveError>

[ToString::to_string]alloc::string::ToString::to_string, but without panic on OOM.

impl<T, U> Into for RiReferenceString<S>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for RiReferenceString<S>

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

impl<T, U> TryInto for RiReferenceString<S>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>