Search PBF files and display matches as markers

Use the parameters -s and --pbf for this.

src/args.rs

             .value_name("FILE")
             .help("Set a custom tile sources file")
             .takes_value(true))
+        .arg(Arg::with_name("pbf")
+            .long("pbf")
+            .value_name("FILE")
+            .help("Set a *.osm.pbf file")
+            .takes_value(true))
+        .arg(Arg::with_name("search")
+            .short("s")
+            .long("search")
+            .value_name("PATTERN")
+            .help("Search for places which match the given pattern")
+            .takes_value(true))
         .arg(Arg::with_name("fps")
             .long("fps")
             .value_name("FPS")

src/config.rs

 pub struct Config {
     tile_cache_dir: PathBuf,
     sources: Vec<(String, TileSource)>,
+    pbf_path: Option<PathBuf>,
+    search_pattern: Option<String>,
     fps: f64,
     use_network: bool,
     async: bool,
             config.add_tile_sources_from_default_or_create()?;
         };
 
+        if let Some(os_path) = matches.value_of_os("pbf") {
+            let path = PathBuf::from(os_path);
+            if path.is_file() {
+                config.pbf_path = Some(path);
+            } else {
+                return Err(format!("PBF file does not exist: {:?}", os_path));
+            }
+        }
+
         config.merge_arg_matches(matches);
 
         Ok(config)
     }
 
     fn merge_arg_matches<'a>(&mut self, matches: &clap::ArgMatches<'a>) {
+        self.search_pattern = matches.value_of("search").map(|s| s.to_string());
+
         if let Some(Ok(fps)) = matches.value_of("fps").map(|s| s.parse()) {
             self.fps = fps;
         }
                     Config {
                         tile_cache_dir,
                         sources: vec![],
+                        pbf_path: None,
+                        search_pattern: None,
                         fps,
                         use_network,
                         async,
         &self.sources
     }
 
+    pub fn pbf_path(&self) -> Option<&Path> {
+        self.pbf_path.as_ref().map(|p| p.as_path())
+    }
+
+    pub fn search_pattern(&self) -> Option<&str> {
+        self.search_pattern.as_ref().map(|s| s.as_str())
+    }
+
     pub fn fps(&self) -> f64 {
         self.fps
     }

src/main.rs

 extern crate linked_hash_map;
 #[macro_use]
 extern crate log;
+extern crate osmpbf;
 extern crate regex;
 extern crate reqwest;
 extern crate toml;
 use coord::ScreenCoord;
 use glutin::{ControlFlow, ElementState, Event, GlContext, MouseButton, MouseScrollDelta, VirtualKeyCode, WindowEvent};
 use map_view_gl::MapViewGl;
+use regex::Regex;
 use std::error::Error;
+use std::path::PathBuf;
+use std::sync::mpsc;
+use std::thread;
 use std::time::{Duration, Instant};
 use tile_source::TileSource;
 
     mouse_pressed: bool,
 }
 
-fn handle_event(event: &Event, map: &mut MapViewGl, input_state: &mut InputState, sources: &mut TileSources) -> Action {
+fn handle_event(
+    event: &Event,
+    map: &mut MapViewGl,
+    input_state: &mut InputState,
+    sources: &mut TileSources,
+    marker_rx: &mpsc::Receiver<(f64, f64)>,
+) -> Action {
     match *event {
-        Event::Awakened => Action::Redraw,
+        Event::Awakened => {
+            for (lat, lon) in marker_rx.try_iter() {
+                map.add_marker(coord::MapCoord::from_latlon(lat, lon));
+            }
+            Action::Redraw
+        },
         Event::WindowEvent{ref event, ..} => match *event {
             WindowEvent::CloseRequested => Action::Close,
             WindowEvent::MouseInput { state: ElementState::Pressed, button: MouseButton::Left, .. } => {
         mouse_pressed: false,
     };
 
+    let (marker_tx, marker_rx) = mpsc::channel();
+    if let (Some(path), Some(pattern)) = (config.pbf_path(), config.search_pattern()) {
+        let pathbuf = PathBuf::from(path);
+        let re = Regex::new(pattern).unwrap();
+        let proxy = events_loop.create_proxy();
+
+        thread::spawn(move|| {
+            let reader = osmpbf::ElementReader::from_path(&pathbuf).unwrap();
+
+            // Increment the counter by one for each way.
+            reader.for_each(|element| {
+                match element {
+                    osmpbf::Element::Node(_) => {},
+                    osmpbf::Element::DenseNode(dnode) => {
+                        for (_key, val) in dnode.tags() {
+                            if re.is_match(val) {
+                                marker_tx.send((dnode.lat(), dnode.lon())).unwrap();
+                                proxy.wakeup().unwrap();
+                            }
+                        }
+                    },
+                    _ => {},
+                }
+            }).unwrap();
+        });
+    }
+
     let duration_per_frame = Duration::from_millis((1000.0 / config.fps() - 0.5).max(0.0).floor() as u64);
     info!("milliseconds per frame: {}", dur_to_sec(duration_per_frame) * 1000.0);
 
         let mut action = Action::Nothing;
 
         events_loop.run_forever(|event| {
-            let a = handle_event(&event, &mut map, &mut input_state, &mut sources);
+            let a = handle_event(&event, &mut map, &mut input_state, &mut sources, &marker_rx);
             action.combine_with(a);
             ControlFlow::Break
         });
         }
 
         events_loop.poll_events(|event| {
-            let a = handle_event(&event, &mut map, &mut input_state, &mut sources);
+            let a = handle_event(&event, &mut map, &mut input_state, &mut sources, &marker_rx);
             action.combine_with(a);
             if action == Action::Close {
                 return;
                     std::thread::sleep(dur);
 
                     events_loop.poll_events(|event| {
-                        let a = handle_event(&event, &mut map, &mut input_state, &mut sources);
+                        let a = handle_event(&event, &mut map, &mut input_state, &mut sources, &marker_rx);
                         action.combine_with(a);
                         if action == Action::Close {
                             return;