Struct DidUrl 

pub struct DidUrl { /* private fields */ }

A DID URL such as did:example:123/path?versionId=1#key-1.

A DidUrl is a Did followed by an optional path, query and fragment as defined by W3C DID Core §3.2 and RFC 3986. It is validated on construction and stores the input unchanged. A DidUrl without path, query or fragment displays as the bare DID.

Equality, ordering and hashing are those of the URL string.

Examples

use identity_kit::did::DidUrl;

let url = DidUrl::parse("did:example:123/path/to?versionId=1#frag")?;
assert_eq!(url.did().as_str(), "did:example:123");
assert_eq!(url.path(), Some("/path/to"));
assert_eq!(url.query(), Some("versionId=1"));
assert_eq!(url.fragment(), Some("frag"));

let key = DidUrl::parse("did:example:123#key-1")?;
assert_eq!(key.path(), None);
assert_eq!(key.without_fragment().as_str(), "did:example:123");
assert_eq!(key.with_fragment("key-2").as_str(), "did:example:123#key-2");

Implementations

impl DidUrl

pub fn parse(s: &str) -> Result<Self, DidError>

Parses a DID URL, rejecting input longer than DEFAULT_MAX_LEN bytes.

Errors

Returns a DidError describing the first violation of the DID URL syntax.

Examples

use identity_kit::did::{DidError, DidUrl};

let url = DidUrl::parse("did:example:123?service=agent&relativeRef=%2Fsome%2Fpath")?;
assert_eq!(url.query(), Some("service=agent&relativeRef=%2Fsome%2Fpath"));

// An empty fragment is present but empty, as in RFC 3986.
assert_eq!(DidUrl::parse("did:example:123#")?.fragment(), Some(""));

assert_eq!(DidUrl::parse("did:example:123#a#b"), Err(DidError::InvalidFragment));

pub fn parse_with_max_len(s: &str, max_len: usize) -> Result<Self, DidError>

Parses a DID URL, rejecting input longer than max_len bytes with DidError::TooLong.

Errors

Returns a DidError describing the first violation of the DID URL syntax.

pub fn did(&self) -> &Did

The DID this URL refers to.

pub fn path(&self) -> Option<&str>

The path, starting with /, or None when the URL has no path.

pub fn query(&self) -> Option<&str>

The query without the leading ?, or None when the URL has no ?.

pub fn fragment(&self) -> Option<&str>

The fragment without the leading #, or None when the URL has no #.

pub fn as_str(&self) -> &str

The DID URL as it was parsed.

pub fn with_fragment(&self, fragment: &str) -> Self

A copy of this URL with its fragment replaced by fragment.

fragment is taken as already percent-encoded: a % followed by two hexadecimal digits is kept, and every other byte that RFC 3986 does not allow in a fragment (including a stray %) is percent-encoded, so the result is always a valid DID URL.

Examples

use identity_kit::did::DidUrl;

let url = DidUrl::parse("did:example:123?versionId=1#key-1")?;
assert_eq!(url.with_fragment("key-2").as_str(), "did:example:123?versionId=1#key-2");
assert_eq!(url.with_fragment("a b").fragment(), Some("a%20b"));

pub fn with_did(&self, did: Did) -> Self

A copy of this URL with its DID replaced by did, keeping path, query and fragment.

Examples

use identity_kit::did::{Did, DidUrl};

let url = DidUrl::parse("did:example:123/path?versionId=1#key-1")?;
let moved = url.with_did(Did::parse("did:web:example.com")?);
assert_eq!(moved.as_str(), "did:web:example.com/path?versionId=1#key-1");
assert_eq!(moved.fragment(), Some("key-1"));

pub fn without_fragment(&self) -> Self

A copy of this URL without a fragment.

Trait Implementations

impl AsRef<str> for DidUrl

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for DidUrl

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DidUrl

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DidUrl

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for DidUrl

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

Formats the value using the given formatter.

impl Eq for DidUrl

impl From<&DidUrl> for DidUrlReference

fn from(url: &DidUrl) -> Self

Converts to this type from the input type.

impl From<&DidUrl> for Uri

fn from(url: &DidUrl) -> Self

Converts to this type from the input type.

impl From<DidUrl> for MethodRef

fn from(id: DidUrl) -> Self

Converts to this type from the input type.

impl From<DidUrl> for DidUrlReference

fn from(url: DidUrl) -> Self

Converts to this type from the input type.

impl From<DidUrl> for Uri

fn from(url: DidUrl) -> Self

Converts to this type from the input type.

impl From<DidUrl> for Party

Available on crate feature vc only.

fn from(url: DidUrl) -> Self

Converts to this type from the input type.

impl FromStr for DidUrl

type Err = DidError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for DidUrl

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for DidUrl

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for DidUrl

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for DidUrl

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for DidUrl

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for DidUrl

type Error = DidError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for DidUrl

type Error = DidError

The type returned in the event of a conversion error.

fn try_from(s: String) -> Result<Self, Self::Error>

Performs the conversion.