Struct RelaySelector

pub struct RelaySelector<'a> {
    usage: Restr<'a>,
    exclusion: Restr<'a>,
    other_restrictions: Vec<Restr<'a>>,
}

Description of the requirements that a relay must implement in order to be selected.

This object is used to pick a Relay from a NetDir, or to ensure that a previously selected Relay still meets its requirements.

The requirements on a relay can be strict or flexible. If any restriction is flexible, and relay selection fails at first, we relax the RelaySelector by removing that restriction, and trying again, before we give up completely.

Fields

usage: Restr<'a>

A usage that the relay must support.

Invariant: This is a RelayUsage.

exclusion: Restr<'a>

An excludion that the relay must obey.

Invariant: This a RelayExclusion.

other_restrictions: Vec<Restr<'a>>

Other restrictions that a Relay must obey in order to be selected.

Implementations

impl<'a> RelaySelector<'a>

pub fn new(usage: RelayUsage, exclusion: RelayExclusion<'a>) -> Self

Create a new RelaySelector to pick relays with a given RelayUsage and RelayExclusion.

Both arguments are required, since every caller should consider them explicitly.

The provided usage and exclusion are strict by default.

pub fn mark_usage_flexible(&mut self)

Mark the originally provided RelayUsage as flexible.

pub fn mark_exclusion_flexible(&mut self)

Mark the originally provided RelayExclusion as flexible.

pub fn push_restriction(&mut self, restriction: RelayRestriction<'a>)

Add a new strict RelayRestriction to this selector.

pub fn push_flexible_restriction(&mut self, restriction: RelayRestriction<'a>)

Add a new flexible RelayRestriction to this selector.

fn push_inner(&mut self, restriction: RelayRestriction<'a>, strict: bool)

Helper to implement adding a new restriction.

pub fn usage(&self) -> &RelayUsage

Return the usage for this selector.

fn weight_role(&self) -> WeightRole

Return the WeightRole to use when randomly picking relays according to this selector.

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

Return true if relay is one that this selector would pick.

fn all_restrictions(&self) -> impl Iterator<Item = &Restr<'a>>

Return an iterator that yields each restriction from this selector, including the usage and exclusion.

fn n_restrictions(&self) -> usize

Return the number of restrictions in this selector, including the usage and exclusion.

pub fn select_relay<'s, 'd, R: Rng>( &'s self, rng: &mut R, netdir: &'d NetDir, ) -> (Option<Relay<'d>>, SelectionInfo<'s>)

Try to pick a random relay from netdir, according to the rules of this selector.

pub fn select_n_relays<'s, 'd, R: Rng>( &'s self, rng: &mut R, n_relays: usize, netdir: &'d NetDir, ) -> (Vec<Relay<'d>>, SelectionInfo<'s>)

Try to pick n_relays distinct random relay from netdir, according to the rules of this selector.

fn relay_usable(&self, r: &Relay<'_>, fc: &mut FilterCounts) -> bool

Check whether a given relay r obeys the restrictions of this selector, updating fc according to which restrictions (if any) accepted or rejected it.

Requires that fc has the same length as self.restrictions.

This differs from <Self as RelayPredicate>::permits_relay in taking fc as an argument.

fn can_relax(&self) -> bool

Return true if this selector has any flexible restrictions.

fn relax(&self) -> Self

Return a new selector created by relaxing every flexible restriction in this selector.

Trait Implementations

impl<'a> Clone for RelaySelector<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for RelaySelector<'a>

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

Formats the value using the given formatter.

impl<'a> LowLevelRelayPredicate for RelaySelector<'a>

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

Return true if relay provides this predicate.