Trait DnsAddressResolver 

pub trait DnsAddressResolver:
    Sized
    + Send
    + Sync
    + 'static {
    type Error: Into<Box<dyn Error + Sync + Send>> + Send + 'static;

    // Required methods
    fn lookup_ipv4(
        &self,
        domain: Domain,
    ) -> impl Stream<Item = Result<Ipv4Addr, Self::Error>> + Send;
    fn lookup_ipv6(
        &self,
        domain: Domain,
    ) -> impl Stream<Item = Result<Ipv6Addr, Self::Error>> + Send;

    // Provided methods
    fn lookup_ipv4_first(
        &self,
        domain: Domain,
    ) -> impl Future<Output = Option<Result<Ipv4Addr, Self::Error>>> + Send { ... }
    fn lookup_ipv4_rand(
        &self,
        domain: Domain,
    ) -> impl Future<Output = Option<Result<Ipv4Addr, Self::Error>>> + Send { ... }
    fn lookup_ipv6_first(
        &self,
        domain: Domain,
    ) -> impl Future<Output = Option<Result<Ipv6Addr, Self::Error>>> + Send { ... }
    fn lookup_ipv6_rand(
        &self,
        domain: Domain,
    ) -> impl Future<Output = Option<Result<Ipv6Addr, Self::Error>>> + Send { ... }
    fn into_box_dns_address_resolver(self) -> BoxDnsAddressResolver { ... }
}

Available on crate feature dns only.

A resolver of Domains into A or AAAA records.

Required Associated Types

type Error: Into<Box<dyn Error + Sync + Send>> + Send + 'static

Error returned by the DnsAddressResolver

Required Methods

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, Self::Error>> + Send

Resolve the ‘A’ records accessible by this resolver for the given Domain into Ipv4Addresses.

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, Self::Error>> + Send

Resolve the ‘AAAA’ records accessible by this resolver for the given Domain into Ipv6Addresses.

Provided Methods

fn lookup_ipv4_first( &self, domain: Domain, ) -> impl Future<Output = Option<Result<Ipv4Addr, Self::Error>>> + Send

Resolve the first ‘A’ record found for the resolver.

fn lookup_ipv4_rand( &self, domain: Domain, ) -> impl Future<Output = Option<Result<Ipv4Addr, Self::Error>>> + Send

Resolve to a pseudo-random ‘A’ record found for the resolver.

fn lookup_ipv6_first( &self, domain: Domain, ) -> impl Future<Output = Option<Result<Ipv6Addr, Self::Error>>> + Send

Resolve the first ‘AAAA’ record found for the resolver.

fn lookup_ipv6_rand( &self, domain: Domain, ) -> impl Future<Output = Option<Result<Ipv6Addr, Self::Error>>> + Send

Resolve to a pseudo-random ‘AAAA’ record found for the resolver.

fn into_box_dns_address_resolver(self) -> BoxDnsAddressResolver

Box this resolver to allow for dynamic dispatch.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl DnsAddressResolver for IpAddr

type Error = Infallible

fn lookup_ipv4( &self, _: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <IpAddr as DnsAddressResolver>::Error>> + Send

fn lookup_ipv4_first( &self, _: Domain, ) -> impl Future<Output = Option<Result<Ipv4Addr, <IpAddr as DnsAddressResolver>::Error>>> + Send

fn lookup_ipv4_rand( &self, _: Domain, ) -> impl Future<Output = Option<Result<Ipv4Addr, <IpAddr as DnsAddressResolver>::Error>>> + Send

fn lookup_ipv6( &self, _: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <IpAddr as DnsAddressResolver>::Error>> + Send

fn lookup_ipv6_first( &self, _: Domain, ) -> impl Future<Output = Option<Result<Ipv6Addr, <IpAddr as DnsAddressResolver>::Error>>> + Send

fn lookup_ipv6_rand( &self, _: Domain, ) -> impl Future<Output = Option<Result<Ipv6Addr, <IpAddr as DnsAddressResolver>::Error>>> + Send

impl<R, const N: usize> DnsAddressResolver for [R; N]

where R: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <[R; N] as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <[R; N] as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <[R; N] as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <[R; N] as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <[R; N] as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <[R; N] as DnsAddressResolver>::Error>>

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> DnsAddressResolver for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T1: DnsAddressResolver, T2: DnsAddressResolver, T3: DnsAddressResolver, T4: DnsAddressResolver, T5: DnsAddressResolver, T6: DnsAddressResolver, T7: DnsAddressResolver, T8: DnsAddressResolver, T9: DnsAddressResolver, T10: DnsAddressResolver, T11: DnsAddressResolver, T12: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) as DnsAddressResolver>::Error>>

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> DnsAddressResolver for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T1: DnsAddressResolver, T2: DnsAddressResolver, T3: DnsAddressResolver, T4: DnsAddressResolver, T5: DnsAddressResolver, T6: DnsAddressResolver, T7: DnsAddressResolver, T8: DnsAddressResolver, T9: DnsAddressResolver, T10: DnsAddressResolver, T11: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) as DnsAddressResolver>::Error>>

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> DnsAddressResolver for (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T1: DnsAddressResolver, T2: DnsAddressResolver, T3: DnsAddressResolver, T4: DnsAddressResolver, T5: DnsAddressResolver, T6: DnsAddressResolver, T7: DnsAddressResolver, T8: DnsAddressResolver, T9: DnsAddressResolver, T10: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) as DnsAddressResolver>::Error>>

