Struct BackoffStrategy 

pub struct BackoffStrategy { /* private fields */ }

Calculates retry delay with exponential backoff and jitter.

The backoff strategy uses the formula: min(base_delay * multiplier^attempt, max_delay) + jitter

Where jitter is a random value in the range [0, delay * jitter_factor].

Example

use ccxt_core::ws_client::{BackoffConfig, BackoffStrategy};

let strategy = BackoffStrategy::new(BackoffConfig::default());

// First attempt (attempt = 0): ~1 second + jitter
let delay0 = strategy.calculate_delay(0);

// Second attempt (attempt = 1): ~2 seconds + jitter
let delay1 = strategy.calculate_delay(1);

// Third attempt (attempt = 2): ~4 seconds + jitter
let delay2 = strategy.calculate_delay(2);

Implementations

impl BackoffStrategy

pub fn new(config: BackoffConfig) -> BackoffStrategy

Creates a new backoff strategy with the given configuration.

Arguments

• config - The backoff configuration to use

pub fn with_defaults() -> BackoffStrategy

Creates a new backoff strategy with default configuration.

pub fn config(&self) -> &BackoffConfig

Returns a reference to the underlying configuration.

pub fn calculate_delay(&self, attempt: u32) -> Duration

Calculates delay for the given attempt number.

Formula: min(base_delay * multiplier^attempt, max_delay) + jitter

Arguments

• attempt - The attempt number (0-indexed)

Returns

The calculated delay duration including jitter.

Example

use ccxt_core::ws_client::{BackoffConfig, BackoffStrategy};
use std::time::Duration;

let config = BackoffConfig {
    base_delay: Duration::from_secs(1),
    max_delay: Duration::from_secs(60),
    jitter_factor: 0.0, // No jitter for predictable results
    multiplier: 2.0,
};
let strategy = BackoffStrategy::new(config);

// With no jitter, delays are exactly: 1s, 2s, 4s, 8s, ...
assert_eq!(strategy.calculate_delay(0), Duration::from_secs(1));
assert_eq!(strategy.calculate_delay(1), Duration::from_secs(2));
assert_eq!(strategy.calculate_delay(2), Duration::from_secs(4));

pub fn calculate_delay_without_jitter(&self, attempt: u32) -> Duration

Calculates the base delay (without jitter) for the given attempt number.

This is useful for testing or when you need predictable delay values.

Arguments

• attempt - The attempt number (0-indexed)

Returns

The calculated delay duration without jitter.

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<(), Error>

Formats the value using the given formatter.