for new protobuf version 2.10.1

Cargo.toml

 [package]
 name = "osmpbf"
-version = "0.1.14"
+version = "0.1.15"
 authors = ["Johannes Hofmann <mail@b-r-u.org>"]
 readme = "README.md"
 repository = "https://github.com/b-r-u/osmpbf"
 system-libz = ["flate2"]
 
 [dependencies]
-protobuf = "~2.10"
+protobuf = "=2.10.1"
 byteorder = "1.1"
 flate2 = { version = "1.0", optional = true }
 inflate = "0.4"

examples/count.rs

 use osmpbf::*;
 
 fn main() {
-    let arg = std::env::args_os().nth(1).expect("need a *.osm.pbf file as argument");
+    let arg = std::env::args_os()
+        .nth(1)
+        .expect("need a *.osm.pbf file as argument");
     let path = std::path::Path::new(&arg);
     let reader = ElementReader::from_path(path).unwrap();
 
     println!("Counting...");
 
     match reader.par_map_reduce(
-        |element| {
-            match element {
-                Element::Node(_) | Element::DenseNode(_) => (1, 0, 0),
-                Element::Way(_) => (0, 1, 0),
-                Element::Relation(_) => (0, 0, 1),
-            }
+        |element| match element {
+            Element::Node(_) | Element::DenseNode(_) => (1, 0, 0),
+            Element::Way(_) => (0, 1, 0),
+            Element::Relation(_) => (0, 0, 1),
         },
         || (0u64, 0u64, 0u64),
-        |a, b| (a.0 + b.0, a.1 + b.1, a.2 + b.2)
+        |a, b| (a.0 + b.0, a.1 + b.1, a.2 + b.2),
     ) {
         Ok((nodes, ways, relations)) => {
             println!("Nodes: {}", nodes);
             println!("Ways: {}", ways);
             println!("Relations: {}", relations);
-        },
+        }
         Err(e) => {
             println!("{}", e);
-        },
+        }
     }
 }

src/blob.rs

 //! Read and decode blobs
 
-extern crate protobuf;
 extern crate byteorder;
+extern crate protobuf;
 
 use block::{HeaderBlock, PrimitiveBlock};
 use byteorder::ReadBytesExt;
-use error::{BlobError, Result, new_blob_error, new_protobuf_error};
+use error::{new_blob_error, new_protobuf_error, BlobError, Result};
 use proto::fileformat;
 use std::fs::File;
 use std::io::{BufReader, Read, Seek, SeekFrom};
 #[cfg(not(feature = "system-libz"))]
 use inflate::DeflateDecoder;
 
-
 /// Maximum allowed `BlobHeader` size in bytes.
 pub static MAX_BLOB_HEADER_SIZE: u64 = 64 * 1024;
 
 /// Maximum allowed uncompressed `Blob` content size in bytes.
 pub static MAX_BLOB_MESSAGE_SIZE: u64 = 32 * 1024 * 1024;
 
-
 /// The content type of a blob.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum BlobType<'a> {
             BlobType::OsmHeader => {
                 let block = Box::new(self.to_headerblock()?);
                 Ok(BlobDecode::OsmHeader(block))
-
-            },
+            }
             BlobType::OsmData => {
                 let block = self.to_primitiveblock()?;
                 Ok(BlobDecode::OsmData(block))
-            },
+            }
             BlobType::Unknown(x) => Ok(BlobDecode::Unknown(x)),
         }
     }
     /// Tries to decode the blob to a `HeaderBlock`. This operation might involve an expensive
     /// decompression step.
     pub fn to_headerblock(&self) -> Result<HeaderBlock> {
-        decode_blob(&self.blob)
-            .map(HeaderBlock::new)
+        decode_blob(&self.blob).map(HeaderBlock::new)
     }
 
     /// Tries to decode the blob to a `PrimitiveBlock`. This operation might involve an expensive
     /// decompression step.
     pub fn to_primitiveblock(&self) -> Result<PrimitiveBlock> {
-        decode_blob(&self.blob)
-            .map(PrimitiveBlock::new)
+        decode_blob(&self.blob).map(PrimitiveBlock::new)
     }
 }
 
     /// # }
     /// # foo().unwrap();
     /// ```
-    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self>
-    {
+    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self> {
         let f = File::open(path)?;
         let reader = BufReader::new(f);
 
             Ok(n) => {
                 self.offset = self.offset.map(|x| ByteOffset(x.0 + 4));
                 u64::from(n)
-            },
+            }
             Err(e) => {
                 self.offset = None;
                 match e.kind() {
                     ::std::io::ErrorKind::UnexpectedEof => {
                         //TODO This also accepts corrupted files in the case of 1-3 available bytes
-                        return None
-                    },
+                        return None;
+                    }
                     _ => {
                         self.last_blob_ok = false;
                         return Some(Err(new_blob_error(BlobError::InvalidHeaderSize)));
-                    },
+                    }
                 }
