Split tokio-threadpool lib.rs into files (#233)

* Builder -> src/builder.rs
* Callback -> src/callback.rs
* Config -> src/config.rs
* Futures2Wake -> src/futures2_wake.rs
* Inner -> src/inner.rs
* Notifier-> src/notifier.rs
* Sender -> src/sender.rs
* Shutdown -> src/shutdown.rs
* ShutdownTask -> src/shutdown_task.rs
* SleepStack -> src/sleep_stack.rs
* State -> src/state.rs
* ThreadPool -> src/thread_pool.rs
* Worker -> src/worker.rs
* WorkerEntry -> src/worker_entry.rs
* WorkerState -> src/worker_state.rs

tokio-threadpool/src/shutdown.rs

@@ -0,0 +1,66 @@
+use sender::Sender;
+use inner::Inner;
+
+use std::sync::atomic::Ordering::{Acquire};
+
+use futures::{Future, Poll, Async};
+#[cfg(feature = "unstable-futures")]
+use futures2;
+
+/// Future that resolves when the thread pool is shutdown.
+///
+/// A `ThreadPool` is shutdown once all the worker have drained their queues and
+/// shutdown their threads.
+///
+/// `Shutdown` is returned by [`shutdown`], [`shutdown_on_idle`], and
+/// [`shutdown_now`].
+///
+/// [`shutdown`]: struct.ThreadPool.html#method.shutdown
+/// [`shutdown_on_idle`]: struct.ThreadPool.html#method.shutdown_on_idle
+/// [`shutdown_now`]: struct.ThreadPool.html#method.shutdown_now
+#[derive(Debug)]
+pub struct Shutdown {
+    pub(crate) inner: Sender,
+}
+
+impl Shutdown {
+    fn inner(&self) -> &Inner {
+        &*self.inner.inner
+    }
+}
+
+impl Future for Shutdown {
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self) -> Poll<(), ()> {
+        use futures::task;
+        trace!("Shutdown::poll");
+
+        self.inner().shutdown_task.task1.register_task(task::current());
+
+        if 0 != self.inner().num_workers.load(Acquire) {
+            return Ok(Async::NotReady);
+        }
+
+        Ok(().into())
+    }
+}
+
+#[cfg(feature = "unstable-futures")]
+impl futures2::Future for Shutdown {
+    type Item = ();
+    type Error = ();
+
+    fn poll(&mut self, cx: &mut futures2::task::Context) -> futures2::Poll<(), ()> {
+        trace!("Shutdown::poll");
+
+        self.inner().shutdown_task.task2.register(cx.waker());
+
+        if 0 != self.inner().num_workers.load(Acquire) {
+            return Ok(futures2::Async::Pending);
+        }
+
+        Ok(().into())
+    }
+}