| use token::Token; |
| use std::{fmt, ops}; |
| |
| #[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord)] |
| pub struct PollOpt(usize); |
| |
| impl PollOpt { |
| #[inline] |
| pub fn edge() -> PollOpt { |
| PollOpt(0x020) |
| } |
| |
| #[inline] |
| pub fn empty() -> PollOpt { |
| PollOpt(0) |
| } |
| |
| #[inline] |
| pub fn level() -> PollOpt { |
| PollOpt(0x040) |
| } |
| |
| #[inline] |
| pub fn oneshot() -> PollOpt { |
| PollOpt(0x080) |
| } |
| |
| #[inline] |
| pub fn all() -> PollOpt { |
| PollOpt::edge() | PollOpt::level() | PollOpt::oneshot() |
| } |
| |
| #[inline] |
| pub fn is_edge(&self) -> bool { |
| self.contains(PollOpt::edge()) |
| } |
| |
| #[inline] |
| pub fn is_level(&self) -> bool { |
| self.contains(PollOpt::level()) |
| } |
| |
| #[inline] |
| pub fn is_oneshot(&self) -> bool { |
| self.contains(PollOpt::oneshot()) |
| } |
| |
| #[inline] |
| pub fn bits(&self) -> usize { |
| self.0 |
| } |
| |
| #[inline] |
| pub fn contains(&self, other: PollOpt) -> bool { |
| (*self & other) == other |
| } |
| |
| #[inline] |
| pub fn insert(&mut self, other: PollOpt) { |
| self.0 |= other.0; |
| } |
| |
| #[inline] |
| pub fn remove(&mut self, other: PollOpt) { |
| self.0 &= !other.0; |
| } |
| } |
| |
| impl ops::BitOr for PollOpt { |
| type Output = PollOpt; |
| |
| #[inline] |
| fn bitor(self, other: PollOpt) -> PollOpt { |
| PollOpt(self.bits() | other.bits()) |
| } |
| } |
| |
| impl ops::BitXor for PollOpt { |
| type Output = PollOpt; |
| |
| #[inline] |
| fn bitxor(self, other: PollOpt) -> PollOpt { |
| PollOpt(self.bits() ^ other.bits()) |
| } |
| } |
| |
| impl ops::BitAnd for PollOpt { |
| type Output = PollOpt; |
| |
| #[inline] |
| fn bitand(self, other: PollOpt) -> PollOpt { |
| PollOpt(self.bits() & other.bits()) |
| } |
| } |
| |
| impl ops::Sub for PollOpt { |
| type Output = PollOpt; |
| |
| #[inline] |
| fn sub(self, other: PollOpt) -> PollOpt { |
| PollOpt(self.bits() & !other.bits()) |
| } |
| } |
| |
| impl ops::Not for PollOpt { |
| type Output = PollOpt; |
| |
| #[inline] |
| fn not(self) -> PollOpt { |
| PollOpt(!self.bits() & PollOpt::all().bits()) |
| } |
| } |
| |
| impl fmt::Debug for PollOpt { |
| fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| let mut one = false; |
| let flags = [ |
| (PollOpt::edge(), "Edge-Triggered"), |
| (PollOpt::level(), "Level-Triggered"), |
| (PollOpt::oneshot(), "OneShot")]; |
| |
| for &(flag, msg) in flags.iter() { |
| if self.contains(flag) { |
| if one { try!(write!(fmt, " | ")) } |
| try!(write!(fmt, "{}", msg)); |
| |
| one = true |
| } |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| #[derive(Copy, PartialEq, Eq, Clone, PartialOrd, Ord)] |
| pub struct EventSet(usize); |
| |
| impl EventSet { |
| pub fn none() -> EventSet { |
| EventSet(0) |
| } |
| |
| #[inline] |
| pub fn readable() -> EventSet { |
| EventSet(0x001) |
| } |
| |
| #[inline] |
| pub fn writable() -> EventSet { |
| EventSet(0x002) |
| } |
| |
| #[inline] |
| pub fn error() -> EventSet { |
| EventSet(0x004) |
| } |
| |
| #[inline] |
| pub fn hup() -> EventSet { |
| EventSet(0x008) |
| } |
| |
| #[inline] |
| pub fn all() -> EventSet { |
| EventSet::readable() | |
| EventSet::writable() | |
| EventSet::hup() | |
| EventSet::error() |
| } |
| |
| #[inline] |
| pub fn is_readable(&self) -> bool { |
| self.contains(EventSet::readable()) |
| } |
| |
| #[inline] |
| pub fn is_writable(&self) -> bool { |
| self.contains(EventSet::writable()) |
| } |
| |
| #[inline] |
| pub fn is_error(&self) -> bool { |
| self.contains(EventSet::error()) |
| } |
| |
| #[inline] |
| pub fn is_hup(&self) -> bool { |
| self.contains(EventSet::hup()) |
| } |
| |
| #[inline] |
| pub fn insert(&mut self, other: EventSet) { |
| self.0 |= other.0; |
| } |
| |
| #[inline] |
| pub fn remove(&mut self, other: EventSet) { |
| self.0 &= !other.0; |
| } |
| |
| #[inline] |
| pub fn bits(&self) -> usize { |
| self.0 |
| } |
| |
| #[inline] |
| pub fn contains(&self, other: EventSet) -> bool { |
| (*self & other) == other |
| } |
| } |
| |
| impl ops::BitOr for EventSet { |
| type Output = EventSet; |
| |
| #[inline] |
| fn bitor(self, other: EventSet) -> EventSet { |
| EventSet(self.bits() | other.bits()) |
| } |
| } |
| |
| impl ops::BitXor for EventSet { |
| type Output = EventSet; |
| |
| #[inline] |
| fn bitxor(self, other: EventSet) -> EventSet { |
| EventSet(self.bits() ^ other.bits()) |
| } |
| } |
| |
| impl ops::BitAnd for EventSet { |
| type Output = EventSet; |
| |
| #[inline] |
| fn bitand(self, other: EventSet) -> EventSet { |
| EventSet(self.bits() & other.bits()) |
| } |
| } |
| |
| impl ops::Sub for EventSet { |
| type Output = EventSet; |
| |
| #[inline] |
| fn sub(self, other: EventSet) -> EventSet { |
| EventSet(self.bits() & !other.bits()) |
| } |
| } |
| |
| impl ops::Not for EventSet { |
| type Output = EventSet; |
| |
| #[inline] |
| fn not(self) -> EventSet { |
| EventSet(!self.bits() & EventSet::all().bits()) |
| } |
| } |
| |
| impl fmt::Debug for EventSet { |
| fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { |
| let mut one = false; |
| let flags = [ |
| (EventSet::readable(), "Readable"), |
| (EventSet::writable(), "Writable"), |
| (EventSet::error(), "Error"), |
| (EventSet::hup(), "Hup")]; |
| |
| for &(flag, msg) in flags.iter() { |
| if self.contains(flag) { |
| if one { try!(write!(fmt, " | ")) } |
| try!(write!(fmt, "{}", msg)); |
| |
| one = true |
| } |
| } |
| |
| Ok(()) |
| } |
| } |
| |
| |
| // Keep this struct internal to mio |
| #[derive(Copy, Clone, Debug)] |
| pub struct IoEvent { |
| pub kind: EventSet, |
| pub token: Token |
| } |
| |
| /// IoEvent represents the raw event that the OS-specific selector |
| /// returned. An event can represent more than one kind (such as |
| /// readable or writable) at a time. |
| /// |
| /// These IoEvent objects are created by the OS-specific concrete |
| /// Selector when they have events to report. |
| impl IoEvent { |
| /// Create a new IoEvent. |
| pub fn new(kind: EventSet, token: Token) -> IoEvent { |
| IoEvent { |
| kind: kind, |
| token: token, |
| } |
| } |
| } |