Initial commit :>

Started 2015

.gitignore

@@ -0,0 +1,2 @@
+target
+.*.swp

Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "osmpbf"
+version = "0.1.0"
+authors = ["Johannes Hofmann <mail@b-r-u.org>"]
+license = "MIT/Apache-2.0"
+readme = "README.md"
+repository = "https://github.com/b-r-u/osmpbf"
+homepage = "https://github.com/b-r-u/osmpbf"
+build = "build.rs"
+description = """
+A reader for the OpenStreetMap PBF file format (*.osm.pbf).
+"""
+
+[features]
+default = ["system-libz"]
+system-libz = ["flate2"]
+
+[dependencies]
+protobuf = "1.4"
+byteorder = "1.1"
+flate2 = { version = "0.2", optional = true }
+inflate = "0.3"
+error-chain = "0.11"
+memmap = "0.6"
+rayon = "0.8.2"
+
+[build-dependencies]
+protoc-rust = "1.4"

LICENSE-APACHE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

LICENSE-MIT

@@ -0,0 +1,25 @@
+Copyright (c) 2014 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,121 @@
+osmpbf
+======
+A Rust library for reading the OpenStreetMap PBF file format (\*.osm.pbf). It
+strives to offer the best performance using parallelization and lazy-decoding
+with a simple interface while also exposing iterators for items of every level
+in a PBF file.
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+osmpbf = "0.1"
+```
+
+and this to your crate root:
+
+```rust
+extern crate osmbpf;
+```
+
+Here's a simple example that counts all the ways in a file:
+
+```rust
+extern crate osmpbf;
+
+use osmpbf::*;
+
+fn main() {
+    let reader = ElementReader::from_path("tests/test.osm.pbf").unwrap();
+    let mut ways = 0_u64;
+
+    // Increment the counter by one for each way.
+    reader.for_each(|element| {
+        if let Element::Way(_) = element {
+            ways += 1;
+        }
+    }).unwrap();
+
+    println!("Number of ways: {}", ways);
+}
+```
+
+In this second example, we also count the ways but make use of all cores by
+decoding the file in parallel:
+
+```rust
+use osmpbf::*;
+ 
+fn main() {
+    let reader = ElementReader::from_path("tests/test.osm.pbf").unwrap();
+
+    // Count the ways
+    let ways = reader.par_map_reduce(
+        |element| {
+            match element {
+                Element::Way(_) => 1,
+                _ => 0,
+            }
+        },
+        || 0_u64,      // Zero is the identity value for addition
+        |a, b| a + b   // Sum the partial results
+    ).unwrap();
+     
+    println!("Number of ways: {}", ways);
+}
+```
+
+## The PBF format
+
+To effectively use the more lower-level features of this library it is useful to
+have an overview of the structure of a PBF file. For a more detailed format
+description see [here](http://wiki.openstreetmap.org/wiki/PBF_Format) or take a
+look at the `.proto` files in this repository.
+
+The PBF format as a hierarchy (square brackets `[]` denote arrays):
+```
+Blob[]
+├── HeaderBlock
+└── PrimitiveBlock
+    └── Group[]
+    	├── Node[]
+    	├── DenseNodes
+    	├── Way[]
+        └── Relation[]
+```
+
+At the highest level a PBF file consists of a sequence of Blobs. Each Blob can
+be decoded into either a HeaderBlock or a PrimitiveBlock.
+
+Iterating over Blobs is very fast, but decoding might involve a more expensive
+decompression step. So especially for larger files it is advisable to
+parallelize at the Blob level as each Blob can be decompressed independently.
+
+Usually the first Blob of a file decodes to a HeaderBlock which holds global
+information for all following PrimitiveBlocks, such as a list of required
+parser features.
+
+A PrimitiveBlock contains an array of Groups (named `PrimitiveGroup` in
+osmformat.proto). Each Group only contains one element type: Node, Way,
+Relation or DenseNodes. A DenseNodes item is an alternative and space-saving
+representation of a Node array. So, do not forget to check for DenseNodes when
+aggregating all nodes in a file.
+
+Elements reference each other using integer IDs. Corresponding elements could be
+stored in any Blob, so finding them can involve iterating over the whole file.
+Some files declare an optional feature "Sort.Type_then_ID" in the HeaderBlock to
+indicate that elements are stored sorted by their type and then ID. This can be
+used to dramatically reduce the search space.
+
+# License
+
+This project is licensed under either of
+
+ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+   http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or
+   http://opensource.org/licenses/MIT)
+
+at your option.

build.rs

@@ -0,0 +1,15 @@
+extern crate protoc_rust;
+
+fn main() {
+    let proto_files = ["src/proto/fileformat.proto", "src/proto/osmformat.proto"];
+
+    for path in &proto_files {
+        println!("cargo:rerun-if-changed={}", path);
+    }
+
+    protoc_rust::run(protoc_rust::Args {
+        out_dir: "src/proto",
+        input: &proto_files,
+        includes: &[],
+    }).expect("protoc");
+}

examples/count.rs

@@ -0,0 +1,27 @@
+extern crate osmpbf;
+
+use osmpbf::*;
+
+fn main() {
+    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...");
+
+    let result = reader.par_map_reduce(
+        |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)
+    ).unwrap();
+
+    println!("Nodes: {}", result.0);
+    println!("Ways: {}", result.1);
+    println!("Relations: {}", result.2);
+}

src/blob.rs

@@ -0,0 +1,216 @@
+//! Read and decode blobs
+
+extern crate protobuf;
+extern crate byteorder;
+
+use block::{HeaderBlock, PrimitiveBlock};
+use byteorder::ReadBytesExt;
+use errors::*;
+use proto::fileformat;
+use std::fs::File;
+use std::io::{BufReader, ErrorKind, Read};
+use std::path::Path;
+
+#[cfg(feature = "system-libz")]
+use flate2::read::ZlibDecoder;
+
+#[cfg(not(feature = "system-libz"))]
+use inflate::DeflateDecoder;
+
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum BlobType<'a> {
+    OsmHeader,
+    OsmData,
+    Unknown(&'a str),
+}
+
+//TODO rename variants to fit proto files
+pub enum BlobDecode<'a> {
+    OsmHeader(HeaderBlock),
+    OsmData(PrimitiveBlock),
+    Unknown(&'a str),
+}
+
+/// A blob.
+/// 
+/// A PBF file consists of a sequence of blobs. This type supports decoding the content of a blob
+/// to different types of blocks that are usually more interesting to the user.
+pub struct Blob {
+    header: fileformat::BlobHeader,
+    blob: fileformat::Blob,
+}
+
+impl Blob {
+    fn new(header: fileformat::BlobHeader, blob: fileformat::Blob) -> Blob {
+        Blob {
+            header: header,
+            blob: blob
+        }
+    }
+
+    /// Decodes the Blob and tries to obtain the inner content (usually a `HeaderBlock` or a
+    /// `PrimitiveBlock`). This operation might involve an expensive decompression step.
+    pub fn decode(&self) -> Result<BlobDecode> {
+        match self.get_type() {
+            BlobType::OsmHeader => {
+                self.to_headerblock()
+                    .map(BlobDecode::OsmHeader)
+            },
+            BlobType::OsmData => {
+                self.to_primitiveblock()
+                    .map(BlobDecode::OsmData)
+            },
+            BlobType::Unknown(x) => Ok(BlobDecode::Unknown(x)),
+        }
+    }
+
+    /// Returns the type of a blob without decoding its content.
+    pub fn get_type(&self) -> BlobType {
+        match self.header.get_field_type() {
+            "OSMHeader" => BlobType::OsmHeader,
+            "OSMData" => BlobType::OsmData,
+            x => BlobType::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)
+            .chain_err(|| "failed to decode blob to header block")
+    }
+
+    /// 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)
+            .chain_err(|| "failed to decode blob to primitive block")
+    }
+}
+
+/// A reader for PBF files that allows iterating over `Blob`s.
+pub struct BlobReader<R: Read> {
+    reader: R,
+    last_blob_ok: bool,
+}
+
+impl<R: Read> BlobReader<R> {
+    /// Creates a new `ElementReader`.
+    /// 
+    /// # Example
+    /// ```
+    /// use osmpbf::*;
+    /// 
+    /// # fn foo() -> Result<()> {
+    /// let f = std::fs::File::open("tests/test.osm.pbf")?;
+    /// let buf_reader = std::io::BufReader::new(f);
+    /// 
+    /// let reader = ElementReader::new(buf_reader);
+    /// 
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn new(reader: R) -> BlobReader<R> {
+        BlobReader {
+            reader: reader,
+            last_blob_ok: true,
+        }
+    }
+}
+
+impl BlobReader<BufReader<File>> {
+    /// Tries to open the file at the given path and constructs a `BlobReader` from this.
+    /// 
+    /// # Errors
+    /// Returns the same errors that `std::fs::File::open` returns.
+    /// 
+    /// # Example
+    /// ```
+    /// use osmpbf::*;
+    /// 
+    /// # fn foo() -> Result<()> {
+    /// let reader = BlobReader::from_path("tests/test.osm.pbf")?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self>
+    {
+        let f = File::open(path)?;
+        let reader = BufReader::new(f);
+
+        Ok(BlobReader::new(reader))
+    }
+}
+
+impl<R: Read> Iterator for BlobReader<R> {
+    type Item = Result<Blob>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // Stop iteration if there was an error.
+        if !self.last_blob_ok {
+            return None;
+        }
+
+        let size: u64 = match self.reader.read_u32::<byteorder::BigEndian>() {
+            Ok(n) => u64::from(n),
+            Err(e) => {
+                match e.kind() {
+                    ErrorKind::UnexpectedEof => {
+                        return None
+                    },
+                    _ => {
+                        self.last_blob_ok = false;
+                        return Some(Err(Error::with_chain(e, "Could not decode blob size")));
+                    },
+                }
+            },
+        };
+
+        let header: fileformat::BlobHeader = match protobuf::parse_from_reader(&mut self.reader.by_ref().take(size)) {
+            Ok(header) => header,
+            Err(e) => {
+                self.last_blob_ok = false;
+                return Some(Err(Error::with_chain(e, "Could not decode BlobHeader")));
+            },
+        };
+
+        let blob: fileformat::Blob = match protobuf::parse_from_reader(&mut self.reader.by_ref().take(header.get_datasize() as u64)) {
+            Ok(blob) => blob,
+            Err(e) => {
+                self.last_blob_ok = false;
+                return Some(Err(Error::with_chain(e, "Could not decode Blob")));
+            },
+        };
+
+        Some(Ok(Blob::new(header, blob)))
+    }
+}
+
+#[cfg(feature = "system-libz")]
+pub(crate) fn decode_blob<T>(blob: &fileformat::Blob) -> Result<T>
+    where T: protobuf::Message + protobuf::MessageStatic {
+    if blob.has_raw() {
+        protobuf::parse_from_bytes(blob.get_raw()).chain_err(|| "Could not parse raw data")
+    } else if blob.has_zlib_data() {
+        let mut decoder = ZlibDecoder::new(blob.get_zlib_data());
+        protobuf::parse_from_reader(&mut decoder).chain_err(|| "Could not parse zlib data")
+    } else {
+        bail!("Blob is missing fields 'raw' and 'zlib_data")
+    }
+}
+
+#[cfg(not(feature = "system-libz"))]
+pub(crate) fn decode_blob<T>(blob: &fileformat::Blob) -> Result<T>
+    where T: protobuf::Message + protobuf::MessageStatic {
+    if blob.has_raw() {
+        protobuf::parse_from_bytes(blob.get_raw()).chain_err(|| "Could not parse raw data")
+    } else if blob.has_zlib_data() {
+        let mut decoder = DeflateDecoder::from_zlib(blob.get_zlib_data());
+        protobuf::parse_from_reader(&mut decoder).chain_err(|| "Could not parse zlib data")
+    } else {
+        bail!("Blob is missing fields 'raw' and 'zlib_data")
+    }
+}

