Trait AnyUriRef

pub trait AnyUriRef {
    // Required method
    fn components(&self) -> UriRawComponents<'_>;

    // Provided methods
    fn write_to<T>(&self, write: &mut T) -> Result<(), Error>
       where T: Write + ?Sized { ... }
    fn display(&self) -> UriDisplay<'_, Self> { ... }
    fn is_empty(&self) -> bool { ... }
    fn uri_type(&self) -> UriType { ... }
    fn to_uri_ref_buf(&self) -> UriRefBuf { ... }
    fn write_resolved<T, D>(
        &self,
        target: &D,
        f: &mut T,
    ) -> Result<(), ResolveError>
       where T: Write + ?Sized,
             D: AnyUriRef + ?Sized { ... }
    fn resolved<T>(&self, dest: &T) -> Result<UriRefBuf, ResolveError>
       where T: AnyUriRef + ?Sized { ... }
}

Trait for objects that represent logical URI-references. Useful for generic programming.

Required Methods

fn components(&self) -> UriRawComponents<'_>

Returns a UriRawComponents instance which contains all of the components for this URI reference.

This is the only method that is required to be implemented—all other methods have defaults in place which use this method, but they may be inefficient.

Provided Methods

fn write_to<T>(&self, write: &mut T) -> Result<(), Error>

where T: Write + ?Sized,

Serializes this URI to anything implementing core::fmt::Write. Override with care!

The purpose of this method is to provide a uniform way for a type that implements this trait to write out a well-formed URI; without making any assumptions on what that type might write out for std::fmt::Display (or even if it implements it at all). Thus, traits can be a bit more fast-and-loose with their implementations of std::fmt::Display.

See the documentation for display and UriDisplay for examples of usage.

Safety

Calling this method is not unsafe, but implementing it is! The underlying guarantee is that the written URI reference SHALL be well-formed. If this method writes out something that is not a valid URI reference, the resulting behavior is undefined.

TODO: Investigate implications of making this method unsafe.

fn display(&self) -> UriDisplay<'_, Self>

Wraps this AnyUriRef instance in a UriDisplay object for use with formatting macros like write! and format!.

The resulting instance will use the AnyUriRef::write_to method on this trait.

This method should not be overridden: override AnyUriRef::write_to instead.

This method is similar to the display method on std::path::Path.

Example

use async_coap_uri::prelude::*;

let uri_ref = uri_ref!("http://example.com/");

println!("uri_ref = {}", uri_ref.display());

fn is_empty(&self) -> bool

Returns true if the underlying URI-reference is actually the empty reference.

fn uri_type(&self) -> UriType

Gets the UriType of the underlying URI-reference.

fn to_uri_ref_buf(&self) -> UriRefBuf

Creates a new UriRefBuf from this AnyUriRef.

The default implementation uses the AnyUriRef::write_to method to render out the content of the URI-reference.

fn write_resolved<T, D>( &self, target: &D, f: &mut T, ) -> Result<(), ResolveError>

where T: Write + ?Sized, D: AnyUriRef + ?Sized,

Writes out to a core::fmt::Write instance the result of performing URI resolution against target, with self being the base URI.

fn resolved<T>(&self, dest: &T) -> Result<UriRefBuf, ResolveError>

where T: AnyUriRef + ?Sized,

Creates a new UriRefBuf that contains the result of performing URI resolution with dest.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a, T> AnyUriRef for Cow<'a, T>

where T: AnyUriRef + Clone + ?Sized,

Blanket implementation for Copy-On-Write types.

fn components(&self) -> UriRawComponents<'_>

fn write_to<W>(&self, write: &mut W) -> Result<(), Error>

where W: Write + ?Sized,

fn is_empty(&self) -> bool

fn uri_type(&self) -> UriType

fn to_uri_ref_buf(&self) -> UriRefBuf

fn write_resolved<W, D>( &self, dest: &D, output: &mut W, ) -> Result<(), ResolveError>

where W: Write + ?Sized, D: AnyUriRef + ?Sized,

fn resolved<W>(&self, dest: &W) -> Result<UriRefBuf, ResolveError>

where W: AnyUriRef + ?Sized,

Implementors

impl AnyUriRef for RelRef

impl AnyUriRef for RelRefBuf

impl AnyUriRef for Uri

impl AnyUriRef for UriBuf

impl AnyUriRef for UriRawComponents<'_>

impl AnyUriRef for UriRef

impl AnyUriRef for UriRefBuf