chore: apply rustfmt to all crates (#917)

tokio-threadpool/src/pool/backup.rs

@@ -1,10 +1,10 @@
 use park::DefaultPark;
-use worker::{WorkerId};
+use worker::WorkerId;
 
 use std::cell::UnsafeCell;
 use std::fmt;
 use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering::{self, Acquire, AcqRel, Relaxed};
+use std::sync::atomic::Ordering::{self, AcqRel, Acquire, Relaxed};
 use std::time::{Duration, Instant};
 
 /// State associated with a thread in the thread pool.
@@ -100,9 +100,11 @@ impl Backup {
         });
 
         // The handoff value is equal to `worker_id`
-        debug_assert_eq!(unsafe { (*self.handoff.get()).as_ref()  }, Some(worker_id));
+        debug_assert_eq!(unsafe { (*self.handoff.get()).as_ref() }, Some(worker_id));
 
-        unsafe { *self.handoff.get() = None; }
+        unsafe {
+            *self.handoff.get() = None;
+        }
     }
 
     pub fn is_running(&self) -> bool {
@@ -167,10 +169,7 @@ impl Backup {
                     return Handoff::Terminated;
                 }
 
-                let worker_id = unsafe {
-                    (*self.handoff.get()).take()
-                        .expect("no worker handoff")
-                };
+                let worker_id = unsafe { (*self.handoff.get()).take().expect("no worker handoff") };
                 return Handoff::Worker(worker_id);
             }
 
