vendor/mio/src/sys/unix/awakener.rs

   1 pub use self::pipe::Awakener;
   2
   3 /// Default awakener backed by a pipe
   4 mod pipe {
   5     use sys::unix;
   6     use {io, Ready, Poll, PollOpt, Token};
   7     use event::Evented;
   8     use std::io::{Read, Write};
   9
  10     /*
  11      *
  12      * ===== Awakener =====
  13      *
  14      */
  15
  16     pub struct Awakener {
  17         reader: unix::Io,
  18         writer: unix::Io,
  19     }
  20
  21     impl Awakener {
  22         pub fn new() -> io::Result<Awakener> {
  23             let (rd, wr) = unix::pipe()?;
  24
  25             Ok(Awakener {
  26                 reader: rd,
  27                 writer: wr,
  28             })
  29         }
  30
  31         pub fn wakeup(&self) -> io::Result<()> {
  32             match (&self.writer).write(&[1]) {
  33                 Ok(_) => Ok(()),
  34                 Err(e) => {
  35                     if e.kind() == io::ErrorKind::WouldBlock {
  36                         Ok(())
  37                     } else {
  38                         Err(e)
  39                     }
  40                 }
  41             }
  42         }
  43
  44         pub fn cleanup(&self) {
  45             let mut buf = [0; 128];
  46
  47             loop {
  48                 // Consume data until all bytes are purged
  49                 match (&self.reader).read(&mut buf) {
  50                     Ok(i) if i > 0 => {},
  51                     _ => return,
  52                 }
  53             }
  54         }
  55
  56         fn reader(&self) -> &unix::Io {
  57             &self.reader
  58         }
  59     }
  60
  61     impl Evented for Awakener {
  62         fn register(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
  63             self.reader().register(poll, token, interest, opts)
  64         }
  65
  66         fn reregister(&self, poll: &Poll, token: Token, interest: Ready, opts: PollOpt) -> io::Result<()> {
  67             self.reader().reregister(poll, token, interest, opts)
  68         }
  69
  70         fn deregister(&self, poll: &Poll) -> io::Result<()> {
  71             self.reader().deregister(poll)
  72         }
  73     }
  74 }