Struct signal_hook::iterator::Signals

pub struct Signals { /* fields omitted */ }

The main structure of the module, representing interest in some signals.

Unlike the helpers in other modules, this registers the signals when created and unregisters them on drop. It provides the pending signals during its lifetime, either in batches or as an infinite iterator.

Multiple consumers

You may have noticed this structure can be used simultaneously by multiple threads. If it is done, a signal arrives to one of the threads (on the first come, first serve basis). The signal is not broadcasted to all currently active threads.

Examples

let signals = signal_hook::iterator::Signals::new(&[libc::SIGUSR1, libc::SIGUSR2])?;
thread::spawn(move || {
    for signal in &signals {
        match signal {
            libc::SIGUSR1 => {},
            libc::SIGUSR2 => {},
            _ => unreachable!(),
        }
    }
});

Methods

impl Signals

pub fn new<I, S>(signals: I) -> Result<Self, Error> where     I: IntoIterator<Item = S>,     S: Borrow<c_int>,

Creates the Signals structure.

This registers all the signals listed. The same restrictions (panics, errors) apply as with register.

Important traits for Pending<'a>

impl<'a> Iterator for Pending<'a> type Item = c_int;

pub fn pending(&self) -> Pending

Returns an iterator of already received signals.

This returns an iterator over all the signal numbers of the signals received since last time they were read (out of the set registered by this Signals instance). Note that they are returned in arbitrary order and a signal number is returned only once even if it was received multiple times.

This method returns immediately (does not block) and may produce an empty iterator if there are no signals ready.

Important traits for Pending<'a>

impl<'a> Iterator for Pending<'a> type Item = c_int;

pub fn wait(&self) -> Pending

Waits for some signals to be available and returns an iterator.

This is similar to pending. If there are no signals available, it tries to wait for some to arrive. However, due to implementation details, this still can produce an empty iterator.

This can block for arbitrary length.

Note that the blocking is done in this method, not in the iterator.

Important traits for Forever<'a>

impl<'a> Iterator for Forever<'a> type Item = c_int;

pub fn forever(&self) -> Forever

Returns an infinite iterator over arriving signals.

The iterator's next() blocks as necessary to wait for signals to arrive. This is adequate if you want to designate a thread solely to handling signals. If multiple signals come at the same time (between two values produced by the iterator), they will be returned in arbitrary order. Multiple instances of the same signal may be collated.

This is also the iterator returned by IntoIterator implementation on &Signals.

Examples

let signals = signal_hook::iterator::Signals::new(&[libc::SIGUSR1, libc::SIGUSR2])?;
thread::spawn(move || {
    for signal in signals.forever() {
        match signal {
            libc::SIGUSR1 => {},
            libc::SIGUSR2 => {},
            _ => unreachable!(),
        }
    }
});

Trait Implementations

impl Clone for Signals

fn clone(&self) -> Signals

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Signals

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

Formats the value using the given formatter.

impl Drop for Signals

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> IntoIterator for &'a Signals

type Item = c_int

The type of the elements being iterated over.

type IntoIter = Forever<'a>

Which kind of iterator are we turning this into?

Important traits for Forever<'a>

impl<'a> Iterator for Forever<'a> type Item = c_int;

fn into_iter(self) -> Forever<'a>

Creates an iterator from a value.