Struct Handle

pub struct Handle<E> { /* private fields */ }

A handle to a running service loop.

You can use it to cancel the running loop at the next opportunity (through [Handle::cancel]), or to wait for the loop to terminate (through Handle::wait). You can also use Handle::canceller to get a Canceller handle, which lets you terminate the service loop elsewhere (e.g., while waiting).

Implementations

impl<E> Handle<E>

pub fn canceller(&self) -> Canceller

Get another handle for cancelling the service loop.

This can be handy if you want one thread to wait for the service loop to exit, while another watches for exit signals.

Examples found in repository

examples/basic.rs (line 29)

fn main() {
    let s = Service::new();
    eprintln!("server running");
    let h = s.spawn();
    let exit = h.canceller();
    thread::spawn(move || {
        thread::sleep(time::Duration::from_secs(10));
        eprintln!("server terminating");
        exit.cancel();
    });
    h.wait().unwrap();
    eprintln!("server terminated");
}

pub fn wait(self) -> Result<(), E>

Block the current thread waiting for the service loop to exit, and return its result.

If the service loop returns an error, this method will return it in the Err value. If the service loop panics, this method will also panic with the same error.

Examples found in repository

examples/basic.rs (line 35)

fn main() {
    let s = Service::new();
    eprintln!("server running");
    let h = s.spawn();
    let exit = h.canceller();
    thread::spawn(move || {
        thread::sleep(time::Duration::from_secs(10));
        eprintln!("server terminating");
        exit.cancel();
    });
    h.wait().unwrap();
    eprintln!("server terminated");
}

Methods from Deref<Target = Canceller>

pub fn cancel(&self)

Cancel the currently running service loop. This method does not block; it sends a signal that the service loop should cease execution and returns immediately.

Note that this will not interrupt a currently executing Cancellable::for_each. Instead, the next time Cancellable::for_each would be called, the service loop will return.

Examples found in repository

examples/basic.rs (line 33)

fn main() {
    let s = Service::new();
    eprintln!("server running");
    let h = s.spawn();
    let exit = h.canceller();
    thread::spawn(move || {
        thread::sleep(time::Duration::from_secs(10));
        eprintln!("server terminating");
        exit.cancel();
    });
    h.wait().unwrap();
    eprintln!("server terminated");
}

Trait Implementations

impl<E> Deref for Handle<E>

type Target = Canceller

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.