Add KeyValueRegex query (-r)

src/args.rs

             .multiple(true)
             .help("Search for places that are tagged with the given key and value")
             .takes_value(true))
+        .arg(Arg::with_name("keyvalregex")
+            .short("r")
+            .long("keyvalregex")
+            .value_names(&["KEY", "REGEX"])
+            .number_of_values(2)
+            .multiple(true)
+            .help("Search for places that are tagged with the given key and a value that matches the given regex")
+            .takes_value(true))
         .arg(Arg::with_name("fps")
             .long("fps")
             .value_name("FPS")

src/config.rs

     pbf_path: Option<PathBuf>,
     search_pattern: Option<String>,
     keyval: Vec<(String, String)>,
+    keyvalregex: Vec<(String, String)>,
     fps: f64,
     use_network: bool,
     async: bool,
             },
         );
 
+        self.keyvalregex = matches.values_of("keyvalregex").map_or_else(
+            || vec![],
+            |mut kv| {
+                let mut vec = vec![];
+                loop {
+                    if let (Some(k), Some(v)) = (kv.next(), kv.next()) {
+                        vec.push((k.to_string(), v.to_string()));
+                    } else {
+                        break;
+                    }
+                }
+                vec
+            },
+        );
+
         if let Some(Ok(fps)) = matches.value_of("fps").map(|s| s.parse()) {
             self.fps = fps;
         }
                         pbf_path,
                         search_pattern: None,
                         keyval: vec![],
+                        keyvalregex: vec![],
                         fps,
                         use_network,
                         async,
         self.keyval.as_slice()
     }
 
