cargo fmt

Author: preyasshah

counters/src/counters.rs

@@ -1,6 +1,6 @@
-use std::io;
-use std::collections::HashMap;
 use std::cell::RefCell;
+use std::collections::HashMap;
+use std::io;
 
 use crate::filters::Filter;
 
@@ -11,7 +11,7 @@ use crate::filters::Filter;
 #[derive(Clone, Debug)]
 #[cfg_attr(feature = "serialization", derive(Serialize, Deserialize))]
 pub struct Counters {
-    events: RefCell<HashMap<String, u64>>
+    events: RefCell<HashMap<String, u64>>,
 }
 
 impl Counters {
@@ -38,7 +38,9 @@ impl Counters {
 
     /// Reset some of the counters to zero.
     pub fn reset_events<F: Filter>(&self, mut filter: F) {
-        self.events.borrow_mut().retain(|key, val| !filter.apply(key, *val));
+        self.events
+            .borrow_mut()
+            .retain(|key, val| !filter.apply(key, *val));
     }
 
     /// Reset all counters to zero.
@@ -48,7 +50,9 @@ impl Counters {
 
     /// Keep some of the counters and throw away the rest.
     pub fn retain<F: Filter>(&self, mut filter: F) {
-        self.events.borrow_mut().retain(|key, val| filter.apply(key, *val));
+        self.events
+            .borrow_mut()
+            .retain(|key, val| filter.apply(key, *val));
     }
 
     /// Get the value of the counter or zero if it does not exist.
@@ -80,7 +84,6 @@ impl Counters {
         Ok(())
     }
 
-
     /// Print the counters to stdout.
     pub fn print_to_stdout<F: Filter>(&self, filter: F) {
         let stdout = io::stdout();
@@ -93,5 +96,5 @@ impl Counters {
         for (key, value) in other.events.borrow_mut().drain() {
             *self.events.borrow_mut().entry(key).or_insert(0) += value;
         }
-    } 
+    }
 }

counters/src/filters.rs

@@ -1,12 +1,13 @@
-
 pub trait Filter {
     fn apply(&mut self, key: &str, value: u64) -> bool;
 }
 
 /// Accept all keys
 pub struct All;
 impl Filter for All {
-    fn apply(&mut self, _: &str, _: u64) -> bool { true }
+    fn apply(&mut self, _: &str, _: u64) -> bool {
+        true
+    }
 }
 
 /// Select keys using a callback.

counters/src/lib.rs

@@ -81,14 +81,20 @@
 #[cfg(feature = "serialization")]
 extern crate serde;
 
-#[cfg(not(feature="noop"))] mod counters;
-#[cfg(not(feature="noop"))] pub use crate::counters::*;
+#[cfg(not(feature = "noop"))]
+mod counters;
+#[cfg(not(feature = "noop"))]
+pub use crate::counters::*;
 
-#[cfg(not(feature="noop"))] mod table;
-#[cfg(not(feature="noop"))] pub use crate::table::*;
+#[cfg(not(feature = "noop"))]
+mod table;
+#[cfg(not(feature = "noop"))]
+pub use crate::table::*;
 
-#[cfg(feature="noop")] mod noop;
-#[cfg(feature="noop")] pub use crate::noop::*;
+#[cfg(feature = "noop")]
+mod noop;
+#[cfg(feature = "noop")]
+pub use crate::noop::*;
 
 pub mod filters;
 
@@ -155,5 +161,5 @@ fn noop() {
 
     assert_eq!(counters.get("foo::bar"), 0);
     assert_eq!(counters.get("foo::baz"), 0);
-    assert_eq!(counters.accumulate("foo::"), 0);    
+    assert_eq!(counters.accumulate("foo::"), 0);
 }

counters/src/noop.rs

@@ -1,29 +1,46 @@
-use std::io;
 use crate::filters::Filter;
+use std::io;
 
 #[derive(Clone, Debug)]
 #[cfg_attr(feature = "serialization", derive(Serialize, Deserialize))]
 pub struct Counters;
 
 impl Counters {
-    pub fn new() -> Self { Counters }
+    pub fn new() -> Self {
+        Counters
+    }
     pub fn event(&self, _key: &str) {}
     pub fn reset_event(&self, _key: &str) {}
     pub fn reset_events<F: Filter>(&self, _filter: F) {}
     pub fn reset_all(&self) {}
     pub fn retain<F: Filter>(&self, _filter: F) {}
-    pub fn get(&self, _key: &str) -> u64 { 0 }
-    pub fn accumulate<F: Filter>(&self, _filter: F) -> u64 { 0 }
-    pub fn print<F: Filter>(&self, _filter: F, _out: &mut io::Write) -> io::Result<()> { Ok(()) }
+    pub fn get(&self, _key: &str) -> u64 {
+        0
+    }
+    pub fn accumulate<F: Filter>(&self, _filter: F) -> u64 {
+        0
+    }
+    pub fn print<F: Filter>(&self, _filter: F, _out: &mut io::Write) -> io::Result<()> {
+        Ok(())
+    }
     pub fn print_to_stdout<F: Filter>(&self, _filter: F) {}
 }
 
 #[cfg_attr(feature = "serialization", derive(Serialize, Deserialize))]
 pub struct Table;
 
 impl Table {
-    pub fn new<Label>(_labels: &[Label]) -> Self where Label: ToString { Table }
-    pub fn add_row(&self, _row: &Counters) -> usize { 0 }
-    pub fn print(&self, _to: &mut io::Write) -> io::Result<()> { Ok(()) }
+    pub fn new<Label>(_labels: &[Label]) -> Self
+    where
+        Label: ToString,
+    {
+        Table
+    }
+    pub fn add_row(&self, _row: &Counters) -> usize {
+        0
+    }
+    pub fn print(&self, _to: &mut io::Write) -> io::Result<()> {
+        Ok(())
+    }
     pub fn print_to_stdout(&self) {}
 }

counters/src/table.rs

@@ -1,33 +1,33 @@
-use crate::Counters;
 use crate::filters::Select;
-use std::io;
+use crate::Counters;
 use std::cell::RefCell;
+use std::io;
 
 /// Helper to print counters as a table in csv format.
 ///
 /// # Example
 ///
 /// ```
 /// use counters::*;
-/// 
+///
 /// let counters = Counters::new();
 /// let table = Table::new(&["foo", "bar", "meh"]);
-/// 
+///
 /// for _ in 0..5 {
 ///     counters.event("bar");
 /// }
 /// counters.event("foo");
-/// 
+///
 /// // "baz" isn't in the table labels, it will be ignored.
 /// counters.event("baz");
-/// 
+///
 /// table.add_row(&counters);
-/// 
+///
 /// // Start a second row...
 /// counters.reset_all();
-/// 
+///
 /// counters.event("foo");
-/// 
+///
 /// table.add_row(&counters);
 ///
 /// // This prints the following to stdout:
@@ -45,7 +45,9 @@ pub struct Table {
 
 impl Table {
     pub fn new<Label>(labels: &[Label]) -> Self
-    where Label: ToString {
+    where
+        Label: ToString,
+    {
         Table {
             labels: labels.iter().map(|label| label.to_string()).collect(),
             rows: RefCell::new(Vec::new()),
@@ -55,7 +57,9 @@ impl Table {
     /// Add collected counters as a row, preserving only the counters that match this table's labels.
     pub fn add_row(&self, row: &Counters) -> usize {
         let row = row.clone();
-        row.retain(Select(|key, _| self.labels.iter().any(|label| label == key) ));
+        row.retain(Select(|key, _| {
+            self.labels.iter().any(|label| label == key)
+        }));
         self.rows.borrow_mut().push(row);
 
         self.rows.borrow().len()
@@ -71,10 +75,9 @@ impl Table {
         }
         writeln!(to, "")?;
         for row in self.rows.borrow().iter() {
-
             for (i, label) in self.labels.iter().enumerate() {
                 if i != 0 {
-                    write!(to, ", ")?;                
+                    write!(to, ", ")?;
                 }
                 write!(to, "{}", row.get(label))?;
             }