Reorganize the entire crate:

Renamed APIs

* Loop => reactor::Core
* LoopHandle => reactor::Handle
* LoopPin => reactor::Pinned
* TcpStream => net::TcpStream
* TcpListener => net::TcpListener
* UdpSocket => net::UdpSocket
* Sender => channel::Sender
* Receiver => channel::Receiver
* Timeout => reactor::Timeout
* ReadinessStream => reactor::PollEvented
* All `LoopHandle` methods to construct objects are now free functions on the
  associated types, e.g. `LoopHandle::tcp_listen` is now `TcpListener::bind`
* All APIs taking a `Handle` now take a `Handle` as the last argument
* All future-returning APIs now return concrete types instead of trait objects

Added APIs

* io::Io trait -- Read + Write + ability to poll

Removed without replacement:

* AddSource
* AddTimeout
* IoToken
* TimeoutToken

Closes #3
Closes #6

tests/buffered.rs

@@ -9,6 +9,8 @@ use std::io::{Read, Write, BufReader, BufWriter};
 use futures::Future;
 use futures::stream::Stream;
 use tokio_core::io::copy;
+use tokio_core::net::TcpListener;
+use tokio_core::reactor::Core;
 
 macro_rules! t {
     ($e:expr) => (match $e {
@@ -22,8 +24,8 @@ fn echo_server() {
     const N: usize = 1024;
     drop(env_logger::init());
 
-    let mut l = t!(tokio_core::Loop::new());
-    let srv = l.handle().tcp_listen(&"127.0.0.1:0".parse().unwrap());
+    let mut l = t!(Core::new());
+    let srv = TcpListener::bind(&t!("127.0.0.1:0".parse()), &l.handle());
     let srv = t!(l.run(srv));
     let addr = t!(srv.local_addr());
 

tests/chain.rs

@@ -8,6 +8,8 @@ use std::io::{Write, Read};
 use futures::Future;
 use futures::stream::Stream;
 use tokio_core::io::read_to_end;
+use tokio_core::net::TcpListener;
+use tokio_core::reactor::Core;
 
 macro_rules! t {
     ($e:expr) => (match $e {
@@ -18,8 +20,8 @@ macro_rules! t {
 
 #[test]
 fn chain_clients() {
-    let mut l = t!(tokio_core::Loop::new());
-    let srv = l.handle().tcp_listen(&"127.0.0.1:0".parse().unwrap());
+    let mut l = t!(Core::new());
+    let srv = TcpListener::bind(&t!("127.0.0.1:0".parse()), &l.handle());
     let srv = t!(l.run(srv));
     let addr = t!(srv.local_addr());
 

tests/echo.rs

@@ -9,6 +9,8 @@ use std::thread;
 use futures::Future;
 use futures::stream::Stream;
 use tokio_core::io::{copy, TaskIo};
+use tokio_core::net::TcpListener;
+use tokio_core::reactor::Core;
 
 macro_rules! t {
     ($e:expr) => (match $e {
@@ -21,8 +23,8 @@ macro_rules! t {
 fn echo_server() {
     drop(env_logger::init());
 
-    let mut l = t!(tokio_core::Loop::new());
-    let srv = l.handle().tcp_listen(&"127.0.0.1:0".parse().unwrap());
+    let mut l = t!(Core::new());
+    let srv = TcpListener::bind(&t!("127.0.0.1:0".parse()), &l.handle());
     let srv = t!(l.run(srv));
     let addr = t!(srv.local_addr());
 

tests/limit.rs

@@ -8,6 +8,8 @@ use std::io::{Write, Read};
 use futures::Future;
 use futures::stream::Stream;
 use tokio_core::io::read_to_end;
+use tokio_core::net::TcpListener;
+use tokio_core::reactor::Core;
 
 macro_rules! t {
     ($e:expr) => (match $e {
@@ -18,8 +20,8 @@ macro_rules! t {
 
 #[test]
 fn limit() {
-    let mut l = t!(tokio_core::Loop::new());
-    let srv = l.handle().tcp_listen(&"127.0.0.1:0".parse().unwrap());
+    let mut l = t!(Core::new());
+    let srv = TcpListener::bind(&t!("127.0.0.1:0".parse()), &l.handle());
     let srv = t!(l.run(srv));
     let addr = t!(srv.local_addr());
 

tests/poll.rs

@@ -1,64 +0,0 @@
-extern crate env_logger;
-extern crate futures;
-extern crate mio;
-extern crate tokio_core;
-
-use futures::{Future, Poll, Async};
-use futures::task;
-use tokio_core::{Loop, IoToken, LoopHandle};
-
-struct Next(usize);
-
-impl Future for Next {
-    type Item = ();
-    type Error = ();
-
-    fn poll(&mut self) -> Poll<(), ()> {
-        if self.0 == 0 {
-            task::park().unpark();
-            self.0 += 1;
-            Ok(Async::NotReady)
-        } else {
-            Ok(().into())
-        }
-    }
-}
-
-#[test]
-fn poll_after_ready() {
-    drop(env_logger::init());
-
-    let mut lp = Loop::new().unwrap();
-    let handle = lp.handle();
-    let (tx, rx) = mio::channel::channel::<u32>();
-    let (_rx, token) = lp.run(handle.add_source(rx)).unwrap();
-    tx.send(2).unwrap();
-    lp.run(Next(0)).unwrap();
-    lp.run(ScheduleThenPoll {
-        token: token,
-        handle: handle,
-        n: 0,
-    }).unwrap();
-
-    struct ScheduleThenPoll {
-        token: IoToken,
-        handle: LoopHandle,
-        n: usize,
-    }
-
-    impl Future for ScheduleThenPoll {
-        type Item = ();
-        type Error = ();
-
-        fn poll(&mut self) -> Poll<(), ()> {
-            if self.n == 0 {
-                self.handle.schedule_read(&self.token);
-                self.n += 1;
-                Ok(Async::NotReady)
-            } else {
-                assert!(self.token.take_readiness() & 1 != 0);
-                Ok(().into())
-            }
-        }
-    }
-}

tests/spawn.rs

@@ -3,12 +3,12 @@ extern crate env_logger;
 extern crate futures;
 
 use futures::Future;
-use tokio_core::Loop;
+use tokio_core::reactor::Core;
 
 #[test]
 fn simple() {
     drop(env_logger::init());
-    let mut lp = Loop::new().unwrap();
+    let mut lp = Core::new().unwrap();
 
     let (tx1, rx1) = futures::oneshot();
     let (tx2, rx2) = futures::oneshot();
@@ -29,7 +29,7 @@ fn simple() {
 #[test]
 fn spawn_in_poll() {
     drop(env_logger::init());
-    let mut lp = Loop::new().unwrap();
+    let mut lp = Core::new().unwrap();
 
     let (tx1, rx1) = futures::oneshot();
     let (tx2, rx2) = futures::oneshot();

tests/stream-buffered.rs

@@ -9,6 +9,8 @@ use std::thread;
 use futures::Future;
 use futures::stream::Stream;
 use tokio_core::io::{copy, TaskIo};
+use tokio_core::net::TcpListener;
+use tokio_core::reactor::Core;
 
 macro_rules! t {
     ($e:expr) => (match $e {
@@ -21,8 +23,8 @@ macro_rules! t {
 fn echo_server() {
     drop(env_logger::init());
 
-    let mut l = t!(tokio_core::Loop::new());
-    let srv = l.handle().tcp_listen(&"127.0.0.1:0".parse().unwrap());
+    let mut l = t!(Core::new());
+    let srv = TcpListener::bind(&"127.0.0.1:0".parse().unwrap(), &l.handle());
     let srv = t!(l.run(srv));
     let addr = t!(srv.local_addr());
 

tests/tcp.rs

@@ -2,12 +2,14 @@ extern crate env_logger;
 extern crate futures;
 extern crate tokio_core;
 
-use std::net::{TcpListener, TcpStream};
+use std::net;
 use std::sync::mpsc::channel;
 use std::thread;
 
 use futures::Future;
 use futures::stream::Stream;
+use tokio_core::reactor::Core;
+use tokio_core::net::{TcpListener, TcpStream};
 
 macro_rules! t {
     ($e:expr) => (match $e {
@@ -19,14 +21,14 @@ macro_rules! t {
 #[test]
 fn connect() {
     drop(env_logger::init());
-    let mut l = t!(tokio_core::Loop::new());
-    let srv = t!(TcpListener::bind("127.0.0.1:0"));
+    let mut l = t!(Core::new());
+    let srv = t!(net::TcpListener::bind("127.0.0.1:0"));
     let addr = t!(srv.local_addr());
     let t = thread::spawn(move || {
         t!(srv.accept()).0
     });
 
-    let stream = l.handle().tcp_connect(&addr);
+    let stream = TcpStream::connect(&addr, &l.handle());
     let mine = t!(l.run(stream));
     let theirs = t.join().unwrap();
 
@@ -37,8 +39,8 @@ fn connect() {
 #[test]
 fn accept() {
     drop(env_logger::init());
-    let mut l = t!(tokio_core::Loop::new());
-    let srv = l.handle().tcp_listen(&"127.0.0.1:0".parse().unwrap());
+    let mut l = t!(Core::new());
+    let srv = TcpListener::bind(&"127.0.0.1:0".parse().unwrap(), &l.handle());
     let srv = t!(l.run(srv));
     let addr = t!(srv.local_addr());
 
@@ -49,7 +51,7 @@ fn accept() {
     }).into_future().map_err(|e| e.0);
     assert!(rx.try_recv().is_err());
     let t = thread::spawn(move || {
-        TcpStream::connect(&addr).unwrap()
+        net::TcpStream::connect(&addr).unwrap()
     });
 
     let (mine, _remaining) = t!(l.run(client));
@@ -63,13 +65,13 @@ fn accept() {
 #[test]
 fn accept2() {
     drop(env_logger::init());
-    let mut l = t!(tokio_core::Loop::new());
-    let srv = l.handle().tcp_listen(&"127.0.0.1:0".parse().unwrap());
+    let mut l = t!(Core::new());
+    let srv = TcpListener::bind(&"127.0.0.1:0".parse().unwrap(), &l.handle());
     let srv = t!(l.run(srv));
     let addr = t!(srv.local_addr());
 
     let t = thread::spawn(move || {
-        TcpStream::connect(&addr).unwrap()
+        net::TcpStream::connect(&addr).unwrap()
     });
 
     let (tx, rx) = channel();

tests/timeout.rs

@@ -5,6 +5,7 @@ extern crate tokio_core;
 use std::time::{Instant, Duration};
 
 use futures::Future;
+use tokio_core::reactor::{Core, Timeout};
 
 macro_rules! t {
     ($e:expr) => (match $e {
@@ -16,9 +17,9 @@ macro_rules! t {
 #[test]
 fn smoke() {
     drop(env_logger::init());
-    let mut l = t!(tokio_core::Loop::new());
+    let mut l = t!(Core::new());
     let dur = Duration::from_millis(10);
-    let timeout = l.handle().timeout(dur).and_then(|t| t);
+    let timeout = Timeout::new(dur, &l.handle()).and_then(|t| t);
     let start = Instant::now();
     t!(l.run(timeout));
     assert!(start.elapsed() >= dur);

tests/udp.rs

@@ -6,7 +6,8 @@ use std::io;
 use std::net::SocketAddr;
 
 use futures::{Future, Poll};
-use tokio_core::UdpSocket;
+use tokio_core::net::UdpSocket;
+use tokio_core::reactor::Core;
 
 macro_rules! t {
     ($e:expr) => (match $e {
@@ -17,9 +18,9 @@ macro_rules! t {
 
 #[test]
 fn send_messages() {
-    let mut l = t!(tokio_core::Loop::new());
-    let a = l.handle().udp_bind(&"127.0.0.1:0".parse().unwrap());
-    let b = l.handle().udp_bind(&"127.0.0.1:0".parse().unwrap());
+    let mut l = t!(Core::new());
+    let a = UdpSocket::bind(&t!("127.0.0.1:0".parse()), &l.handle());
+    let b = UdpSocket::bind(&t!("127.0.0.1:0".parse()), &l.handle());
     let (a, b) = t!(l.run(a.join(b)));
     let a_addr = t!(a.local_addr());
     let b_addr = t!(b.local_addr());