feat: add iter_<xxx> for node/way/relation (#51)

Author: hxsf

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "osmpbfreader"
-version = "0.17.0"
+version = "0.18.0"
 authors = ["Guillaume Pinot <[email protected]>"]
 description = "Read OpenStreetMap PBF files in rust."
 documentation = "https://docs.rs/osmpbfreader"

src/blobs.rs

@@ -9,39 +9,49 @@
 
 use std::iter;
 
-use crate::blocks;
-use crate::blocks::OsmObjs as OsmBlockObjs;
+use crate::blocks::{self, OsmObjs as OsmBlockObjs, Relations as BlockRelations, Ways as BlockWays, Nodes as BlockNodes};
 use crate::fileformat::Blob;
 use crate::objects::OsmObj;
 use crate::osmformat::PrimitiveBlock;
 
+macro_rules! wrap {
+    ($name: ident, $wrap_type: ident => $inner_type: path) => {
 self_cell::self_cell!(
-    struct OsmBlobObjs {
+    #[allow(missing_docs)]
+    pub struct $name {
         owner: PrimitiveBlock,
 
         #[covariant]
-        dependent: OsmBlockObjs,
+        dependent: $wrap_type,
     }
 );
 
-impl Iterator for OsmBlobObjs {
-    type Item = OsmObj;
+impl Iterator for $name {
+    type Item = $inner_type;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.with_dependent_mut(|_, objs| objs.next())
     }
 }
 
+    };
+}
+
+wrap!(OsmBlobObjs, OsmBlockObjs => OsmObj);
+wrap!(OsmBlobRelations, BlockRelations => super::Relation);
+wrap!(OsmBlobWays, BlockWays => super::Way);
+wrap!(OsmBlobNodes, BlockNodes => super::Node);
+
 /// An iterator on `Result<OsmObj>`.
-pub struct OsmObjs(OsmObjsImpl);
+pub struct OsmObjs<T: Iterator>(OsmObjsImpl<T>);
 
-enum OsmObjsImpl {
-    OkIter(iter::Map<OsmBlobObjs, fn(OsmObj) -> crate::Result<OsmObj>>),
-    ErrIter(iter::Once<crate::Result<OsmObj>>),
+enum OsmObjsImpl<T: Iterator> {
+    OkIter(iter::Map<T, fn(<T as Iterator>::Item) -> crate::Result<<T as Iterator>::Item>>),
+    ErrIter(iter::Once<crate::Result<<T as Iterator>::Item>>),
 }
 
-impl Iterator for OsmObjs {
-    type Item = crate::Result<OsmObj>;
+impl<T: Iterator> Iterator for OsmObjs<T> {
+    type Item = crate::Result<<T as Iterator>::Item>;
     fn next(&mut self) -> Option<Self::Item> {
         match self.0 {
             OsmObjsImpl::OkIter(ref mut iter) => iter.next(),
@@ -51,13 +61,33 @@ impl Iterator for OsmObjs {
 }
 
 /// Transforms a `Result<blob>` into a `Iterator<Item = Result<OsmObj>>`.
-pub fn result_blob_into_iter(result: crate::Result<Blob>) -> OsmObjs {
+pub fn result_blob_into_iter(result: crate::Result<Blob>) -> OsmObjs<OsmBlobObjs> {
+    match result.and_then(|b| crate::reader::primitive_block_from_blob(&b)) {
+        Ok(block) => OsmObjs(OsmObjsImpl::OkIter(OsmBlobObjs::new(block, blocks::iter).map(Ok))),
+        Err(e) => OsmObjs(OsmObjsImpl::ErrIter(iter::once(Err(e)))),
+    }
+}
+
+/// Transforms a `Result<blob>` into a `Iterator<Item = Result<Node>>`.
+pub fn result_blob_into_node_iter(result: crate::Result<Blob>) -> OsmObjs<OsmBlobNodes> {
     match result.and_then(|b| crate::reader::primitive_block_from_blob(&b)) {
-        Ok(block) => OsmObjs(OsmObjsImpl::OkIter(new_rent_osm_objs(block).map(Ok))),
+        Ok(block) => OsmObjs(OsmObjsImpl::OkIter(OsmBlobNodes::new(block, blocks::nodes).map(Ok))),
         Err(e) => OsmObjs(OsmObjsImpl::ErrIter(iter::once(Err(e)))),
     }
 }
 
-fn new_rent_osm_objs(block: PrimitiveBlock) -> OsmBlobObjs {
-    OsmBlobObjs::new(block, blocks::iter)
+/// Transforms a `Result<blob>` into a `Iterator<Item = Result<Way>>`.
+pub fn result_blob_into_way_iter(result: crate::Result<Blob>) -> OsmObjs<OsmBlobWays> {
+    match result.and_then(|b| crate::reader::primitive_block_from_blob(&b)) {
+        Ok(block) => OsmObjs(OsmObjsImpl::OkIter(OsmBlobWays::new(block, blocks::ways).map(Ok))),
+        Err(e) => OsmObjs(OsmObjsImpl::ErrIter(iter::once(Err(e)))),
+    }
+}
+
+/// Transforms a `Result<blob>` into a `Iterator<Item = Result<Relation>>`.
+pub fn result_blob_into_relation_iter(result: crate::Result<Blob>) -> OsmObjs<OsmBlobRelations> {
+    match result.and_then(|b| crate::reader::primitive_block_from_blob(&b)) {
+        Ok(block) => OsmObjs(OsmObjsImpl::OkIter(OsmBlobRelations::new(block, blocks::relations).map(Ok))),
+        Err(e) => OsmObjs(OsmObjsImpl::ErrIter(iter::once(Err(e)))),
+    }
 }

src/reader.rs

@@ -7,7 +7,7 @@
 
 //! Tools for reading a pbf file.
 
-use crate::blobs::{self, result_blob_into_iter};
+use crate::blobs;
 use crate::error::{Error, Result};
 use crate::fileformat::{Blob, BlobHeader};
 use crate::objects::{OsmId, OsmObj};
@@ -67,7 +67,7 @@ impl<R: io::Read> OsmPbfReader<R> {
     /// }
     /// ```
     pub fn iter(&mut self) -> Iter<R> {
-        Iter(self.blobs().flat_map(result_blob_into_iter))
+        Iter(self.blobs().flat_map(blobs::result_blob_into_iter))
     }
 
     /// Returns a parallel iterator on the OsmObj of the pbf file.
@@ -85,9 +85,53 @@ impl<R: io::Read> OsmPbfReader<R> {
     /// }
     /// ```
     pub fn par_iter(&mut self) -> ParIter<'_, R> {
-        ParIter(self.blobs().par_flat_map(result_blob_into_iter))
+        ParIter(self.blobs().par_flat_map(blobs::result_blob_into_iter))
     }
 
+    /// Returns an iterator on the Node of the pbf file.
+    pub fn iter_nodes(&mut self) -> NodeIter<R> {
+        NodeIter(self.blobs().flat_map(blobs::result_blob_into_node_iter))
+    }
+
+    /// Returns a parallel iterator on the Node of the pbf file.
+    ///
+    /// Several threads decode in parallel the file.  The memory and
+    /// CPU usage are guaranteed to be bounded even if the caller stop
+    /// consuming items.
+    pub fn par_iter_nodes(&mut self) -> NodeParIter<'_, R> {
+        NodeParIter(self.blobs().par_flat_map(blobs::result_blob_into_node_iter))
+    }
+
+    /// Returns an iterator on the Way of the pbf file.
+    pub fn iter_ways(&mut self) -> WayIter<R> {
+        WayIter(self.blobs().flat_map(blobs::result_blob_into_way_iter))
+    }
+
+    /// Returns a parallel iterator on the Way of the pbf file.
+    ///
+    /// Several threads decode in parallel the file.  The memory and
+    /// CPU usage are guaranteed to be bounded even if the caller stop
+    /// consuming items.
+    pub fn par_iter_ways(&mut self) -> WayParIter<'_, R> {
+        WayParIter(self.blobs().par_flat_map(blobs::result_blob_into_way_iter))
+    }
+
+    /// Returns an iterator on the Relation of the pbf file.
+    pub fn iter_relations(&mut self) -> RelationIter<R> {
+        RelationIter(self.blobs().flat_map(blobs::result_blob_into_relation_iter))
+    }
+
+    /// Returns a parallel iterator on the Relation of the pbf file.
+    ///
+    /// Several threads decode in parallel the file.  The memory and
+    /// CPU usage are guaranteed to be bounded even if the caller stop
+    /// consuming items.
+    pub fn par_iter_relations(&mut self) -> RelationParIter<'_, R> {
+        RelationParIter(self.blobs().par_flat_map(blobs::result_blob_into_relation_iter))
+    }
+
+
+
     /// Rewinds the pbf file to the begining.
     ///
     /// Useful if you want to read several consecutive times the same
@@ -283,14 +327,57 @@ pub fn primitive_block_from_blob(blob: &Blob) -> Result<PrimitiveBlock> {
 
 pub_iterator_type! {
     #[doc="Iterator on the `OsmObj` of the pbf file."]
-    Iter['a, R] = iter::FlatMap<Blobs<'a, R>, blobs::OsmObjs, fn(Result<Blob>) -> blobs::OsmObjs>
+    Iter['a, R] = iter::FlatMap<Blobs<'a, R>, blobs::OsmObjs<blobs::OsmBlobObjs>, fn(Result<Blob>) -> blobs::OsmObjs<blobs::OsmBlobObjs>>
     where R: io::Read + 'a
 }
 
 pub_iterator_type! {
     #[doc="Parallel iterator on the `OsmObj` of the pbf file."]
     ParIter['a, R] = par_map::FlatMap<Blobs<'a, R>,
-                                      blobs::OsmObjs,
-                                      fn(Result<Blob>) -> blobs::OsmObjs>
+                                      blobs::OsmObjs<blobs::OsmBlobObjs>,
+                                      fn(Result<Blob>) -> blobs::OsmObjs<blobs::OsmBlobObjs>>
+    where R: io::Read + 'a
+}
+
+pub_iterator_type! {
+    #[doc="Iterator on the `OsmObj` of the pbf file."]
+    NodeIter['a, R] = iter::FlatMap<Blobs<'a, R>, blobs::OsmObjs<blobs::OsmBlobNodes>, fn(Result<Blob>) -> blobs::OsmObjs<blobs::OsmBlobNodes>>
+    where R: io::Read + 'a
+}
+
+pub_iterator_type! {
+    #[doc="Parallel iterator on the `OsmObj` of the pbf file."]
+    NodeParIter['a, R] = par_map::FlatMap<Blobs<'a, R>,
+                                      blobs::OsmObjs<blobs::OsmBlobNodes>,
+                                      fn(Result<Blob>) -> blobs::OsmObjs<blobs::OsmBlobNodes>>
+    where R: io::Read + 'a
+}
+
+pub_iterator_type! {
+    #[doc="Iterator on the `OsmObj` of the pbf file."]
+    WayIter['a, R] = iter::FlatMap<Blobs<'a, R>, blobs::OsmObjs<blobs::OsmBlobWays>, fn(Result<Blob>) -> blobs::OsmObjs<blobs::OsmBlobWays>>
+    where R: io::Read + 'a
+}
+
+pub_iterator_type! {
+    #[doc="Parallel iterator on the `OsmObj` of the pbf file."]
+    WayParIter['a, R] = par_map::FlatMap<Blobs<'a, R>,
+                                      blobs::OsmObjs<blobs::OsmBlobWays>,
+                                      fn(Result<Blob>) -> blobs::OsmObjs<blobs::OsmBlobWays>>
+    where R: io::Read + 'a
+}
+
+
+pub_iterator_type! {
+    #[doc="Iterator on the `OsmObj` of the pbf file."]
+    RelationIter['a, R] = iter::FlatMap<Blobs<'a, R>, blobs::OsmObjs<blobs::OsmBlobRelations>, fn(Result<Blob>) -> blobs::OsmObjs<blobs::OsmBlobRelations>>
+    where R: io::Read + 'a
+}
+
+pub_iterator_type! {
+    #[doc="Parallel iterator on the `OsmObj` of the pbf file."]
+    RelationParIter['a, R] = par_map::FlatMap<Blobs<'a, R>,
+                                      blobs::OsmObjs<blobs::OsmBlobRelations>,
+                                      fn(Result<Blob>) -> blobs::OsmObjs<blobs::OsmBlobRelations>>
     where R: io::Read + 'a
 }