Struct StatusExecutor

pub struct StatusExecutor<T, S> { /* private fields */ }

A StatusExecutor runs a function in some Context (this will usually be a thread)

For the general behaviour, see Executor.

StatusExecutor additionally takes a Status S (which has to be Send + 'static for the underlying channel). This status can then be updated from within the work function.

Implementations

impl<T, S> StatusExecutor<T, S>

where T: Send + Sync + 'static, S: Send + Clone + 'static,

pub fn new<E, F>(e: E, f: F) -> Self

where F: FnOnce(StatusSender<S>) -> T + Send + 'static, E: Context,

Run f in the Execution context _e, creating an Executor

Arguments

• e: The context to run on. For StdContext or RayonGlobalContext you can just use ::default(), they are stateless.
• f: The function to run. f must be FnOnce + Send + 'static - as if you would pass it to std::thread::spawn

Additionally, f takes a StatusSender<S> that can be use to update the status.

Examples found in repository

examples/with_panic.rs (line 12)

fn main() {
    let e1 = StatusExecutor::new(StdContext::default(), takes_a_while);
    std::thread::sleep(std::time::Duration::from_millis(100));
    let e2 = StatusExecutor::new(StdContext::default(), takes_a_while);

    while !e1.is_done() || !e2.is_done() {
        if let Some(s) = e1.status() {
            println!("E1: {}", s);
        }
        if let Some(s) = e2.status() {
            println!("E2: {}", s);
        }
    }

    println!(
        "E1: {} - {}",
        e1.latest_status().unwrap(),
        e1.take_result().unwrap()
    );
    println!(
        "E2: {} - {}",
        e2.latest_status().unwrap(),
        e2.take_result().unwrap()
    );
}

examples/with_std.rs (line 13)

fn main() {
    let e1 = StatusExecutor::new(StdContext::default(), takes_a_while);
    std::thread::sleep(std::time::Duration::from_millis(100));
    let e2 = StatusExecutor::new(StdContext::default(), takes_a_while);

    while !e1.is_done() || !e2.is_done() {
        if let Some(s) = e1.status() {
            println!("E1: {}", s);
        }
        if let Some(s) = e2.status() {
            println!("E2: {}", s);
        }
    }

    println!(
        "E1: {} - {}",
        e1.latest_status().unwrap(),
        e1.take_result().unwrap()
    );
    println!(
        "E2: {} - {}",
        e2.latest_status().unwrap(),
        e2.take_result().unwrap()
    );
}

pub fn is_done(&self) -> bool

Returns true if the function passed into StatusExecutor::new() has completed

Examples found in repository

examples/with_panic.rs (line 16)

fn main() {
    let e1 = StatusExecutor::new(StdContext::default(), takes_a_while);
    std::thread::sleep(std::time::Duration::from_millis(100));
    let e2 = StatusExecutor::new(StdContext::default(), takes_a_while);

    while !e1.is_done() || !e2.is_done() {
        if let Some(s) = e1.status() {
            println!("E1: {}", s);
        }
        if let Some(s) = e2.status() {
            println!("E2: {}", s);
        }
    }

    println!(
        "E1: {} - {}",
        e1.latest_status().unwrap(),
        e1.take_result().unwrap()
    );
    println!(
        "E2: {} - {}",
        e2.latest_status().unwrap(),
        e2.take_result().unwrap()
    );
}

examples/with_std.rs (line 17)

fn main() {
    let e1 = StatusExecutor::new(StdContext::default(), takes_a_while);
    std::thread::sleep(std::time::Duration::from_millis(100));
    let e2 = StatusExecutor::new(StdContext::default(), takes_a_while);

    while !e1.is_done() || !e2.is_done() {
        if let Some(s) = e1.status() {
            println!("E1: {}", s);
        }
        if let Some(s) = e2.status() {
            println!("E2: {}", s);
        }
    }

    println!(
        "E1: {} - {}",
        e1.latest_status().unwrap(),
        e1.take_result().unwrap()
    );
    println!(
        "E2: {} - {}",
        e2.latest_status().unwrap(),
        e2.take_result().unwrap()
    );
}

pub fn result(&self) -> Option<Arc<T>>

Returns Some(Arc<T>) if the function passed into StatusExecutor::new() has completed, or None otherwise

pub fn take_result(self) -> Option<T>

Consumes this Executor, returning either Some(T) if the executor has completed, or None if it has not.

There is no way to retrieve the data if you call this before the work function is done. So you probably only want to only `Executor::take()` if `Executor::is_done()` returnd true before.

StatusSender::send will begin to return false if you take before the execution is done, so you could abort processing that way.

Examples found in repository

examples/with_panic.rs (line 28)

fn main() {
    let e1 = StatusExecutor::new(StdContext::default(), takes_a_while);
    std::thread::sleep(std::time::Duration::from_millis(100));
    let e2 = StatusExecutor::new(StdContext::default(), takes_a_while);

    while !e1.is_done() || !e2.is_done() {
        if let Some(s) = e1.status() {
            println!("E1: {}", s);
        }
        if let Some(s) = e2.status() {
            println!("E2: {}", s);
        }
    }

    println!(
        "E1: {} - {}",
        e1.latest_status().unwrap(),
        e1.take_result().unwrap()
    );
    println!(
        "E2: {} - {}",
        e2.latest_status().unwrap(),
        e2.take_result().unwrap()
    );
}

examples/with_std.rs (line 29)

fn main() {
    let e1 = StatusExecutor::new(StdContext::default(), takes_a_while);
    std::thread::sleep(std::time::Duration::from_millis(100));
    let e2 = StatusExecutor::new(StdContext::default(), takes_a_while);

    while !e1.is_done() || !e2.is_done() {
        if let Some(s) = e1.status() {
            println!("E1: {}", s);
        }
        if let Some(s) = e2.status() {
            println!("E2: {}", s);
        }
    }

    println!(
        "E1: {} - {}",
        e1.latest_status().unwrap(),
        e1.take_result().unwrap()
    );
    println!(
        "E2: {} - {}",
        e2.latest_status().unwrap(),
        e2.take_result().unwrap()
    );
}

pub fn status(&self) -> Option<S>

Returns a status Some(S) if there are any status infos pending, or None if there isn’t anything new.

Examples found in repository

examples/with_panic.rs (line 17)

fn main() {
    let e1 = StatusExecutor::new(StdContext::default(), takes_a_while);
    std::thread::sleep(std::time::Duration::from_millis(100));
    let e2 = StatusExecutor::new(StdContext::default(), takes_a_while);

    while !e1.is_done() || !e2.is_done() {
        if let Some(s) = e1.status() {
            println!("E1: {}", s);
        }
        if let Some(s) = e2.status() {
            println!("E2: {}", s);
        }
    }

    println!(
        "E1: {} - {}",
        e1.latest_status().unwrap(),
        e1.take_result().unwrap()
    );
    println!(
        "E2: {} - {}",
        e2.latest_status().unwrap(),
        e2.take_result().unwrap()
    );
}

examples/with_std.rs (line 18)

fn main() {
    let e1 = StatusExecutor::new(StdContext::default(), takes_a_while);
    std::thread::sleep(std::time::Duration::from_millis(100));
    let e2 = StatusExecutor::new(StdContext::default(), takes_a_while);

    while !e1.is_done() || !e2.is_done() {
        if let Some(s) = e1.status() {
            println!("E1: {}", s);
        }
        if let Some(s) = e2.status() {
            println!("E2: {}", s);
        }
    }

    println!(
        "E1: {} - {}",
        e1.latest_status().unwrap(),
        e1.take_result().unwrap()
    );
    println!(
        "E2: {} - {}",
        e2.latest_status().unwrap(),
        e2.take_result().unwrap()
    );
}

pub fn latest_status(&self) -> Option<S>

Checks for a new status and returns the latest one it has seen. Similar to StatusExecutor::status, but will always return something.

Technically, since this is using try_iter, you could produce status faster than consuming them with this function Then it would block. However, for latest_status to be slower than a producer, the producer would basically have to call send() in an infinite loop That’s not an intended use case, so its deemed an acceptable issue.

Examples found in repository

examples/with_panic.rs (line 27)

fn main() {
    let e1 = StatusExecutor::new(StdContext::default(), takes_a_while);
    std::thread::sleep(std::time::Duration::from_millis(100));
    let e2 = StatusExecutor::new(StdContext::default(), takes_a_while);

    while !e1.is_done() || !e2.is_done() {
        if let Some(s) = e1.status() {
            println!("E1: {}", s);
        }
        if let Some(s) = e2.status() {
            println!("E2: {}", s);
        }
    }

    println!(
        "E1: {} - {}",
        e1.latest_status().unwrap(),
        e1.take_result().unwrap()
    );
    println!(
        "E2: {} - {}",
        e2.latest_status().unwrap(),
        e2.take_result().unwrap()
    );
}

examples/with_std.rs (line 28)

fn main() {
    let e1 = StatusExecutor::new(StdContext::default(), takes_a_while);
    std::thread::sleep(std::time::Duration::from_millis(100));
    let e2 = StatusExecutor::new(StdContext::default(), takes_a_while);

    while !e1.is_done() || !e2.is_done() {
        if let Some(s) = e1.status() {
            println!("E1: {}", s);
        }
        if let Some(s) = e2.status() {
            println!("E2: {}", s);
        }
    }

    println!(
        "E1: {} - {}",
        e1.latest_status().unwrap(),
        e1.take_result().unwrap()
    );
    println!(
        "E2: {} - {}",
        e2.latest_status().unwrap(),
        e2.take_result().unwrap()
    );
}