broke io::read/write out into non-buffering and buffering solutions

.gitignore

@@ -1,3 +1,4 @@
 Cargo.lock
 target
 libs
+.*.sw*

Cargo.toml

@@ -8,6 +8,10 @@ authors = ["Carl Lerche <me@carllerche.com>"]
 
 git = "https://github.com/carllerche/nix-rust"
 
+[dependencies.time]
+
+git = "https://github.com/rust-lang/time"
+
 [[test]]
 
 name = "test"

src/error.rs

@@ -5,7 +5,7 @@ pub type MioResult<T> = Result<T, MioError>;
 
 #[deriving(Show, PartialEq, Clone)]
 pub struct MioError {
-    kind: MioErrorKind,
+    pub kind: MioErrorKind,
     sys: Option<SysError>
 }
 

src/event_ctx.rs

@@ -0,0 +1,171 @@
+use std::fmt;
+use token::Token;
+use handler::{ReadHint, DATAHINT, HUPHINT, ERRORHINT};
+
+
+bitflags!(
+          flags IoEventKind: uint {
+          const IOREADABLE = 0x001,
+          const IOWRITABLE = 0x002,
+          const IOERROR    = 0x004,
+          const IOHUPHINT  = 0x008,
+          const IOHINTED   = 0x010,
+          const IOONESHOT  = 0x020,
+          const IOEDGE     = 0x040,
+          const IOLEVEL    = 0x080,
+          const IOALL      = 0x001 | 0x002 | 0x004 | 0x008 
+          }
+         )
+
+impl fmt::Show for IoEventKind {
+  fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+    let mut one = false;
+    let flags = [
+      (IOREADABLE, "IoReadable"),
+      (IOWRITABLE, "IoWritable"),
+      (IOERROR, "IoError"),
+      (IOHUPHINT, "IoHupHint"),
+      (IOHINTED, "IoHinted"),
+      (IOEDGE, "IoEdgeTriggered")];
+
+    for &(flag, msg) in flags.iter() {
+      if self.contains(flag) {
+        if one { try!(write!(fmt, " | ")) }
+        try!(write!(fmt, "{}", msg));
+
+        one = true
+      }
+    }
+
+    Ok(())
+  }
+}
+
+#[deriving(Show)]
+pub struct IoEventCtx {
+kind: IoEventKind,
+        token: Token
+}
+
+/// IoEventCtx represents the raw event upon which the OS-specific selector
+/// operates. It takes an IoEventCtx when registering and re-registering event
+/// interest for Tokens. It also returns IoEventCtx when calling handlers. 
+/// An event can represent more than one kind (such as readable or writable) at a time.
+///
+/// These IoEventCtx objects are created by the OS-specific concrete
+/// Selector when they have events to report.
+impl IoEventCtx {
+  /// Create a new IoEvent.
+  pub fn new(kind: IoEventKind, token: Token) -> IoEventCtx {
+    IoEventCtx {
+        kind: kind, 
+        token: token
+    }
+  }
+
+  pub fn token(&self) -> Token {
+    self.token
+  }
+
+  /// Return an optional hint for a readable IO handle. Currently,
+  /// this method supports the HupHint, which indicates that the
+  /// kernel reported that the remote side hung up. This allows a
+  /// consumer to avoid reading in order to discover the hangup.
+  pub fn read_hint(&self) -> ReadHint {
+    let mut hint = ReadHint::empty();
+
+    // The backend doesn't support hinting
+    if !self.kind.contains(IOHINTED) {
+      return hint;
+    }
+
+    if self.kind.contains(IOHUPHINT) {
+      hint = hint | HUPHINT
+    }
+
+    if self.kind.contains(IOREADABLE) {
+      hint = hint | DATAHINT
+    }
+
+    if self.kind.contains(IOERROR) {
+      hint = hint | ERRORHINT
+    }
+
+    hint
+  }
+
+  /// This event indicated that the IO handle is now readable
+  pub fn is_readable(&self) -> bool {
+    self.kind.contains(IOREADABLE) || self.kind.contains(IOHUPHINT)
+  }
+
+  /// This event indicated that the IO handle is now writable
+  pub fn is_writable(&self) -> bool {
+    self.kind.contains(IOWRITABLE)
+  }
+
+  /// This event indicated that the IO handle had an error
+  pub fn is_error(&self) -> bool {
+    self.kind.contains(IOERROR)
+  }
+
+  pub fn is_hangup(&self) -> bool {
+    self.kind.contains(IOHUPHINT)
+  }
+
+  pub fn is_edge_triggered(&self) -> bool {
+    self.kind.contains(IOEDGE)
+  }
+
+  /// This event indicated that the IO handle is now readable
+  pub fn set_readable(&mut self, flag: bool) -> &IoEventCtx {
+    match flag {
+      true => self.kind.insert(IOREADABLE),
+      false => self.kind.remove(IOREADABLE)
+    }
+    return self;
+  }
+
+  /// This event indicated that the IO handle is now writable
+  pub fn set_writable(&mut self, flag: bool) -> &IoEventCtx { 
+    match flag {
+      true => self.kind.insert(IOWRITABLE),
+      false => self.kind.remove(IOWRITABLE)
+    }
+    return self;
+  }
+
+  /// This event indicated that the IO handle had an error
+  pub fn set_error(&mut self, flag: bool) -> &IoEventCtx {
+    match flag {
+      true => self.kind.insert(IOERROR),
+      false => self.kind.remove(IOERROR)
+    }
+    return self;
+  }
+
+  pub fn set_hangup(&mut self, flag: bool) -> &IoEventCtx {
+    match flag {
+      true => self.kind.insert(IOHUPHINT),
+      false => self.kind.remove(IOHUPHINT)
+    }
+    return self;
+  }
+
+  pub fn set_edge_triggered(&mut self, flag: bool) -> &IoEventCtx {
+    match flag {
+      true => self.kind.insert(IOEDGE),
+      false => self.kind.remove(IOEDGE)
+    }
+    return self;
+  }
+
+  pub fn set_all(&mut self, flag: bool) -> &IoEventCtx {
+    match flag {
+      true => self.kind.insert(IOALL),
+      false => self.kind.remove(IOALL)
+    }
+    return self;
+  }
+}
+

