Struct UniformDelayPerPacketConfig 

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

The configuration struct for UniformDelayPerPacket.

See UniformDelayPerPacket for more details.

Fields

upper_bound: Option<Delay>

lower_bound: Option<Delay>

count: usize

seed: Option<u64>

Implementations

impl UniformDelayPerPacketConfig

pub fn new() -> Self

Creates an uninitialized config

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 10ms.

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

Creates a new UniformDelayPerPacket 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, ) -> UniformDelayPerPacket<Rng>

Creates a new UniformDelayPerPacket corresponding to this config.

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

Example

let uniform_delay = UniformDelayPerPacketConfig::new()
    .upper_bound(Delay::from_micros(12100))
    .lower_bound(Delay::from_micros(11900))
    .count(3)
    .seed(42);

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

for cha in [12002810, 11982040, 11919563] {
    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 UniformDelayPerPacketConfig

fn clone(&self) -> UniformDelayPerPacketConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for UniformDelayPerPacketConfig

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

Formats the value using the given formatter.

impl Default for UniformDelayPerPacketConfig

fn default() -> UniformDelayPerPacketConfig

Returns the “default value” for a type.

impl DelayPerPacketTraceConfig for UniformDelayPerPacketConfig

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

impl<'de> Deserialize<'de> for UniformDelayPerPacketConfig

where UniformDelayPerPacketConfig: 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 UniformDelayPerPacketConfig

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

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 UniformDelayPerPacketConfig

impl StructuralPartialEq for UniformDelayPerPacketConfig