Struct NormalizedDelayPerPacketConfig 

pub struct NormalizedDelayPerPacketConfig {
    pub mean: Option<Delay>,
    pub std_dev: Option<Delay>,
    pub upper_bound: Option<Delay>,
    pub lower_bound: Option<Delay>,
    pub count: usize,
    pub seed: Option<u64>,
}

The configuration struct for NormalizedDelayPerPacket.

See NormalizedDelayPerPacket for more details.

Fields

mean: Option<Delay>

std_dev: Option<Delay>

upper_bound: Option<Delay>

lower_bound: Option<Delay>

count: usize

seed: Option<u64>

Implementations

impl NormalizedDelayPerPacketConfig

pub fn new() -> Self

Creates an uninitialized config

pub fn mean(self, mean: Delay) -> Self

Sets the mean

If the mean is not set, 10ms will be used.

pub fn std_dev(self, std_dev: Delay) -> Self

Sets the standard deviation

If the standard deviation is not set, 0ms will be used.

pub fn upper_bound(self, upper_bound: Delay) -> Self

Sets the upper bound

If the upper bound is not set, the upper bound will be the one of Delay.

pub fn lower_bound(self, lower_bound: Delay) -> Self

Sets the lower bound

If the lower bound is not set, 0ms will be used.

pub fn count(self, count: usize) -> Self

Sets the number of packets to repeat

If the count is not set, it will be set to 0 (ie, infinite repeat).

pub fn seed(self, seed: u64) -> Self

Set the seed for a random generator

If the seed is not set, 42 will be used.

pub fn random_seed(self) -> Self

Allows to use a randomly generated seed

This is equivalent to: self.seed(rand::random())

pub fn build(self) -> NormalizedDelayPerPacket

Creates a new NormalizedDelayPerPacket corresponding to this config.

The created model will use StdRng as source of randomness (the call is equivalent to self.build_with_rng::<StdRng>()). It should be sufficient for most cases, but StdRng is not a portable random number generator, so one may want to use a portable random number generator like ChaCha, to this end one can use build_with_rng.

pub fn build_with_rng<Rng: RngCore + SeedableRng>( self, ) -> NormalizedDelayPerPacket<Rng>

Creates a new NormalizedDelayPerPacket corresponding to this config.

Unlike build, this method let you choose the random generator.

Example

let normal_delay = NormalizedDelayPerPacketConfig::new()
    .mean(Delay::from_millis(12))
    .std_dev(Delay::from_millis(1))
    .count(3)
    .seed(42);

let mut default_build = normal_delay.clone().build();
let mut std_build = normal_delay.clone().build_with_rng::<StdRng>();
// ChaCha is deterministic and portable, unlike StdRng
let mut chacha_build = normal_delay.clone().build_with_rng::<ChaCha20Rng>();

for cha in [12044676, 11754367, 11253775] {
    let default = default_build.next_delay();
    let std = std_build.next_delay();
    let chacha = chacha_build.next_delay();

    assert!(default.is_some());
    assert_eq!(default, std);
    assert_ne!(default, chacha);
    assert_eq!(chacha, Some(Delay::from_nanos(cha)));
}

assert_eq!(default_build.next_delay(), None);
assert_eq!(std_build.next_delay(), None);
assert_eq!(chacha_build.next_delay(), None);

impl NormalizedDelayPerPacketConfig

pub fn build_truncated(self) -> NormalizedDelayPerPacket

This is another implementation for converting NormalizedPerPacketConfig into NormalizedDelayPerPacket, where the impact of truncation (lower_bound and upper_bound field) on the mathematical expectation of the distribution is taking account by modifying the center of the distribution.

Examples

let normal_delay = NormalizedDelayPerPacketConfig::new()
    .mean(Delay::from_millis(12))
    .std_dev(Delay::from_millis(12))
    .count(1_000_000)
    .seed(42);

let mut default_build = normal_delay.clone().build();
let mut truncate_build = normal_delay.clone().build_truncated();

fn avg_delay(mut model: impl DelayPerPacketTrace) -> Delay {
    let mut count = 0;
    std::iter::from_fn( move ||{
        model.next_delay()
    }).inspect(|_| count += 1).sum::<Delay>() / count
}

assert_eq!(avg_delay(default_build), Delay::from_nanos(12998335)); // significantly higher than the expected mean
assert_eq!(avg_delay(truncate_build), Delay::from_nanos(11998818));

let normal_delay = NormalizedDelayPerPacketConfig::new()
    .mean(Delay::from_millis(12))
    .std_dev(Delay::from_millis(12))
    .lower_bound(Delay::from_millis(8))
    .upper_bound(Delay::from_millis(20))
    .count(1_000_000)
    .seed(42);

let mut default_build = normal_delay.clone().build();
let mut truncate_build = normal_delay.clone().build_truncated();

assert_eq!(avg_delay(default_build),  Delay::from_nanos(13234261)); // significantly higher than the expected mean
assert_eq!(avg_delay(truncate_build), Delay::from_nanos(11999151));

pub fn build_truncated_with_rng<Rng: SeedableRng + RngCore>( self, ) -> NormalizedDelayPerPacket<Rng>

Similar to build_truncated but let you choose the random generator.

See build for details about the reason for using another random number generator than StdRng.

Trait Implementations

impl Clone for NormalizedDelayPerPacketConfig

fn clone(&self) -> NormalizedDelayPerPacketConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NormalizedDelayPerPacketConfig

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

Formats the value using the given formatter.

impl Default for NormalizedDelayPerPacketConfig

fn default() -> NormalizedDelayPerPacketConfig

Returns the “default value” for a type.

impl DelayPerPacketTraceConfig for NormalizedDelayPerPacketConfig

fn into_model( self: Box<NormalizedDelayPerPacketConfig>, ) -> Box<dyn DelayPerPacketTrace>

impl<'de> Deserialize<'de> for NormalizedDelayPerPacketConfig

where NormalizedDelayPerPacketConfig: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Forever for NormalizedDelayPerPacketConfig

fn forever(self) -> RepeatedDelayPerPacketPatternConfig

impl PartialEq for NormalizedDelayPerPacketConfig

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for NormalizedDelayPerPacketConfig

impl StructuralPartialEq for NormalizedDelayPerPacketConfig