src/block.rs

@@ -0,0 +1,211 @@
+//! `HeaderBlock`, `PrimitiveBlock` and `Group`s
+
+use dense::DenseNodeIter;
+use elements::{Node, Way, Relation};
+use errors::*;
+use proto::osmformat;
+use std;
+
+
+pub struct HeaderBlock {
+    header: osmformat::HeaderBlock,
+}
+
+impl HeaderBlock {
+    pub(crate) fn new(header: osmformat::HeaderBlock) -> HeaderBlock {
+        HeaderBlock { header: header }
+    }
+
+    pub fn required_features(&self) -> &[String] {
+        self.header.get_required_features()
+    }
+
+    pub fn optional_features(&self) -> &[String] {
+        self.header.get_optional_features()
+    }
+}
+
+pub struct PrimitiveBlock {
+    block: osmformat::PrimitiveBlock,
+}
+
+impl PrimitiveBlock {
+    pub fn new(block: osmformat::PrimitiveBlock) -> PrimitiveBlock {
+        PrimitiveBlock { block: block }
+    }
+
+    pub fn groups(&self) -> GroupIter {
+        GroupIter::new(&self.block)
+    }
+}
+
+pub struct PrimitiveGroup<'a> {
+    block: &'a osmformat::PrimitiveBlock,
+    group: &'a osmformat::PrimitiveGroup,
+}
+
+impl<'a> PrimitiveGroup<'a> {
+    fn new(block: &'a osmformat::PrimitiveBlock,
+           group: &'a osmformat::PrimitiveGroup)
+          -> PrimitiveGroup<'a> {
+        PrimitiveGroup {
+            block: block,
+            group: group,
+        }
+    }
+
+    pub fn nodes(&self) -> GroupNodeIter<'a> {
+        GroupNodeIter::new(self.block, self.group)
+    }
+
+    pub fn dense_nodes(&self) -> DenseNodeIter<'a> {
+        DenseNodeIter::new(self.block, self.group.get_dense())
+    }
+
+    pub fn ways(&self) -> GroupWayIter<'a> {
+        GroupWayIter::new(self.block, self.group)
+    }
+
+    pub fn relations(&self) -> GroupRelationIter<'a> {
+        GroupRelationIter::new(self.block, self.group)
+    }
+}
+
+pub struct GroupIter<'a> {
+    block: &'a osmformat::PrimitiveBlock,
+    groups: std::slice::Iter<'a, osmformat::PrimitiveGroup>,
+}
+
+impl<'a> GroupIter<'a> {
+    fn new(block: &'a osmformat::PrimitiveBlock) -> GroupIter<'a> {
+        GroupIter {
+            block: block,
+            groups: block.get_primitivegroup().iter(),
+        }
+    }
+}
+
+impl<'a> Iterator for GroupIter<'a> {
+    type Item = PrimitiveGroup<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.groups.next() {
+            Some(g) => Some(PrimitiveGroup::new(self.block, g)),
+            None => None,
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.groups.size_hint()
+    }
+}
+
+impl<'a> ExactSizeIterator for GroupIter<'a> {}
+
+pub struct GroupNodeIter<'a> {
+    block: &'a osmformat::PrimitiveBlock,
+    nodes: std::slice::Iter<'a, osmformat::Node>,
+}
+
+impl<'a> GroupNodeIter<'a> {
+    fn new(block: &'a osmformat::PrimitiveBlock,
+           group: &'a osmformat::PrimitiveGroup)
+          -> GroupNodeIter<'a> {
+        GroupNodeIter {
+            block: block,
+            nodes: group.get_nodes().iter(),
+        }
+    }
+}
+
+impl<'a> Iterator for GroupNodeIter<'a> {
+    type Item = Node<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.nodes.next() {
+            Some(n) => Some(Node::new(self.block, n)),
+            None => None,
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.nodes.size_hint()
+    }
+}
+
+impl<'a> ExactSizeIterator for GroupNodeIter<'a> {}
+
+pub struct GroupWayIter<'a> {
+    block: &'a osmformat::PrimitiveBlock,
+    ways: std::slice::Iter<'a, osmformat::Way>,
+}
+
+impl<'a> GroupWayIter<'a> {
+    fn new(block: &'a osmformat::PrimitiveBlock,
+           group: &'a osmformat::PrimitiveGroup)
+          -> GroupWayIter<'a> {
+        GroupWayIter {
+            block: block,
+            ways: group.get_ways().iter(),
+        }
+    }
+}
+
+impl<'a> Iterator for GroupWayIter<'a> {
+    type Item = Way<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.ways.next() {
+            Some(way) => Some(Way::new(self.block, way)),
+            None => None,
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.ways.size_hint()
+    }
+}
+
+impl<'a> ExactSizeIterator for GroupWayIter<'a> {}
+
+pub struct GroupRelationIter<'a> {
+    block: &'a osmformat::PrimitiveBlock,
+    rels: std::slice::Iter<'a, osmformat::Relation>,
+}
+
+impl<'a> GroupRelationIter<'a> {
+    fn new(block: &'a osmformat::PrimitiveBlock,
+           group: &'a osmformat::PrimitiveGroup)
+          -> GroupRelationIter<'a> {
+        GroupRelationIter {
+            block: block,
+            rels: group.get_relations().iter(),
+        }
+    }
+}
+
+impl<'a> Iterator for GroupRelationIter<'a> {
+    type Item = Relation<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.rels.next() {
+            Some(rel) => Some(Relation::new(self.block, rel)),
+            None => None,
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.rels.size_hint()
+    }
+}
+
+impl<'a> ExactSizeIterator for GroupRelationIter<'a> {}
+
+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)
+            .chain_err(|| "failed to decode string from string table")
+    } else {
+        Err(ErrorKind::StringtableIndexOutOfBounds(index).into())
+    }
+}

src/dense.rs

