Struct RelayExclusion 

pub struct RelayExclusion<'a> { /* private fields */ }

A set of relays that we must not use when picking a given relays.

Exclusions are generally used to make sure that we obey family-based path-selection rules, that we avoid putting the same relay into a set more than once, or similar purposes.

(This is a separate type from RelayRestriction so that we can enforce our rule that every RelaySelector must have a RelayExclusion.)

Implementations

impl<'a> RelayExclusion<'a>

pub fn no_relays_excluded() -> Self

Exclude no relays at all.

This kind of restriction is useful when picking the first relay for something,

pub fn exclude_identities(ids: RelayIdSet) -> Self

Exclude every relay that has an identity in ids.

pub fn exclude_specific_relays(relays: &[Relay<'a>]) -> Self

Exclude every relay that appears in relays.

pub fn exclude_channel_target_family<CT: ChanTarget>( cfg: &RelaySelectionConfig<'_>, ct: &CT, netdir: &'a NetDir, ) -> Self

Try to exclude every relay in the same family as the ChanTarget ct.

Limitations

A ChanTarget does not have a listed family. Thus, if it does not correspond to a relay listed in netdir, we can only exclude relays that share the same identity, or relays that are in the same subnet.

Whenever possible, it’s better to use exclude_relays_in_same_family.

pub fn exclude_relays_in_same_family( cfg: &RelaySelectionConfig<'_>, relays: Vec<Relay<'a>>, family_rules: FamilyRules, ) -> Self

Exclude every relay that is in the same family as any member of relays.

(Remember that every relay is considered to be in the same family as itself, so you don’t typically need to use exclude_specific_relays along with this.)

Considers relays that are in the same subnets (according to cfg) to belong to the same family.

pub fn extend(&mut self, other: &RelayExclusion<'a>)

Modify this RelayExclusion by adding every exclusion from other.

(Any subnet configuration becomes the union of previous subnet configurations.)

Trait Implementations

impl<'a> Clone for RelayExclusion<'a>

fn clone(&self) -> RelayExclusion<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for RelayExclusion<'a>

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

Formats the value using the given formatter.

impl<'a> From<RelayExclusion<'a>> for RelayRestriction<'a>

fn from(value: RelayExclusion<'a>) -> Self

Converts to this type from the input type.

impl<'a> LowLevelRelayPredicate for RelayExclusion<'a>

fn low_level_predicate_permits_relay(&self, relay: &Relay<'_>) -> bool

Return true if relay provides this predicate.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 152 bytes