Add key-value queries

* Add --keyval command line option to search for elements with a
  specific tag
* Add query module and Query trait to abstract over different types of
  queries

src/args.rs

@@ -34,6 +34,21 @@ pub fn parse<'a>() -> clap::ArgMatches<'a> {
             .value_name("PATTERN")
             .help("Search for places which match the given pattern")
             .takes_value(true))
+        .arg(Arg::with_name("keyval")
+            .short("k")
+            .long("keyval")
+            .value_name("KEY:VALUE")
+            .validator(|s| {
+                let colons = (s.split(':').count() - 1).max(0);
+                if colons == 1 {
+                    Ok(())
+                } else {
+                    Err(format!("exactly one colon (':') is required to separate key and value, \
+                                found {}", colons))
+                }
+            })
+            .help("Search for places that are tagged with the given key and value")
+            .takes_value(true))
         .arg(Arg::with_name("fps")
             .long("fps")
             .value_name("FPS")

src/config.rs

@@ -1,5 +1,6 @@
 use clap;
 use directories::ProjectDirs;
+use query::QueryArgs;
 use session::Session;
 use std::fmt::Debug;
 use std::fs::File;
@@ -28,6 +29,7 @@ pub struct Config {
     sources: Vec<(String, TileSource)>,
     pbf_path: Option<PathBuf>,
     search_pattern: Option<String>,
+    keyval: Option<(String, String)>,
     fps: f64,
     use_network: bool,
     async: bool,
@@ -67,6 +69,16 @@ impl Config {
     fn merge_arg_matches<'a>(&mut self, matches: &clap::ArgMatches<'a>) {
         self.search_pattern = matches.value_of("search").map(|s| s.to_string());
 
+        self.keyval = matches.value_of("keyval").and_then(|kv| {
+            let mut split = kv.split(':');
+
+            if let (Some(key), Some(value)) = (split.next(), split.next()) {
+                Some((key.to_string(), value.to_string()))
+            } else {
+                None
+            }
+        });
+
         if let Some(Ok(fps)) = matches.value_of("fps").map(|s| s.parse()) {
             self.fps = fps;
         }
@@ -229,6 +241,7 @@ impl Config {
                         sources: vec![],
                         pbf_path,
                         search_pattern: None,
+                        keyval: None,
                         fps,
                         use_network,
                         async,
@@ -390,6 +403,22 @@ impl Config {
         self.search_pattern.as_ref().map(|s| s.as_str())
     }
 
+    pub fn keyval(&self) -> Option<(&str, &str)> {
+        self.keyval.as_ref().map(|kv| (kv.0.as_str(), kv.1.as_str()))
+    }
+
+    pub fn query_args(&self) -> Option<QueryArgs> {
+        match (&self.search_pattern, &self.keyval) {
+            (&Some(ref pattern), &None) => Some(QueryArgs::ValuePattern(pattern.to_string())),
+            (&None, &Some(ref kv)) => Some(QueryArgs::KeyValue(kv.0.to_string(), kv.1.to_string())),
+            (&Some(_), &Some(_)) => {
+                //TODO implement
+                unimplemented!();
+            },
+            (&None, &None) => None,
+        }
+    }
+
     pub fn fps(&self) -> f64 {
         self.fps
     }

src/main.rs

@@ -36,6 +36,7 @@ pub mod ortho_tile_layer;
 pub mod orthografic_view;
 pub mod program;
 pub mod projection;
+pub mod query;
 pub mod search;
 pub mod session;
 pub mod texture;
@@ -314,12 +315,13 @@ fn run() -> Result<(), Box<Error>> {
     }
 
     let (marker_tx, marker_rx) = mpsc::channel();
-    if let (Some(path), Some(pattern)) = (config.pbf_path(), config.search_pattern()) {
+
+    if let (Some(path), Some(query_args)) = (config.pbf_path(), config.query_args()) {
         let proxy = events_loop.create_proxy();
 
         search::par_search(
             path,
-            pattern,
+            query_args,
             move |coords| {
                 if coords.is_empty() {
                     search::ControlFlow::Continue

src/query.rs

@@ -0,0 +1,189 @@
+use coord::LatLonDeg;
+use osmpbf::{DenseNode, Node, PrimitiveBlock, Relation, Way};
+use regex::Regex;
+
+
+pub trait Query {
+    type BI;
+    fn create_block_index(&self, &PrimitiveBlock) -> Self::BI;
+    fn node_matches(&self, &Self::BI, node: &Node) -> bool;
+    fn dense_node_matches(&self, &Self::BI, dnode: &DenseNode) -> bool;
+    fn way_matches(&self, &Self::BI, way: &Way) -> bool;
+    fn relation_matches(&self, &Self::BI, relation: &Relation) -> bool;
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum QueryArgs {
+    ValuePattern(String),
+    KeyValue(String, String),
+    Intersection(Box<(QueryArgs, QueryArgs)>),
+}
+
+#[derive(Debug)]
+pub enum QueryKind {
+    ValuePattern(ValuePatternQuery),
+    KeyValue(KeyValueQuery),
+    Intersection(Box<(QueryArgs, QueryArgs)>),
+}
+
+impl QueryArgs {
+    pub fn compile(self) -> Result<QueryKind, String> {
+        match self {
+            QueryArgs::ValuePattern(pattern) => {
+                Ok(QueryKind::ValuePattern(ValuePatternQuery::new(&pattern)?))
+            },
+            QueryArgs::KeyValue(k, v) => {
+                Ok(QueryKind::KeyValue(KeyValueQuery::new(k, v)))
+            },
+            _ => {
+                //TODO implement
+                unimplemented!();
+            },
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ValuePatternQuery {
+    re: Regex,
+}
+
+impl ValuePatternQuery {
+    pub fn new(pattern: &str) -> Result<Self, String> {
+        let re = Regex::new(&pattern)
+            .map_err(|e| format!("{}", e))?;
+        Ok(ValuePatternQuery { re })
+    }
+}
+
+impl Query for ValuePatternQuery {
+    type BI = ();
+
+    fn create_block_index(&self, _block: &PrimitiveBlock) -> () {
+        ()
+    }
+
+    fn node_matches(&self, _: &(), node: &Node) -> bool {
+        for (_key, val) in node.tags() {
+            if self.re.is_match(val) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    fn dense_node_matches(&self, _: &(), dnode: &DenseNode) -> bool {
+        for (_key, val) in dnode.tags() {
+            if self.re.is_match(val) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    fn way_matches(&self, _: &(), way: &Way) -> bool {
+        for (_key, val) in way.tags() {
+            if self.re.is_match(val) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    fn relation_matches(&self, _: &(), relation: &Relation) -> bool {
+        for (_key, val) in relation.tags() {
+            if self.re.is_match(val) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+#[derive(Debug)]
+pub struct KeyValueQuery {
+    key: String,
+    value: String,
+}
+
+impl KeyValueQuery {
+    pub fn new<S: Into<String>>(key: S, value: S) -> Self {
+        KeyValueQuery {
+            key: key.into(),
+            value: value.into(),
+        }
+    }
+}
+
+impl Query for KeyValueQuery {
+    type BI = ();
+
+    fn create_block_index(&self, _block: &PrimitiveBlock) -> () {
+        ()
+    }
+
+    fn node_matches(&self, _: &(), node: &Node) -> bool {
+        for (key, val) in node.tags() {
+            if key == self.key && val == self.value {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    fn dense_node_matches(&self, _: &(), dnode: &DenseNode) -> bool {
+        for (key, val) in dnode.tags() {
+            if key == self.key && val == self.value {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    fn way_matches(&self, _: &(), way: &Way) -> bool {
+        for (key, val) in way.tags() {
+            if key == self.key && val == self.value {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    fn relation_matches(&self, _: &(), relation: &Relation) -> bool {
+        for (key, val) in relation.tags() {
+            if key == self.key && val == self.value {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+pub fn find_query_matches<Q: Query>(
+    block: &PrimitiveBlock,
+    query: &Q,
+    matches: &mut Vec<LatLonDeg>,
+    way_node_ids: &mut Vec<i64>,
+) {
+    let block_index = query.create_block_index(block);
+
+    for node in block.groups().flat_map(|g| g.nodes()) {
+        if query.node_matches(&block_index, &node) {
+            let pos = LatLonDeg::new(node.lat(), node.lon());
+            matches.push(pos);
+        }
+    }
+
+    for node in block.groups().flat_map(|g| g.dense_nodes()) {
+        if query.dense_node_matches(&block_index, &node) {
+            let pos = LatLonDeg::new(node.lat(), node.lon());
+            matches.push(pos);
+        }
+    }
+
+    for way in block.groups().flat_map(|g| g.ways()) {
+        if query.way_matches(&block_index, &way) {
+            way_node_ids.push(way.refs_slice()[0]);
+        }
+    }
+}

src/search.rs

@@ -1,6 +1,6 @@
 use coord::LatLonDeg;
 use osmpbf::{Blob, BlobDecode, BlobReader, PrimitiveBlock};
-use regex::Regex;
+use query::{find_query_matches, QueryArgs, QueryKind};
 use scoped_threadpool::Pool;
 use std::collections::hash_set::HashSet;
 use std::path::{Path, PathBuf};
@@ -31,7 +31,7 @@ enum WorkerMessage {
 
 pub fn par_search<P, F, G>(
     pbf_path: P,
-    search_pattern: &str,
+    query_args: QueryArgs,
     found_func: F,
     finished_func: G,
 ) -> Result<thread::JoinHandle<()>, String>
@@ -40,9 +40,8 @@ where P: AsRef<Path>,
       G: Fn(Result<(), String>) + Send + 'static,
 {
     let pbf_path = PathBuf::from(pbf_path.as_ref());
-    let search_pattern = search_pattern.to_string();
     let handle = thread::spawn(move|| {
-        let res = par_search_blocking(pbf_path, &search_pattern, found_func);
+        let res = par_search_blocking(pbf_path, query_args, found_func);
         finished_func(res);
     });
 
@@ -51,48 +50,30 @@ where P: AsRef<Path>,
 
 pub fn par_search_blocking<P, F>(
     pbf_path: P,
-    search_pattern: &str,
+    query_args: QueryArgs,
     found_func: F,
 ) -> Result<(), String>
 where P: AsRef<Path>,
       F: Fn(Vec<LatLonDeg>) -> ControlFlow + Send + 'static,
 {
-    let re = Regex::new(search_pattern)
-        .map_err(|e| format!("{}", e))?;
-    let re = &re;
+    let query = query_args.compile()?;
+    let query = &query;
 
     let first_pass = move |block: &PrimitiveBlock, _: &()| {
         let mut matches = vec![];
         let mut way_node_ids = vec![];
 
-        for node in block.groups().flat_map(|g| g.nodes()) {
-            for (_key, val) in node.tags() {
-                if re.is_match(val) {
-                    let pos = LatLonDeg::new(node.lat(), node.lon());
-                    matches.push(pos);
-                    break;
-                }
-            }
-        }
-
-        for node in block.groups().flat_map(|g| g.dense_nodes()) {
-            for (_key, val) in node.tags() {
-                if re.is_match(val) {
-                    let pos = LatLonDeg::new(node.lat(), node.lon());
-                    matches.push(pos);
-                    break;
-                }
-            }
-        }
-
-        for way in block.groups().flat_map(|g| g.ways()) {
-            for (_key, val) in way.tags() {
-                if re.is_match(val) && !way.refs_slice().is_empty() {
-                    //TODO take middle node, not first one
-                    way_node_ids.push(way.refs_slice()[0]);
-                    break;
-                }
-            }
+        match query {
+            &QueryKind::ValuePattern(ref query) => {
+                find_query_matches(block, query, &mut matches, &mut way_node_ids);
+            },
+            &QueryKind::KeyValue(ref query) => {
+                find_query_matches(block, query, &mut matches, &mut way_node_ids);
+            },
+            _ => {
+                //TODO implement
+                unimplemented!();
+            },
         }
 
         (matches, way_node_ids)