@@ -0,0 +1,196 @@
+//! Iterate over the dense nodes in a `PrimitiveGroup`
+
+use errors::*;
+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 DenseNodes (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Node)).
+pub struct DenseNode<'a> {
+    block: &'a osmformat::PrimitiveBlock,
+    pub id: i64,
+    pub version: i32,
+    timestamp: i64,
+    pub changeset: i64,
+    pub uid: i32,
+    pub user_sid: i32,
+    lat: i64,
+    lon: i64,
+    keys_vals_indices: &'a [i32],
+}
+
+impl<'a> DenseNode<'a> {
+    pub fn user(&self) -> Result<&'a str> {
+        str_from_stringtable(self.block, self.user_sid as usize)
+    }
+
+    pub fn lat(&self) -> f64 {
+        0.000_000_001_f64 * (self.block.get_lat_offset() +
+                             (i64::from(self.block.get_granularity()) *
+                              self.lat)) as f64
+    }
+
+    pub fn lon(&self) -> f64 {
+        0.000_000_001_f64 * (self.block.get_lon_offset() +
+                             (i64::from(self.block.get_granularity()) *
+                              self.lon)) as f64
+    }
+
+    pub fn milli_timestamp(&self) -> i64 {
+        self.timestamp * i64::from(self.block.get_date_granularity())
+    }
+
+    pub fn tags(&self) -> DenseTagIter<'a> {
+        DenseTagIter {
+            block: self.block,
+            keys_vals_indices: self.keys_vals_indices.iter(),
+        }
+    }
+}
+
+pub struct DenseNodeIter<'a> {
+    block: &'a osmformat::PrimitiveBlock,
+    dids: std::slice::Iter<'a, i64>, // deltas
+    cid: i64, // current id
+    versions: std::slice::Iter<'a, i32>,
+    dtimestamps: std::slice::Iter<'a, i64>, // deltas
+    ctimestamp: i64,
+    dchangesets: std::slice::Iter<'a, i64>, // deltas
+    cchangeset: i64,
+    duids: std::slice::Iter<'a, i32>, // deltas
+    cuid: i32,
+    duser_sids: std::slice::Iter<'a, i32>, // deltas
+    cuser_sid: i32,
+    dlats: std::slice::Iter<'a, i64>, // deltas
+    clat: i64,
+    dlons: std::slice::Iter<'a, i64>, // deltas
+    clon: i64,
+    keys_vals_slice: &'a [i32],
+    keys_vals_index: usize,
+}
+
+impl<'a> DenseNodeIter<'a> {
+    pub fn new(block: &'a osmformat::PrimitiveBlock,
+           osmdense: &'a osmformat::DenseNodes) -> DenseNodeIter<'a> {
+        let info = osmdense.get_denseinfo();
+        DenseNodeIter {
+            block: block,
+            dids: osmdense.get_id().iter(),
+            cid: 0,
+            versions: info.get_version().iter(),
+            dtimestamps: info.get_timestamp().iter(),
+            ctimestamp: 0,
+            dchangesets: info.get_changeset().iter(),
+            cchangeset: 0,
+            duids: info.get_uid().iter(),
+            cuid: 0,
+            duser_sids: info.get_user_sid().iter(),
+            cuser_sid: 0,
+            dlats: osmdense.get_lat().iter(),
+            clat: 0,
+            dlons: osmdense.get_lon().iter(),
+            clon: 0,
+            keys_vals_slice: osmdense.get_keys_vals(),
+            keys_vals_index: 0,
+        }
+    }
+}
+
+
+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)) => {
+                self.cid += *did;
+                self.ctimestamp += *dtimestamp;
+                self.cchangeset += *dchangeset;
+                self.cuid += *duid;
+                self.cuser_sid += *duser_sid;
+                self.clat += *dlat;
+                self.clon += *dlon;
+
+                let start_index = self.keys_vals_index;
+                let mut end_index = start_index;
+                for chunk in self.keys_vals_slice[self.keys_vals_index..].chunks(2) {
+                    if chunk[0] != 0 && chunk.len() == 2 {
+                        end_index += 2;
+                        self.keys_vals_index += 2;
+                    } else {
+                        self.keys_vals_index += 1;
+                        break;
+                    }
+                }
+
+                Some(DenseNode {
+                    block: self.block,
+                    id: self.cid,
+                    version: *version,
+                    timestamp: self.ctimestamp,
+                    changeset: self.cchangeset,
+                    uid: self.cuid,
+                    user_sid: self.cuser_sid,
+                    lat: self.clat,
+                    lon: self.clon,
+                    keys_vals_indices: &self.keys_vals_slice[start_index..end_index],
+                })
+
+            },
+            _ => None,
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.dids.size_hint()
+    }
+}
+
+impl<'a> ExactSizeIterator for DenseNodeIter<'a> {}
+
+pub struct DenseTagIter<'a> {
+    block: &'a osmformat::PrimitiveBlock,
+    keys_vals_indices: std::slice::Iter<'a, i32>,
+}
+
+//TODO return Result
+impl<'a> Iterator for DenseTagIter<'a> {
+    type Item = (&'a str, &'a str);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match (self.keys_vals_indices.next(), self.keys_vals_indices.next()) {
+            (Some(&key_index), Some(&val_index)) => {
+                let k_res = str_from_stringtable(self.block, key_index as usize);
+                let v_res = str_from_stringtable(self.block, val_index as usize);
+                if let (Ok(k), Ok(v)) = (k_res, v_res) {
+                    Some((k, v))
+                } else {
+                    None
+                }
+            },
+            _ => None,
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.keys_vals_indices.size_hint()
+    }
+}
+
+impl<'a> ExactSizeIterator for DenseTagIter<'a> {}

src/elements.rs

