Struct osm_io::osm::pbf::reader::Reader

source ·

pub struct Reader { /* private fields */ }

Implementations§

source §

impl Reader

*.osm.pbf file reader

Prepare the *.osm.pbf file for reading. The actual reading is performed by associated iterators.

source

pub fn new(path: &PathBuf) -> Result<Reader, Error>

Create a new Reader

path - a path to a valid *.osm.pbf file Example:

use std::path::PathBuf;
use osm_io::osm::pbf::reader::Reader;
let input_path = PathBuf::from("./planet.osm.pbf");
let reader = Reader::new(&input_path);

source

pub fn blocks(&self) -> Result<FileBlockIterator, Error>

Low level FileBlockIterator used to access the sequence of underlying PBF blocks

source

pub fn elements(&self) -> Result<ElementIterator, Error>

Iterator used to iterate over elements. Example:

use std::path::PathBuf;
use osm_io::osm::model::element::Element;
use osm_io::osm::pbf;
fn example() -> Result<(), anyhow::Error> {
    let input_path = PathBuf::from("./tests/fixtures/malta-230109.osm.pbf");
    let reader = pbf::reader::Reader::new(&input_path)?;

    let mut nodes = 0 as usize;
    let mut ways = 0 as usize;
    let mut relations = 0 as usize;

    for element in reader.elements()? {
        match element {
            Element::Node { node } => {
                nodes += 1;
            }
            Element::Way { way } => {
                ways += 1;
            }
            Element::Relation { relation } => {
                relations += 1;
            }
            Element::Sentinel => {
            }
        }
    }

    println!("nodes: {}", nodes);
    println!("ways: {}", ways);
    println!("relations: {}", relations);

    Ok(())
}

source

pub fn parallel_for_each( &self, tasks: usize, f: impl Fn(Element) -> Result<(), Error> + Send + Sync + 'static ) -> Result<(), Error>

Parallel iteration over elements in a *.osm.pbf file

Note that because of the parallel access the order of elements enforced by *.osm.pbf format is lost. Example:

use std::path::PathBuf;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use osm_io::osm::model::element::Element;
use osm_io::osm::pbf;
fn example() -> Result<(), anyhow::Error> {
    let input_path = PathBuf::from("./tests/fixtures/malta-230109.osm.pbf");
    let reader = pbf::reader::Reader::new(&input_path)?;

    let nodes = Arc::new(AtomicUsize::new(0));
    let ways = Arc::new(AtomicUsize::new(0));
    let relations = Arc::new(AtomicUsize::new(0));

    let nodes_clone = nodes.clone();
    let ways_clone = ways.clone();
    let relations_clone = relations.clone();

    reader.parallel_for_each(4, move |element| {
        match element {
            Element::Node { node: _ } => {
                nodes.fetch_add(1, Ordering::SeqCst);
            }
            Element::Way { .. } => {
                ways.fetch_add(1, Ordering::SeqCst);
            }
            Element::Relation { .. } => {
                relations.fetch_add(1, Ordering::SeqCst);
            }
            Element::Sentinel => {}
            }
            Ok(())
        },
    )?;

    println!("nodes: {}", nodes_clone.load(Ordering::SeqCst));
    println!("ways: {}", ways_clone.load(Ordering::SeqCst));
    println!("relations: {}", relations_clone.load(Ordering::SeqCst));
    Ok(())
}