+    pub fn keyvalregex(&self) -> &[(String, String)] {
+        self.keyvalregex.as_slice()
+    }
+
     pub fn query_args(&self) -> Option<QueryArgs> {
-        match (&self.search_pattern, self.keyval.len()) {
-            (&Some(ref pattern), 0) => Some(QueryArgs::ValuePattern(pattern.to_string())),
-            (&None, 1) => Some(
-                QueryArgs::KeyValue(self.keyval[0].0.to_string(), self.keyval[0].1.to_string())
+        match (&self.search_pattern, self.keyval.first(), self.keyvalregex.first()) {
+            (&Some(ref pattern), None, None) => Some(
+                QueryArgs::ValuePattern(pattern.to_string())
+            ),
+            (&None, Some(keyval), None) => Some(
+                QueryArgs::KeyValue(keyval.0.to_string(), keyval.1.to_string())
             ),
-            (&Some(ref pattern), _) => {
-                let mut vec = vec![QueryArgs::ValuePattern(pattern.to_string())];
+            (&None, None, Some(keyvalregex)) => Some(
+                QueryArgs::KeyValueRegex(keyvalregex.0.to_string(), keyvalregex.1.to_string())
+            ),
+            (pattern_opt, _, _) => {
+                let mut vec = vec![];
+
+                if let Some(ref pattern) = pattern_opt {
+                    vec.push(QueryArgs::ValuePattern(pattern.to_string()));
+                }
 
                 for (k, v) in &self.keyval {
                     vec.push(QueryArgs::KeyValue(k.to_string(), v.to_string()));
                 }
-                Some(QueryArgs::Intersection(vec))
-            },
-            (&None, x) if x > 0 => {
-                let mut vec = self.keyval.iter()
-                    .map(|&(ref k, ref v)| QueryArgs::KeyValue(k.to_string(), v.to_string()))
-                    .collect();
-                Some(QueryArgs::Intersection(vec))
+
+                for (k, v) in &self.keyvalregex {
+                    vec.push(QueryArgs::KeyValueRegex(k.to_string(), v.to_string()));
+                }
+
+                if vec.is_empty() {
+                    None
+                } else {
+                    Some(QueryArgs::Intersection(vec))
+                }
             },
-            (&None, _) => None,
         }
     }
 

src/query.rs

 pub enum QueryArgs {
     ValuePattern(String),
     KeyValue(String, String),
+    KeyValueRegex(String, String),
     Intersection(Vec<QueryArgs>),
 }
 
 pub enum QueryKind {
     ValuePattern(ValuePatternQuery),
     KeyValue(KeyValueQuery),
+    KeyValueRegex(KeyValueRegexQuery),
     Intersection(Vec<QueryKind>),
 }
 
             QueryArgs::KeyValue(k, v) => {
                 Ok(QueryKind::KeyValue(KeyValueQuery::new(k, v)))
             },
+            QueryArgs::KeyValueRegex(k, v) => {
+                Ok(QueryKind::KeyValueRegex(KeyValueRegexQuery::new(k, &v)?))
+            },
             QueryArgs::Intersection(queries) => {
                 let mut subqueries = Vec::with_capacity(queries.len());
                 for q in queries {
     }
 }
 
+#[derive(Debug)]
+pub struct KeyValueRegexQuery {
+    key: String,
+    value_re: Regex,
+}
+
+impl KeyValueRegexQuery {
+    pub fn new<S: Into<String>>(key: S, value_pattern: &str) -> Result<Self, String> {
+        let value_re = Regex::new(value_pattern)
+            .map_err(|e| format!("{}", e))?;
+        Ok(KeyValueRegexQuery {
+            key: key.into(),
+            value_re,
+        })
+    }
+}
+
+impl Query for KeyValueRegexQuery {
+    type BI = (Vec<u32>, Vec<u32>);
+
+    fn create_block_index(&self, block: &PrimitiveBlock) -> Option<(Vec<u32>, Vec<u32>)> {
+        let mut key_indices = vec![];
+        let mut value_indices = vec![];
+
+        let key_bytes = self.key.as_bytes();
+
+        for (i, string) in block.raw_stringtable().iter().enumerate() {
+            if string.as_slice() == key_bytes {
+                key_indices.push(i as u32);
+            }
+
+            if let Ok(s) = ::std::str::from_utf8(string) {
+                if self.value_re.is_match(s) {
+                    value_indices.push(i as u32);
+                }
+            }
+        }
+
+        if key_indices.is_empty() || value_indices.is_empty() {
+            // No matches possible for this block
+            return None;
+        }
+
+        key_indices.sort();
+        value_indices.sort();
+
+        Some((key_indices, value_indices))
+    }
+
+    fn node_matches(&self, bi: &Self::BI, node: &Node) -> bool {
+        for (key, val) in node.raw_tags() {
+            if bi.0.binary_search(&key).is_ok() && bi.1.binary_search(&val).is_ok() {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    fn dense_node_matches(&self, bi: &Self::BI, dnode: &DenseNode) -> bool {
+        for (key, val) in dnode.raw_tags() {
+            if key >= 0 &&
+               val >= 0 &&
+               bi.0.binary_search(&(key as u32)).is_ok() &&
+               bi.1.binary_search(&(val as u32)).is_ok()
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    fn way_matches(&self, bi: &Self::BI, way: &Way) -> bool {
+        for (key, val) in way.raw_tags() {
+            if bi.0.binary_search(&key).is_ok() && bi.1.binary_search(&val).is_ok() {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    fn relation_matches(&self, bi: &Self::BI, relation: &Relation) -> bool {
+        for (key, val) in relation.raw_tags() {
+            if bi.0.binary_search(&key).is_ok() && bi.1.binary_search(&val).is_ok() {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
 pub fn find_query_matches<Q: Query>(
     block: &PrimitiveBlock,
     query: &Q,

src/search.rs

         &QueryKind::KeyValue(ref query) => {
             find_query_matches(block, query, &mut matches, &mut way_node_ids);
         },
+        &QueryKind::KeyValueRegex(ref query) => {
+            find_query_matches(block, query, &mut matches, &mut way_node_ids);
+        },
         &QueryKind::Intersection(ref queries) => {
             let mut q_iter = queries.iter();