Implement custom Error struct, remove error_chain

and fix some clippy warnings.

Cargo.toml

 byteorder = "1.1"
 flate2 = { version = "1.0", optional = true }
 inflate = "0.4"
-error-chain = "0.11"
 memmap = "0.6"
 rayon = "1.0"

examples/count.rs

 // Count the number of nodes, ways and relations in a PBF file given as the
 // first command line argument.
 
-extern crate error_chain;
 extern crate osmpbf;
 
 use osmpbf::*;
-use error_chain::ChainedError;
 
 fn main() {
     let arg = std::env::args_os().nth(1).expect("need a *.osm.pbf file as argument");
             println!("Relations: {}", relations);
         },
         Err(e) => {
-            println!("{}", e.display_chain().to_string());
+            println!("{}", e);
         },
     }
 }

src/blob.rs

 
 use block::{HeaderBlock, PrimitiveBlock};
 use byteorder::ReadBytesExt;
-use errors::*;
+use error::{BlobError, Result, new_blob_error, new_protobuf_error};
 use proto::fileformat;
 use std::fs::File;
 use std::io::{BufReader, Read};
 impl Blob {
     fn new(header: fileformat::BlobHeader, blob: fileformat::Blob) -> Blob {
         Blob {
-            header: header,
-            blob: blob
+            header,
+            blob
         }
     }
 
     pub fn to_headerblock(&self) -> Result<HeaderBlock> {
         decode_blob(&self.blob)
             .map(HeaderBlock::new)
-            .chain_err(|| "failed to decode blob to header block")
     }
 
     /// Tries to decode the blob to a `PrimitiveBlock`. This operation might involve an expensive
     pub fn to_primitiveblock(&self) -> Result<PrimitiveBlock> {
         decode_blob(&self.blob)
             .map(PrimitiveBlock::new)
-            .chain_err(|| "failed to decode blob to primitive block")
     }
 }
 
     /// ```
     pub fn new(reader: R) -> BlobReader<R> {
         BlobReader {
-            reader: reader,
+            reader,
             last_blob_ok: true,
         }
     }
             Err(e) => {
                 match e.kind() {
                     ::std::io::ErrorKind::UnexpectedEof => {
+                        //TODO This also accepts corrupted files in the case of 1-3 available bytes
                         return None
                     },
                     _ => {
                         self.last_blob_ok = false;
-                        return Some(Err(Error::with_chain(e, "Could not decode blob header size")));
+                        return Some(Err(new_blob_error(BlobError::InvalidHeaderSize)));
                     },
                 }
             },
 
         if header_size >= MAX_BLOB_HEADER_SIZE {
             self.last_blob_ok = false;
-            return Some(Err(ErrorKind::BlobHeaderTooBig(header_size).into()));
+            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.last_blob_ok = false;
-                return Some(Err(Error::with_chain(e, "Could not decode BlobHeader")));
+                return Some(Err(new_protobuf_error(e, "blob header")));
             },
         };
 
             Ok(blob) => blob,
             Err(e) => {
                 self.last_blob_ok = false;
-                return Some(Err(Error::with_chain(e, "Could not decode Blob")));
+                return Some(Err(new_protobuf_error(e, "blob content")));
             },
         };
 
     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()).chain_err(|| "Could not parse raw data")
+            parse_message_from_bytes(blob.get_raw())
+                .map_err(|e| new_protobuf_error(e, "raw blob data"))
         } else {
-            Err(ErrorKind::BlobMessageTooBig(size).into())
+            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).chain_err(|| "Could not parse zlib data")
+        parse_message_from_reader(&mut decoder)
+            .map_err(|e| new_protobuf_error(e, "blob zlib data"))
     } else {
-        bail!("Blob is missing fields 'raw' and 'zlib_data")
+        Err(new_blob_error(BlobError::Empty))
     }
 }
 
     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()).chain_err(|| "Could not parse raw data")
