Struct EyeballSet 

pub struct EyeballSet<F, T, E> { /* private fields */ }

Implements the Happy Eyeballs algorithm for connecting to a set of addresses.

This algorithm is used to connect to a set of addresses in parallel, with a delay between each attempt. The first successful connection is returned.

When the timeout is not set, the algorithm will attempt to connect to only one address at a time.

To connect to all addresses simultaneously, set the timeout to zero.

Implementations

impl<F, T, E> EyeballSet<F, T, E>

pub fn new(configuration: EyeballConfiguration) -> Self

Create a new EyeballSet with an optional timeout.

The timeout is the amount of time between individual connection attempts.

pub fn is_empty(&self) -> bool

Returns true if the set of tasks is empty.

pub fn len(&self) -> usize

Returns the number of tasks in the set.

pub fn push(&mut self, future: F)

where F: Future<Output = Result<T, E>>,

Push a future into the set of tasks.

impl<F, T, E> EyeballSet<F, T, E>

where F: Future<Output = Result<T, E>>,

pub async fn finish(&mut self) -> Result<T, HappyEyeballsError<E>>

Finish the happy eyeballs algorithm, returning the first successful connection.

Trait Implementations

impl<F: Debug, T: Debug, E: Debug> Debug for EyeballSet<F, T, E>

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

Formats the value using the given formatter.

impl<F, T, E> Extend<F> for EyeballSet<F, T, E>

where F: Future<Output = Result<T, E>>,

fn extend<I: IntoIterator<Item = F>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<F, T, E> IntoFuture for EyeballSet<F, T, E>

where T: Send + 'static, E: Send + 'static, F: Future<Output = Result<T, E>> + Send + 'static,

type Output = Result<T, HappyEyeballsError<E>>

The output that the future will produce on completion.

type IntoFuture = Pin<Box<dyn Future<Output = <EyeballSet<F, T, E> as IntoFuture>::Output> + Send>>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.