-            },
+            }
         };
 
         if header_size >= MAX_BLOB_HEADER_SIZE {
             self.last_blob_ok = false;
-            return Some(Err(new_blob_error(BlobError::HeaderTooBig{size: header_size})));
+            return Some(Err(new_blob_error(BlobError::HeaderTooBig {
+                size: header_size,
+            })));
         }
 
-        let header: fileformat::BlobHeader = match parse_message_from_reader(&mut self.reader.by_ref().take(header_size)) {
-            Ok(header) => header,
-            Err(e) => {
-                self.offset = None;
-                self.last_blob_ok = false;
-                return Some(Err(new_protobuf_error(e, "blob header")));
-            },
-        };
+        let header: fileformat::BlobHeader =
+            match parse_message_from_reader(&mut self.reader.by_ref().take(header_size)) {
+                Ok(header) => header,
+                Err(e) => {
+                    self.offset = None;
+                    self.last_blob_ok = false;
+                    return Some(Err(new_protobuf_error(e, "blob header")));
+                }
+            };
 
-        let blob: fileformat::Blob = match parse_message_from_reader(&mut self.reader.by_ref().take(header.get_datasize() as u64)) {
+        let blob: fileformat::Blob = match parse_message_from_reader(
+            &mut self.reader.by_ref().take(header.get_datasize() as u64),
+        ) {
             Ok(blob) => blob,
             Err(e) => {
                 self.offset = None;
                 self.last_blob_ok = false;
                 return Some(Err(new_protobuf_error(e, "blob content")));
-            },
+            }
         };
 
-        self.offset = self.offset.map(|x| ByteOffset(
-            x.0 + header_size + header.get_datasize() as u64
-        ));
+        self.offset = self
+            .offset
+            .map(|x| ByteOffset(x.0 + header_size + header.get_datasize() as u64));
 
         Some(Ok(Blob::new(header, blob, prev_offset)))
     }
             Ok(offset) => {
                 self.offset = Some(ByteOffset(offset));
                 Ok(())
-            },
+            }
             Err(e) => {
                 self.offset = None;
                 Err(e.into())
-            },
+            }
         }
     }
 
             Ok(offset) => {
                 self.offset = Some(ByteOffset(offset));
                 Ok(offset)
-            },
+            }
             Err(e) => {
                 self.offset = None;
                 Err(e.into())
-            },
+            }
         }
     }
 }
 
 #[cfg(feature = "system-libz")]
 pub(crate) fn decode_blob<T>(blob: &fileformat::Blob) -> Result<T>
