Function iri_string::resolve::try_resolve_normalize

pub fn try_resolve_normalize<S: Spec>(
    reference: impl AsRef<RiReferenceStr<S>>, 
    base: impl AsRef<RiAbsoluteStr<S>>
) -> Result<RiString<S>, TaskError<Error>>

Resolves and normalizes the IRI reference.

It is recommended to use methods such as RiReferenceStr::try_resolve_normalize_against() and RiRelativeStr::try_resolve_normalize_against(), rather than this freestanding function.

If you are going to resolve multiple references against the common base, consider using FixedBaseResolver.

Enabled by alloc or std feature.

Failures

This fails if

• memory allocation failed, or
• the IRI referernce is unresolvable against the base.

To see examples of unresolvable IRIs, visit the module documentation.

Examples

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

let base = IriAbsoluteStr::new("http://example.com/base/")?;
let reference = IriReferenceStr::new("../there")?;

// Resolve and normalize `reference` against `base`.
let resolved = try_resolve_normalize(reference, base)?;
assert_eq!(resolved, "http://example.com/there");

// These two produces the same result with the same type.
assert_eq!(
    FixedBaseResolver::new(base).try_resolve(reference)?,
    "http://example.com/there"
);
assert_eq!(
    FixedBaseResolver::new(base)
        .create_normalizing_task(reference)
        .allocate_and_write()?,
    "http://example.com/there"
);