Struct WaitLinear 

pub struct WaitLinear { /* private fields */ }

A linearly increasing wait strategy.

Created by linear. The wait after attempt n is initial + (n - 1) * increment. Overflow saturates at Duration::MAX.

Examples

use relentless::wait;
use relentless::Wait;
use core::time::Duration;

let w = wait::linear(Duration::from_millis(100), Duration::from_millis(50));
// 100ms + (3-1)*50ms = 200ms
assert_eq!(w.next_wait(&state), Duration::from_millis(200));

Trait Implementations

impl<Rhs: Wait> Add<Rhs> for WaitLinear

type Output = WaitCombine<WaitLinear, Rhs>

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> Self::Output

Performs the + operation.

impl Clone for WaitLinear

fn clone(&self) -> WaitLinear

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WaitLinear

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

Formats the value using the given formatter.

impl PartialEq for WaitLinear

fn eq(&self, other: &WaitLinear) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Wait for WaitLinear

fn next_wait(&self, state: &RetryState) -> Duration

Returns the duration to sleep before the next retry attempt.

fn cap(self, max: Duration) -> WaitCapped<Self>

where Self: Sized,

Clamps the returned duration to at most max.

fn chain<W2: Wait>(self, other: W2, after: u32) -> WaitChain<Self, W2>

where Self: Sized,

Uses this strategy for the first after attempts, then switches to other.

fn add<W2: Wait>(self, other: W2) -> WaitCombine<Self, W2>

where Self: Sized,

Adds another wait strategy to this one.

fn jitter(self, max_jitter: Duration) -> Jittered<Self>

where Self: Sized,

Adds uniformly distributed jitter in [0, max_jitter].

fn full_jitter(self) -> Jittered<Self>

where Self: Sized,

Replaces the computed delay with a random value in [0, base].

fn equal_jitter(self) -> Jittered<Self>

where Self: Sized,

Keeps half the computed delay and jitters the other half.

impl Copy for WaitLinear

impl Eq for WaitLinear

impl StructuralPartialEq for WaitLinear