which is now deprecated in stable Rust.

.travis.yml

 dist: trusty
-sudo: false
 language: rust
 rust:
   - stable
       cargo test --verbose;
       cargo test --verbose --no-default-features;
       cargo doc --verbose;
+env:
+  - RUSTFLAGS="-D warnings"

Cargo.toml

 [package]
 name = "osmpbf"
-version = "0.1.16"
+version = "0.1.17"
 authors = ["Johannes Hofmann <mail@b-r-u.org>"]
 readme = "README.md"
 repository = "https://github.com/b-r-u/osmpbf"

README.md

 osmpbf = "0.1"
 ```
 
-and this to your crate root:
+and if you're using Rust 2015, add this line to the crate root:
 
 ```rust
 extern crate osmpbf;

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/error.rs

 impl StdError for Error {
     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::Io(ref err, ..) => {
+                use std::io::ErrorKind;
+                match err.kind() {
+                    ErrorKind::NotFound => "io error: not found",
+                    ErrorKind::PermissionDenied => "io error: permission denied",
+                    ErrorKind::ConnectionRefused => "io error: connection refused",
+                    ErrorKind::ConnectionReset => "io error: connection reset",
+                    ErrorKind::ConnectionAborted => "io error: connection aborted",
+                    ErrorKind::NotConnected => "io error: not connected",
+                    ErrorKind::AddrInUse => "io error: address in use",
+                    ErrorKind::AddrNotAvailable => "io error: address not available",
+                    ErrorKind::BrokenPipe => "io error: broken pipe",
+                    ErrorKind::AlreadyExists => "io error: already exists",
+                    ErrorKind::WouldBlock => "io error: would block",
+                    ErrorKind::InvalidInput => "io error: invalid input",
+                    ErrorKind::InvalidData => "io error: invalid data",
+                    ErrorKind::TimedOut => "io error: timed out",
+                    ErrorKind::WriteZero => "io error: write zero",
+                    ErrorKind::Interrupted => "io error: interrupted",
+                    ErrorKind::Other => "io error: other",
+                    ErrorKind::UnexpectedEof => "io error: unexpected EOF",
+                    _ => "io error",
+                }
+            }
+            ErrorKind::Protobuf { .. } => "protobuf error",
+            ErrorKind::StringtableUtf8 { .. } => "UTF-8 error in stringtable",
             ErrorKind::StringtableIndexOutOfBounds { .. } => "stringtable index out of bounds",
             ErrorKind::Blob(BlobError::InvalidHeaderSize) => {
                 "blob header size could not be decoded"

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()).map(|x| *x).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);