Add search module

src/main.rs

 pub mod map_view;
 pub mod map_view_gl;
 pub mod program;
+pub mod search;
 pub mod texture;
 pub mod tile;
 pub mod tile_atlas;
 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;
 
 
     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(node) => {
-                        for (_key, val) in node.tags() {
-                            if re.is_match(val) {
-                                marker_tx.send((node.lat(), node.lon())).unwrap();
-                                proxy.wakeup().unwrap();
-                            }
-                        }
-                    },
-                    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();
-        });
+        search::search_pbf(
+            path,
+            pattern,
+            move |lat, lon| {
+                marker_tx.send((lat, lon)).unwrap();
+                proxy.wakeup().unwrap();
+            },
+        )?;
     }
 
     let duration_per_frame = Duration::from_millis((1000.0 / config.fps() - 0.5).max(0.0).floor() as u64);

src/search.rs

+use regex::Regex;
+use std::path::{Path, PathBuf};
+use std::thread;
+use osmpbf::{Element, ElementReader};
+
+
+pub fn search_pbf<P, F>(
+    pbf_path: P,
+    search_pattern: &str,
+    update_func: F,
+) -> Result<thread::JoinHandle<()>, String>
+where P: AsRef<Path>,
+      F: Fn(f64, f64) + Send + 'static,
+{
+    let pathbuf = PathBuf::from(pbf_path.as_ref());
+    let re = Regex::new(search_pattern)
+        .map_err(|e| format!("{}", e))?;
+    let reader = ElementReader::from_path(&pathbuf)
+        .map_err(|e| format!("Failed to read PBF file {:?}: {}", pbf_path.as_ref(), e))?;
+
+    let handle = thread::spawn(move|| {
+        //TODO do something about the unwrap()
+        reader.for_each(|element| {
+            match element {
+                Element::Node(node) => {
+                    for (_key, val) in node.tags() {
+                        if re.is_match(val) {
+                            update_func(node.lat(), node.lon());
+                            break;
+                        }
+                    }
+                },
+                Element::DenseNode(dnode) => {
+                    for (_key, val) in dnode.tags() {
+                        if re.is_match(val) {
+                            update_func(dnode.lat(), dnode.lon());
+                            break;
+                        }
+                    }
+                },
+                _ => {},
+            }
+        }).unwrap();
+    });
+
+    Ok(handle)
+}