@@ -0,0 +1,364 @@
+//! Nodes, ways and relations
+
+use errors::*;
+use block::str_from_stringtable;
+use proto::osmformat::PrimitiveBlock;
+use proto::osmformat;
+use std;
+
+
+/// An OpenStreetMap node element (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Node)).
+pub struct Node<'a> {
+    block: &'a PrimitiveBlock,
+    osmnode: &'a osmformat::Node,
+}
+
+impl<'a> Node<'a> {
+    pub(crate) fn new(block: &'a PrimitiveBlock, osmnode: &'a osmformat::Node) -> Node<'a> {
+        Node {
+            block: block,
+            osmnode: osmnode,
+        }
+    }
+
+    /// Returns the node id. It should be unique between nodes and might be negative to indicate
+    /// that the element has not yet been uploaded to a server.
+    pub fn id(&self) -> i64 {
+        self.osmnode.get_id()
+    }
+
+    /// Returns an iterator over the tags of this node (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Tags)).
+    pub fn tags(&self) -> TagIter<'a> {
+        TagIter {
+            block: self.block,
+            key_indices: self.osmnode.get_keys().iter(),
+            val_indices: self.osmnode.get_vals().iter(),
+        }
+    }
+
+    /// Returns additional metadata for this element.
+    pub fn info(&self) -> Info<'a> {
+        Info::new(self.block, self.osmnode.get_info())
+    }
+
+    /// Returns the latitude coordinate in degrees.
+    pub fn lat(&self) -> f64 {
+        0.000_000_001_f64 * (self.block.get_lat_offset() +
+                             (i64::from(self.block.get_granularity()) *
+                              self.osmnode.get_lat())) as f64
+    }
+
+    /// Returns the longitude coordinate in degrees.
+    pub fn lon(&self) -> f64 {
+        0.000_000_001_f64 * (self.block.get_lon_offset() +
+                             (i64::from(self.block.get_granularity()) *
+                              self.osmnode.get_lon())) as f64
+    }
+}
+
+/// An OpenStreetMap way element (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Way)).
+/// 
+/// A way contains an ordered list of node references that can be accessed with the `refs` or the
+/// `refs_slice` method.
+pub struct Way<'a> {
+    block: &'a PrimitiveBlock,
+    osmway: &'a osmformat::Way,
+}
+
+impl<'a> Way<'a> {
+    pub(crate) fn new(block: &'a PrimitiveBlock, osmway: &'a osmformat::Way) -> Way<'a> {
+        Way {
+            block: block,
+            osmway: osmway,
+        }
+    }
+
+    /// Returns the way id.
+    pub fn id(&self) -> i64 {
+        self.osmway.get_id()
+    }
+
+    /// Returns an iterator over the tags of this way (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Tags)).
+    pub fn tags(&self) -> TagIter<'a> {
+        TagIter {
+            block: self.block,
+            key_indices: self.osmway.get_keys().iter(),
+            val_indices: self.osmway.get_vals().iter(),
+        }
+    }
+
+    /// Returns additional metadata for this element.
+    pub fn info(&self) -> Info<'a> {
+        Info::new(self.block, self.osmway.get_info())
+    }
+
+    /// Returns an iterator over the references of this way. Each reference should correspond to a
+    /// node id.
+    pub fn refs(&self) -> WayRefIter<'a> {
+        WayRefIter {
+           deltas: self.osmway.get_refs().iter(),
+           current: 0,
+        }
+    }
+
+    /// Returns a slice of references. Each reference should correspond to a node id.
+    pub fn refs_slice(&self) -> &[i64] {
+        self.osmway.get_refs()
+    }
+}
+
+/// An OpenStreetMap relation element (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Relation)).
+/// 
+/// A relation contains an ordered list of members that can be of any element type.
+pub struct Relation<'a> {
+    block: &'a PrimitiveBlock,
+    osmrel: &'a osmformat::Relation,
+}
+
+impl<'a> Relation<'a> {
+    pub(crate) fn new(block: &'a PrimitiveBlock, osmrel: &'a osmformat::Relation) -> Relation<'a> {
+        Relation {
+            block: block,
+            osmrel: osmrel,
+        }
+    }
+
+    /// Returns the relation id.
+    pub fn id(&self) -> i64 {
+        self.osmrel.get_id()
+    }
+
+    /// Returns an iterator over the tags of this relation (See [OSM wiki](http://wiki.openstreetmap.org/wiki/Tags)).
+    pub fn tags(&self) -> TagIter<'a> {
+        TagIter {
+            block: self.block,
+            key_indices: self.osmrel.get_keys().iter(),
+            val_indices: self.osmrel.get_vals().iter(),
+        }
+    }
+
+    /// Returns additional metadata for this element.
+    pub fn info(&self) -> Info<'a> {
+        Info::new(self.block, self.osmrel.get_info())
+    }
+
+    /// Returns an iterator over the members of this relation.
+    pub fn members(&self) -> RelMemberIter<'a> {
+        RelMemberIter::new(self.block, self.osmrel)
+    }
+}
+
+/// An iterator over the references of a way.
+/// 
+/// Each reference corresponds to a node id.
+pub struct WayRefIter<'a> {
+    deltas: std::slice::Iter<'a, i64>,
+    current: i64,
+}
+
+impl<'a> Iterator for WayRefIter<'a> {
+    type Item = i64;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.deltas.next() {
+            Some(&d) => {
+                self.current += d;
+                Some(self.current)
+            },
+            None => None,
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.deltas.size_hint()
+    }
+}
+
+impl<'a> ExactSizeIterator for WayRefIter<'a> {}
+
+/// The element type of a relation member.
+pub enum RelMemberType {
+    Node,
+    Way,
+    Relation
+}
+
+impl From<osmformat::Relation_MemberType> for RelMemberType {
+    fn from(rmt: osmformat::Relation_MemberType) -> RelMemberType {
+        match rmt {
+            osmformat::Relation_MemberType::NODE => RelMemberType::Node,
+            osmformat::Relation_MemberType::WAY => RelMemberType::Way,
+            osmformat::Relation_MemberType::RELATION => RelMemberType::Relation,
+        }
+    }
+}
+
+//TODO encapsulate member_id based on member_type (NodeId, WayId, RelationId)
+/// A member of a relation.
+/// 
+/// Each member has a member type and a member id that references an element of that type.
+pub struct RelMember<'a> {
+    block: &'a PrimitiveBlock,
+    pub role_sid: i32,
+    pub member_id: i64,
+    pub member_type: RelMemberType,
+}
+
+impl<'a> RelMember<'a> {
+    /// Returns the role of a relation member.
+    pub fn role(&self) -> Result<&'a str> {
+        str_from_stringtable(self.block, self.role_sid as usize)
+    }
+}
+
+/// An iterator over the members of a relation.
+pub struct RelMemberIter<'a> {
+    block: &'a PrimitiveBlock,
+    role_sids: std::slice::Iter<'a, i32>,
+    member_id_deltas: std::slice::Iter<'a, i64>,
+    member_types: std::slice::Iter<'a, osmformat::Relation_MemberType>,
+    current_member_id: i64,
+}
+
+impl<'a> RelMemberIter<'a> {
+    fn new(block: &'a PrimitiveBlock, osmrel: &'a osmformat::Relation) -> RelMemberIter<'a> {
+        RelMemberIter {
+            block: block,
+            role_sids: osmrel.get_roles_sid().iter(),
+            member_id_deltas: osmrel.get_memids().iter(),
+            member_types: osmrel.get_types().iter(),
+            current_member_id: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for RelMemberIter<'a> {
+    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()) {
+            (Some(role_sid), Some(mem_id_delta), Some(member_type)) => {
+                self.current_member_id += *mem_id_delta;
+                Some(RelMember {
+                    block: self.block,
+                    role_sid: *role_sid,
+                    member_id: self.current_member_id,
+                    member_type: RelMemberType::from(*member_type),
+                })
+            },
+            _ => None,
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.role_sids.size_hint()
+    }
+}
+
+impl<'a> ExactSizeIterator for RelMemberIter<'a> {}
+
+/// An iterator over the tags of an element.
+pub struct TagIter<'a> {
+    block: &'a PrimitiveBlock,
+    key_indices: std::slice::Iter<'a, u32>,
+    val_indices: std::slice::Iter<'a, u32>,
+}
+
+//TODO return Result?
+impl<'a> Iterator for TagIter<'a> {
+    type Item = (&'a str, &'a str);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match (self.key_indices.next(), self.val_indices.next()) {
+            (Some(&key_index), Some(&val_index)) => {
+                let k_res = str_from_stringtable(self.block, key_index as usize);
+                let v_res = str_from_stringtable(self.block, val_index as usize);
+                if let (Ok(k), Ok(v)) = (k_res, v_res) {
+                    Some((k, v))
+                } else {
+                    None
+                }
+            },
+            _ => None,
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.key_indices.size_hint()
+    }
+}
+
+impl<'a> ExactSizeIterator for TagIter<'a> {}
+
+/// Additional metadata that might be included in each element.
+pub struct Info<'a> {
+    block: &'a PrimitiveBlock,
+    info: &'a osmformat::Info,
+}
+
+impl<'a> Info<'a> {
+    fn new(block: &'a PrimitiveBlock, info: &'a osmformat::Info) -> Info<'a> {
+        Info {
+            block: block,
+            info: info,
+        }
+    }
+
+    /// Returns the version of this element.
+    pub fn version(&self) -> Option<i32> {
+        if self.info.has_version() {
+            Some(self.info.get_version())
+        } else {
+            None
+        }
+    }
+
+    /// Returns the time stamp in milliseconds since the epoch.
+    pub fn milli_timestamp(&self) -> Option<i64> {
+        if self.info.has_timestamp() {
+            Some(self.info.get_timestamp() * i64::from(self.block.get_date_granularity()))
+        } else {
+            None
+        }
+    }
+
+    /// Returns the changeset id.
+    pub fn changeset(&self) -> Option<i64> {
+        if self.info.has_changeset() {
+            Some(self.info.get_changeset())
+        } else {
+            None
+        }
+    }
+
+    /// Returns the user id.
+    pub fn uid(&self) -> Option<i32> {
+        if self.info.has_uid() {
+            Some(self.info.get_uid())
+        } else {
+            None
+        }
+    }
+
+    /// 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))
+        } else {
+            None
+        }
+    }
+
+    /// Returns the visibility status of an element. This is only relevant if the PBF file contains
+    /// historical information.
+    pub fn visible(&self) -> bool {
+        if self.info.has_visible() {
+            self.info.get_visible()
+        } else {
+            // If the visible flag is not present it must be assumed to be true.
+            true
+        }
+    }
+}

src/errors.rs

@@ -0,0 +1,15 @@
+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)
+        }
+
+        //TODO add UnexpectedPrimitiveBlock
+    }
+}

src/lib.rs

@@ -0,0 +1,35 @@
+//! A fast reader for the PBF file format (\*.osm.pbf) for OpenStreetMap data.
+
+#![recursion_limit = "1024"]
+
+extern crate byteorder;
+extern crate memmap;
+extern crate protobuf;
+extern crate rayon;
+#[macro_use]
+extern crate error_chain;
+
+#[cfg(feature = "system-libz")]
+extern crate flate2;
+
+#[cfg(not(feature = "system-libz"))]
+extern crate inflate;
+
+
+pub use blob::*;
+pub use block::*;
+pub use dense::*;
+pub use elements::*;
+pub use errors::{Error, ErrorKind, Result, ResultExt};
+pub use mmap_blob::*;
+pub use reader::*;
+
+mod errors;
+mod proto;
+pub mod reader;
+pub mod blob;
+pub mod block;
+pub mod dense;
+pub mod elements;
+pub mod mmap_blob;
+

src/mmap_blob.rs

@@ -0,0 +1,142 @@
+//! Iterate over blobs from a memory map
+
+extern crate protobuf;
+extern crate byteorder;
+extern crate memmap;
+
+use blob::{BlobDecode, decode_blob};
+use byteorder::ByteOrder;
+use errors::*;
+use block::{HeaderBlock, PrimitiveBlock};
+use proto::{fileformat, osmformat};
+use self::fileformat::BlobHeader;
+use std::fs::File;
+use std::path::Path;
+
+
+pub struct Mmap {
+    mmap: memmap::Mmap,
+}
+
+impl Mmap {
+    // The underlying file should not be modified while holding the memory map.
+    // See https://github.com/danburkert/memmap-rs/issues/25
+    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")
+    }
+
+    // The underlying file should not be modified while holding the memory map.
+    // See https://github.com/danburkert/memmap-rs/issues/25
+    pub unsafe fn from_path<P: AsRef<Path>>(path: P) -> Result<Mmap> {
+        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()))
+    }
+
+    pub fn blob_iter(&self) -> MmapBlobReader {
+        MmapBlobReader::new(self)
+    }
+
+    fn as_slice(&self) -> &[u8] {
+        &self.mmap
+    }
+}
+
+pub struct MmapBlob<'a> {
+    header: BlobHeader,
+    data: &'a [u8],
+}
+
+impl<'a> MmapBlob<'a> {
+    pub fn decode(&'a self) -> Result<BlobDecode<'a>> {
+        let blob: fileformat::Blob = protobuf::parse_from_bytes(self.data)
+            .chain_err(|| "failed to parse Blob")?;
+        match self.header.get_field_type() {
+            "OSMHeader" => {
+                let block: osmformat::HeaderBlock = decode_blob(&blob).unwrap();
+                Ok(BlobDecode::OsmHeader(HeaderBlock::new(block)))
+            }
+            "OSMData" => {
+                let block: osmformat::PrimitiveBlock = decode_blob(&blob).unwrap();
+                Ok(BlobDecode::OsmData(PrimitiveBlock::new(block)))
+            }
+            x => Ok(BlobDecode::Unknown(x)),
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct MmapBlobReader<'a> {
+    mmap: &'a Mmap,
+    offset: usize,
+    last_blob_ok: bool,
+}
+
+impl<'a> MmapBlobReader<'a> {
+    pub fn new(mmap: &Mmap) -> MmapBlobReader {
+        MmapBlobReader {
+            mmap: mmap,
+            offset: 0,
+            last_blob_ok: true,
+        }
+    }
+}
+
+impl<'a> Iterator for MmapBlobReader<'a> {
+    type Item = Result<MmapBlob<'a>>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let slice = &self.mmap.as_slice()[self.offset..];
+
+        match slice.len() {
+            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 length"
+                );
+                return Some(Err(Error::from_kind(ErrorKind::Io(io_error))));
+            },
+            _ => {},
+        }
+
+        let header_size = byteorder::BigEndian::read_u32(slice) as usize;
+
+        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"
+            );
+            return Some(Err(Error::from_kind(ErrorKind::Io(io_error))));
+        }
+
+        let header: BlobHeader = match protobuf::parse_from_bytes(&slice[4..(4 + header_size)]) {
+            Ok(x) => x,
+            Err(e) => {
+                self.last_blob_ok = false;
+                return Some(Err(e.into()));
+            },
+        };
+
+        let data_size = header.get_datasize() as usize;
+        let chunk_size = 4 + header_size + data_size;
+
+        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"
+            );
+            return Some(Err(Error::from_kind(ErrorKind::Io(io_error))));
+        }
+
+        self.offset += chunk_size;
+
+        Some(Ok(MmapBlob {
+            header: header,
+            data: &slice[(4 + header_size)..chunk_size]
+        }))
+    }
+}

