search_pbf: Update closure can change control flow

src/main.rs

             path,
             pattern,
             move |lat, lon| {
-                marker_tx.send((lat, lon)).unwrap();
-                proxy.wakeup().unwrap();
+                if marker_tx.send((lat, lon)).is_err() {
+                    return search::ControlFlow::Break;
+                }
+                proxy.wakeup().into()
             },
         )?;
     }

src/search.rs

+use osmpbf::{Element, ElementReader};
 use regex::Regex;
 use std::path::{Path, PathBuf};
 use std::thread;
-use osmpbf::{Element, ElementReader};
 
+#[derive(Debug, Eq, PartialEq)]
+pub enum ControlFlow {
+    Continue,
+    Break,
+}
+
+impl<T, E> From<Result<T, E>> for ControlFlow
+{
+    fn from(result: Result<T, E>) -> Self {
+        match result {
+            Ok(_) => ControlFlow::Continue,
+            Err(_) => ControlFlow::Break,
+        }
+    }
+}
 
+//TODO Add callbacks for other events: search finished, on error, ...
 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,
+      F: Fn(f64, f64) -> ControlFlow + Send + 'static,
 {
     let pathbuf = PathBuf::from(pbf_path.as_ref());
     let re = Regex::new(search_pattern)
         .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());
+                            if update_func(node.lat(), node.lon()) == ControlFlow::Break {
+                                return;
+                            }
                             break;
                         }
                     }
                 Element::DenseNode(dnode) => {
                     for (_key, val) in dnode.tags() {
                         if re.is_match(val) {
-                            update_func(dnode.lat(), dnode.lon());
+                            if update_func(dnode.lat(), dnode.lon()) == ControlFlow::Break {
+                                return;
+                            }
                             break;
                         }
                     }