Struct NormalizedDelayPerPacket 

pub struct NormalizedDelayPerPacket<Rng = StdRng>
where
    Rng: RngCore,
{
    pub mean: Delay,
    pub std_dev: Delay,
    pub upper_bound: Option<Delay>,
    pub lower_bound: Delay,
    pub seed: u64,
    pub count: usize,
    /* private fields */
}

The model of a per-packet delay trace subjects to a normal distribution.

The delay will subject to N(mean, std_dev²), but bounded within [lower_bound, upper_bound] (optional)

If the count is 0, the delay will be repeated forever, else it will be repeated count times.

Examples

A simple example without any bound on delay:

let mut normal_delay = NormalizedDelayPerPacketConfig::new()
    .mean(Delay::from_millis(12))
    .std_dev(Delay::from_millis(1))
    .count(2)
    .seed(42)
    .build();
assert_eq!(normal_delay.next_delay(), Some(Delay::from_nanos(12069428)));
assert_eq!(normal_delay.next_delay(), Some(Delay::from_nanos(12132938)));
assert_eq!(normal_delay.next_delay(), None);

A more complex example with bounds on delay:

let mut normal_delay = NormalizedDelayPerPacketConfig::new()
    .mean(Delay::from_millis(12))
    .std_dev(Delay::from_millis(1))
    .count(2)
    .seed(42)
    .upper_bound(Delay::from_micros(12100))
    .lower_bound(Delay::from_micros(11900))
    .build();
assert_eq!(normal_delay.next_delay(), Some(Delay::from_nanos(12069428)));
assert_eq!(normal_delay.next_delay(), Some(Delay::from_nanos(12100000)));
assert_eq!(normal_delay.next_delay(), None);

Fields

mean: Delay

std_dev: Delay

upper_bound: Option<Delay>

lower_bound: Delay

seed: u64

count: usize

Trait Implementations

impl<Rng> Clone for NormalizedDelayPerPacket<Rng>

where Rng: RngCore + Clone,

fn clone(&self) -> NormalizedDelayPerPacket<Rng>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Rng> Debug for NormalizedDelayPerPacket<Rng>

where Rng: RngCore + Debug,

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

Formats the value using the given formatter.

impl<Rng: RngCore + Send> DelayPerPacketTrace for NormalizedDelayPerPacket<Rng>

fn next_delay(&mut self) -> Option<Delay>

impl<Rng> PartialEq for NormalizedDelayPerPacket<Rng>

where Rng: RngCore + PartialEq,

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

where Rng: RngCore + Copy,

impl<Rng> StructuralPartialEq for NormalizedDelayPerPacket<Rng>

where Rng: RngCore,