Struct Robot

pub struct Robot<T> {
    pub transport: T,
}

Fields

transport: T

Implementations

impl<T: Transport> Robot<T>

pub fn new(transport: T) -> Self

Examples found in repository

examples/latency.rs (line 18)

fn main() -> Result<()> {
    // roblib_client::logger::init_log(Some("roblib_client=debug")); // uncomment if you want to spam the terminal

    let ip = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "localhost:1111".into());

    let robot = Robot::new(Tcp::connect(ip)?);

    // boring arg parsing
    let mut args = args().skip(1);

    let runs = args
        .next()
        .unwrap_or_else(|| NO_OF_RUNS.to_string())
        .parse()
        .unwrap_or(NO_OF_RUNS);

    let wait_ms = args
        .next()
        .unwrap_or_else(|| WAIT_MS.to_string())
        .parse()
        .unwrap_or(WAIT_MS);

    println!("Starting test with {runs} runs, in intervals of {wait_ms}ms",);

    let start = Instant::now();
    let mut v = Vec::with_capacity(runs);

    for _ in 0..runs {
        let r = robot.measure_latency()?.as_secs_f64();
        v.push(r);
        sleep(Duration::from_millis(wait_ms));
    }

    let sum = v.iter().sum::<f64>();
    let min = v
        .iter()
        .copied()
        .reduce(f64::min)
        .expect("results contained NaN");
    let max = v
        .iter()
        .copied()
        .reduce(f64::max)
        .expect("results contained NaN");

    let avg = sum / v.len() as f64;
    let dur = Instant::now().duration_since(start).as_millis() as f64 / 1000f64;

    println!(
        "Results:\n{v:?}\nRuns: {runs}\nTime elapsed: {dur}s\nMin: {min:.3}ms\nMax: {max:.3}ms\nAverage: {avg:.3}ms",
        v=v.iter().map(|n|format!("{n:.3}").parse().unwrap()).collect::<Vec<f64>>()
    );

    Ok(())
}

pub fn measure_latency(&self) -> Result<Duration>

Examples found in repository

examples/latency.rs (line 41)

fn main() -> Result<()> {
    // roblib_client::logger::init_log(Some("roblib_client=debug")); // uncomment if you want to spam the terminal

    let ip = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "localhost:1111".into());

    let robot = Robot::new(Tcp::connect(ip)?);

    // boring arg parsing
    let mut args = args().skip(1);

    let runs = args
        .next()
        .unwrap_or_else(|| NO_OF_RUNS.to_string())
        .parse()
        .unwrap_or(NO_OF_RUNS);

    let wait_ms = args
        .next()
        .unwrap_or_else(|| WAIT_MS.to_string())
        .parse()
        .unwrap_or(WAIT_MS);

    println!("Starting test with {runs} runs, in intervals of {wait_ms}ms",);

    let start = Instant::now();
    let mut v = Vec::with_capacity(runs);

    for _ in 0..runs {
        let r = robot.measure_latency()?.as_secs_f64();
        v.push(r);
        sleep(Duration::from_millis(wait_ms));
    }

    let sum = v.iter().sum::<f64>();
    let min = v
        .iter()
        .copied()
        .reduce(f64::min)
        .expect("results contained NaN");
    let max = v
        .iter()
        .copied()
        .reduce(f64::max)
        .expect("results contained NaN");

    let avg = sum / v.len() as f64;
    let dur = Instant::now().duration_since(start).as_millis() as f64 / 1000f64;

    println!(
        "Results:\n{v:?}\nRuns: {runs}\nTime elapsed: {dur}s\nMin: {min:.3}ms\nMax: {max:.3}ms\nAverage: {avg:.3}ms",
        v=v.iter().map(|n|format!("{n:.3}").parse().unwrap()).collect::<Vec<f64>>()
    );

    Ok(())
}

pub fn get_server_uptime(&self) -> Result<Duration>

impl<T: Subscribable> Robot<T>

pub fn subscribe<E: Event>( &self, ev: E, handler: impl FnMut(E::Item) -> Result<()> + Send + Sync + 'static, ) -> Result<()>

pub fn unsubscribe<E: Event>(&self, ev: E) -> Result<()>

Trait Implementations

impl<T: Transport> RoblibBuiltin for Robot<T>

fn nop(&self) -> Result<()>

fn get_uptime(&self) -> Result<Duration>

fn abort(&self) -> Result<()>