Format code using 'cargo fmt'

examples/main.rs

@@ -1,11 +1,11 @@
 //! A simple example demonstrating how to use Telemetry to measure and
 //! store performance data, then eventually dump it to console/disk.
 
-use std::thread;
-use std::sync::mpsc::channel;
 use std::collections::BTreeMap;
 use std::fs::File;
 use std::io::Write;
+use std::sync::mpsc::channel;
+use std::thread;
 
 extern crate rustc_serialize;
 use rustc_serialize::json::Json;
@@ -17,15 +17,17 @@ extern crate telemetry;
 use telemetry::plain::*;
 use telemetry::Flatten;
 
-
 // A stopwatch for microsecond precision.
 struct StopwatchUS {
-    pub value: time::Duration
+    pub value: time::Duration,
 }
 impl StopwatchUS {
-    fn span<F>(f: F) -> StopwatchUS where F: FnOnce() {
+    fn span<F>(f: F) -> StopwatchUS
+    where
+        F: FnOnce(),
+    {
         StopwatchUS {
-            value: time::Duration::span(f)
+            value: time::Duration::span(f),
         }
     }
 }
@@ -35,15 +37,15 @@ impl telemetry::Flatten for StopwatchUS {
             Some(x) if x >= std::u32::MAX as i64 => std::u32::MAX,
             Some(x) if x <= 0 => 0,
             Some(x) => x as u32,
-            None => std::u32::MAX
+            None => std::u32::MAX,
         }
     }
 }
 
 struct Histograms {
     /// The duration of execution of a recursive implementation of
     /// Fibonacci's function, in microseconds.
-    fibonacci_us: telemetry::plain::Linear<StopwatchUS>
+    fibonacci_us: telemetry::plain::Linear<StopwatchUS>,
 }
 
 fn fibonacci(i: u32) -> u32 {
@@ -61,17 +63,20 @@ fn main() {
         fibonacci_us: telemetry::plain::Linear::new(
             &telemetry,
             "FIBONACCI_DURATION_US".to_string(),
-            0 /* min */,
-            1_000_000 /* max */,
-            20 /* buckets */)
+            0,         /* min */
+            1_000_000, /* max */
+            20,        /* buckets */
+        ),
     };
 
     // Measure a number of durations.
     let mut handles = Vec::new();
     for _ in 1..10 {
         let hist = histograms.fibonacci_us.clone();
         handles.push(thread::spawn(move || {
-            hist.record(StopwatchUS::span(|| {fibonacci(30);}));
+            hist.record(StopwatchUS::span(|| {
+                fibonacci(30);
+            }));
         }));
     }
 
@@ -81,7 +86,11 @@ fn main() {
 
     // Now look at the histogram.
     let (sender, receiver) = channel();
-    telemetry.to_json(telemetry::Subset::AllPlain, telemetry::SerializationFormat::SimpleJson, sender.clone());
+    telemetry.to_json(
+        telemetry::Subset::AllPlain,
+        telemetry::SerializationFormat::SimpleJson,
+        sender.clone(),
+    );
     let plain = receiver.recv().unwrap();
 
     print!("{}\n", plain);
@@ -93,8 +102,14 @@ fn main() {
 
     // If we had keyed histograms, we should put them here, too.
     // Now, add metadata.
-    storage.insert("application".to_string(), Json::String("telemetry example app".to_string()));
-    storage.insert("version".to_string(), Json::Array(vec![Json::I64(0), Json::I64(1), Json::I64(0)]));
+    storage.insert(
+        "application".to_string(),
+        Json::String("telemetry example app".to_string()),
+    );
+    storage.insert(
+        "version".to_string(),
+        Json::Array(vec![Json::I64(0), Json::I64(1), Json::I64(0)]),
+    );
 
     print!("{}\n", Json::Object(storage.clone()).pretty());
 

src/indexing.rs

@@ -1,7 +1,6 @@
 use std::marker::PhantomData;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
-
 /// Witness type, used to specify that the data is specific to a plain histogram.
 #[derive(Clone)]
 pub struct Plain;
@@ -13,12 +12,12 @@ pub struct Map;
 /// Witness type, used to specify that the data is specific to a map
 /// histogram with keys of a specific type `T`.
 pub struct Keyed<T> {
-    pub witness: PhantomData<T>
+    pub witness: PhantomData<T>,
 }
 impl<T> Clone for Keyed<T> {
     fn clone(&self) -> Self {
         Keyed {
-            witness: PhantomData
+            witness: PhantomData,
         }
     }
 }
@@ -32,7 +31,7 @@ impl<T> Clone for Key<T> {
     fn clone(&self) -> Self {
         Key {
             witness: PhantomData,
-            index: self.index
+            index: self.index,
         }
     }
 }
@@ -54,17 +53,15 @@ impl KeyGenerator<Plain> {
     pub fn next(&self) -> Key<Plain> {
         Key {
             index: self.counter.fetch_add(1, Ordering::Relaxed),
-            witness: PhantomData
+            witness: PhantomData,
         }
     }
 }
 impl KeyGenerator<Map> {
     pub fn next<T>(&self) -> Key<Keyed<T>> {
         Key {
             index: self.counter.fetch_add(1, Ordering::Relaxed),
-            witness: PhantomData
+            witness: PhantomData,
         }
     }
 }
-
-