Enum BackoffStrategy 

pub enum BackoffStrategy {
    Immediate,
    Fixed {
        delay_ms: u32,
    },
    Exponential {
        base_delay_ms: u32,
        max_delay_ms: u32,
    },
    Linear {
        initial_delay_ms: u32,
        increment_ms: u32,
        max_delay_ms: u32,
    },
}

Retry delay strategy used after a request times out.

The delay is computed per retry attempt in a poll-driven manner. No internal sleeping or blocking waits are performed by the library.

Variants

Immediate

Retry immediately after timeout detection.

Fixed

Retry using a constant delay in milliseconds.

Fields

delay_ms: u32

Delay applied before each retry.

Exponential

Retry with an exponential sequence: base_delay_ms * 2^(attempt-1).

Fields

base_delay_ms: u32

Base delay for the first retry attempt.

max_delay_ms: u32

Upper bound used to clamp growth.

Linear

Retry with a linear sequence: initial_delay_ms + (attempt-1) * increment_ms.

Fields

initial_delay_ms: u32

Delay for the first retry attempt.

increment_ms: u32

Increment added on every subsequent retry.

max_delay_ms: u32

Upper bound used to clamp growth.

Implementations

impl BackoffStrategy

pub fn delay_ms_for_retry(&self, retry_attempt: u8) -> u32

Computes the base retry delay in milliseconds for a 1-based retry attempt index.

retry_attempt is expected to start at 1 for the first retry after the initial request timeout.

Trait Implementations

impl Clone for BackoffStrategy

fn clone(&self) -> BackoffStrategy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BackoffStrategy

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

Formats the value using the given formatter.

impl Default for BackoffStrategy

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for BackoffStrategy

fn eq(&self, other: &BackoffStrategy) -> 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 Copy for BackoffStrategy

impl Eq for BackoffStrategy

impl StructuralPartialEq for BackoffStrategy