+            parse_message_from_bytes(blob.get_raw())
+                .map_err(|e| new_protobuf_error(e, "raw blob data"))
         } else {
-            Err(ErrorKind::BlobMessageTooBig(size).into())
+            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).chain_err(|| "Could not parse zlib data")
+        parse_message_from_reader(&mut decoder)
+            .map_err(|e| new_protobuf_error(e, "blob zlib data"))
     } else {
-        bail!("Blob is missing fields 'raw' and 'zlib_data")
+        Err(new_blob_error(BlobError::Empty))
     }
 }

src/block.rs

 
 use dense::DenseNodeIter;
 use elements::{Element, Node, Way, Relation};
-use errors::*;
+use error::{ErrorKind, Result, new_error};
 use proto::osmformat;
 use std;
 
 
 impl HeaderBlock {
     pub(crate) fn new(header: osmformat::HeaderBlock) -> HeaderBlock {
-        HeaderBlock { header: header }
+        HeaderBlock { header }
     }
 
     /// Returns a list of required features that a parser needs to implement to parse the following
 
 impl PrimitiveBlock {
     pub(crate) fn new(block: osmformat::PrimitiveBlock) -> PrimitiveBlock {
-        PrimitiveBlock { block: block }
+        PrimitiveBlock { block }
     }
 
     /// Returns an iterator over the elements in this `PrimitiveBlock`.
            group: &'a osmformat::PrimitiveGroup)
           -> PrimitiveGroup<'a> {
         PrimitiveGroup {
-            block: block,
-            group: group,
+            block,
+            group,
         }
     }
 
 impl<'a> BlockElementsIter<'a> {
     fn new(block: &'a osmformat::PrimitiveBlock) -> BlockElementsIter<'a> {
         BlockElementsIter {
-            block: block,
+            block,
             state: ElementsIterState::Group,
             groups: block.get_primitivegroup().iter(),
             dense_nodes: DenseNodeIter::empty(block),
 impl<'a> GroupIter<'a> {
     fn new(block: &'a osmformat::PrimitiveBlock) -> GroupIter<'a> {
         GroupIter {
-            block: block,
+            block,
             groups: block.get_primitivegroup().iter(),
         }
     }
            group: &'a osmformat::PrimitiveGroup)
           -> GroupNodeIter<'a> {
         GroupNodeIter {
-            block: block,
+            block,
             nodes: group.get_nodes().iter(),
         }
     }
            group: &'a osmformat::PrimitiveGroup)
           -> GroupWayIter<'a> {
         GroupWayIter {
-            block: block,
+            block,
             ways: group.get_ways().iter(),
         }
     }
            group: &'a osmformat::PrimitiveGroup)
           -> GroupRelationIter<'a> {
         GroupRelationIter {
-            block: block,
+            block,
             rels: group.get_relations().iter(),
         }
     }
 
 pub(crate) fn str_from_stringtable(block: &osmformat::PrimitiveBlock, index: usize) -> Result<&str> {
     if let Some(vec) = block.get_stringtable().get_s().get(index) {
+        //TODO at location to ErrorKind::Utf8
         std::str::from_utf8(vec)
-            .chain_err(|| "failed to decode string from string table")
+            .map_err(|e| new_error(ErrorKind::Utf8(e)))
     } else {
-        Err(ErrorKind::StringtableIndexOutOfBounds(index).into())
+        Err(new_error(ErrorKind::StringtableIndexOutOfBounds{index}))
     }
 }

src/dense.rs

 //! Iterate over the dense nodes in a `PrimitiveGroup`
 
-use errors::*;
+use error::Result;
 use proto::osmformat;
 use block::str_from_stringtable;
 use std;
            osmdense: &'a osmformat::DenseNodes) -> DenseNodeIter<'a> {
         let info = osmdense.get_denseinfo();
         DenseNodeIter {
-            block: block,
+            block,
             dids: osmdense.get_id().iter(),
             cid: 0,
             versions: info.get_version().iter(),
 
     pub(crate) fn empty(block: &'a osmformat::PrimitiveBlock) -> DenseNodeIter<'a> {
         DenseNodeIter {
-            block: block,
+            block,
             dids: [].iter(),
             cid: 0,
             versions: [].iter(),

src/elements.rs

 //! Nodes, ways and relations
 
-use errors::*;
+use error::Result;
 use block::str_from_stringtable;
 use dense::DenseNode;
 use proto::osmformat::PrimitiveBlock;
 impl<'a> Node<'a> {
     pub(crate) fn new(block: &'a PrimitiveBlock, osmnode: &'a osmformat::Node) -> Node<'a> {
         Node {
-            block: block,
-            osmnode: osmnode,
+            block,
+            osmnode,
         }
     }
 
 impl<'a> Way<'a> {
     pub(crate) fn new(block: &'a PrimitiveBlock, osmway: &'a osmformat::Way) -> Way<'a> {
         Way {
-            block: block,
-            osmway: osmway,
+            block,
+            osmway,
         }
     }
 
 impl<'a> Relation<'a> {
     pub(crate) fn new(block: &'a PrimitiveBlock, osmrel: &'a osmformat::Relation) -> Relation<'a> {
         Relation {
-            block: block,
-            osmrel: osmrel,
+            block,
+            osmrel,
         }
     }
 
 impl<'a> RelMemberIter<'a> {
     fn new(block: &'a PrimitiveBlock, osmrel: &'a osmformat::Relation) -> RelMemberIter<'a> {
         RelMemberIter {
-            block: block,
+            block,
             role_sids: osmrel.get_roles_sid().iter(),
             member_id_deltas: osmrel.get_memids().iter(),
             member_types: osmrel.get_types().iter(),
 impl<'a> Info<'a> {
     fn new(block: &'a PrimitiveBlock, info: &'a osmformat::Info) -> Info<'a> {
         Info {
-            block: block,
-            info: info,
+            block,
+            info,
         }
     }
 

src/error.rs

+use std::error::Error as StdError;
+use std::fmt;
+use std::io;
+use std::result;
+use std::str;
+use std::str::Utf8Error;
+
+use protobuf::ProtobufError;
+
+// Error data structures are modeled just like in the `csv` crate by BurntSushi.
+
+pub(crate) fn new_error(kind: ErrorKind) -> Error {
+    Error(Box::new(kind))
+}
+
+pub(crate) fn new_blob_error(kind: BlobError) -> Error {
+    Error(Box::new(ErrorKind::Blob(kind)))
+}
+
+pub(crate) fn new_protobuf_error(err: ProtobufError, location: &'static str) -> Error {
+    Error(Box::new(ErrorKind::Protobuf{ err, location }))
+}
+
+/// A type alias for `Result<T, osmpbf::Error>`.
+pub type Result<T> = result::Result<T, Error>;
+
+/// An error that can occur when reading PBF files.
+#[derive(Debug)]
+pub struct Error(Box<ErrorKind>);
+
+impl Error {
+    /// Return the specific type of this error.
+    pub fn kind(&self) -> &ErrorKind {
+        &self.0
+    }
+
+    /// Unwrap this error into its underlying type.
+    pub fn into_kind(self) -> ErrorKind {
+        *self.0
+    }
+}
+
+/// The specific type of an error.
+#[derive(Debug)]
+pub enum ErrorKind {
+    Io(io::Error),
+    Protobuf{err: ProtobufError, location: &'static str},
+    Utf8(Utf8Error),
+    StringtableIndexOutOfBounds{index: usize},
+    Blob(BlobError),
+
+    //TODO add UnexpectedPrimitiveBlock
+
+    /// Hints that destructuring should not be exhaustive.
+    ///
+    /// This enum may grow additional variants, so this makes sure clients
+    /// don't count on exhaustive matching. (Otherwise, adding a new variant
+    /// could break existing code.)
+    #[doc(hidden)]
+    __Nonexhaustive,
+}
+
+/// An error that occurs when decoding a blob.
+#[derive(Debug)]
+pub enum BlobError {
+    InvalidHeaderSize,
+    HeaderTooBig{size: u64},
+    MessageTooBig{size: u64},
+    Empty,
+    /// Hints that destructuring should not be exhaustive.
+    #[doc(hidden)]
+    __Nonexhaustive,
+}
+
+
+impl From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
+        new_error(ErrorKind::Io(err))
+    }
+}
+
+impl From<Error> for io::Error {
+    fn from(err: Error) -> io::Error {
+        io::Error::new(io::ErrorKind::Other, err)
+    }
+}
+
+impl StdError for Error {
+    fn description(&self) -> &str {
+        match *self.0 {
+            ErrorKind::Io(ref err) => err.description(),
+            ErrorKind::Protobuf{ref err, ..} => err.description(),
+            ErrorKind::Utf8(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<&StdError> {
+        match *self.0 {
+            ErrorKind::Io(ref err) => Some(err),
+            ErrorKind::Protobuf{ref err, ..} => Some(err),
+            ErrorKind::Utf8(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::Empty) => None,
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self.0 {
+            ErrorKind::Io(ref err) => err.fmt(f),
+            ErrorKind::Protobuf{ref err, location} => {
+                write!(f, "protobuf error at '{}': {}", location, err)
+            },
+            ErrorKind::Utf8(ref err) => err.fmt(f),
+            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/errors.rs

-error_chain!{
-    foreign_links {
-        Io(::std::io::Error);
-        Protobuf(::protobuf::ProtobufError);
-    }
-
-    errors {
-        StringtableIndexOutOfBounds(index: usize) {
-            description("stringtable index out of bounds")
-            display("stringtable index out of bounds: {}", index)
-        }
-
-        BlobHeaderTooBig(size: u64) {
-            description("blob header is too big")
-            display("blob header is too big: {} bytes", size)
-        }
-
-        BlobMessageTooBig(size: u64) {
-            description("blob message is too big")
-            display("blob message is too big: {} bytes", size)
-        }
-
-        //TODO add UnexpectedPrimitiveBlock
-    }
-}

src/lib.rs

 extern crate memmap;
 extern crate protobuf;
 extern crate rayon;
-#[macro_use]
-extern crate error_chain;
 
 #[cfg(feature = "system-libz")]
 extern crate flate2;
 pub use block::*;
 pub use dense::*;
 pub use elements::*;
-pub use errors::{Error, ErrorKind, Result, ResultExt};
+pub use error::{Error, ErrorKind, Result};
 pub use mmap_blob::*;
 pub use reader::*;
 
-mod errors;
+mod error;
 mod proto;
 pub mod reader;
 pub mod blob;

src/mmap_blob.rs

 use blob::{BlobDecode, BlobType, decode_blob};
 use block::{HeaderBlock, PrimitiveBlock};
 use byteorder::ByteOrder;
-use errors::*;
+use error::{BlobError, Result, new_blob_error, new_protobuf_error};
 use proto::{fileformat, osmformat};
 use self::fileformat::BlobHeader;
 use std::fs::File;
     pub unsafe fn from_file(file: &File) -> Result<Mmap> {
         memmap::Mmap::map(file)
             .map(|m| Mmap { mmap: m })
-            .chain_err(|| "Could not create memory map from file")
+            .map_err(|e| e.into())
     }
 
     /// Creates a memory map from a given path.
         let file = File::open(&path)?;
         memmap::Mmap::map(&file)
             .map(|m| Mmap { mmap: m })
-            .chain_err(|| format!("Could not create memory map from path {}", path.as_ref().display()))
+            .map_err(|e| e.into())
     }
 
     /// Returns an iterator over the blobs in this memory map.
     /// `PrimitiveBlock`). This operation might involve an expensive decompression step.
     pub fn decode(&'a self) -> Result<BlobDecode<'a>> {
         let blob: fileformat::Blob = parse_message_from_bytes(self.data)
-            .chain_err(|| "failed to parse Blob")?;
+            .map_err(|e| new_protobuf_error(e, "blob content"))?;
         match self.header.get_field_type() {
             "OSMHeader" => {
                 let block = Box::new(HeaderBlock::new(decode_blob(&blob)?));
     /// ```
     pub fn new(mmap: &Mmap) -> MmapBlobReader {
         MmapBlobReader {
-            mmap: mmap,
+            mmap,
             offset: 0,
             last_blob_ok: true,
         }
             0 => return None,
             1 ... 3 => {
                 self.last_blob_ok = false;
-                let io_error = ::std::io::Error::new(
-                    ::std::io::ErrorKind::UnexpectedEof, "failed to parse blob header length"
-                );
-                return Some(Err(Error::from_kind(ErrorKind::Io(io_error))));
+                return Some(Err(new_blob_error(BlobError::InvalidHeaderSize)));
             },
             _ => {},
         }
 
         if header_size as u64 >= ::blob::MAX_BLOB_HEADER_SIZE {
             self.last_blob_ok = false;
-            return Some(Err(ErrorKind::BlobHeaderTooBig(header_size as u64).into()));
+            return Some(Err(new_blob_error(BlobError::HeaderTooBig{size: header_size as u64})));
         }
 
         if slice.len() < 4 + header_size {
             let io_error = ::std::io::Error::new(
                 ::std::io::ErrorKind::UnexpectedEof, "content too short for header"
             );
-            return Some(Err(Error::from_kind(ErrorKind::Io(io_error))));
+            return Some(Err(io_error.into()));
         }
 
         let header: BlobHeader = match parse_message_from_bytes(&slice[4..(4 + header_size)]) {
             Ok(x) => x,
             Err(e) => {
                 self.last_blob_ok = false;
-                return Some(Err(e));
+                return Some(Err(new_protobuf_error(e, "blob header")));
             },
         };
 
             let io_error = ::std::io::Error::new(
                 ::std::io::ErrorKind::UnexpectedEof, "content too short for block data"
             );
-            return Some(Err(Error::from_kind(ErrorKind::Io(io_error))));
+            return Some(Err(io_error.into()));
         }
 
         self.offset += chunk_size;
 
         Some(Ok(MmapBlob {
-            header: header,
+            header,
             data: &slice[(4 + header_size)..chunk_size]
         }))
     }

src/reader.rs

 
 use blob::{BlobDecode, BlobReader};
 use elements::Element;
-use errors::*;
+use error::Result;
 use rayon::prelude::*;
 use std::fs::File;
 use std::io::{BufReader, Read};

src/util.rs

-use errors::*;
+use protobuf::ProtobufError;
 use std::io::Read;
 
 
-pub(crate) fn parse_message_from_bytes<M>(bytes: &[u8]) -> Result<M>
+pub(crate) fn parse_message_from_bytes<M>(bytes: &[u8]) -> Result<M, ProtobufError>
     where M: ::protobuf::Message
 {
     let mut stream = ::protobuf::CodedInputStream::from_bytes(bytes);
     if message.is_initialized() {
         Ok(message)
     } else {
-        Err(::protobuf::ProtobufError::message_not_initialized("").into())
+        Err(::protobuf::ProtobufError::message_not_initialized(""))
     }
 }
 
-pub(crate) fn parse_message_from_reader<R, M>(reader: &mut R) -> Result<M>
+pub(crate) fn parse_message_from_reader<R, M>(reader: &mut R) -> Result<M, ProtobufError>
     where R: Read,
           M: ::protobuf::Message,
 {
     if message.is_initialized() {
         Ok(message)
     } else {
-        Err(::protobuf::ProtobufError::message_not_initialized("").into())
+        Err(::protobuf::ProtobufError::message_not_initialized(""))
     }
 }