Struct DomainTrie 

pub struct DomainTrie<T> { /* private fields */ }

Available on crate feature net only.

An efficient radix tree that can be used to match (sub)domains.

Each inserted entry is either an exact entry or a subtree entry, inferred from the input:

• "example.com" — exact: matches only the domain example.com itself.
• "*.example.com" — subtree: matches example.com and every name under it (foo.example.com, a.b.example.com, …).

Both modes can coexist at the same name: inserting example.com and later *.example.com (or vice versa) leaves both values addressable.

Implementations

impl<T> DomainTrie<T>

pub fn new() -> DomainTrie<T>

Create a new DomainTrie.

pub fn is_empty(&self) -> bool

Determine if the Trie contains 0 key-value pairs.

pub fn len(&self) -> usize

pub fn with_insert_domain( self, domain: impl AsDomainRef, value: T, ) -> DomainTrie<T>

Consume self and insert the given domain paired with the input value.

See Self::insert_domain for the matching semantics (wildcard *.x is stored as subtree at x; plain x is stored as exact).

pub fn insert_domain( &mut self, domain: impl AsDomainRef, value: T, ) -> &mut DomainTrie<T>

Insert the given domain paired with the input value.

Dispatch:

• If the input is a wildcard ("*.foo.bar"), the *. prefix is stripped and the value is stored as a subtree entry at foo.bar — it matches foo.bar and every domain under it.
• Otherwise the value is stored as an exact entry — only the stored name matches.

Inserting at a name that already has a value of the same kind overwrites it. Exact and subtree slots at the same name are independent.

pub fn with_insert_domain_iter<I, S>( self, domains: I, value: T, ) -> DomainTrie<T>

where I: IntoIterator<Item = S>, S: AsDomainRef, T: Clone,

Consume self and insert the given domains paired with the input value.

Each domain is dispatched through Self::insert_domain.

pub fn insert_domain_iter<I, S>( &mut self, domains: I, value: T, ) -> &mut DomainTrie<T>

where I: IntoIterator<Item = S>, S: AsDomainRef, T: Clone,

Insert the given domains paired with the input value.

pub fn extend<I, S>(&mut self, iter: I) -> &mut DomainTrie<T>

where I: IntoIterator<Item = (S, T)>, S: AsDomainRef,

Extend this DomainTrie with the given pairs.

pub fn is_match(&self, domain: impl AsDomainRef) -> bool

Returns true if domain matches at least one entry in this trie.

Cheaper than self.get(domain).is_some() — does not build the MatchKind::Subtree { apex } payload for subtree hits.

pub fn get_value(&self, domain: impl AsDomainRef) -> Option<&T>

Returns the value for the most-specific entry that matches domain, without computing the apex for subtree matches.

Cheaper than Self::get when the caller doesn’t need the apex. Matching rules are identical to get.

pub fn get(&self, domain: impl AsDomainRef) -> Option<DomainMatch<'_, T>>

Look up domain and return a DomainMatch describing the most- specific entry that matches it, along with whether the match was exact or via a subtree apex.

Matching rules:

• Exact entries match only their stored name.
• Subtree entries match their apex plus every descendant.

For exact-only lookups, use get(d).filter(|m| matches!(m.kind, MatchKind::Exact)).

pub fn match_exact(&self, domain: impl AsDomainRef) -> Option<&T>

Returns the value stored for the exact domain (either its exact slot, or its subtree slot if exact is unset).

Single-key direct lookup — not the same as Self::get, which walks ancestors.

pub fn is_match_exact(&self, domain: impl AsDomainRef) -> bool

Returns true if domain is stored as an exact (or subtree-apex) entry in this trie.

Shortcut for self.match_exact(domain).is_some().

pub fn iter(&self) -> impl Iterator<Item = (Domain, &T)>

Iterate over the domains and values stored in this Trie.

Each stored entry yields one item per slot that is set: a subtree entry yields the apex domain as a wildcard "*.apex", an exact entry yields the apex itself.

Trait Implementations

impl<T> Clone for DomainTrie<T>

where T: Clone,

fn clone(&self) -> DomainTrie<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for DomainTrie<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for DomainTrie<T>

fn default() -> DomainTrie<T>

Returns the “default value” for a type.

impl<R> DnsAddressResolver for DomainTrie<R>

where R: DnsAddressResolver,

type Error = <R as DnsAddressResolver>::Error

Error returned by the DnsAddressResolver

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

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

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

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

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

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

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

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

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

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

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

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.

impl<R> DnsTxtResolver for DomainTrie<R>

where R: DnsTxtResolver,

type Error = <R as DnsTxtResolver>::Error

Error returned by the DnsTxtResolver

fn lookup_txt( &self, domain: Domain, ) -> impl Stream<Item = Result<Bytes, <DomainTrie<R> as DnsTxtResolver>::Error>> + Send

Resolve the ‘TXT’ records accessible by this resolver for the given Domain into Bytes.

fn into_box_dns_txt_resolver(self) -> BoxDnsTxtResolver

Box this resolver to allow for dynamic dispatch.

impl<S, T> FromIterator<(S, T)> for DomainTrie<T>

where S: AsDomainRef,

fn from_iter<I>(iter: I) -> DomainTrie<T>

where I: IntoIterator<Item = (S, T)>,

Creates a value from an iterator.