search: Allow intersection of multiple queries

src/args.rs

         .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))
-                }
-            })
+            .value_names(&["KEY", "VALUE"])
+            .number_of_values(2)
+            .multiple(true)
             .help("Search for places that are tagged with the given key and value")
             .takes_value(true))
         .arg(Arg::with_name("fps")

src/config.rs

     sources: Vec<(String, TileSource)>,
     pbf_path: Option<PathBuf>,
     search_pattern: Option<String>,
-    keyval: Option<(String, String)>,
+    keyval: Vec<(String, String)>,
     fps: f64,
     use_network: bool,
     async: bool,
     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
-            }
-        });
+        self.keyval = matches.values_of("keyval").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;
                         sources: vec![],
                         pbf_path,
                         search_pattern: None,
-                        keyval: None,
+                        keyval: vec![],
                         fps,
                         use_network,
                         async,
         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 keyval(&self) -> &[(String, String)] {
+        self.keyval.as_slice()
     }
 
     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!();
+        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())
+            ),
+            (&Some(ref pattern), _) => {
+                let mut vec = vec![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))
             },
-            (&None, &None) => None,
+            (&None, _) => None,
         }
     }
 

src/main.rs

 pub mod url_template;
 pub mod vertex_attrib;
 
-use coord::{LatLonDeg, ScreenCoord};
+use coord::ScreenCoord;
 use glutin::dpi::{LogicalPosition, LogicalSize, PhysicalPosition};
 use glutin::{ControlFlow, ElementState, Event, GlContext, MouseButton, MouseScrollDelta, VirtualKeyCode, WindowEvent};
 use map_view_gl::MapViewGl;
+use search::MatchItem;
+use std::collections::hash_set::HashSet;
 use std::error::Error;
 use std::sync::mpsc;
 use std::time::{Duration, Instant};
     map: &mut MapViewGl,
     input_state: &mut InputState,
     sources: &mut TileSources,
-    marker_rx: &mpsc::Receiver<Vec<LatLonDeg>>,
+    marker_rx: &mpsc::Receiver<HashSet<MatchItem>>,
 ) -> Action {
     trace!("{:?}", event);
     match *event {
         Event::Awakened => {
-            for pos in marker_rx.try_iter().flat_map(|c| c.into_iter()) {
-                map.add_marker(pos.into());
+            for item in marker_rx.try_iter().flat_map(|c| c.into_iter()) {
+                match item {
+                    MatchItem::Node{pos, ..} => map.add_marker(pos.into()),
+                    MatchItem::Way{pos, ..} => map.add_marker(pos.into()),
+                }
             }
             Action::Redraw
         },

src/query.rs

 use coord::LatLonDeg;
 use osmpbf::{DenseNode, Node, PrimitiveBlock, Relation, Way};
 use regex::Regex;
+use search::MatchItem;
+use std::collections::hash_set::HashSet;
 
 
 pub trait Query {
 pub enum QueryArgs {
     ValuePattern(String),
     KeyValue(String, String),
-    Intersection(Box<(QueryArgs, QueryArgs)>),
+    Intersection(Vec<QueryArgs>),
 }
 
 #[derive(Debug)]
 pub enum QueryKind {
     ValuePattern(ValuePatternQuery),
     KeyValue(KeyValueQuery),
-    Intersection(Box<(QueryArgs, QueryArgs)>),
+    Intersection(Vec<QueryKind>),
 }
 
 impl QueryArgs {
             QueryArgs::KeyValue(k, v) => {
                 Ok(QueryKind::KeyValue(KeyValueQuery::new(k, v)))
             },
-            _ => {
-                //TODO implement
-                unimplemented!();
+            QueryArgs::Intersection(queries) => {
+                let mut subqueries = Vec::with_capacity(queries.len());
+                for q in queries {
+                    subqueries.push(q.compile()?);
+                }
+                Ok(QueryKind::Intersection(subqueries))
             },
         }
     }
 pub fn find_query_matches<Q: Query>(
     block: &PrimitiveBlock,
     query: &Q,
-    matches: &mut Vec<LatLonDeg>,
-    way_node_ids: &mut Vec<i64>,
+    matches: &mut HashSet<MatchItem>,
+    way_node_ids: &mut HashSet<i64>,
 ) {
     if let Some(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);
+                matches.insert(MatchItem::Node{
+                    id: node.id(),
+                    pos: LatLonDeg::new(node.lat(), node.lon()),
+                });
             }
         }
 
         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);
+                matches.insert(MatchItem::Node{
+                    id: node.id,
+                    pos: LatLonDeg::new(node.lat(), node.lon()),
+                });
             }
         }
 
         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]);
+                way_node_ids.insert(way.refs_slice()[0]);
             }
         }
     }

src/search.rs

 use query::{find_query_matches, QueryArgs, QueryKind};
 use scoped_threadpool::Pool;
 use std::collections::hash_set::HashSet;
