#![doc(test(attr(deny(warnings))))]
#![warn(missing_docs)]
#![cfg_attr(docsrs, feature(doc_cfg))]
#[cfg(any(feature = "support-v0_6", feature = "support-v0_7"))]
macro_rules! implement_signals_with_pipe {
($pipe:path) => {
use std::borrow::Borrow;
use std::io::Error;
use signal_hook::iterator::backend::{self, SignalDelivery};
use signal_hook::iterator::exfiltrator::{Exfiltrator, SignalOnly};
use $pipe as Pipe;
use libc::c_int;
pub struct SignalsInfo<E: Exfiltrator = SignalOnly>(SignalDelivery<Pipe, E>);
pub use backend::Pending;
impl<E: Exfiltrator> SignalsInfo<E> {
pub fn new<I, S>(signals: I) -> Result<Self, Error>
where
I: IntoIterator<Item = S>,
S: Borrow<c_int>,
E: Default,
{
Self::with_exfiltrator(signals, E::default())
}
pub fn with_exfiltrator<I, S>(signals: I, exfiltrator: E) -> Result<Self, Error>
where
I: IntoIterator<Item = S>,
S: Borrow<c_int>,
{
let (read, write) = Pipe::pair()?;
let delivery = SignalDelivery::with_pipe(read, write, exfiltrator, signals)?;
Ok(Self(delivery))
}
pub fn add_signal(&self, signal: c_int) -> Result<(), Error> {
self.0.handle().add_signal(signal)
}
pub fn pending(&mut self) -> Pending<E> {
self.0.pending()
}
}
pub type Signals = SignalsInfo<SignalOnly>;
};
}
#[cfg(feature = "support-v0_7")]
pub mod v0_7 {
use mio::event::Source;
use mio::{Interest, Registry, Token};
use mio_0_7 as mio;
implement_signals_with_pipe!(mio::net::UnixStream);
impl Source for Signals {
fn register(
&mut self,
registry: &Registry,
token: Token,
interest: Interest,
) -> Result<(), Error> {
self.0.get_read_mut().register(registry, token, interest)
}
fn reregister(
&mut self,
registry: &Registry,
token: Token,
interest: Interest,
) -> Result<(), Error> {
self.0.get_read_mut().reregister(registry, token, interest)
}
fn deregister(&mut self, registry: &Registry) -> Result<(), Error> {
self.0.get_read_mut().deregister(registry)
}
}
}
#[cfg(feature = "support-v0_6")]
pub mod v0_6 {
use mio::event::Evented;
use mio::{Poll, PollOpt, Ready, Token};
use mio_0_6 as mio;
implement_signals_with_pipe!(mio_uds::UnixStream);
impl Evented for Signals {
fn register(
&self,
poll: &Poll,
token: Token,
interest: Ready,
opts: PollOpt,
) -> Result<(), Error> {
self.0.get_read().register(poll, token, interest, opts)
}
fn reregister(
&self,
poll: &Poll,
token: Token,
interest: Ready,
opts: PollOpt,
) -> Result<(), Error> {
self.0.get_read().reregister(poll, token, interest, opts)
}
fn deregister(&self, poll: &Poll) -> Result<(), Error> {
self.0.get_read().deregister(poll)
}
}
}