src/proto/fileformat.proto

@@ -0,0 +1,54 @@
+/** Copyright (c) 2010 Scott A. Crosby. <scott@sacrosby.com>
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as 
+   published by the Free Software Foundation, either version 3 of the 
+   License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+option optimize_for = LITE_RUNTIME;
+option java_package = "crosby.binary";
+package OSMPBF;
+
+//protoc --java_out=../.. fileformat.proto
+
+
+//
+//  STORAGE LAYER: Storing primitives.
+//
+
+message Blob {
+  optional bytes raw = 1; // No compression
+  optional int32 raw_size = 2; // When compressed, the uncompressed size
+
+  // Possible compressed versions of the data.
+  optional bytes zlib_data = 3;
+
+  // PROPOSED feature for LZMA compressed data. SUPPORT IS NOT REQUIRED.
+  optional bytes lzma_data = 4;
+
+  // Formerly used for bzip2 compressed data. Depreciated in 2010.
+  optional bytes OBSOLETE_bzip2_data = 5 [deprecated=true]; // Don't reuse this tag number.
+}
+
+/* A file contains an sequence of fileblock headers, each prefixed by
+their length in network byte order, followed by a data block
+containing the actual data. types staring with a "_" are reserved.
+*/
+
+message BlobHeader {
+  required string type = 1;
+  optional bytes indexdata = 2;
+  required int32 datasize = 3;
+}
+
+

src/proto/fileformat.rs

