Struct LogNormalizedDelayPerPacketConfig 

pub struct LogNormalizedDelayPerPacketConfig {
    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 LogNormalizedDelayPerPacket.

See LogNormalizedDelayPerPacket 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 LogNormalizedDelayPerPacketConfig

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) -> LogNormalizedDelayPerPacket

Creates a new LogNormalizedDelayPerPacket 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: SeedableRng + RngCore>( self, ) -> LogNormalizedDelayPerPacket<Rng>

Creates a new LogNormalizedDelayPerPacket corresponding to this config.

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

Example

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

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

for cha in [12003077, 11716668, 11238761] {
    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);

Trait Implementations

impl Clone for LogNormalizedDelayPerPacketConfig

fn clone(&self) -> LogNormalizedDelayPerPacketConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogNormalizedDelayPerPacketConfig

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

Formats the value using the given formatter.

impl Default for LogNormalizedDelayPerPacketConfig

fn default() -> LogNormalizedDelayPerPacketConfig

Returns the “default value” for a type.

impl DelayPerPacketTraceConfig for LogNormalizedDelayPerPacketConfig

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

impl<'de> Deserialize<'de> for LogNormalizedDelayPerPacketConfig

where LogNormalizedDelayPerPacketConfig: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LogNormalizedDelayPerPacketConfig

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

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 LogNormalizedDelayPerPacketConfig

impl StructuralPartialEq for LogNormalizedDelayPerPacketConfig