@@ -192,10 +191,10 @@ impl Backup {
                         let mut next = state;
                         next.unset_running();
 
-                        let actual = self.state.compare_and_swap(
-                            state.into(),
-                            next.into(),
-                            AcqRel).into();
+                        let actual = self
+                            .state
+                            .compare_and_swap(state.into(), next.into(), AcqRel)
+                            .into();
 
                         if actual == state {
                             debug_assert!(!next.is_running());
@@ -226,7 +225,9 @@ impl Backup {
 
     #[inline]
     pub fn set_next_sleeper(&self, val: BackupId) {
-        unsafe { *self.next_sleeper.get() = val; }
+        unsafe {
+            *self.next_sleeper.get() = val;
+        }
     }
 }
 
@@ -271,8 +272,9 @@ impl State {
             next.set_running();
             next.unset_pushed();
 
-            let actual = state.compare_and_swap(
-                curr.into(), next.into(), AcqRel).into();
+            let actual = state
+                .compare_and_swap(curr.into(), next.into(), AcqRel)
+                .into();
 
             if actual == curr {
                 return curr;

tokio-threadpool/src/pool/backup_stack.rs

@@ -1,7 +1,7 @@
 use pool::{Backup, BackupId};
 
 use std::sync::atomic::AtomicUsize;
-use std::sync::atomic::Ordering::{Acquire, AcqRel};
+use std::sync::atomic::Ordering::{AcqRel, Acquire};
 
 #[derive(Debug)]
 pub(crate) struct BackupStack {
@@ -65,8 +65,10 @@ impl BackupStack {
             entries[id.0].set_next_sleeper(head);
             next.set_head(id);
 
-            let actual = self.state.compare_and_swap(
-                state.into(), next.into(), AcqRel).into();
+            let actual = self
+                .state
+                .compare_and_swap(state.into(), next.into(), AcqRel)
+                .into();
 
             if state == actual {
                 return Ok(());
@@ -110,8 +112,10 @@ impl BackupStack {
                     return Ok(None);
                 }
 
-                let actual = self.state.compare_and_swap(
-                    state.into(), next.into(), AcqRel).into();
+                let actual = self
+                    .state
+                    .compare_and_swap(state.into(), next.into(), AcqRel)
+                    .into();
 
                 if actual != state {
                     state = actual;
@@ -138,8 +142,10 @@ impl BackupStack {
                 next.set_head(next_head);
             }
 
-            let actual = self.state.compare_and_swap(
-                state.into(), next.into(), AcqRel).into();
+            let actual = self
+                .state
+                .compare_and_swap(state.into(), next.into(), AcqRel)
+                .into();
 
             if actual == state {
                 debug_assert!(entries[head.0].is_pushed());

tokio-threadpool/src/pool/mod.rs

@@ -4,11 +4,7 @@ mod state;
 
 pub(crate) use self::backup::{Backup, BackupId};
 pub(crate) use self::backup_stack::MAX_BACKUP;
-pub(crate) use self::state::{
-    State,
-    Lifecycle,
-    MAX_FUTURES,
-};
+pub(crate) use self::state::{Lifecycle, State, MAX_FUTURES};
 
 use self::backup::Handoff;
 use self::backup_stack::BackupStack;
@@ -22,8 +18,8 @@ use futures::Poll;
 
 use std::cell::Cell;
 use std::num::Wrapping;
-use std::sync::atomic::Ordering::{Acquire, AcqRel};
 use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::{AcqRel, Acquire};
 use std::sync::{Arc, Weak};
 use std::thread;
 
@@ -100,15 +96,15 @@ impl Pool {
         //
         // This is `backup + pool_size` because the core thread pool running the
         // workers is spawned from backup as well.
-        let backup = (0..total_size).map(|_| {
-            Backup::new()
-        }).collect::<Vec<_>>().into_boxed_slice();
+        let backup = (0..total_size)
+            .map(|_| Backup::new())
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
 
         let backup_stack = BackupStack::new();
 
         for i in (0..backup.len()).rev() {
-            backup_stack.push(&backup, BackupId(i))
-                .unwrap();
+            backup_stack.push(&backup, BackupId(i)).unwrap();
         }
 
         // Initialize the blocking state
@@ -174,8 +170,10 @@ impl Pool {
                 }
             }
 
-            let actual = self.state.compare_and_swap(
-                state.into(), next.into(), AcqRel).into();
+            let actual = self
+                .state
+                .compare_and_swap(state.into(), next.into(), AcqRel)
+                .into();
 
             if state == actual {
                 state = next;
@@ -299,8 +297,7 @@ impl Pool {
             }
         };
 
-        let need_spawn = self.backup[backup_id.0]
-            .worker_handoff(id.clone());
+        let need_spawn = self.backup[backup_id.0].worker_handoff(id.clone());
 
         if !need_spawn {
             return;
@@ -355,8 +352,7 @@ impl Pool {
                 // available for future handoffs.
                 //
                 // This **must** happen before notifying the task.
-                let res = pool.backup_stack
-                    .push(&pool.backup, backup_id);
+                let res = pool.backup_stack.push(&pool.backup, backup_id);
 
                 if res.is_err() {
                     // The pool is being shutdown.
@@ -370,8 +366,7 @@ impl Pool {
                 debug_assert!(pool.backup[backup_id.0].is_running());
 
                 // Wait for a handoff
-                let handoff = pool.backup[backup_id.0]
-                    .wait_for_handoff(pool.config.keep_alive);
+                let handoff = pool.backup[backup_id.0].wait_for_handoff(pool.config.keep_alive);
 
                 match handoff {
                     Handoff::Worker(id) => {
@@ -407,7 +402,8 @@ impl Pool {
 
             debug_assert!(
                 worker_state.lifecycle() != Signaled,
-                "actual={:?}", worker_state.lifecycle(),
+                "actual={:?}",
+                worker_state.lifecycle(),
             );
 
             trace!("signal_work -- notify; idx={}", idx);

tokio-threadpool/src/pool/state.rs

@@ -82,8 +82,7 @@ impl State {
     }
 
     pub fn is_terminated(&self) -> bool {
-        self.lifecycle() == Lifecycle::ShutdownNow &&
-            self.num_futures() == 0
+        self.lifecycle() == Lifecycle::ShutdownNow && self.num_futures() == 0
     }
 }
 
@@ -115,9 +114,10 @@ impl From<usize> for Lifecycle {
         use self::Lifecycle::*;
 
         debug_assert!(
-            src == Running as usize ||
-            src == ShutdownOnIdle as usize ||
-            src == ShutdownNow as usize);
+            src == Running as usize
+                || src == ShutdownOnIdle as usize
+                || src == ShutdownNow as usize
+        );
 
         unsafe { ::std::mem::transmute(src) }
     }