+use std::hash::{Hash, Hasher};
 use std::path::{Path, PathBuf};
 use std::sync::mpsc::sync_channel;
 use std::thread;
     DoBlob(Box<Blob>),
 }
 
+#[derive(Clone, Copy, Debug)]
+pub enum MatchItem {
+    Node{id: i64, pos: LatLonDeg},
+    Way{id: i64, pos: LatLonDeg},
+}
+
+impl Hash for MatchItem {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        match *self {
+            MatchItem::Node{id, pos: _} => {
+                1u64.hash(state);
+                id.hash(state);
+            },
+            MatchItem::Way{id, pos: _} => {
+                2u64.hash(state);
+                id.hash(state);
+            },
+        }
+    }
+}
+
+impl PartialEq for MatchItem {
+    fn eq(&self, other: &MatchItem) -> bool {
+        match (*self, *other) {
+            (MatchItem::Node{id: a, ..}, MatchItem::Node{id: b, ..}) => a == b,
+            (MatchItem::Way{id: a, ..}, MatchItem::Way{id: b, ..}) => a == b,
+            _ => false,
+        }
+    }
+}
+
+impl Eq for MatchItem {
+}
+
 pub fn par_search<P, F, G>(
     pbf_path: P,
     query_args: QueryArgs,
     finished_func: G,
 ) -> Result<thread::JoinHandle<()>, String>
 where P: AsRef<Path>,
-      F: Fn(Vec<LatLonDeg>) -> ControlFlow + Send + 'static,
+      F: Fn(HashSet<MatchItem>) -> ControlFlow + Send + 'static,
       G: Fn(Result<(), String>) + Send + 'static,
 {
     let pbf_path = PathBuf::from(pbf_path.as_ref());
     Ok(handle)
 }
 
+fn first_query_pass(block: &PrimitiveBlock, query: &QueryKind)
+    -> (HashSet<MatchItem>, HashSet<i64>)
+{
+    let mut matches = HashSet::new();
+    let mut way_node_ids = HashSet::new();
+
+    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);
+        },
+        &QueryKind::Intersection(ref queries) => {
+            let mut q_iter = queries.iter();
+
+            let (mut sub_matches, mut sub_way_node_ids) = q_iter.next()
+                .map_or_else(
+                    || (HashSet::new(), HashSet::new()),
+                    |q| first_query_pass(block, q),
+                );
+
+            for q in q_iter {
+                let (m, w) = first_query_pass(block, q);
+                sub_matches = sub_matches.intersection(&m).cloned().collect();
+                sub_way_node_ids = sub_way_node_ids.intersection(&w).cloned().collect();
+            }
+            matches.extend(sub_matches);
+            way_node_ids.extend(sub_way_node_ids);
+        },
+    }
+
+    (matches, way_node_ids)
+}
+
 pub fn par_search_blocking<P, F>(
     pbf_path: P,
     query_args: QueryArgs,
     found_func: F,
 ) -> Result<(), String>
 where P: AsRef<Path>,
-      F: Fn(Vec<LatLonDeg>) -> ControlFlow + Send + 'static,
+      F: Fn(HashSet<MatchItem>) -> ControlFlow + Send + 'static,
 {
     let query = query_args.compile()?;
     let query = &query;
 
-    let first_pass = move |block: &PrimitiveBlock, _: &()| {
-        let mut matches = vec![];
-        let mut way_node_ids = vec![];
-
-        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)
-    };
-
     let mut way_node_ids: HashSet<i64> = HashSet::new();
 
     par_iter_blobs(
         &pbf_path,
         || {},
-        first_pass,
+        move |block: &PrimitiveBlock, _: &()| {
+            first_query_pass(block, query)
+        },
         |(matches, node_ids)| {
-            way_node_ids.extend(&node_ids);
+            way_node_ids.extend(node_ids);
             found_func(matches)
         },
     )?;
     let way_node_ids = &way_node_ids;
 
     let second_pass = move |block: &PrimitiveBlock, _: &()| {
-        let mut matches = vec![];
+        let mut matches = HashSet::new();
 
         for node in block.groups().flat_map(|g| g.nodes()) {
             if way_node_ids.contains(&node.id()) {
-                let pos = LatLonDeg::new(node.lat(), node.lon());
-                matches.push(pos);
+                matches.insert(MatchItem::Way{
+                    id: node.id(),
+                    pos: LatLonDeg::new(node.lat(), node.lon()),
+                });
             }
         }
 
         for node in block.groups().flat_map(|g| g.dense_nodes()) {
             if way_node_ids.contains(&node.id) {
-                let pos = LatLonDeg::new(node.lat(), node.lon());
-                matches.push(pos);
+                matches.insert(MatchItem::Way{
+                    id: node.id,
+                    pos: LatLonDeg::new(node.lat(), node.lon()),
+                });
             }
         }