Struct iri_string::resolve::FixedBaseResolver

pub struct FixedBaseResolver<'a, S: Spec> { /* private fields */ }

A resolver against the fixed base.

If you want more control over how to resolve the buffer, create NormalizationTask by create_task or create_normalizing_task method.

Implementations

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

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

Creates a new resolver with the given 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);

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

assert_eq!(resolved, "http://example.com/there");

pub fn base(&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);

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

pub fn resolve(
    &self,
    reference: &RiReferenceStr<S>
) -> Result<RiString<S>, TaskError<Error>>

Resolves the given reference against the fixed base.

Enabled by alloc or std feature.

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

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::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, "http://example.com/there");

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

use iri_string::resolve::FixedBaseResolver;
use iri_string::task::ProcessAndWrite;
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 task = resolver.create_task(reference);

let resolved = task.allocate_and_write()?;
// Resolved but not normalized.
assert_eq!(resolved, "HTTP://example.COM/dot%2edot");

pub fn resolve_normalize(
    &self,
    reference: &RiReferenceStr<S>
) -> Result<RiString<S>, TaskError<Error>>

Resolves the given reference against the fixed base, and normalizes the result.

Enabled by alloc or std feature.

The task returned by this method is normalized.

If you don’t want the result to be normalized, use create_task method.

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::FixedBaseResolver;
use iri_string::task::ProcessAndWrite;
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 `..`.
let reference = IriReferenceStr::new("%2e%2e/../dot%2edot")?;
let task = resolver.create_normalizing_task(reference);

let resolved = task.allocate_and_write()?;
// Not only resolved, but also normalized.
assert_eq!(resolved, "http://example.com/dot.dot");

pub fn create_task(
    &self,
    reference: &'a RiReferenceStr<S>
) -> NormalizationTask<'a, RiStr<S>>

Creates a resolution task.

The returned NormalizationTask allows you to resolve the IRI without memory allocation, resolve to existing buffers, estimate required memory size, etc. If you need more control than resolve method, use this.

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

If you don’t want to normalize the result, use create_task instead.

Examples

use iri_string::resolve::FixedBaseResolver;
use iri_string::task::ProcessAndWrite;
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 task = resolver.create_task(reference);

let resolved = task.allocate_and_write()?;
// Resolved but not normalized.
assert_eq!(resolved, "HTTP://example.COM/dot%2edot");

pub fn create_normalizing_task(
    &self,
    reference: &'a RiReferenceStr<S>
) -> NormalizationTask<'a, RiStr<S>>

Creates a resolution task.

The returned NormalizationTask allows you to resolve the IRI without memory allocation, resolve to existing buffers, estimate required memory size, etc. If you need more control than resolve_normalize method, use this.

The task returned by this method normalizes the resolution result.

Examples

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

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

let reference = IriReferenceStr::new("%2e%2e/../dot%2edot")?;
let task = resolver.create_normalizing_task(reference);

let resolved = task.allocate_and_write()?;
// Not only resolved, but also normalized.
assert_eq!(resolved, "http://example.com/dot.dot");

Trait Implementations

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

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

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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