Rustfmt

Author: jeehoonkang

crossbeam-circbuf/src/buffer.rs

@@ -1,7 +1,7 @@
 use std::cell::UnsafeCell;
+use std::mem;
 use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
-use std::mem;
 
 /// A slot in buffer.
 #[derive(Debug)]
@@ -60,7 +60,7 @@ impl<T> Buffer<T> {
 
 impl<T> Drop for Buffer<T> {
     fn drop(&mut self) {
-        unsafe { 
+        unsafe {
             drop(Vec::from_raw_parts(self.ptr, 0, self.cap));
         }
     }
@@ -110,7 +110,10 @@ impl<T> Buffer<T> {
         let slot = self.at(index);
 
         // Writes the value.
-        (*slot).data.get().write_volatile(mem::ManuallyDrop::new(value));
+        (*slot)
+            .data
+            .get()
+            .write_volatile(mem::ManuallyDrop::new(value));
 
         // Writes the index with `Release`.
         (*slot).index.store(index, Ordering::Release);

crossbeam-circbuf/src/lib.rs

@@ -12,14 +12,14 @@ extern crate crossbeam_utils as utils;
 
 mod buffer;
 
-#[doc(hidden)] // for doc-tests
-pub mod sp;
 #[doc(hidden)] // for doc-tests
 pub mod mp;
+#[doc(hidden)] // for doc-tests
+pub mod sp;
 
+pub use mp::mc as mpmc;
 pub use sp::mc as spmc;
 pub use sp::sc as spsc;
-pub use mp::mc as mpmc;
 
 /// The return type for `try_recv` methods.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

crossbeam-circbuf/src/mp/mc.rs

@@ -24,10 +24,10 @@
 /// assert_eq!(r.recv(), Some('b'));
 /// ```
 pub mod bounded {
-    use std::sync::atomic::Ordering;
-    use std::sync::atomic::AtomicUsize;
     use std::marker::PhantomData;
     use std::mem::ManuallyDrop;
+    use std::sync::atomic::AtomicUsize;
+    use std::sync::atomic::Ordering;
     use utils::CachePadded;
 
     use buffer::Buffer;
@@ -135,7 +135,7 @@ pub mod bounded {
                         unsafe { self.buffer.write(index.wrapping_add(self.lap()), value) };
                         return Ok(());
                     }
-                    // But if the slot lags one lap behind the tail...
+                // But if the slot lags one lap behind the tail...
                 } else if index.wrapping_add(self.lap()) == tail {
                     let head = self.head.load(Ordering::Acquire);
 
@@ -179,7 +179,10 @@ pub mod bounded {
                     {
                         // Reads the value from the slot and update the stamp.
                         let value = unsafe { self.buffer.read_value(index) };
-                        unsafe { self.buffer.write_index(index.wrapping_add(self.lap()), Ordering::Release) };
+                        unsafe {
+                            self.buffer
+                                .write_index(index.wrapping_add(self.lap()), Ordering::Release)
+                        };
                         return Some(ManuallyDrop::into_inner(value));
                     }
                 // But if the slot lags one lap behind the head...
@@ -194,7 +197,7 @@ pub mod bounded {
                 }
             }
         }
-        
+
         /// Returns `true` if the queue is empty.
         ///
         /// Inaccurate in the presence of concurrent method invocations.
@@ -208,21 +211,21 @@ pub mod bounded {
             // when the queue was not empty, so it is safe to just return `false`.
             tail.wrapping_add(self.lap()) == head
         }
-        
+
         /// Returns `true` if the queue is full.
         ///
         /// Inaccurate in the presence of concurrent method invocations.
         pub fn is_full(&self) -> bool {
             let tail = self.tail.load(Ordering::Relaxed);
             let head = self.head.load(Ordering::Relaxed);
-            
+
             // Is the head lagging one lap behind tail?
             //
             // Note: If the tail changes just before we load the head, that means there was a moment
             // when the queue was not full, so it is safe to just return `false`.
             head.wrapping_add(self.lap()) == tail
         }
-        
+
         /// Returns the current number of elements inside the queue.
         ///
         /// Inaccurate in the presence of concurrent method invocations.
@@ -233,7 +236,7 @@ pub mod bounded {
 
             let hix = head & (self.lap() - 1);
             let tix = tail & (self.lap() - 1);
-            
+
             if hix < tix {
                 tix - hix
             } else if hix > tix {
@@ -250,7 +253,7 @@ pub mod bounded {
         fn drop(&mut self) {
             // Get the index of the head.
             let hix = self.head.load(Ordering::Relaxed) & (self.lap() - 1);
-            
+
             // Loop over all slots that hold a message and drop them.
             for i in 0..self.len() {
                 // Compute the index of the next slot holding a message.

crossbeam-circbuf/src/sp/internal.rs

@@ -677,7 +677,8 @@ impl<T> Receiver<T> {
                 rx.wrapping_add(num),
                 Ordering::Release,
                 Ordering::Relaxed,
-            ).is_err()
+            )
+            .is_err()
         {
             // We didn't receive the values.
             return TryRecv::Retry;
@@ -886,7 +887,8 @@ mod tests {
                         }
                     }
                 })
-            }).collect::<Vec<_>>();
+            })
+            .collect::<Vec<_>>();
 
         while remaining.load(SeqCst) > 0 {
             if let TryRecv::Data(_) = cb.try_recv() {
@@ -919,7 +921,8 @@ mod tests {
                         }
                     }
                 })
-            }).collect::<Vec<_>>();
+            })
+            .collect::<Vec<_>>();
 
         let mut rng = rand::thread_rng();
         let mut expected = 0;
@@ -982,7 +985,8 @@ mod tests {
                 };
 
                 (t, hits)
-            }).unzip();
+            })
+            .unzip();
 
         let mut rng = rand::thread_rng();
         let mut my_hits = 0;
@@ -1040,7 +1044,8 @@ mod tests {
                         }
                     }
                 })
-            }).collect::<Vec<_>>();
+            })
+            .collect::<Vec<_>>();
 
         for _ in 0..1000 {
             if let TryRecv::Data(_) = cb.try_recv() {

crossbeam-circbuf/tests/mpmc_bounded.rs

@@ -108,7 +108,8 @@ fn len() {
                 assert!(len <= CAP);
             }
         });
-    }).unwrap();
+    })
+    .unwrap();
     assert_eq!(q.len(), 0);
 }
 
@@ -136,7 +137,8 @@ fn spsc() {
                 while q.send(i).is_err() {}
             }
         });
-    }).unwrap();
+    })
+    .unwrap();
 }
 
 #[test]
@@ -167,7 +169,8 @@ fn mpmc() {
                 }
             });
         }
-    }).unwrap();
+    })
+    .unwrap();
 
     for c in v {
         assert_eq!(c.load(Ordering::SeqCst), THREADS);
@@ -212,7 +215,8 @@ fn drops() {
                     }
                 }
             });
-        }).unwrap();
+        })
+        .unwrap();
 
         for _ in 0..additional {
             q.send(DropCounter).unwrap();
@@ -240,5 +244,6 @@ fn linearizable() {
                 }
             });
         }
-    }).unwrap();
+    })
+    .unwrap();
 }