Enum Policy 

pub enum Policy {
    Periodic(Duration),
    Exponential {
        base_delay: Duration,
        factor: f64,
    },
    Fibonacci {
        first: Duration,
        second: Duration,
    },
    Immediate,
    Never,
    CountBox {
        max_retries: u32,
        inner: Box<Policy>,
    },
    TimeBox {
        limit: Duration,
        inner: Box<Policy>,
    },
    Clamp {
        min_delay: Duration,
        max_delay: Duration,
        inner: Box<Policy>,
    },
    AddDelay {
        delay: Duration,
        inner: Box<Policy>,
    },
    Jitter {
        factor: f64,
        inner: Box<Policy>,
    },
    OnlyWhen {
        predicate: Predicate,
        inner: Box<Policy>,
    },
    AndThen(Box<Policy>, Box<Policy>),
    Union(Box<Policy>, Box<Policy>),
    Intersect(Box<Policy>, Box<Policy>),
}

High-level retry policy that keeps tree structure until conversion.

Variants

Periodic(Duration)

Exponential

Fields

base_delay: Duration

factor: f64

Fibonacci

Fields

first: Duration

second: Duration

Immediate

Never

CountBox

Fields

max_retries: u32

inner: Box<Policy>

TimeBox

Fields

limit: Duration

inner: Box<Policy>

Clamp

Fields

min_delay: Duration

max_delay: Duration

inner: Box<Policy>

AddDelay

Fields

delay: Duration

inner: Box<Policy>

Jitter

Fields

factor: f64

inner: Box<Policy>

OnlyWhen

Fields

predicate: Predicate

inner: Box<Policy>

AndThen(Box<Policy>, Box<Policy>)

Union(Box<Policy>, Box<Policy>)

Intersect(Box<Policy>, Box<Policy>)

Implementations

impl Policy

pub fn immediate() -> Self

pub fn never() -> Self

pub fn periodic(delay: Duration) -> Self

pub fn exponential(base_delay: Duration, factor: f64) -> Self

pub fn fibonacci(first: Duration, second: Duration) -> Self

pub fn max_retries(self, max_retries: u32) -> Self

pub fn within(self, limit: Duration) -> Self

pub fn clamp(self, min_delay: Duration, max_delay: Duration) -> Self

pub fn add_delay(self, delay: Duration) -> Self

pub fn with_jitter(self, factor: f64) -> Self

pub fn only_when(self, predicate: Predicate) -> Self

pub fn and_then(self, other: Policy) -> Self

pub fn union(self, other: Policy) -> Self

pub fn intersect(self, other: Policy) -> Self

pub fn try_to_raw(&self) -> Result<RetryPolicy, RetryBuilderError>

Trait Implementations

impl Clone for Policy

fn clone(&self) -> Policy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Policy

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

Formats the value using the given formatter.

impl PartialEq for Policy

fn eq(&self, other: &Policy) -> 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 TryFrom<Policy> for RetryPolicy

type Error = RetryBuilderError

The type returned in the event of a conversion error.

fn try_from(policy: Policy) -> Result<Self, Self::Error>

Performs the conversion.

impl StructuralPartialEq for Policy