impl<'a, S: Spec> FixedBaseResolver<'a, S>

fn resolve(self: &Self, reference: &'a RiReferenceStr<S>) -> Normalized<'a, RiStr<S>>

Resolves the given reference against the fixed base.

The task returned by this method does not normalize the resolution result. However, .. and . are recognized even when they are percent-encoded.

Failures

This function itself does not fail, but resolution algorithm defined by RFC 3986 can fail. In that case, serialization algorithm defined by WHATWG URL Standard would be automatically applied.

See the documentation of Normalized.

Examples

# use iri_string::validate::Error;
# // `ToDedicatedString` is available only when
# // `alloc` feature is enabled.
# #[cfg(feature = "alloc")] {
use iri_string::format::ToDedicatedString;
use iri_string::resolve::FixedBaseResolver;
use iri_string::types::{IriAbsoluteStr, IriReferenceStr};

let base = IriAbsoluteStr::new("http://example.com/base/")?;
let resolver = FixedBaseResolver::new(base);

let reference = IriReferenceStr::new("../there")?;
let resolved = resolver.resolve(reference);

assert_eq!(resolved.to_dedicated_string(), "http://example.com/there");
# }
# Ok::<_, Error>(())

Note that .. and . path segments are recognized even when they are percent-encoded.

# use iri_string::validate::Error;
# // `ToDedicatedString` is available only when
# // `alloc` feature is enabled.
# #[cfg(feature = "alloc")] {
use iri_string::format::ToDedicatedString;
use iri_string::resolve::FixedBaseResolver;
use iri_string::types::{IriAbsoluteStr, IriReferenceStr};

let base = IriAbsoluteStr::new("HTTP://example.COM/base/base2/")?;
let resolver = FixedBaseResolver::new(base);

// `%2e%2e` is recognized as `..`.
// However, `dot%2edot` is NOT normalized into `dot.dot`.
let reference = IriReferenceStr::new("%2e%2e/../dot%2edot")?;
let resolved = resolver.resolve(reference);

// Resolved but not normalized.
assert_eq!(resolved.to_dedicated_string(), "HTTP://example.COM/dot%2edot");
# }
# Ok::<_, Error>(())

impl<'a, S: Spec> FixedBaseResolver<'a, S>

fn new(base: &'a RiAbsoluteStr<S>) -> Self

Creates a new resolver with the given base.

Examples

# use iri_string::validate::Error;
# // `ToDedicatedString` is available only when
# // `alloc` feature is enabled.
#[cfg(feature = "alloc")] {
use iri_string::format::ToDedicatedString;
use iri_string::resolve::FixedBaseResolver;
use iri_string::types::{IriAbsoluteStr, IriReferenceStr};

let base = IriAbsoluteStr::new("http://example.com/base/")?;
let resolver = FixedBaseResolver::new(base);

let reference = IriReferenceStr::new("../there")?;
let resolved = resolver.resolve(reference);

assert_eq!(resolved.to_dedicated_string(), "http://example.com/there");
# }
# Ok::<_, Error>(())

fn base(self: &Self) -> &'a RiAbsoluteStr<S>

Returns the base.

Examples

use iri_string::resolve::FixedBaseResolver;
use iri_string::types::{IriAbsoluteStr, IriReferenceStr};

let base = IriAbsoluteStr::new("http://example.com/base/")?;
let resolver = FixedBaseResolver::new(base);

assert_eq!(resolver.base(), base);
# Ok::<_, iri_string::validate::Error>(())

impl<S: Spec> FixedBaseResolver<'_, S>

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

Returns the scheme.

The following colon is truncated.

Examples

# use iri_string::validate::Error;
use iri_string::resolve::FixedBaseResolver;
use iri_string::types::IriAbsoluteStr;

let base = IriAbsoluteStr::new("http://example.com/base/?query")?;
let resolver = FixedBaseResolver::new(base);

assert_eq!(resolver.scheme_str(), "http");
assert_eq!(base.scheme_str(), "http");
# Ok::<_, Error>(())

fn authority_str(self: &Self) -> Option<&str>

Returns the authority.

The leading // is truncated.

Examples

# use iri_string::validate::Error;
use iri_string::resolve::FixedBaseResolver;
use iri_string::types::IriAbsoluteStr;

let base = IriAbsoluteStr::new("http://user:pass@example.com/base/?query")?;
let resolver = FixedBaseResolver::new(base);

assert_eq!(resolver.authority_str(), Some("user:pass@example.com"));
assert_eq!(base.authority_str(), Some("user:pass@example.com"));
# Ok::<_, Error>(())

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

Returns the path.

Examples

# use iri_string::validate::Error;
use iri_string::resolve::FixedBaseResolver;
use iri_string::types::IriAbsoluteStr;

let base = IriAbsoluteStr::new("http://user:pass@example.com/base/?query")?;
let resolver = FixedBaseResolver::new(base);

assert_eq!(resolver.path_str(), "/base/");
assert_eq!(base.path_str(), "/base/");
# Ok::<_, Error>(())

fn query(self: &Self) -> Option<&RiQueryStr<S>>

Returns the query.

The leading question mark (?) is truncated.

Examples

# use iri_string::validate::Error;
use iri_string::resolve::FixedBaseResolver;
use iri_string::types::{IriAbsoluteStr, IriQueryStr};

let base = IriAbsoluteStr::new("http://user:pass@example.com/base/?query")?;
let resolver = FixedBaseResolver::new(base);
let query = IriQueryStr::new("query")?;

assert_eq!(resolver.query(), Some(query));
assert_eq!(base.query(), Some(query));
# Ok::<_, Error>(())

fn query_str(self: &Self) -> Option<&str>

Returns the query in a raw string slice.

The leading question mark (?) is truncated.

Examples

# use iri_string::validate::Error;
use iri_string::resolve::FixedBaseResolver;
use iri_string::types::IriAbsoluteStr;

let base = IriAbsoluteStr::new("http://user:pass@example.com/base/?query")?;
let resolver = FixedBaseResolver::new(base);

assert_eq!(resolver.query_str(), Some("query"));
assert_eq!(base.query_str(), Some("query"));
# Ok::<_, Error>(())

impl<'a, S> Freeze for FixedBaseResolver<'a, S>

impl<'a, S> RefUnwindSafe for FixedBaseResolver<'a, S>

impl<'a, S> Send for FixedBaseResolver<'a, S>

impl<'a, S> Sync for FixedBaseResolver<'a, S>

impl<'a, S> Unpin for FixedBaseResolver<'a, S>

impl<'a, S> UnsafeUnpin for FixedBaseResolver<'a, S>

impl<'a, S> UnwindSafe for FixedBaseResolver<'a, S>

impl<'a, S: $crate::clone::Clone + Spec> Clone for FixedBaseResolver<'a, S>

fn clone(self: &Self) -> FixedBaseResolver<'a, S>

impl<'a, S: $crate::fmt::Debug + Spec> Debug for FixedBaseResolver<'a, S>

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

impl<'a, S: $crate::marker::Copy + Spec> Copy for FixedBaseResolver<'a, S>

impl<T> Any for FixedBaseResolver<'a, S>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for FixedBaseResolver<'a, S>

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

impl<T> BorrowMut for FixedBaseResolver<'a, S>

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

impl<T> CloneToUninit for FixedBaseResolver<'a, S>

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

impl<T> From for FixedBaseResolver<'a, S>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for FixedBaseResolver<'a, S>

fn to_owned(self: &Self) -> T

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

impl<T, U> Into for FixedBaseResolver<'a, 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 FixedBaseResolver<'a, S>

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

impl<T, U> TryInto for FixedBaseResolver<'a, S>

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