Struct `PercentEncoded`

struct PercentEncoded<T, S> { ... }

A proxy to percent-encode a string.

Type aliases PercentEncodedForIri and PercentEncodedForUri are provided. You can use them to make the expression simpler, for example write PercentEncodedForUri::from_path(foo) instead of PercentEncoded::<_, UriSpec>::from_path(foo).

Implementations

`impl<T: fmt::Display, S: Spec> PercentEncoded<T, S>`

fn from_reg_name(raw: T) -> Self

Creates an encoded string from a raw reg-name (i.e. hostname or domain).

Examples

# #[cfg(feature = "alloc")] {
use iri_string::percent_encode::PercentEncoded;
use iri_string::spec::UriSpec;

let raw = "alpha.\u{03B1}.example.com";
let encoded = "alpha.%CE%B1.example.com";
assert_eq!(
    PercentEncoded::<_, UriSpec>::from_reg_name(raw).to_string(),
    encoded
);
# }

fn from_user(raw: T) -> Self

Creates an encoded string from a raw user name (inside userinfo component).

Examples

# #[cfg(feature = "alloc")] {
use iri_string::percent_encode::PercentEncoded;
use iri_string::spec::UriSpec;

let raw = "user:\u{03B1}";
// The first `:` will be interpreted as a delimiter, so colons will be escaped.
let encoded = "user%3A%CE%B1";
assert_eq!(
    PercentEncoded::<_, UriSpec>::from_user(raw).to_string(),
    encoded
);
# }

fn from_password(raw: T) -> Self

Creates an encoded string from a raw user name (inside userinfo component).

Examples

# #[cfg(feature = "alloc")] {
use iri_string::percent_encode::PercentEncoded;
use iri_string::spec::UriSpec;

let raw = "password:\u{03B1}";
// The first `:` will be interpreted as a delimiter, and the colon
// inside the password will be the first one if the user name is empty,
// so colons will be escaped.
let encoded = "password%3A%CE%B1";
assert_eq!(
    PercentEncoded::<_, UriSpec>::from_password(raw).to_string(),
    encoded
);
# }

fn from_path_segment(raw: T) -> Self

Creates an encoded string from a raw path segment.

Examples

# #[cfg(feature = "alloc")] {
use iri_string::percent_encode::PercentEncoded;
use iri_string::spec::UriSpec;

let raw = "alpha/\u{03B1}?#";
// Note that `/` is encoded to `%2F`.
let encoded = "alpha%2F%CE%B1%3F%23";
assert_eq!(
    PercentEncoded::<_, UriSpec>::from_path_segment(raw).to_string(),
    encoded
);
# }

fn from_path(raw: T) -> Self

Creates an encoded string from a raw path.

Examples

# #[cfg(feature = "alloc")] {
use iri_string::percent_encode::PercentEncoded;
use iri_string::spec::UriSpec;

let raw = "alpha/\u{03B1}?#";
// Note that `/` is NOT percent encoded.
let encoded = "alpha/%CE%B1%3F%23";
assert_eq!(
    PercentEncoded::<_, UriSpec>::from_path(raw).to_string(),
    encoded
);
# }

fn from_query(raw: T) -> Self

Creates an encoded string from a raw query.

Examples

# #[cfg(feature = "alloc")] {
use iri_string::percent_encode::PercentEncoded;
use iri_string::spec::UriSpec;

let raw = "alpha/\u{03B1}?#";
let encoded = "alpha/%CE%B1?%23";
assert_eq!(
    PercentEncoded::<_, UriSpec>::from_query(raw).to_string(),
    encoded
);
# }

fn from_fragment(raw: T) -> Self

Creates an encoded string from a raw fragment.

Examples

# #[cfg(feature = "alloc")] {
use iri_string::percent_encode::PercentEncoded;
use iri_string::spec::UriSpec;

let raw = "alpha/\u{03B1}?#";
let encoded = "alpha/%CE%B1?%23";
assert_eq!(
    PercentEncoded::<_, UriSpec>::from_fragment(raw).to_string(),
    encoded
);
# }

fn unreserve(raw: T) -> Self

Creates a string consists of only unreserved string and percent-encoded triplets.

Examples

# #[cfg(feature = "alloc")] {
use iri_string::percent_encode::PercentEncoded;
use iri_string::spec::UriSpec;

let unreserved = "%a0-._~\u{03B1}";
let unreserved_encoded = "%25a0-._~%CE%B1";
assert_eq!(
    PercentEncoded::<_, UriSpec>::unreserve(unreserved).to_string(),
    unreserved_encoded
);

let reserved = ":/?#[]@ !$&'()*+,;=";
let reserved_encoded =
    "%3A%2F%3F%23%5B%5D%40%20%21%24%26%27%28%29%2A%2B%2C%3B%3D";
assert_eq!(
    PercentEncoded::<_, UriSpec>::unreserve(reserved).to_string(),
    reserved_encoded
);
# }

fn characters(raw: T) -> Self

Percent-encodes characters only if they cannot appear anywhere in an IRI reference.

% character will be always encoded. In other words, this conversion is not aware of percent-encoded triplets.

Note that this encoding process does not guarantee that the resulting string is a valid IRI reference.

Examples

# #[cfg(feature = "alloc")] {
use iri_string::percent_encode::PercentEncoded;
use iri_string::spec::UriSpec;

let unreserved = "%a0-._~\u{03B1}";
let unreserved_encoded = "%25a0-._~%CE%B1";
assert_eq!(
    PercentEncoded::<_, UriSpec>::characters(unreserved).to_string(),
    unreserved_encoded
);

let reserved = ":/?#[]@ !$&'()*+,;=";
// Note that `%20` cannot appear directly in an IRI reference.
let expected = ":/?#[]@%20!$&'()*+,;=";
assert_eq!(
    PercentEncoded::<_, UriSpec>::characters(reserved).to_string(),
    expected
);
# }

`impl<T> Any for PercentEncoded<T, S>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for PercentEncoded<T, S>`

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

`impl<T> BorrowMut for PercentEncoded<T, S>`

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

`impl<T> CloneToUninit for PercentEncoded<T, S>`

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

`impl<T> From for PercentEncoded<T, S>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for PercentEncoded<T, S>`

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

`impl<T> ToString for PercentEncoded<T, S>`

fn to_string(self: &Self) -> String

`impl<T> ToStringFallible for PercentEncoded<T, 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, S> Freeze for PercentEncoded<T, S>`

`impl<T, S> RefUnwindSafe for PercentEncoded<T, S>`

`impl<T, S> Send for PercentEncoded<T, S>`

`impl<T, S> Sync for PercentEncoded<T, S>`

`impl<T, S> Unpin for PercentEncoded<T, S>`

`impl<T, S> UnsafeUnpin for PercentEncoded<T, S>`

`impl<T, S> UnwindSafe for PercentEncoded<T, S>`

`impl<T, U> Into for PercentEncoded<T, 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 PercentEncoded<T, S>`

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

`impl<T, U> TryInto for PercentEncoded<T, S>`

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

`impl<T: $crate::clone::Clone, S: $crate::clone::Clone> Clone for PercentEncoded<T, S>`

fn clone(self: &Self) -> PercentEncoded<T, S>

`impl<T: $crate::fmt::Debug, S: $crate::fmt::Debug> Debug for PercentEncoded<T, S>`

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

`impl<T: $crate::marker::Copy, S: $crate::marker::Copy> Copy for PercentEncoded<T, S>`

`impl<T: fmt::Display, S: Spec> Display for PercentEncoded<T, S>`

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