impl<T1, T2, T3, T4, T5, T6, T7, T8, T9> DnsAddressResolver for (T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T1: DnsAddressResolver, T2: DnsAddressResolver, T3: DnsAddressResolver, T4: DnsAddressResolver, T5: DnsAddressResolver, T6: DnsAddressResolver, T7: DnsAddressResolver, T8: DnsAddressResolver, T9: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8, T9) as DnsAddressResolver>::Error>>

impl<T1, T2, T3, T4, T5, T6, T7, T8> DnsAddressResolver for (T1, T2, T3, T4, T5, T6, T7, T8)

where T1: DnsAddressResolver, T2: DnsAddressResolver, T3: DnsAddressResolver, T4: DnsAddressResolver, T5: DnsAddressResolver, T6: DnsAddressResolver, T7: DnsAddressResolver, T8: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7, T8) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7, T8) as DnsAddressResolver>::Error>>

impl<T1, T2, T3, T4, T5, T6, T7> DnsAddressResolver for (T1, T2, T3, T4, T5, T6, T7)

where T1: DnsAddressResolver, T2: DnsAddressResolver, T3: DnsAddressResolver, T4: DnsAddressResolver, T5: DnsAddressResolver, T6: DnsAddressResolver, T7: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6, T7) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6, T7) as DnsAddressResolver>::Error>>

impl<T1, T2, T3, T4, T5, T6> DnsAddressResolver for (T1, T2, T3, T4, T5, T6)

where T1: DnsAddressResolver, T2: DnsAddressResolver, T3: DnsAddressResolver, T4: DnsAddressResolver, T5: DnsAddressResolver, T6: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5, T6) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5, T6) as DnsAddressResolver>::Error>>

impl<T1, T2, T3, T4, T5> DnsAddressResolver for (T1, T2, T3, T4, T5)

where T1: DnsAddressResolver, T2: DnsAddressResolver, T3: DnsAddressResolver, T4: DnsAddressResolver, T5: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1, T2, T3, T4, T5) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4, T5) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1, T2, T3, T4, T5) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4, T5) as DnsAddressResolver>::Error>>

impl<T1, T2, T3, T4> DnsAddressResolver for (T1, T2, T3, T4)

where T1: DnsAddressResolver, T2: DnsAddressResolver, T3: DnsAddressResolver, T4: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1, T2, T3, T4) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3, T4) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1, T2, T3, T4) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3, T4) as DnsAddressResolver>::Error>>

impl<T1, T2, T3> DnsAddressResolver for (T1, T2, T3)

where T1: DnsAddressResolver, T2: DnsAddressResolver, T3: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1, T2, T3) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2, T3) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1, T2, T3) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2, T3) as DnsAddressResolver>::Error>>

impl<T1, T2> DnsAddressResolver for (T1, T2)

where T1: DnsAddressResolver, T2: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1, T2) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1, T2) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1, T2) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1, T2) as DnsAddressResolver>::Error>>

impl<T1> DnsAddressResolver for (T1,)

where T1: DnsAddressResolver,

type Error = OpaqueError