@@ -0,0 +1,648 @@
+// This file is generated. Do not edit
+// @generated
+
+// https://github.com/Manishearth/rust-clippy/issues/702
+#![allow(unknown_lints)]
+#![allow(clippy)]
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
+
+#![allow(box_pointers)]
+#![allow(dead_code)]
+#![allow(missing_docs)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+#![allow(trivial_casts)]
+#![allow(unsafe_code)]
+#![allow(unused_imports)]
+#![allow(unused_results)]
+
+use protobuf::Message as Message_imported_for_functions;
+use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions;
+
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct Blob {
+    // message fields
+    raw: ::protobuf::SingularField<::std::vec::Vec<u8>>,
+    raw_size: ::std::option::Option<i32>,
+    zlib_data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
+    lzma_data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
+    OBSOLETE_bzip2_data: ::protobuf::SingularField<::std::vec::Vec<u8>>,
+    // special fields
+    unknown_fields: ::protobuf::UnknownFields,
+    cached_size: ::protobuf::CachedSize,
+}
+
+// see codegen.rs for the explanation why impl Sync explicitly
+unsafe impl ::std::marker::Sync for Blob {}
+
+impl Blob {
+    pub fn new() -> Blob {
+        ::std::default::Default::default()
+    }
+
+    pub fn default_instance() -> &'static Blob {
+        static mut instance: ::protobuf::lazy::Lazy<Blob> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const Blob,
+        };
+        unsafe {
+            instance.get(Blob::new)
+        }
+    }
+
+    // optional bytes raw = 1;
+
+    pub fn clear_raw(&mut self) {
+        self.raw.clear();
+    }
+
+    pub fn has_raw(&self) -> bool {
+        self.raw.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_raw(&mut self, v: ::std::vec::Vec<u8>) {
+        self.raw = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_raw(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.raw.is_none() {
+            self.raw.set_default();
+        }
+        self.raw.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_raw(&mut self) -> ::std::vec::Vec<u8> {
+        self.raw.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    pub fn get_raw(&self) -> &[u8] {
+        match self.raw.as_ref() {
+            Some(v) => &v,
+            None => &[],
+        }
+    }
+
+    fn get_raw_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec<u8>> {
+        &self.raw
+    }
+
+    fn mut_raw_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec<u8>> {
+        &mut self.raw
+    }
+
+    // optional int32 raw_size = 2;
+
+    pub fn clear_raw_size(&mut self) {
+        self.raw_size = ::std::option::Option::None;
+    }
+
+    pub fn has_raw_size(&self) -> bool {
+        self.raw_size.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_raw_size(&mut self, v: i32) {
+        self.raw_size = ::std::option::Option::Some(v);
+    }
+
+    pub fn get_raw_size(&self) -> i32 {
+        self.raw_size.unwrap_or(0)
+    }
+
+    fn get_raw_size_for_reflect(&self) -> &::std::option::Option<i32> {
+        &self.raw_size
+    }
+
+    fn mut_raw_size_for_reflect(&mut self) -> &mut ::std::option::Option<i32> {
+        &mut self.raw_size
+    }
+
+    // optional bytes zlib_data = 3;
+
+    pub fn clear_zlib_data(&mut self) {
+        self.zlib_data.clear();
+    }
+
+    pub fn has_zlib_data(&self) -> bool {
+        self.zlib_data.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_zlib_data(&mut self, v: ::std::vec::Vec<u8>) {
+        self.zlib_data = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_zlib_data(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.zlib_data.is_none() {
+            self.zlib_data.set_default();
+        }
+        self.zlib_data.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_zlib_data(&mut self) -> ::std::vec::Vec<u8> {
+        self.zlib_data.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    pub fn get_zlib_data(&self) -> &[u8] {
+        match self.zlib_data.as_ref() {
+            Some(v) => &v,
+            None => &[],
+        }
+    }
+
+    fn get_zlib_data_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec<u8>> {
+        &self.zlib_data
+    }
+
+    fn mut_zlib_data_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec<u8>> {
+        &mut self.zlib_data
+    }
+
+    // optional bytes lzma_data = 4;
+
+    pub fn clear_lzma_data(&mut self) {
+        self.lzma_data.clear();
+    }
+
+    pub fn has_lzma_data(&self) -> bool {
+        self.lzma_data.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_lzma_data(&mut self, v: ::std::vec::Vec<u8>) {
+        self.lzma_data = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_lzma_data(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.lzma_data.is_none() {
+            self.lzma_data.set_default();
+        }
+        self.lzma_data.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_lzma_data(&mut self) -> ::std::vec::Vec<u8> {
+        self.lzma_data.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    pub fn get_lzma_data(&self) -> &[u8] {
+        match self.lzma_data.as_ref() {
+            Some(v) => &v,
+            None => &[],
+        }
+    }
+
+    fn get_lzma_data_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec<u8>> {
+        &self.lzma_data
+    }
+
+    fn mut_lzma_data_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec<u8>> {
+        &mut self.lzma_data
+    }
+
+    // optional bytes OBSOLETE_bzip2_data = 5;
+
+    pub fn clear_OBSOLETE_bzip2_data(&mut self) {
+        self.OBSOLETE_bzip2_data.clear();
+    }
+
+    pub fn has_OBSOLETE_bzip2_data(&self) -> bool {
+        self.OBSOLETE_bzip2_data.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_OBSOLETE_bzip2_data(&mut self, v: ::std::vec::Vec<u8>) {
+        self.OBSOLETE_bzip2_data = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_OBSOLETE_bzip2_data(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.OBSOLETE_bzip2_data.is_none() {
+            self.OBSOLETE_bzip2_data.set_default();
+        }
+        self.OBSOLETE_bzip2_data.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_OBSOLETE_bzip2_data(&mut self) -> ::std::vec::Vec<u8> {
+        self.OBSOLETE_bzip2_data.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    pub fn get_OBSOLETE_bzip2_data(&self) -> &[u8] {
+        match self.OBSOLETE_bzip2_data.as_ref() {
+            Some(v) => &v,
+            None => &[],
+        }
+    }
+
+    fn get_OBSOLETE_bzip2_data_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec<u8>> {
+        &self.OBSOLETE_bzip2_data
+    }
+
+    fn mut_OBSOLETE_bzip2_data_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec<u8>> {
+        &mut self.OBSOLETE_bzip2_data
+    }
+}
+
+impl ::protobuf::Message for Blob {
+    fn is_initialized(&self) -> bool {
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.raw)?;
+                },
+                2 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_int32()?;
+                    self.raw_size = ::std::option::Option::Some(tmp);
+                },
+                3 => {
+                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.zlib_data)?;
+                },
+                4 => {
+                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.lzma_data)?;
+                },
+                5 => {
+                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.OBSOLETE_bzip2_data)?;
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        if let Some(ref v) = self.raw.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(1, &v);
+        }
+        if let Some(v) = self.raw_size {
+            my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
+        }
+        if let Some(ref v) = self.zlib_data.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(3, &v);
+        }
+        if let Some(ref v) = self.lzma_data.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(4, &v);
+        }
+        if let Some(ref v) = self.OBSOLETE_bzip2_data.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(5, &v);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
+        if let Some(ref v) = self.raw.as_ref() {
+            os.write_bytes(1, &v)?;
+        }
+        if let Some(v) = self.raw_size {
+            os.write_int32(2, v)?;
+        }
+        if let Some(ref v) = self.zlib_data.as_ref() {
+            os.write_bytes(3, &v)?;
+        }
+        if let Some(ref v) = self.lzma_data.as_ref() {
+            os.write_bytes(4, &v)?;
+        }
+        if let Some(ref v) = self.OBSOLETE_bzip2_data.as_ref() {
+            os.write_bytes(5, &v)?;
+        }
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &::std::any::Any {
+        self as &::std::any::Any
+    }
+    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
+        self as &mut ::std::any::Any
+    }
+    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        ::protobuf::MessageStatic::descriptor_static(None::<Self>)
+    }
+}
+
+impl ::protobuf::MessageStatic for Blob {
+    fn new() -> Blob {
+        Blob::new()
+    }
+}
+
+impl ::protobuf::Clear for Blob {
+    fn clear(&mut self) {
+        self.clear_raw();
+        self.clear_raw_size();
+        self.clear_zlib_data();
+        self.clear_lzma_data();
+        self.clear_OBSOLETE_bzip2_data();
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for Blob {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    }
+}
+
+#[derive(PartialEq,Clone,Default,Debug)]
+pub struct BlobHeader {
+    // message fields
+    field_type: ::protobuf::SingularField<::std::string::String>,
+    indexdata: ::protobuf::SingularField<::std::vec::Vec<u8>>,
+    datasize: ::std::option::Option<i32>,
+    // special fields
+    unknown_fields: ::protobuf::UnknownFields,
+    cached_size: ::protobuf::CachedSize,
+}
+
+// see codegen.rs for the explanation why impl Sync explicitly
+unsafe impl ::std::marker::Sync for BlobHeader {}
+
+impl BlobHeader {
+    pub fn new() -> BlobHeader {
+        ::std::default::Default::default()
+    }
+
+    pub fn default_instance() -> &'static BlobHeader {
+        static mut instance: ::protobuf::lazy::Lazy<BlobHeader> = ::protobuf::lazy::Lazy {
+            lock: ::protobuf::lazy::ONCE_INIT,
+            ptr: 0 as *const BlobHeader,
+        };
+        unsafe {
+            instance.get(BlobHeader::new)
+        }
+    }
+
+    // required string type = 1;
+
+    pub fn clear_field_type(&mut self) {
+        self.field_type.clear();
+    }
+
+    pub fn has_field_type(&self) -> bool {
+        self.field_type.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_field_type(&mut self, v: ::std::string::String) {
+        self.field_type = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_field_type(&mut self) -> &mut ::std::string::String {
+        if self.field_type.is_none() {
+            self.field_type.set_default();
+        }
+        self.field_type.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_field_type(&mut self) -> ::std::string::String {
+        self.field_type.take().unwrap_or_else(|| ::std::string::String::new())
+    }
+
+    pub fn get_field_type(&self) -> &str {
+        match self.field_type.as_ref() {
+            Some(v) => &v,
+            None => "",
+        }
+    }
+
+    fn get_field_type_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> {
+        &self.field_type
+    }
+
+    fn mut_field_type_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> {
+        &mut self.field_type
+    }
+
+    // optional bytes indexdata = 2;
+
+    pub fn clear_indexdata(&mut self) {
+        self.indexdata.clear();
+    }
+
+    pub fn has_indexdata(&self) -> bool {
+        self.indexdata.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_indexdata(&mut self, v: ::std::vec::Vec<u8>) {
+        self.indexdata = ::protobuf::SingularField::some(v);
+    }
+
+    // Mutable pointer to the field.
+    // If field is not initialized, it is initialized with default value first.
+    pub fn mut_indexdata(&mut self) -> &mut ::std::vec::Vec<u8> {
+        if self.indexdata.is_none() {
+            self.indexdata.set_default();
+        }
+        self.indexdata.as_mut().unwrap()
+    }
+
+    // Take field
+    pub fn take_indexdata(&mut self) -> ::std::vec::Vec<u8> {
+        self.indexdata.take().unwrap_or_else(|| ::std::vec::Vec::new())
+    }
+
+    pub fn get_indexdata(&self) -> &[u8] {
+        match self.indexdata.as_ref() {
+            Some(v) => &v,
+            None => &[],
+        }
+    }
+
+    fn get_indexdata_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec<u8>> {
+        &self.indexdata
+    }
+
+    fn mut_indexdata_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec<u8>> {
+        &mut self.indexdata
+    }
+
+    // required int32 datasize = 3;
+
+    pub fn clear_datasize(&mut self) {
+        self.datasize = ::std::option::Option::None;
+    }
+
+    pub fn has_datasize(&self) -> bool {
+        self.datasize.is_some()
+    }
+
+    // Param is passed by value, moved
+    pub fn set_datasize(&mut self, v: i32) {
+        self.datasize = ::std::option::Option::Some(v);
+    }
+
+    pub fn get_datasize(&self) -> i32 {
+        self.datasize.unwrap_or(0)
+    }
+
+    fn get_datasize_for_reflect(&self) -> &::std::option::Option<i32> {
+        &self.datasize
+    }
+
+    fn mut_datasize_for_reflect(&mut self) -> &mut ::std::option::Option<i32> {
+        &mut self.datasize
+    }
+}
+
+impl ::protobuf::Message for BlobHeader {
+    fn is_initialized(&self) -> bool {
+        if self.field_type.is_none() {
+            return false;
+        }
+        if self.datasize.is_none() {
+            return false;
+        }
+        true
+    }
+
+    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> {
+        while !is.eof()? {
+            let (field_number, wire_type) = is.read_tag_unpack()?;
+            match field_number {
+                1 => {
+                    ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.field_type)?;
+                },
+                2 => {
+                    ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.indexdata)?;
+                },
+                3 => {
+                    if wire_type != ::protobuf::wire_format::WireTypeVarint {
+                        return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
+                    }
+                    let tmp = is.read_int32()?;
+                    self.datasize = ::std::option::Option::Some(tmp);
+                },
+                _ => {
+                    ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
+                },
+            };
+        }
+        ::std::result::Result::Ok(())
+    }
+
+    // Compute sizes of nested messages
+    #[allow(unused_variables)]
+    fn compute_size(&self) -> u32 {
+        let mut my_size = 0;
+        if let Some(ref v) = self.field_type.as_ref() {
+            my_size += ::protobuf::rt::string_size(1, &v);
+        }
+        if let Some(ref v) = self.indexdata.as_ref() {
+            my_size += ::protobuf::rt::bytes_size(2, &v);
+        }
+        if let Some(v) = self.datasize {
+            my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
+        }
+        my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
+        self.cached_size.set(my_size);
+        my_size
+    }
+
+    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> {
+        if let Some(ref v) = self.field_type.as_ref() {
+            os.write_string(1, &v)?;
+        }
+        if let Some(ref v) = self.indexdata.as_ref() {
+            os.write_bytes(2, &v)?;
+        }
+        if let Some(v) = self.datasize {
+            os.write_int32(3, v)?;
+        }
+        os.write_unknown_fields(self.get_unknown_fields())?;
+        ::std::result::Result::Ok(())
+    }
+
+    fn get_cached_size(&self) -> u32 {
+        self.cached_size.get()
+    }
+
+    fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
+        &self.unknown_fields
+    }
+
+    fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
+        &mut self.unknown_fields
+    }
+
+    fn as_any(&self) -> &::std::any::Any {
+        self as &::std::any::Any
+    }
+    fn as_any_mut(&mut self) -> &mut ::std::any::Any {
+        self as &mut ::std::any::Any
+    }
+    fn into_any(self: Box<Self>) -> ::std::boxed::Box<::std::any::Any> {
+        self
+    }
+
+    fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
+        ::protobuf::MessageStatic::descriptor_static(None::<Self>)
+    }
+}
+
+impl ::protobuf::MessageStatic for BlobHeader {
+    fn new() -> BlobHeader {
+        BlobHeader::new()
+    }
+}
+
+impl ::protobuf::Clear for BlobHeader {
+    fn clear(&mut self) {
+        self.clear_field_type();
+        self.clear_indexdata();
+        self.clear_datasize();
+        self.unknown_fields.clear();
+    }
+}
+
+impl ::protobuf::reflect::ProtobufValue for BlobHeader {
+    fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef {
+        ::protobuf::reflect::ProtobufValueRef::Message(self)
+    }
+}

src/proto/mod.rs

@@ -0,0 +1,2 @@
+pub mod fileformat;
+pub mod osmformat;

src/proto/osmformat.proto

@@ -0,0 +1,260 @@
+/** Copyright (c) 2010 Scott A. Crosby. <scott@sacrosby.com>
+
+   This program is free software: you can redistribute it and/or modify
+   it under the terms of the GNU Lesser General Public License as 
+   published by the Free Software Foundation, either version 3 of the 
+   License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+option optimize_for = LITE_RUNTIME;
+option java_package = "crosby.binary";
+package OSMPBF;
+
+/* OSM Binary file format 
+
+This is the master schema file of the OSM binary file format. This
+file is designed to support limited random-access and future
+extendability.
+
+A binary OSM file consists of a sequence of FileBlocks (please see
+fileformat.proto). The first fileblock contains a serialized instance
+of HeaderBlock, followed by a sequence of PrimitiveBlock blocks that
+contain the primitives.
+
+Each primitiveblock is designed to be independently parsable. It
+contains a string table storing all strings in that block (keys and
+values in tags, roles in relations, usernames, etc.) as well as
+metadata containing the precision of coordinates or timestamps in that
+block.
+
+A primitiveblock contains a sequence of primitive groups, each
+containing primitives of the same type (nodes, densenodes, ways,
+relations). Coordinates are stored in signed 64-bit integers. Lat&lon
+are measured in units <granularity> nanodegrees. The default of
+granularity of 100 nanodegrees corresponds to about 1cm on the ground,
+and a full lat or lon fits into 32 bits.
+
+Converting an integer to a lattitude or longitude uses the formula:
+$OUT = IN * granularity / 10**9$. Many encoding schemes use delta
+coding when representing nodes and relations.
+
+*/
+
+//////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////
+
+/* Contains the file header. */
+
+message HeaderBlock {
+  optional HeaderBBox bbox = 1;
+  /* Additional tags to aid in parsing this dataset */
+  repeated string required_features = 4;
+  repeated string optional_features = 5;
+
+  optional string writingprogram = 16; 
+  optional string source = 17; // From the bbox field.
+
+  /* Tags that allow continuing an Osmosis replication */
+
+  // replication timestamp, expressed in seconds since the epoch, 
+  // otherwise the same value as in the "timestamp=..." field
+  // in the state.txt file used by Osmosis
+  optional int64 osmosis_replication_timestamp = 32;
+
+  // replication sequence number (sequenceNumber in state.txt)
+  optional int64 osmosis_replication_sequence_number = 33;
+
+  // replication base URL (from Osmosis' configuration.txt file)
+  optional string osmosis_replication_base_url = 34;
+}
+
+
+/** The bounding box field in the OSM header. BBOX, as used in the OSM
+header. Units are always in nanodegrees -- they do not obey
+granularity rules. */
+
+message HeaderBBox {
+   required sint64 left = 1;
+   required sint64 right = 2;
+   required sint64 top = 3;
+   required sint64 bottom = 4;
+}
+
+
+///////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////
+
+
+message PrimitiveBlock {
+  required StringTable stringtable = 1;
+  repeated PrimitiveGroup primitivegroup = 2;
+
+  // Granularity, units of nanodegrees, used to store coordinates in this block
+  optional int32 granularity = 17 [default=100]; 
+  // Offset value between the output coordinates coordinates and the granularity grid in unites of nanodegrees.
+  optional int64 lat_offset = 19 [default=0];
+  optional int64 lon_offset = 20 [default=0]; 
+
+// Granularity of dates, normally represented in units of milliseconds since the 1970 epoch.
+  optional int32 date_granularity = 18 [default=1000]; 
+
+
+  // Proposed extension:
+  //optional BBox bbox = XX;
+}
+
+// Group of OSMPrimitives. All primitives in a group must be the same type.
+message PrimitiveGroup {
+  repeated Node     nodes = 1;
+  optional DenseNodes dense = 2;
+  repeated Way      ways = 3;
+  repeated Relation relations = 4;
+  repeated ChangeSet changesets = 5;
+}
+
+
+/** String table, contains the common strings in each block.
+
+ Note that we reserve index '0' as a delimiter, so the entry at that
+ index in the table is ALWAYS blank and unused.
+
+ */
+message StringTable {
+   repeated bytes s = 1;
+}
+
+/* Optional metadata that may be included into each primitive. */
+message Info {
+   optional int32 version = 1 [default = -1];
+   optional int64 timestamp = 2;
+   optional int64 changeset = 3;
+   optional int32 uid = 4;
+   optional uint32 user_sid = 5; // String IDs
+
+   // The visible flag is used to store history information. It indicates that
+   // the current object version has been created by a delete operation on the
+   // OSM API.
+   // When a writer sets this flag, it MUST add a required_features tag with
+   // value "HistoricalInformation" to the HeaderBlock.
+   // If this flag is not available for some object it MUST be assumed to be
+   // true if the file has the required_features tag "HistoricalInformation"
+   // set.
+   optional bool visible = 6;
+}
+
+/** Optional metadata that may be included into each primitive. Special dense format used in DenseNodes. */
+message DenseInfo {
+   repeated int32 version = 1 [packed = true]; 
+   repeated sint64 timestamp = 2 [packed = true]; // DELTA coded
+   repeated sint64 changeset = 3 [packed = true]; // DELTA coded
+   repeated sint32 uid = 4 [packed = true]; // DELTA coded
+   repeated sint32 user_sid = 5 [packed = true]; // String IDs for usernames. DELTA coded
+
+   // The visible flag is used to store history information. It indicates that
+   // the current object version has been created by a delete operation on the
+   // OSM API.
+   // When a writer sets this flag, it MUST add a required_features tag with
+   // value "HistoricalInformation" to the HeaderBlock.
+   // If this flag is not available for some object it MUST be assumed to be
+   // true if the file has the required_features tag "HistoricalInformation"
+   // set.
+   repeated bool visible = 6 [packed = true];
+}
+
+
+// THIS IS STUB DESIGN FOR CHANGESETS. NOT USED RIGHT NOW.
+// TODO:    REMOVE THIS?
+message ChangeSet {
+   required int64 id = 1;
+//   
+//   // Parallel arrays.
+//   repeated uint32 keys = 2 [packed = true]; // String IDs.
+//   repeated uint32 vals = 3 [packed = true]; // String IDs.
+//
+//   optional Info info = 4;
+
+//   optional int64 created_at = 8;
+//   optional int64 closetime_delta = 9;
+//   optional bool open = 10;
+//   optional HeaderBBox bbox = 11;
+}
+
+
+message Node {
+   required sint64 id = 1;
+   // Parallel arrays.
+   repeated uint32 keys = 2 [packed = true]; // String IDs.
+   repeated uint32 vals = 3 [packed = true]; // String IDs.
+
+   optional Info info = 4; // May be omitted in omitmeta
+
+   required sint64 lat = 8;
+   required sint64 lon = 9;
+}
+
+/* Used to densly represent a sequence of nodes that do not have any tags.
+
+We represent these nodes columnwise as five columns: ID's, lats, and
+lons, all delta coded. When metadata is not omitted, 
+
+We encode keys & vals for all nodes as a single array of integers
+containing key-stringid and val-stringid, using a stringid of 0 as a
+delimiter between nodes.
+
+   ( (<keyid> <valid>)* '0' )*
+ */
+
+message DenseNodes {
+   repeated sint64 id = 1 [packed = true]; // DELTA coded
+
+   //repeated Info info = 4;
+   optional DenseInfo denseinfo = 5;
+
+   repeated sint64 lat = 8 [packed = true]; // DELTA coded
+   repeated sint64 lon = 9 [packed = true]; // DELTA coded
+
+   // Special packing of keys and vals into one array. May be empty if all nodes in this block are tagless.
+   repeated int32 keys_vals = 10 [packed = true]; 
+}
+
+
+message Way {
+   required int64 id = 1;
+   // Parallel arrays.
+   repeated uint32 keys = 2 [packed = true];
+   repeated uint32 vals = 3 [packed = true];
+
+   optional Info info = 4;
+
+   repeated sint64 refs = 8 [packed = true];  // DELTA coded
+}
+
+message Relation {
+  enum MemberType {
+    NODE = 0;
+    WAY = 1;
+    RELATION = 2;
+  } 
+   required int64 id = 1;
+
+   // Parallel arrays.
+   repeated uint32 keys = 2 [packed = true];
+   repeated uint32 vals = 3 [packed = true];
+
+   optional Info info = 4;
+
+   // Parallel arrays
+   repeated int32 roles_sid = 8 [packed = true];
+   repeated sint64 memids = 9 [packed = true]; // DELTA encoded
+   repeated MemberType types = 10 [packed = true];
+}
+

src/reader.rs

@@ -0,0 +1,207 @@
+//! High level reader interface
+
+use blob::{BlobDecode, BlobReader};
+use dense::DenseNode;
+use elements::{Node, Way, Relation};
+use errors::*;
+use rayon::prelude::*;
+use std::fs::File;
+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.
+pub struct ElementReader<R: Read> {
+    blob_iter: BlobReader<R>,
+}
+
+impl<R: Read> ElementReader<R> {
+    /// Creates a new `ElementReader`.
+    /// 
+    /// # Example
+    /// ```
+    /// use osmpbf::*;
+    /// 
+    /// # fn foo() -> Result<()> {
+    /// let f = std::fs::File::open("tests/test.osm.pbf")?;
+    /// let buf_reader = std::io::BufReader::new(f);
+    /// 
+    /// let reader = ElementReader::new(buf_reader);
+    /// 
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn new(reader: R) -> ElementReader<R> {
+        ElementReader {
+            blob_iter: BlobReader::new(reader),
+        }
+    }
+
+    /// Decodes the PBF structure sequentially and calls the given closure on each element.
+    /// Consider using `par_map_reduce` instead if you need better performance.
+    /// 
+    /// # Errors
+    /// Returns the first Error encountered while parsing the PBF structure.
+    /// 
+    /// # Example
+    /// ```
+    /// use osmpbf::*;
+    /// 
+    /// # fn foo() -> Result<()> {
+    /// let reader = ElementReader::from_path("tests/test.osm.pbf")?;
+    /// let mut ways = 0_u64;
+    ///
+    /// // Increment the counter by one for each way.
+    /// reader.for_each(|element| {
+    ///     if let Element::Way(_) = element {
+    ///         ways += 1;
+    ///     }
+    /// })?;
+    /// 
+    /// println!("Number of ways: {}", ways);
+    /// 
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn for_each<F>(self, mut f: F) -> Result<()>
+        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::OsmData(block)) => {
+                    for group in block.groups() {
+                        group.nodes().for_each(|dnode| f(Element::Node(dnode)));
+                        group.dense_nodes().for_each(|node| f(Element::DenseNode(node)));
+                        group.ways().for_each(|way| f(Element::Way(way)));
+                        group.relations().for_each(|relation| f(Element::Relation(relation)));
+                    }
+                },
+                Err(e) => return Err(e),
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Parallel map/reduce. Decodes the PBF structure in parallel, calls the closure `map_op` on
+    /// each element and then reduces the number of results to one item with the closure
+    /// `reduce_op`. Similarly to the `init` argument in the `fold` method on iterators, the
+    /// `identity` closure should produce an identity value that is inserted into `reduce_op` when
+    /// necessary. The number of times that this identity value is inserted should not alter the
+    /// result.
+    /// 
+    /// # Errors
+    /// Returns the first Error encountered while parsing the PBF structure.
+    /// 
+    /// # Example
+    /// ```
+    /// use osmpbf::*;
+    /// 
+    /// # fn foo() -> Result<()> {
+    /// let reader = ElementReader::from_path("tests/test.osm.pbf")?;
+    ///
+    /// // Count the ways
+    /// let ways = reader.par_map_reduce(
+    ///     |element| {
+    ///         match element {
+    ///             Element::Way(_) => 1,
+    ///             _ => 0,
+    ///         }
+    ///     },
+    ///     || 0_u64,      // Zero is the identity value for addition
+    ///     |a, b| a + b   // Sum the partial results
+    /// )?;
+    /// 
+    /// println!("Number of ways: {}", ways);
+    /// # Ok(())
+    /// # }
+    /// ```
+    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,
+    {
+        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)) => {
+                    let dnodes = block.groups()
+                         .flat_map(|g| g.dense_nodes())
+                         .map(|dn| map_op(Element::DenseNode(dn)));
+                    let nodes = block.groups()
+                         .flat_map(|g| g.nodes())
+                         .map(|n| map_op(Element::Node(n)));
+                    let ways = block.groups()
+                         .flat_map(|g| g.ways())
+                         .map(|w| map_op(Element::Way(w)));
+                    let rels = block.groups()
+                         .flat_map(|g| g.relations())
+                         .map(|r| map_op(Element::Relation(r)));
+                
+                    Ok(dnodes.chain(nodes)
+                        .chain(ways)
+                        .chain(rels)
+                        .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),
+            }
+        })
+    }
+}
+
+impl ElementReader<BufReader<File>> {
+    /// Tries to open the file at the given path and constructs an `ElementReader` from this.
+    /// 
+    /// # Errors
+    /// Returns the same errors that `std::fs::File::open` returns.
+    /// 
+    /// # Example
+    /// ```
+    /// use osmpbf::*;
+    /// 
+    /// # fn foo() -> Result<()> {
+    /// let reader = ElementReader::from_path("tests/test.osm.pbf")?;
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn from_path<P: AsRef<Path>>(path: P) -> Result<Self>
+    {
+        let f = File::open(path)?;
+        let reader = BufReader::new(f);
+
+        Ok(ElementReader {
+            blob_iter: BlobReader::new(reader),
+        })
+    }
+}
+
+/// An enum with the OSM core elements: nodes, ways and relations.
+pub enum Element<'a> {
+    /// A node. Also, see `DenseNode`.
+    Node(Node<'a>),
+
+    /// Just like `Node`, but with a different representation in memory. This distinction is
+    /// usually not important but is not abstracted away to avoid copying. So, if you want to match
+    /// `Node`, you also likely want to match `DenseNode`.
+    DenseNode(DenseNode<'a>),
+
+    /// A way.
+    Way(Way<'a>),
+
+    /// A relation.
+    Relation(Relation<'a>),
+}

tests/read.rs

@@ -0,0 +1,64 @@
+extern crate osmpbf;
+
+use osmpbf::*;
+
+static TEST_FILE_PATH: &str = "tests/test.osm.pbf";
+
+fn approx_eq(a: f64, b: f64) -> bool {
+    (a - b).abs() < 1.0e-6
+}
+
+#[test]
+fn read() {
+    let reader = BlobReader::from_path(TEST_FILE_PATH).unwrap();
+
+    let blobs = reader.collect::<Result<Vec<_>>>().unwrap();
+
+    assert_eq!(blobs.len(), 2);
+
+    assert_eq!(blobs[0].get_type(), BlobType::OsmHeader);
+    assert_eq!(blobs[1].get_type(), BlobType::OsmData);
+
+    {
+        let header = blobs[0].to_headerblock().unwrap();
+        assert!(header.required_features().contains(&String::from("OsmSchema-V0.6")));
+        assert!(header.required_features().contains(&String::from("DenseNodes")));
+    }
+
+    {
+        let primitive_block = blobs[1].to_primitiveblock().unwrap();
+
+        let nodes = primitive_block.groups().flat_map(|g| g.nodes()).count();
+        assert_eq!(nodes, 0);
+
+        {
+            let dense_nodes: Vec<_> = primitive_block.groups().flat_map(|g| g.dense_nodes()).collect();
+            assert_eq!(dense_nodes.len(), 3);
+
+            assert!(approx_eq(dense_nodes[1].lat(), 52.11992359584));
+            assert!(approx_eq(dense_nodes[1].lon(), 11.62564468943));
+
+            assert!(approx_eq(dense_nodes[2].lat(), 52.11989910567));
+            assert!(approx_eq(dense_nodes[2].lon(), 11.63101926915));
+
+            assert_eq!(dense_nodes[0].id, 105);
+            assert_eq!(dense_nodes[1].id, 106);
+            assert_eq!(dense_nodes[2].id, 108);
+
+            assert_eq!(dense_nodes[0].uid, 17);
+            assert_eq!(dense_nodes[1].uid, 17);
+            assert_eq!(dense_nodes[2].uid, 17);
+        }
+
+        {
+            let ways: Vec<_> = primitive_block.groups().flat_map(|g| g.ways()).collect();
+            assert_eq!(ways.len(), 1);
+
+            let way_tags = ways[0].tags().collect::<Vec<_>>();
+            assert_eq!(way_tags.len(), 2);
+
+            assert!(way_tags.contains(&("building", "yes")));
+            assert!(way_tags.contains(&("name", "triangle")));
+        }
+    }
+}

tests/test.osm

@@ -0,0 +1,18 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<osm version='0.6' generator='JOSM'>
+  <node timestamp='2003-04-05T06:07:08Z' id='105' lat='52.12240315616' lon='11.62840177902' version='1' user='testuser' uid='17' visible='true' />
+  <node timestamp='2003-04-05T06:07:09Z' id='106' lat='52.11992359584' lon='11.62564468943' version='1' user='testuser' uid='17' visible='true' />
+  <node timestamp='2003-04-05T06:07:10Z' id='108' lat='52.11989910567' lon='11.63101926915' version='1' user='testuser' uid='17' visible='true' />
+  <way timestamp='2003-04-05T06:07:11Z' id='107' version='1' user='testuser' uid='17' visible='true'>
+    <nd ref='105' />
+    <nd ref='106' />
+    <nd ref='108' />
+    <nd ref='105' />
+    <tag k='building' v='yes' />
+    <tag k='name' v='triangle' />
+  </way>
+  <relation timestamp='2003-04-05T06:07:12Z' id='120' version='1' user='testuser' uid='17' visible='true'>
+    <member type='way' ref='107' role='test_role' />
+    <tag k='rel_key' v='rel_value' />
+  </relation>
+</osm>