Struct ResolverBuilder 

pub struct ResolverBuilder { /* private fields */ }

Builds a Resolver.

Examples

use std::time::Duration;

use identity_kit::did::{
    Did, ResolutionError, ResolutionErrorKind, ResolutionOptions, ResolutionResult,
};
use identity_kit::resolver::{DidResolver, Resolver};

struct Nothing;

#[async_trait::async_trait]
impl DidResolver for Nothing {
    fn method(&self) -> &'static str {
        "example"
    }

    async fn resolve(
        &self,
        _: &Did,
        _: &ResolutionOptions,
    ) -> Result<ResolutionResult, ResolutionError> {
        Err(ResolutionErrorKind::NotFound.into())
    }
}

let resolver = Resolver::builder()
    .with(Nothing)
    .cache(Duration::from_secs(60))
    .build();
assert_eq!(resolver.methods(), ["example"]);
assert!(resolver.supports("example") && !resolver.supports("web"));
assert_eq!(resolver.cache().map(|cache| cache.ttl()), Some(Duration::from_secs(60)));

Implementations

impl ResolverBuilder

pub fn new() -> Self

A builder with no method registered and no cache.

pub fn with(self, resolver: impl DidResolver + 'static) -> Self

Registers resolver for its method, replacing any resolver registered for the same method before, so a later registration overrides a default.

pub fn with_arc(self, resolver: Arc<dyn DidResolver>) -> Self

Registers an already shared resolver, as with.

pub fn cache(self, ttl: Duration) -> Self

Caches resolution results for ttl in a DocumentCache of default capacity.

pub fn with_cache(self, cache: DocumentCache) -> Self

Caches resolution results in cache.

pub fn build(self) -> Resolver

The resolver.

Trait Implementations

impl Debug for ResolverBuilder

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

Formats the value using the given formatter.

impl Default for ResolverBuilder

fn default() -> Self

Returns the “default value” for a type.