Blanket rename Core to Reactor

This commit uses a script to rename `Core` to `Reactor` all at once, notably:

    find . -name '*.rs' | xargs sed -i 's/\bCore\b/Reactor/g'

examples/chat.rs

@@ -33,7 +33,7 @@ use futures::future::Executor;
 use futures::stream::{self, Stream};
 use futures_cpupool::CpuPool;
 use tokio::net::TcpListener;
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 use tokio_io::io;
 use tokio_io::AsyncRead;
 
@@ -42,7 +42,7 @@ fn main() {
     let addr = addr.parse().unwrap();
 
     // Create the event loop and TCP listener we'll accept connections on.
-    let mut core = Core::new().unwrap();
+    let mut core = Reactor::new().unwrap();
     let handle = core.handle();
     let socket = TcpListener::bind(&addr, &handle).unwrap();
     println!("Listening on: {}", addr);

examples/compress.rs

@@ -32,7 +32,7 @@ use futures::{Future, Stream, Poll};
 use futures::future::Executor;
 use futures_cpupool::CpuPool;
 use tokio::net::{TcpListener, TcpStream};
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 use tokio_io::{AsyncRead, AsyncWrite};
 use flate2::write::GzEncoder;
 
@@ -41,7 +41,7 @@ fn main() {
     // reactor.
     let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
     let addr = addr.parse::<SocketAddr>().unwrap();
-    let mut core = Core::new().unwrap();
+    let mut core = Reactor::new().unwrap();
     let handle = core.handle();
     let socket = TcpListener::bind(&addr, &handle).unwrap();
     println!("Listening on: {}", addr);

examples/connect.rs

@@ -28,7 +28,7 @@ use std::thread;
 use futures::sync::mpsc;
 use futures::{Sink, Future, Stream};
 use futures_cpupool::CpuPool;
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 
 fn main() {
     // Determine if we're going to run in TCP or UDP mode
@@ -48,7 +48,7 @@ fn main() {
     let addr = addr.parse::<SocketAddr>().unwrap();
 
     // Create the event loop and initiate the connection to the remote server
-    let mut core = Core::new().unwrap();
+    let mut core = Reactor::new().unwrap();
     let handle = core.handle();
 
     let pool = CpuPool::new(1);

examples/echo-threads.rs

@@ -31,7 +31,7 @@ use futures_cpupool::CpuPool;
 use tokio_io::AsyncRead;
 use tokio_io::io::copy;
 use tokio::net::TcpStream;
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 
 fn main() {
     // First argument, the address to bind
@@ -69,7 +69,7 @@ fn main() {
 }
 
 fn worker(rx: mpsc::UnboundedReceiver<net::TcpStream>) {
-    let mut core = Core::new().unwrap();
+    let mut core = Reactor::new().unwrap();
     let handle = core.handle();
 
     let pool = CpuPool::new(1);

examples/echo-udp.rs

@@ -20,7 +20,7 @@ use std::net::SocketAddr;
 
 use futures::{Future, Poll};
 use tokio::net::UdpSocket;
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 
 struct Server {
     socket: UdpSocket,
@@ -56,7 +56,7 @@ fn main() {
 
     // Create the event loop that will drive this server, and also bind the
     // socket we'll be listening to.
-    let mut l = Core::new().unwrap();
+    let mut l = Reactor::new().unwrap();
     let handle = l.handle();
     let socket = UdpSocket::bind(&addr, &handle).unwrap();
     println!("Listening on: {}", socket.local_addr().unwrap());

examples/echo.rs

@@ -32,7 +32,7 @@ use futures_cpupool::CpuPool;
 use tokio_io::AsyncRead;
 use tokio_io::io::copy;
 use tokio::net::TcpListener;
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 
 fn main() {
     // Allow passing an address to listen on as the first argument of this
@@ -42,15 +42,15 @@ fn main() {
     let addr = addr.parse::<SocketAddr>().unwrap();
 
     // First up we'll create the event loop that's going to drive this server.
-    // This is done by creating an instance of the `Core` type, tokio-core's
+    // This is done by creating an instance of the `Reactor` type, tokio-core's
     // event loop. Most functions in tokio-core return an `io::Result`, and
-    // `Core::new` is no exception. For this example, though, we're mostly just
+    // `Reactor::new` is no exception. For this example, though, we're mostly just
     // ignoring errors, so we unwrap the return value.
     //
     // After the event loop is created we acquire a handle to it through the
     // `handle` method. With this handle we'll then later be able to create I/O
     // objects.
-    let mut core = Core::new().unwrap();
+    let mut core = Reactor::new().unwrap();
     let handle = core.handle();
 
     // Next up we create a TCP listener which will listen for incoming
@@ -126,7 +126,7 @@ fn main() {
     });
 
     // And finally now that we've define what our server is, we run it! We
-    // didn't actually do much I/O up to this point and this `Core::run` method
+    // didn't actually do much I/O up to this point and this `Reactor::run` method
     // is responsible for driving the entire server to completion.
     //
     // The `run` method will return the result of the future that it's running,

examples/hello.rs

@@ -20,7 +20,7 @@ use std::env;
 use std::net::SocketAddr;
 
 use futures::stream::Stream;
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 use tokio::net::TcpListener;
 
 fn main() {
@@ -28,7 +28,7 @@ fn main() {
     let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
     let addr = addr.parse::<SocketAddr>().unwrap();
 
-    let mut core = Core::new().unwrap();
+    let mut core = Reactor::new().unwrap();
     let listener = TcpListener::bind(&addr, &core.handle()).unwrap();
 
     let addr = listener.local_addr().unwrap();

examples/proxy.rs

@@ -31,7 +31,7 @@ use futures::{Future, Poll};
 use futures::future::Executor;
 use futures_cpupool::CpuPool;
 use tokio::net::{TcpListener, TcpStream};
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 use tokio_io::{AsyncRead, AsyncWrite};
 use tokio_io::io::{copy, shutdown};
 
@@ -43,7 +43,7 @@ fn main() {
     let server_addr = server_addr.parse::<SocketAddr>().unwrap();
 
     // Create the event loop that will drive this server.
-    let mut l = Core::new().unwrap();
+    let mut l = Reactor::new().unwrap();
     let handle = l.handle();
 
     let pool = CpuPool::new(1);

examples/sink.rs

@@ -31,7 +31,7 @@ use futures::stream::{self, Stream};
 use futures_cpupool::CpuPool;
 use tokio_io::IoFuture;
 use tokio::net::{TcpListener, TcpStream};
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 
 fn main() {
     env_logger::init().unwrap();
@@ -40,7 +40,7 @@ fn main() {
 
     let pool = CpuPool::new(1);
 
-    let mut core = Core::new().unwrap();
+    let mut core = Reactor::new().unwrap();
     let handle = core.handle();
     let socket = TcpListener::bind(&addr, &handle).unwrap();
     println!("Listening on: {}", addr);

examples/tinydb.rs

@@ -54,7 +54,7 @@ use futures::prelude::*;
 use futures::future::Executor;
 use futures_cpupool::CpuPool;
 use tokio::net::TcpListener;
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 use tokio_io::AsyncRead;
 use tokio_io::io::{lines, write_all};
 
@@ -80,11 +80,11 @@ enum Response {
 }
 
 fn main() {
-    // Parse the address we're going to run this server on, create a `Core`, and
+    // Parse the address we're going to run this server on, create a `Reactor`, and
     // set up our TCP listener to accept connections.
     let addr = env::args().nth(1).unwrap_or("127.0.0.1:8080".to_string());
     let addr = addr.parse::<SocketAddr>().unwrap();
-    let mut core = Core::new().unwrap();
+    let mut core = Reactor::new().unwrap();
     let handle = core.handle();
     let listener = TcpListener::bind(&addr, &handle).expect("failed to bind");
     println!("Listening on: {}", addr);

examples/tinyhttp.rs

@@ -39,7 +39,7 @@ use futures_cpupool::CpuPool;
 use http::{Request, Response, StatusCode};
 use http::header::HeaderValue;
 use tokio::net::TcpStream;
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 use tokio_io::codec::{Encoder, Decoder};
 use tokio_io::{AsyncRead};
 
@@ -70,7 +70,7 @@ fn main() {
 }
 
 fn worker(rx: mpsc::UnboundedReceiver<net::TcpStream>) {
-    let mut core = Core::new().unwrap();
+    let mut core = Reactor::new().unwrap();
     let handle = core.handle();
 
     let pool = CpuPool::new(1);

examples/udp-codec.rs

@@ -18,7 +18,7 @@ use futures::{Future, Stream, Sink};
 use futures::future::Executor;
 use futures_cpupool::CpuPool;
 use tokio::net::{UdpSocket, UdpCodec};
-use tokio::reactor::Core;
+use tokio::reactor::Reactor;
 
 pub struct LineCodec;
 
@@ -39,7 +39,7 @@ impl UdpCodec for LineCodec {
 fn main() {
     drop(env_logger::init());
 
-    let mut core = Core::new().unwrap();
+    let mut core = Reactor::new().unwrap();
     let handle = core.handle();
 
     let pool = CpuPool::new(1);