fn lookup_ipv4( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv4Addr, <(T1,) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv4_first( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1,) as DnsAddressResolver>::Error>>

async fn lookup_ipv4_rand( &self, domain: Domain, ) -> Option<Result<Ipv4Addr, <(T1,) as DnsAddressResolver>::Error>>

fn lookup_ipv6( &self, domain: Domain, ) -> impl Stream<Item = Result<Ipv6Addr, <(T1,) as DnsAddressResolver>::Error>> + Send

async fn lookup_ipv6_first( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1,) as DnsAddressResolver>::Error>>

async fn lookup_ipv6_rand( &self, domain: Domain, ) -> Option<Result<Ipv6Addr, <(T1,) as DnsAddressResolver>::Error>>

Implementors

impl DnsAddressResolver for BoxDnsAddressResolver

type Error = OpaqueError

impl DnsAddressResolver for BoxDnsResolver

type Error = OpaqueError

impl DnsAddressResolver for DenyAllDnsResolver

type Error = DnsDeniedError

impl DnsAddressResolver for DnsAddresssResolverOverwrite

type Error = OpaqueError

impl DnsAddressResolver for EmptyDnsResolver

type Error = Infallible

impl DnsAddressResolver for GlobalDnsResolver

type Error = OpaqueError

impl DnsAddressResolver for HickoryDnsResolver

type Error = Box<dyn Error + Sync + Send>

impl DnsAddressResolver for Ipv4Addr

type Error = Infallible

impl DnsAddressResolver for Ipv6Addr

type Error = Infallible

impl DnsAddressResolver for LinuxDnsResolver

type Error = Box<dyn Error + Sync + Send>

impl DnsAddressResolver for TokioDnsResolver

type Error = Box<dyn Error + Sync + Send>

impl<A, B, C, D, E, F, G, H, I> DnsAddressResolver for Either9<A, B, C, D, E, F, G, H, I>

where A: DnsAddressResolver, B: DnsAddressResolver, C: DnsAddressResolver, D: DnsAddressResolver, E: DnsAddressResolver, F: DnsAddressResolver, G: DnsAddressResolver, H: DnsAddressResolver, I: DnsAddressResolver,

type Error = OpaqueError

impl<A, B, C, D, E, F, G, H> DnsAddressResolver for Either8<A, B, C, D, E, F, G, H>

where A: DnsAddressResolver, B: DnsAddressResolver, C: DnsAddressResolver, D: DnsAddressResolver, E: DnsAddressResolver, F: DnsAddressResolver, G: DnsAddressResolver, H: DnsAddressResolver,

type Error = OpaqueError

impl<A, B, C, D, E, F, G> DnsAddressResolver for Either7<A, B, C, D, E, F, G>

where A: DnsAddressResolver, B: DnsAddressResolver, C: DnsAddressResolver, D: DnsAddressResolver, E: DnsAddressResolver, F: DnsAddressResolver, G: DnsAddressResolver,

type Error = OpaqueError

impl<A, B, C, D, E, F> DnsAddressResolver for Either6<A, B, C, D, E, F>

where A: DnsAddressResolver, B: DnsAddressResolver, C: DnsAddressResolver, D: DnsAddressResolver, E: DnsAddressResolver, F: DnsAddressResolver,

type Error = OpaqueError

impl<A, B, C, D, E> DnsAddressResolver for Either5<A, B, C, D, E>

where A: DnsAddressResolver, B: DnsAddressResolver, C: DnsAddressResolver, D: DnsAddressResolver, E: DnsAddressResolver,

type Error = OpaqueError

impl<A, B, C, D> DnsAddressResolver for Either4<A, B, C, D>

where A: DnsAddressResolver, B: DnsAddressResolver, C: DnsAddressResolver, D: DnsAddressResolver,

type Error = OpaqueError

impl<A, B, C> DnsAddressResolver for Either3<A, B, C>

where A: DnsAddressResolver, B: DnsAddressResolver, C: DnsAddressResolver,

type Error = OpaqueError

impl<A, B> DnsAddressResolver for Either<A, B>

where A: DnsAddressResolver, B: DnsAddressResolver,

type Error = OpaqueError

impl<R> DnsAddressResolver for Arc<R>

where R: DnsAddressResolver,

type Error = <R as DnsAddressResolver>::Error

impl<R> DnsAddressResolver for DomainTrie<R>

where R: DnsAddressResolver,

type Error = <R as DnsAddressResolver>::Error

impl<R> DnsAddressResolver for NonEmptyVec<R>

where R: DnsAddressResolver,

type Error = OpaqueError

impl<R> DnsAddressResolver for Option<R>

where R: DnsAddressResolver,

type Error = <R as DnsAddressResolver>::Error

impl<R> DnsAddressResolver for Vec<R>

where R: DnsAddressResolver,

type Error = OpaqueError