Run cargo fmt

examples/indexed.rs

 
 extern crate osmpbf;
 
-use osmpbf::{IndexedReader, Element};
+use osmpbf::{Element, IndexedReader};
 use std::error::Error;
 
 fn main() -> Result<(), Box<dyn Error>> {
                 Element::Way(_way) => ways += 1,
                 Element::Node(_node) => nodes += 1,
                 Element::DenseNode(_dense_node) => nodes += 1,
-                Element::Relation(_) => {}, // should not occur
+                Element::Relation(_) => {} // should not occur
             }
         },
     )?;

src/blob.rs

     }
 }
 
-
 /// A reader for PBF files that allows iterating over `Blob`s.
 #[derive(Clone, Debug)]
 pub struct BlobReader<R: Read + Send> {
                 }
             };
 
-        self.offset = self
-            .offset
-            .map(|x| ByteOffset(x.0 + header_size));
+        self.offset = self.offset.map(|x| ByteOffset(x.0 + header_size));
 
         Some(Ok(header))
     }

src/indexed.rs

     /// # }
     /// # foo().unwrap();
     /// ```
-    pub fn read_ways_and_deps<F, E>(
-        &mut self,
-        mut filter: F,
-        mut element_callback: E,
-    ) -> Result<()>
+    pub fn read_ways_and_deps<F, E>(&mut self, mut filter: F, mut element_callback: E) -> Result<()>
     where
         F: for<'a> FnMut(&Way<'a>) -> bool,
         E: for<'a> FnMut(&Element<'a>),
         //   * Iterate only over blobs that may include the node IDs we're searching for
         for info in &mut self.index {
             if info.blob_type == SimpleBlobType::Primitive {
-                if let Some(node_id_range) = info.id_ranges.as_ref().and_then(|r| r.node_ids.as_ref()) {
+                if let Some(node_id_range) =
+                    info.id_ranges.as_ref().and_then(|r| r.node_ids.as_ref())
+                {
                     if range_included(node_id_range.clone(), &node_ids) {
                         //TODO Only collect into Vec if range has a reasonable size
-                        let node_ids: Vec<i64> = node_ids.range(node_id_range.clone()).copied().collect();
+                        let node_ids: Vec<i64> =
+                            node_ids.range(node_id_range.clone()).copied().collect();
                         self.reader.seek(info.offset)?;
                         let blob = self.reader.next().ok_or_else(|| {
                             ::std::io::Error::new(
     #[test]
     fn test_range_included_set() {
         let mut set = BTreeSet::<i64>::new();
-        set.extend(&[1,2,6]);
+        set.extend(&[1, 2, 6]);
 
         assert_eq!(range_included(RangeInclusive::new(0, 0), &set), false);
         assert_eq!(range_included(RangeInclusive::new(1, 1), &set), true);

tests/read.rs

         let mut ways = 0;
         let mut nodes = 0;
 
-        reader.read_ways_and_deps(
-            |way| {
-                way.tags()
-                   .find(|&key_value| key_value == ("building", "yes"))
-                   .is_some()
-            },
-            |element| {
-                match element {
-                    Element::Way(_) => ways += 1,
-                    Element::Node(_) => nodes += 1,
-                    Element::DenseNode(_) => nodes += 1,
-                    Element::Relation(_) => panic!(), // should not occur
-                }
-            },
-        ).unwrap();
+        reader
+            .read_ways_and_deps(
+                |way| {
+                    way.tags()
+                        .find(|&key_value| key_value == ("building", "yes"))
+                        .is_some()
+                },
+                |element| {
+                    match element {
+                        Element::Way(_) => ways += 1,
+                        Element::Node(_) => nodes += 1,
+                        Element::DenseNode(_) => nodes += 1,
+                        Element::Relation(_) => panic!(), // should not occur
+                    }
+                },
+            )
+            .unwrap();
 
         assert_eq!(ways, 1);
         assert_eq!(nodes, 3);