-    where T: protobuf::Message {
+where
+    T: protobuf::Message,
+{
     if blob.has_raw() {
         let size = blob.get_raw().len() as u64;
         if size < MAX_BLOB_MESSAGE_SIZE {
             parse_message_from_bytes(blob.get_raw())
                 .map_err(|e| new_protobuf_error(e, "raw blob data"))
         } else {
-            Err(new_blob_error(BlobError::MessageTooBig{size}))
+            Err(new_blob_error(BlobError::MessageTooBig { size }))
         }
     } else if blob.has_zlib_data() {
-        let mut decoder = ZlibDecoder::new(blob.get_zlib_data())
-            .take(MAX_BLOB_MESSAGE_SIZE);
-        parse_message_from_reader(&mut decoder)
-            .map_err(|e| new_protobuf_error(e, "blob zlib data"))
+        let mut decoder = ZlibDecoder::new(blob.get_zlib_data()).take(MAX_BLOB_MESSAGE_SIZE);
+        parse_message_from_reader(&mut decoder).map_err(|e| new_protobuf_error(e, "blob zlib data"))
     } else {
         Err(new_blob_error(BlobError::Empty))
     }
 
 #[cfg(not(feature = "system-libz"))]
 pub(crate) fn decode_blob<T>(blob: &fileformat::Blob) -> Result<T>
-    where T: protobuf::Message {
+where
+    T: protobuf::Message,
+{
     if blob.has_raw() {
         let size = blob.get_raw().len() as u64;
         if size < MAX_BLOB_MESSAGE_SIZE {
             parse_message_from_bytes(blob.get_raw())
                 .map_err(|e| new_protobuf_error(e, "raw blob data"))
         } else {
-            Err(new_blob_error(BlobError::MessageTooBig{size}))
+            Err(new_blob_error(BlobError::MessageTooBig { size }))
         }
     } else if blob.has_zlib_data() {
-        let mut decoder = DeflateDecoder::from_zlib(blob.get_zlib_data())
-            .take(MAX_BLOB_MESSAGE_SIZE);
-        parse_message_from_reader(&mut decoder)
-            .map_err(|e| new_protobuf_error(e, "blob zlib data"))
+        let mut decoder =
+            DeflateDecoder::from_zlib(blob.get_zlib_data()).take(MAX_BLOB_MESSAGE_SIZE);
+        parse_message_from_reader(&mut decoder).map_err(|e| new_protobuf_error(e, "blob zlib data"))
     } else {
         Err(new_blob_error(BlobError::Empty))
     }

src/block.rs

 //! `HeaderBlock`, `PrimitiveBlock` and `PrimitiveGroup`s
 
 use dense::DenseNodeIter;
-use elements::{Element, Node, Way, Relation};
-use error::{ErrorKind, Result, new_error};
+use elements::{Element, Node, Relation, Way};
+use error::{new_error, ErrorKind, Result};
 use proto::osmformat;
 use std;
 
-
 /// A `HeaderBlock`. It contains metadata about following `PrimitiveBlock`s.
 #[derive(Clone, Debug)]
 pub struct HeaderBlock {
 
     /// Calls the given closure on each element.
     pub fn for_each_element<F>(&self, mut f: F)
-        where F: for<'a> FnMut(Element<'a>)
+    where
+        F: for<'a> FnMut(Element<'a>),
     {
         for group in self.groups() {
             for node in group.nodes() {
 }
 
 impl<'a> PrimitiveGroup<'a> {
-    fn new(block: &'a osmformat::PrimitiveBlock,
-           group: &'a osmformat::PrimitiveGroup)
-          -> PrimitiveGroup<'a> {
-        PrimitiveGroup {
-            block,
-            group,
-        }
+    fn new(
+        block: &'a osmformat::PrimitiveBlock,
+        group: &'a osmformat::PrimitiveGroup,
+    ) -> PrimitiveGroup<'a> {
+        PrimitiveGroup { block, group }
     }
 
     /// Returns an iterator over the nodes in this group.
     DenseNode,
     Node,
     Way,
-    Relation
+    Relation,
 }
 
 impl<'a> BlockElementsIter<'a> {
     #[allow(clippy::option_option)]
     fn step(&mut self) -> Option<Option<Element<'a>>> {
         match self.state {
-            ElementsIterState::Group => {
-                match self.groups.next() {
-                    Some(group) => {
-                        self.state = ElementsIterState::DenseNode;
-                        self.dense_nodes = DenseNodeIter::new(self.block, group.get_dense());
-                        self.nodes = group.get_nodes().iter();
-                        self.ways = group.get_ways().iter();
-                        self.relations = group.get_relations().iter();
-                        None
-                    },
-                    None => Some(None),
+            ElementsIterState::Group => match self.groups.next() {
+                Some(group) => {
+                    self.state = ElementsIterState::DenseNode;
+                    self.dense_nodes = DenseNodeIter::new(self.block, group.get_dense());
+                    self.nodes = group.get_nodes().iter();
+                    self.ways = group.get_ways().iter();
+                    self.relations = group.get_relations().iter();
+                    None
                 }
+                None => Some(None),
             },
-            ElementsIterState::DenseNode => {
-                match self.dense_nodes.next() {
-                    Some(dense_node) => {
-                        Some(Some(Element::DenseNode(dense_node)))
-                    },
-                    None => {
-                        self.state = ElementsIterState::Node;
-                        None
-                    },
+            ElementsIterState::DenseNode => match self.dense_nodes.next() {
+                Some(dense_node) => Some(Some(Element::DenseNode(dense_node))),
+                None => {
+                    self.state = ElementsIterState::Node;
+                    None
                 }
             },
-            ElementsIterState::Node => {
-                match self.nodes.next() {
-                    Some(node) => {
-                        Some(Some(Element::Node(Node::new(self.block, node))))
-                    },
-                    None => {
-                        self.state = ElementsIterState::Way;
-                        None
-                    },
+            ElementsIterState::Node => match self.nodes.next() {
+                Some(node) => Some(Some(Element::Node(Node::new(self.block, node)))),
+                None => {
+                    self.state = ElementsIterState::Way;
+                    None
                 }
             },
-            ElementsIterState::Way => {
-                match self.ways.next() {
-                    Some(way) => {
-                        Some(Some(Element::Way(Way::new(self.block, way))))
-                    },
-                    None => {
-                        self.state = ElementsIterState::Relation;
-                        None
-                    },
+            ElementsIterState::Way => match self.ways.next() {
+                Some(way) => Some(Some(Element::Way(Way::new(self.block, way)))),
+                None => {
+                    self.state = ElementsIterState::Relation;
+                    None
                 }
             },
-            ElementsIterState::Relation => {
-                match self.relations.next() {
-                    Some(rel) => {
-                        Some(Some(Element::Relation(Relation::new(self.block, rel))))
-                    },
-                    None => {
-                        self.state = ElementsIterState::Group;
-                        None
-                    },
+            ElementsIterState::Relation => match self.relations.next() {
+                Some(rel) => Some(Some(Element::Relation(Relation::new(self.block, rel)))),
+                None => {
+                    self.state = ElementsIterState::Group;
+                    None
                 }
             },
         }
     }
 }
 
-
 /// An iterator over the groups in a `PrimitiveBlock`.
 #[derive(Clone, Debug)]
 pub struct GroupIter<'a> {
 }
 
 impl<'a> GroupNodeIter<'a> {
-    fn new(block: &'a osmformat::PrimitiveBlock,
-           group: &'a osmformat::PrimitiveGroup)
-          -> GroupNodeIter<'a> {
+    fn new(
+        block: &'a osmformat::PrimitiveBlock,
+        group: &'a osmformat::PrimitiveGroup,
+    ) -> GroupNodeIter<'a> {
         GroupNodeIter {
             block,
             nodes: group.get_nodes().iter(),
 }
 
 impl<'a> GroupWayIter<'a> {
-    fn new(block: &'a osmformat::PrimitiveBlock,
-           group: &'a osmformat::PrimitiveGroup)
-          -> GroupWayIter<'a> {
+    fn new(
+        block: &'a osmformat::PrimitiveBlock,
+        group: &'a osmformat::PrimitiveGroup,
+    ) -> GroupWayIter<'a> {
         GroupWayIter {
             block,
             ways: group.get_ways().iter(),
 }
 
 impl<'a> GroupRelationIter<'a> {
-    fn new(block: &'a osmformat::PrimitiveBlock,
-           group: &'a osmformat::PrimitiveGroup)
-          -> GroupRelationIter<'a> {
+    fn new(
+        block: &'a osmformat::PrimitiveBlock,
+        group: &'a osmformat::PrimitiveGroup,
+    ) -> GroupRelationIter<'a> {
         GroupRelationIter {
             block,
             rels: group.get_relations().iter(),
 
 impl<'a> ExactSizeIterator for GroupRelationIter<'a> {}
 
-pub(crate) fn str_from_stringtable(block: &osmformat::PrimitiveBlock, index: usize) -> Result<&str> {
+pub(crate) fn str_from_stringtable(
+    block: &osmformat::PrimitiveBlock,
+    index: usize,
+) -> Result<&str> {
     if let Some(vec) = block.get_stringtable().get_s().get(index) {
         std::str::from_utf8(vec)
-            .map_err(|e| new_error(ErrorKind::StringtableUtf8{err: e, index}))
+            .map_err(|e| new_error(ErrorKind::StringtableUtf8 { err: e, index }))
     } else {
-        Err(new_error(ErrorKind::StringtableIndexOutOfBounds{index}))
+        Err(new_error(ErrorKind::StringtableIndexOutOfBounds { index }))
     }
 }

src/dense.rs

 //! Iterate over the dense nodes in a `PrimitiveGroup`
 
+use block::str_from_stringtable;
 use error::Result;
 use proto::osmformat;
-use block::str_from_stringtable;
 use std;
 
-
 //TODO Add getter functions for id, version, uid, ...
 /// An OpenStreetMap node element from a compressed array of dense nodes (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Node)).
 #[derive(Clone, Debug)]
 pub struct DenseNodeIter<'a> {
     block: &'a osmformat::PrimitiveBlock,
     dids: std::slice::Iter<'a, i64>, // deltas
-    cid: i64, // current id
+    cid: i64,                        // current id
     versions: std::slice::Iter<'a, i32>,
     dtimestamps: std::slice::Iter<'a, i64>, // deltas
     ctimestamp: i64,
 }
 
 impl<'a> DenseNodeIter<'a> {
-    pub(crate) fn new(block: &'a osmformat::PrimitiveBlock,
-           osmdense: &'a osmformat::DenseNodes) -> DenseNodeIter<'a> {
+    pub(crate) fn new(
+        block: &'a osmformat::PrimitiveBlock,
+        osmdense: &'a osmformat::DenseNodes,
+    ) -> DenseNodeIter<'a> {
         let info = osmdense.get_denseinfo();
         DenseNodeIter {
             block,
     }
 }
 
-
 impl<'a> Iterator for DenseNodeIter<'a> {
     type Item = DenseNode<'a>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match (self.dids.next(),
-               self.versions.next(),
-               self.dtimestamps.next(),
-               self.dchangesets.next(),
-               self.duids.next(),
-               self.duser_sids.next(),
-               self.dlats.next(),
-               self.dlons.next()) {
-            (Some(did),
-             Some(version),
-             Some(dtimestamp),
-             Some(dchangeset),
-             Some(duid),
-             Some(duser_sid),
-             Some(dlat),
-             Some(dlon)) => {
+        match (
+            self.dids.next(),
+            self.versions.next(),
+            self.dtimestamps.next(),
+            self.dchangesets.next(),
+            self.duids.next(),
+            self.duser_sids.next(),
+            self.dlats.next(),
+            self.dlons.next(),
+        ) {
+            (
+                Some(did),
+                Some(version),
+                Some(dtimestamp),
+                Some(dchangeset),
+                Some(duid),
+                Some(duser_sid),
+                Some(dlat),
+                Some(dlon),
+            ) => {
                 self.cid += *did;
                 self.ctimestamp += *dtimestamp;
                 self.cchangeset += *dchangeset;
                     lon: self.clon,
                     keys_vals_indices: &self.keys_vals_slice[start_index..end_index],
                 })
-
-            },
+            }
             _ => None,
         }
     }
                 } else {
                     None
                 }
-            },
+            }
             _ => None,
         }
     }

src/elements.rs

 //! Nodes, ways and relations
 
-use error::Result;
 use block::str_from_stringtable;
 use dense::DenseNode;
-use proto::osmformat::PrimitiveBlock;
+use error::Result;
 use proto::osmformat;
+use proto::osmformat::PrimitiveBlock;
 use std;
 
-
 /// An enum with the OSM core elements: nodes, ways and relations.
 #[derive(Clone, Debug)]
 pub enum Element<'a> {
 
 impl<'a> Node<'a> {
     pub(crate) fn new(block: &'a PrimitiveBlock, osmnode: &'a osmformat::Node) -> Node<'a> {
-        Node {
-            block,
-            osmnode,
-        }
+        Node { block, osmnode }
     }
 
     /// Returns the node id. It should be unique between nodes and might be negative to indicate
 
     /// Returns the latitude coordinate in nanodegrees (10⁻⁹).
     pub fn nano_lat(&self) -> i64 {
-        self.block.get_lat_offset() + i64::from(self.block.get_granularity()) * self.osmnode.get_lat()
+        self.block.get_lat_offset()
+            + i64::from(self.block.get_granularity()) * self.osmnode.get_lat()
     }
 
     /// Returns the latitude coordinate in decimicrodegrees (10⁻⁷).
 
     /// Returns the longitude in nanodegrees (10⁻⁹).
     pub fn nano_lon(&self) -> i64 {
-        self.block.get_lon_offset() + i64::from(self.block.get_granularity()) * self.osmnode.get_lon()
+        self.block.get_lon_offset()
+            + i64::from(self.block.get_granularity()) * self.osmnode.get_lon()
     }
 
     /// Returns the longitude coordinate in decimicrodegrees (10⁻⁷).
 
 impl<'a> Way<'a> {
     pub(crate) fn new(block: &'a PrimitiveBlock, osmway: &'a osmformat::Way) -> Way<'a> {
-        Way {
-            block,
-            osmway,
-        }
+        Way { block, osmway }
     }
 
     /// Returns the way id.
     /// node id.
     pub fn refs(&self) -> WayRefIter<'a> {
         WayRefIter {
-           deltas: self.osmway.get_refs().iter(),
-           current: 0,
+            deltas: self.osmway.get_refs().iter(),
+            current: 0,
         }
     }
 
 
 impl<'a> Relation<'a> {
     pub(crate) fn new(block: &'a PrimitiveBlock, osmrel: &'a osmformat::Relation) -> Relation<'a> {
-        Relation {
-            block,
-            osmrel,
-        }
+        Relation { block, osmrel }
     }
 
     /// Returns the relation id.
             Some(&d) => {
                 self.current += d;
                 Some(self.current)
-            },
+            }
             None => None,
         }
     }
 pub enum RelMemberType {
     Node,
     Way,
-    Relation
+    Relation,
 }
 
 impl From<osmformat::Relation_MemberType> for RelMemberType {
     type Item = RelMember<'a>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        match (self.role_sids.next(),
-               self.member_id_deltas.next(),
-               self.member_types.next()) {
+        match (
+            self.role_sids.next(),
+            self.member_id_deltas.next(),
+            self.member_types.next(),
+        ) {
             (Some(role_sid), Some(mem_id_delta), Some(member_type)) => {
                 self.current_member_id += *mem_id_delta;
                 Some(RelMember {
                     member_id: self.current_member_id,
                     member_type: RelMemberType::from(*member_type),
                 })
-            },
+            }
             _ => None,
         }
     }
                 } else {
                     None
                 }
-            },
+            }
             _ => None,
         }
     }
 
 impl<'a> Info<'a> {
     fn new(block: &'a PrimitiveBlock, info: &'a osmformat::Info) -> Info<'a> {
-        Info {
-            block,
-            info,
-        }
+        Info { block, info }
     }
 
     /// Returns the version of this element.
     /// Returns the user name.
     pub fn user(&self) -> Option<Result<&'a str>> {
         if self.info.has_user_sid() {
-            Some(str_from_stringtable(self.block, self.info.get_user_sid() as usize))
+            Some(str_from_stringtable(
+                self.block,
+                self.info.get_user_sid() as usize,
+            ))
         } else {
             None
         }

src/error.rs

 }
 
 pub(crate) fn new_protobuf_error(err: ProtobufError, location: &'static str) -> Error {
-    Error(Box::new(ErrorKind::Protobuf{ err, location }))
+    Error(Box::new(ErrorKind::Protobuf { err, location }))
 }
 
 /// A type alias for `Result<T, osmpbf::Error>`.
     /// An error for I/O operations.
     Io(io::Error),
     /// An error that occurs when decoding a protobuf message.
-    Protobuf{err: ProtobufError, location: &'static str},
+    Protobuf {
+        err: ProtobufError,
+        location: &'static str,
+    },
     /// The stringtable contains an entry at `index` that could not be decoded to a valid UTF-8
     /// string.
-    StringtableUtf8{err: Utf8Error, index: usize},
+    StringtableUtf8 { err: Utf8Error, index: usize },
     /// An element contains an out-of-bounds index to the stringtable.
-    StringtableIndexOutOfBounds{index: usize},
+    StringtableIndexOutOfBounds { index: usize },
     /// An error that occurs when decoding `Blob`s.
     Blob(BlobError),
 
     //TODO add UnexpectedPrimitiveBlock
-
     /// Hints that destructuring should not be exhaustive.
     ///
     /// This enum may grow additional variants, so this makes sure clients
     /// Header size could not be decoded to a u32.
     InvalidHeaderSize,
     /// Blob header is bigger than [`MAX_BLOB_HEADER_SIZE`](blob/MAX_BLOB_HEADER_SIZE.v.html).
-    HeaderTooBig{
+    HeaderTooBig {
         /// Blob header size in bytes.
-        size: u64
+        size: u64,
     },
     /// Blob content is bigger than [`MAX_BLOB_MESSAGE_SIZE`](blob/MAX_BLOB_MESSAGE_SIZE.v.html).
-    MessageTooBig{
+    MessageTooBig {
         /// Blob content size in bytes.
-        size: u64
+        size: u64,
     },
     /// The blob is empty because the `raw` and `zlib-data` fields are missing.
     Empty,
     __Nonexhaustive,
 }
 
-
 impl From<io::Error> for Error {
     fn from(err: io::Error) -> Error {
         new_error(ErrorKind::Io(err))
     fn description(&self) -> &str {
         match *self.0 {
             ErrorKind::Io(ref err) => err.description(),
-            ErrorKind::Protobuf{ref err, ..} => err.description(),
-            ErrorKind::StringtableUtf8{ref err, ..} => err.description(),
-            ErrorKind::StringtableIndexOutOfBounds{..} => "stringtable index out of bounds",
-            ErrorKind::Blob(BlobError::InvalidHeaderSize) => "blob header size could not be decoded",
-            ErrorKind::Blob(BlobError::HeaderTooBig{..}) => "blob header is too big",
-            ErrorKind::Blob(BlobError::MessageTooBig{..}) => "blob message is too big",
+            ErrorKind::Protobuf { ref err, .. } => err.description(),
+            ErrorKind::StringtableUtf8 { ref err, .. } => err.description(),
+            ErrorKind::StringtableIndexOutOfBounds { .. } => "stringtable index out of bounds",
+            ErrorKind::Blob(BlobError::InvalidHeaderSize) => {
+                "blob header size could not be decoded"
+            }
+            ErrorKind::Blob(BlobError::HeaderTooBig { .. }) => "blob header is too big",
+            ErrorKind::Blob(BlobError::MessageTooBig { .. }) => "blob message is too big",
             ErrorKind::Blob(BlobError::Empty) => "blob is missing fields 'raw' and 'zlib_data",
             _ => unreachable!(),
         }
     fn cause(&self) -> Option<&dyn StdError> {
         match *self.0 {
             ErrorKind::Io(ref err) => Some(err),
-            ErrorKind::Protobuf{ref err, ..} => Some(err),
-            ErrorKind::StringtableUtf8{ref err, ..} => Some(err),
-            ErrorKind::StringtableIndexOutOfBounds{..} => None,
+            ErrorKind::Protobuf { ref err, .. } => Some(err),
+            ErrorKind::StringtableUtf8 { ref err, .. } => Some(err),
+            ErrorKind::StringtableIndexOutOfBounds { .. } => None,
             ErrorKind::Blob(BlobError::InvalidHeaderSize) => None,
-            ErrorKind::Blob(BlobError::HeaderTooBig{..}) => None,
-            ErrorKind::Blob(BlobError::MessageTooBig{..}) => None,
+            ErrorKind::Blob(BlobError::HeaderTooBig { .. }) => None,
+            ErrorKind::Blob(BlobError::MessageTooBig { .. }) => None,
             ErrorKind::Blob(BlobError::Empty) => None,
             _ => unreachable!(),
         }
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self.0 {
             ErrorKind::Io(ref err) => err.fmt(f),
-            ErrorKind::Protobuf{ref err, location} => {
+            ErrorKind::Protobuf { ref err, location } => {
                 write!(f, "protobuf error at '{}': {}", location, err)
-            },
-            ErrorKind::StringtableUtf8{ref err, index} => {
+            }
+            ErrorKind::StringtableUtf8 { ref err, index } => {
                 write!(f, "invalid UTF-8 at string table index {}: {}", index, err)
             }
             ErrorKind::StringtableIndexOutOfBounds { index } => {
                 write!(f, "stringtable index out of bounds: {}", index)
-            },
+            }
             ErrorKind::Blob(BlobError::InvalidHeaderSize) => {
                 write!(f, "blob header size could not be decoded")
-            },
+            }
             ErrorKind::Blob(BlobError::HeaderTooBig { size }) => {
                 write!(f, "blob header is too big: {} bytes", size)
-            },
+            }
             ErrorKind::Blob(BlobError::MessageTooBig { size }) => {
                 write!(f, "blob message is too big: {} bytes", size)
-            },
+            }
             ErrorKind::Blob(BlobError::Empty) => {
                 write!(f, "blob is missing fields 'raw' and 'zlib_data'")
-            },
+            }
             _ => unreachable!(),
         }
     }
 }
-

src/lib.rs

 #[cfg(not(feature = "system-libz"))]
 extern crate inflate;
 
-
 pub use blob::*;
 pub use block::*;
 pub use dense::*;
 pub use mmap_blob::*;
 pub use reader::*;
 
-mod error;
-mod proto;
-pub mod reader;
 pub mod blob;
 pub mod block;
 pub mod dense;
 pub mod elements;
+mod error;
 pub mod mmap_blob;
+mod proto;
+pub mod reader;
 mod util;

src/mmap_blob.rs

 //! Iterate over blobs from a memory map
 
-extern crate protobuf;
 extern crate byteorder;
 extern crate memmap;
+extern crate protobuf;
 
-use blob::{BlobDecode, ByteOffset, BlobType, decode_blob};
+use self::fileformat::BlobHeader;
+use blob::{decode_blob, BlobDecode, BlobType, ByteOffset};
 use block::{HeaderBlock, PrimitiveBlock};
 use byteorder::ByteOrder;
-use error::{BlobError, Result, new_blob_error, new_protobuf_error};
+use error::{new_blob_error, new_protobuf_error, BlobError, Result};
 use proto::{fileformat, osmformat};
-use self::fileformat::BlobHeader;
 use std::fs::File;
 use std::path::Path;
 use util::parse_message_from_bytes;
 
-
 /// A read-only memory map.
 #[derive(Debug)]
 pub struct Mmap {
 
         match slice.len() {
             0 => return None,
-            1 ..= 3 => {
+            1..=3 => {
                 self.last_blob_ok = false;
                 return Some(Err(new_blob_error(BlobError::InvalidHeaderSize)));
-            },
-            _ => {},
+            }
+            _ => {}
         }
 
         let header_size = byteorder::BigEndian::read_u32(slice) as usize;
 
         if header_size as u64 >= ::blob::MAX_BLOB_HEADER_SIZE {
             self.last_blob_ok = false;
-            return Some(Err(new_blob_error(BlobError::HeaderTooBig{size: header_size as u64})));
+            return Some(Err(new_blob_error(BlobError::HeaderTooBig {
+                size: header_size as u64,
+            })));
         }
 
         if slice.len() < 4 + header_size {
             self.last_blob_ok = false;
             let io_error = ::std::io::Error::new(
-                ::std::io::ErrorKind::UnexpectedEof, "content too short for header"
+                ::std::io::ErrorKind::UnexpectedEof,
+                "content too short for header",
             );
             return Some(Err(io_error.into()));
         }
             Err(e) => {
                 self.last_blob_ok = false;
                 return Some(Err(new_protobuf_error(e, "blob header")));
-            },
+            }
         };
 
         let data_size = header.get_datasize() as usize;
         if slice.len() < chunk_size {
             self.last_blob_ok = false;
             let io_error = ::std::io::Error::new(
-                ::std::io::ErrorKind::UnexpectedEof, "content too short for block data"
+                ::std::io::ErrorKind::UnexpectedEof,
+                "content too short for block data",
             );
             return Some(Err(io_error.into()));
         }

src/proto/fileformat.rs

-// This file is generated by rust-protobuf 2.10.0. Do not edit
+// This file is generated by rust-protobuf 2.10.1. Do not edit
 // @generated
 
-// https://github.com/Manishearth/rust-clippy/issues/702
+// https://github.com/rust-lang/rust-clippy/issues/702
 #![allow(unknown_lints)]
 #![allow(clippy::all)]
 
 
 /// Generated files are compatible only with the same version
 /// of protobuf runtime.
-const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_10_0;
+// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_10_1;
 
 #[derive(PartialEq,Clone,Default,Debug)]
 pub struct Blob {

src/proto/osmformat.rs

-// This file is generated by rust-protobuf 2.10.0. Do not edit
+// This file is generated by rust-protobuf 2.10.1. Do not edit
 // @generated
 
-// https://github.com/Manishearth/rust-clippy/issues/702
+// https://github.com/rust-lang/rust-clippy/issues/702
 #![allow(unknown_lints)]
 #![allow(clippy::all)]
 
 
 /// Generated files are compatible only with the same version
 /// of protobuf runtime.
-const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_10_0;
+// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_10_1;
 
 #[derive(PartialEq,Clone,Default,Debug)]
 pub struct HeaderBlock {

src/reader.rs

 use std::io::{BufReader, Read};
 use std::path::Path;
 
-
 /// A reader for PBF files that gives access to the stored elements: nodes, ways and relations.
 #[derive(Clone, Debug)]
 pub struct ElementReader<R: Read> {
     /// # foo().unwrap();
     /// ```
     pub fn for_each<F>(self, mut f: F) -> Result<()>
-        where F: for<'a> FnMut(Element<'a>) {
-
+    where
+        F: for<'a> FnMut(Element<'a>),
+    {
         let blobs = self.blob_iter.collect::<Result<Vec<_>>>()?;
 
         //TODO do something useful with header blocks
         for blob in &blobs {
             match blob.decode() {
-                Ok(BlobDecode::OsmHeader(_)) | Ok(BlobDecode::Unknown(_)) => {},
+                Ok(BlobDecode::OsmHeader(_)) | Ok(BlobDecode::Unknown(_)) => {}
                 Ok(BlobDecode::OsmData(block)) => {
                     block.for_each_element(&mut f);
-                },
+                }
                 Err(e) => return Err(e),
             }
         }
     /// # foo().unwrap();
     /// ```
     pub fn par_map_reduce<MP, RD, ID, T>(self, map_op: MP, identity: ID, reduce_op: RD) -> Result<T>
-        where MP: for<'a> Fn(Element<'a>) -> T + Sync + Send,
-              RD: Fn(T, T) -> T + Sync + Send,
-              ID: Fn() -> T + Sync + Send,
-              T: Send,
+    where
+        MP: for<'a> Fn(Element<'a>) -> T + Sync + Send,
+        RD: Fn(T, T) -> T + Sync + Send,
+        ID: Fn() -> T + Sync + Send,
+        T: Send,
     {
         let blobs = self.blob_iter.collect::<Result<Vec<_>>>()?;
 
-        blobs.into_par_iter().map(|blob| {
-            match blob.decode() {
-                Ok(BlobDecode::OsmHeader(_)) | Ok(BlobDecode::Unknown(_)) => {
-                    Ok(identity())
-                },
-                Ok(BlobDecode::OsmData(block)) => {
-                    Ok(block.elements()
-                            .map(|e| map_op(e))
-                            .fold(identity(), |a, b| reduce_op(a, b)))
-                },
+        blobs
+            .into_par_iter()
+            .map(|blob| match blob.decode() {
+                Ok(BlobDecode::OsmHeader(_)) | Ok(BlobDecode::Unknown(_)) => Ok(identity()),
+                Ok(BlobDecode::OsmData(block)) => Ok(block
+                    .elements()
+                    .map(|e| map_op(e))
+                    .fold(identity(), |a, b| reduce_op(a, b))),
                 Err(e) => Err(e),
-            }
-        }).reduce(|| Ok(identity()), |a, b| {
-            match (a, b) {
-                (Ok(x), Ok(y)) => Ok(reduce_op(x, y)),
-                (x, y) => x.and(y),
-            }
-        })
+            })
+            .reduce(
+                || Ok(identity()),
+                |a, b| match (a, b) {
+                    (Ok(x), Ok(y)) => Ok(reduce_op(x, y)),
+                    (x, y) => x.and(y),
+                },
+            )
     }
 }
 
     /// # }
     /// # foo().unwrap();
     /// ```
-    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self>
-    {
+    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self> {
         Ok(ElementReader {
             blob_iter: BlobReader::from_path(path)?,
         })

src/util.rs

 use protobuf::ProtobufError;
 use std::io::Read;
 
-
 pub(crate) fn parse_message_from_bytes<M>(bytes: &[u8]) -> Result<M, ProtobufError>
-    where M: ::protobuf::Message
+where
+    M: ::protobuf::Message,
 {
     let mut stream = ::protobuf::CodedInputStream::from_bytes(bytes);
     let mut message: M = ::protobuf::Message::new();
 }
 
 pub(crate) fn parse_message_from_reader<R, M>(reader: &mut R) -> Result<M, ProtobufError>
-    where R: Read,
-          M: ::protobuf::Message,
+where
+    R: Read,
+    M: ::protobuf::Message,
 {
     let mut stream = ::protobuf::CodedInputStream::new(reader);
     let mut message: M = ::protobuf::Message::new();

tests/read.rs

 use osmpbf::*;
 
 static TEST_FILE_PATHS: [&str; 3] = [
-"tests/test.osm.pbf",
-"tests/test_nozlib.osm.pbf",
-"tests/test_nozlib_nodense.osm.pbf",
+    "tests/test.osm.pbf",
+    "tests/test_nozlib.osm.pbf",
+    "tests/test_nozlib_nodense.osm.pbf",
 ];
 
 fn approx_eq(a: f64, b: f64) -> bool {
     for path in &TEST_FILE_PATHS {
         let reader = ElementReader::from_path(path).unwrap();
 
-        let elements = reader.par_map_reduce(
-            |_element| 1,
-            || 0_usize,
-            |a, b| a + b,
-        ).unwrap();
+        let elements = reader
+            .par_map_reduce(|_element| 1, || 0_usize, |a, b| a + b)
+            .unwrap();
 
         assert_eq!(elements, 5);
     }