src/event_loop.rs

@@ -3,12 +3,12 @@ use std::uint;
 use error::{MioResult, MioError};
 use handler::Handler;
 use io::IoHandle;
-use net::{Socket, SockAddr};
 use notify::Notify;
-use os;
-use poll::{Poll, IoEvent};
+use poll::Poll;
 use timer::{Timer, Timeout, TimerResult};
 use token::Token;
+use event_ctx::IoEventCtx;
+use event_ctx as evt;
 
 /// A lightweight event loop.
 ///
@@ -73,7 +73,8 @@ impl<T, M: Send> EventLoop<T, M> {
         let notify = try!(Notify::with_capacity(config.notify_capacity));
 
         // Register the notification wakeup FD with the IO poller
-        try!(poll.register(&notify, NOTIFY));
+        let ctx = evt::IoEventCtx::new(evt::IOREADABLE, NOTIFY);
+        try!(poll.register(&notify, &ctx));
 
         // Set the timer's starting time reference point
         timer.setup();
@@ -112,32 +113,13 @@ impl<T, M: Send> EventLoop<T, M> {
     }
 
     /// Registers an IO handle with the event loop.
-    pub fn register<H: IoHandle>(&mut self, io: &H, token: Token) -> MioResult<()> {
-        self.poll.register(io, token)
+    pub fn register<H: IoHandle>(&mut self, io: &H, eventctx: &IoEventCtx) -> MioResult<()> {
+        self.poll.register(io, eventctx)
     }
 
-    /// Connects the socket to the specified address. When the operation
-    /// completes, the handler will be notified with the supplied token.
-    ///
-    /// The goal of this method is to ensure that the event loop will always
-    /// notify about the connection, even if the connection happens
-    /// immediately. Otherwise, every consumer of the event loop would have
-    /// to worry about possibly-immediate connection.
-    pub fn connect<S: Socket>(&mut self, io: &S, addr: &SockAddr, token: Token) -> MioResult<()> {
-        debug!("socket connect; addr={}", addr);
-
-        // Attempt establishing the context. This may not complete immediately.
-        if try!(os::connect(io.desc(), addr)) {
-            // On some OSs, connecting to localhost succeeds immediately. In
-            // this case, queue the writable callback for execution during the
-            // next event loop tick.
-            debug!("socket connected immediately; addr={}", addr);
-        }
-
-        // Register interest with socket on the event loop
-        try!(self.register(io, token));
-
-        Ok(())
+    /// Re-Registers an IO handle with the event to change/update interest
+    pub fn reregister<H: IoHandle>(&mut self, io: &H, eventctx: &IoEventCtx) -> MioResult<()> {
+        self.poll.reregister(io, eventctx)
     }
 
     /// Keep spinning the event loop indefinitely, and notify the handler whenever
@@ -238,7 +220,7 @@ impl<T, M: Send> EventLoop<T, M> {
         }
     }
 
-    fn io_event<H: Handler<T, M>>(&mut self, handler: &mut H, evt: IoEvent) {
+    fn io_event<H: Handler<T, M>>(&mut self, handler: &mut H, evt: IoEventCtx) {
         let tok = evt.token();
 
         if evt.is_readable() {
@@ -269,7 +251,7 @@ impl<T, M: Send> EventLoop<T, M> {
 
         loop {
             match self.timer.tick_to(now) {
-                Some(t) => handler.timeout(self, t),
+                Some(t) => { debug!("received timeout at {}", now); handler.timeout(self, t); }
                 _ => return
             }
         }
@@ -315,6 +297,8 @@ mod tests {
     use super::EventLoop;
     use io::{IoWriter, IoReader};
     use {io, buf, Buf, Handler, Token, ReadHint};
+    use event_ctx::IoEventCtx;
+    use event_ctx as evt;
 
     type TestEventLoop = EventLoop<uint, ()>;
 
@@ -350,7 +334,9 @@ mod tests {
         let handler = Funtimes::new(rcount.clone(), wcount.clone());
 
         writer.write(&mut buf::wrap("hello".as_bytes())).unwrap();
-        event_loop.register(&reader, Token(10)).unwrap();
+
+        let evt = IoEventCtx::new(evt::IOREADABLE, Token(10));
+        event_loop.register(&reader, &evt).unwrap();
 
         let _ = event_loop.run_once(handler);
         let mut b = buf::ByteBuf::new(16);