Struct Delay

pub struct Delay(/* private fields */);

Available on crate feature default only.

Provide the crate::Delay to specify the event for crate::Command execution start.

The default configuration is created with Delay::new providing a crate::DelayKind to specify the event type and parameters for the Delay.

Additionally, the Delay can be created using from*() methods.

• Delay::from(duration)
• Delay::from_tcp_socket(addr)
• Delay::from_udp_request(addr, request)
• Delay::from_path(path)

Examples

Suppose your command needs to start 60 seconds after the benchmark started:

use std::time::Duration;

use iai_callgrind::{Command, Delay, DelayKind};

let command = Command::new(env!("CARGO_BIN_EXE_my-echo")).delay(Delay::new(
    DelayKind::DurationElapse(Duration::from_secs(60)),
));

let command_from =
    Command::new(env!("CARGO_BIN_EXE_my-echo")).delay(Delay::from(Duration::from_secs(60)));

let command_duration =
    Command::new(env!("CARGO_BIN_EXE_my-echo")).delay(Duration::from_secs(60));

However, an iai-callgrind Delay is not limited to a duration, it can be any path creation event, a successful TCP connect or as well a received UDP response.

use iai_callgrind::{Command, Delay, DelayKind};

let command = Command::new("echo").delay(Delay::new(DelayKind::PathExists(
    "/your/path/to/wait/for".into(),
)));

let command_from = Command::new("echo").delay(Delay::from_path("/your/path/to/wait/for"));

use std::net::SocketAddr;
use std::time::Duration;

use iai_callgrind::{Command, Delay, DelayKind};

let command = Command::new("echo").delay(
    Delay::new(DelayKind::TcpConnect(
        "127.0.0.1:31000".parse::<SocketAddr>().unwrap(),
    ))
    .timeout(Duration::from_secs(3))
    .poll(Duration::from_millis(50)),
);

let command_from = Command::new("echo").delay(
    Delay::from_tcp_socket("127.0.0.1:31000".parse::<SocketAddr>().unwrap())
        .timeout(Duration::from_secs(3))
        .poll(Duration::from_millis(50)),
);

use std::net::SocketAddr;
use std::time::Duration;

use iai_callgrind::{Command, Delay, DelayKind};

let command = Command::new("echo").delay(
    Delay::new(DelayKind::UdpResponse(
        "127.0.0.1:34000".parse::<SocketAddr>().unwrap(),
        vec![1],
    ))
    .timeout(Duration::from_secs(3))
    .poll(Duration::from_millis(50)),
);

let command_from = Command::new("echo").delay(
    Delay::from_udp_request("127.0.0.1:34000".parse::<SocketAddr>().unwrap(), vec![1])
        .timeout(Duration::from_secs(3))
        .poll(Duration::from_millis(50)),
);

Implementations

impl Delay

pub fn from_path<T>(path: T) -> Self

where T: Into<PathBuf>,

Instantiate a Delay which will wait until a path exists (Path::exists).

use iai_callgrind::{Command, Delay};

let command = Command::new("echo").delay(Delay::from_path("/your/path/to/wait/for"));

pub fn from_tcp_socket<T>(addr: T) -> Self

where T: Into<SocketAddr>,

Instantiate a Delay which will wait until successful TCP connect (std::net::TcpStream::connect).

use std::net::SocketAddr;

use iai_callgrind::{Command, Delay};

let command = Command::new("echo").delay(Delay::from_tcp_socket(
    "127.0.0.1:31000".parse::<SocketAddr>().unwrap(),
));

pub fn from_udp_request<T, U>(addr: T, req: U) -> Self

where T: Into<SocketAddr>, U: Into<Vec<u8>>,

Instantiate a Delay which will wait until a UDP response is received after sending the UDP request. The poll duration is also used as the reconnect and request resend interval. (std::net::UdpSocket::bind, std::net::UdpSocket::connect, std::net::UdpSocket::recv).

use std::net::SocketAddr;

use iai_callgrind::{Command, Delay};

let command = Command::new("echo").delay(Delay::from_udp_request(
    "127.0.0.1:34000".parse::<SocketAddr>().unwrap(),
    vec![1],
));

pub fn new(kind: DelayKind) -> Self

Instantiate a Delay waiting until an event has happened.

The possible events are defined in DelayKind.

use std::time::Duration;

use iai_callgrind::{Command, Delay, DelayKind};

let command = Command::new("echo").delay(Delay::new(DelayKind::DurationElapse(
    Duration::from_secs(15),
)));

pub fn poll<T: Into<Duration>>(self, duration: T) -> Self

Update the Delay poll interval.

The poll interval should be considered together with the Delay::timeout, and ideally should have a value of n * timeout duration.

In case the poll interval is set to a value >= timeout duration it is attempted to set the poll interval to a value of timeout duration - 5ms.

use std::net::SocketAddr;
use std::time::Duration;

use iai_callgrind::{Command, Delay};

let command = Command::new("echo").delay(
    Delay::from_udp_request("127.0.0.1:34000".parse::<SocketAddr>().unwrap(), vec![1])
        .poll(Duration::from_millis(150)),
);

pub fn timeout<T: Into<Duration>>(self, duration: T) -> Self

Update the Delay timeout interval.

The timeout duration should be considered together with the poll interval. For further details please refer to Delay::poll. The minimum timeout duration is 10ms.

use std::net::SocketAddr;
use std::time::Duration;

use iai_callgrind::{Command, Delay};
let command = Command::new("echo").delay(
    Delay::from_tcp_socket("127.0.0.1:31000".parse::<SocketAddr>().unwrap())
        .timeout(Duration::from_secs(5)),
);

Trait Implementations

impl AsRef<Delay> for Delay

fn as_ref(&self) -> &InternalDelay

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Delay

fn clone(&self) -> Delay

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Delay

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

Formats the value using the given formatter.

impl Default for Delay

fn default() -> Delay

Returns the “default value” for a type.

impl From<&Delay> for InternalDelay

fn from(value: &Delay) -> Self

Converts to this type from the input type.

impl From<&mut Delay> for InternalDelay

fn from(value: &mut Delay) -> Self

Converts to this type from the input type.

impl From<Delay> for InternalDelay

fn from(value: Delay) -> Self

Converts to this type from the input type.

impl<T> From<T> for Delay

where T: Into<Duration>,

fn from(duration: T) -> Self

Instantiate a Delay which will wait until the duration has elapsed.

use std::time::Duration;

use iai_callgrind::{Command, Delay};

let command = Command::new("echo").delay(Delay::from(Duration::from_secs(10)));

impl PartialEq for Delay

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