Struct OSMReader 

pub struct OSMReader<T: Reader, _N: KVStore<u64, VectorPoint<MValue>> = KV<u64, VectorPoint<MValue>>, N: KVStore<u64, IntermediateNode> = KV<u64, IntermediateNode>, _W: KVStore<u64, WayNodes> = KV<u64, WayNodes>, W: KVStore<u64, IntermediateWay> = KV<u64, IntermediateWay>, R: KVStore<u64, IntermediateRelation> = KV<u64, IntermediateRelation>> { /* private fields */ }

OSM Reader

Description

Parses OSM PBF files

Implements the FeatureReader trait

Usage

For Simplicity, you can use the OSMFileReader or OSMLocalReader wrappers.

The methods you have access to:

• OSMReader::new: Create a new OSMReader
• OSMReader::cleanup: Cleans up the reader’s temp data
• OSMReader::get_header: Get the OSM Header
• OSMReader::parse_blocks: Parse all blocks to prepare for reads
• OSMReader::next_block: Get the next block (if you want to iteratively use blocks yourself)
• OSMReader::par_parse_node_blocks: If you are only interested in nodes, parse all of them quicker using threads
• OSMReader::parse_node_blocks: If you are only interested in nodes, parse all of them quicker
• OSMReader::iter: Create a new OSMReader Iterator

Local Reader

All data is stored locally in memory and will be cleaned up on drop

use gistools::{parsers::{FileReader, FeatureReader}, readers::OSMLocalReader};
use std::path::PathBuf;

let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
path.push("tests/readers/osm/fixtures/test.pbf");
let path_str = path.to_str().unwrap();
let reader = FileReader::from(path_str);

let mut osm = OSMLocalReader::new(reader, None);
osm.parse_blocks();

let features: Vec<_> = osm.iter().collect();
assert_eq!(features.len(), 8);

Implementations

impl<T: Reader, _N: KVStore<u64, VectorPoint<MValue>>, N: KVStore<u64, IntermediateNode>, _W: KVStore<u64, WayNodes>, W: KVStore<u64, IntermediateWay>, R: KVStore<u64, IntermediateRelation>> OSMReader<T, _N, N, _W, W, R>

pub fn new(reader: T, options: Option<OSMReaderOptions>) -> Self

Creates a new OSM Reader

pub fn cleanup(&mut self)

Cleanup the data which will cleanup any temporary files if they exist

pub fn get_header(&mut self) -> OSMHeader

returns - The header of the OSM file

pub fn parse_blocks(&mut self)

Parse all blocks, storing all nodes, ways, and relations into local stores for future consumption

pub fn next_block(data: Vec<u8>) -> PrimitiveBlock

Read the input blob and parse the block of data

pub fn par_parse_node_blocks( &mut self, pool_size: usize, thread_id: usize, cb: &mut dyn FnMut(VectorFeature<OSMMetadata, Properties, MValue>), )

Parse only nodes using threads. Assumed this reader has already been cloned and passed to a thread.

pub fn parse_node_blocks( &mut self, cb: &mut dyn FnMut(VectorFeature<OSMMetadata, Properties, MValue>), )

If you are only interested in the nodes, run this function instead as it doesn’t need Prep data in memory

Trait Implementations

impl<T: Clone + Reader, _N: Clone + KVStore<u64, VectorPoint<MValue>>, N: Clone + KVStore<u64, IntermediateNode>, _W: Clone + KVStore<u64, WayNodes>, W: Clone + KVStore<u64, IntermediateWay>, R: Clone + KVStore<u64, IntermediateRelation>> Clone for OSMReader<T, _N, N, _W, W, R>

fn clone(&self) -> OSMReader<T, _N, N, _W, W, R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Reader, _N: Debug + KVStore<u64, VectorPoint<MValue>>, N: Debug + KVStore<u64, IntermediateNode>, _W: Debug + KVStore<u64, WayNodes>, W: Debug + KVStore<u64, IntermediateWay>, R: Debug + KVStore<u64, IntermediateRelation>> Debug for OSMReader<T, _N, N, _W, W, R>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Reader, _N: KVStore<u64, VectorPoint<MValue>>, N: KVStore<u64, IntermediateNode>, _W: KVStore<u64, WayNodes>, W: KVStore<u64, IntermediateWay>, R: KVStore<u64, IntermediateRelation>> FeatureReader<OSMMetadata, Map<String, ValueType>, Map<String, ValueType>> for OSMReader<T, _N, N, _W, W, R>

type FeatureIterator<'a> = OsmReaderIter<'a, T, _N, N, _W, W, R> where T: 'a, _N: 'a, N: 'a, _W: 'a, W: 'a, R: 'a

The Feature Reader should implement an iterator of some kind

fn iter(&self) -> Self::FeatureIterator<'_>

All readers have an iter function that returns a Iterator struct

fn par_iter( &self, _pool_size: usize, _thread_id: usize, ) -> Self::FeatureIterator<'_>

All readers have a par_iter function that returns a ParallelIterator struct