Merge pull request #17 from j2inn/feature/STK-2059/add-visitor-to-filter

Add visitor to haystack filter processing

Author: garethj2

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "libhaystack"
-version = "1.0.12"
+version = "1.0.13"
 description = "Rust implementation of the Haystack 4 data types, defs, filter, units, and encodings"
 authors = ["J2 Innovations", "Radu Racariu <radur@j2inn.com>"]
 edition = "2021"

Cargo.toml

@@ -247,7 +247,7 @@ impl<'a> Namespace<'a> {
                         Value::Symbol(sym) => self
                             .subtypes
                             .entry(sym.clone())
-                            .or_insert_with(Vec::new)
+                            .or_default()
                             .push(def.clone()),
                         _ => continue,
                     }
@@ -542,16 +542,19 @@ impl<'a> Namespace<'a> {
                 .map(|conjunct| conjunct.def_name())
                 .map(|def_name| def_name.split('-').collect::<Vec<&str>>())
                 .filter(|parts| !parts.is_empty())
-                .fold(BTreeMap::default(), |mut map, parts| {
-                    let marker = parts[0];
-                    map.entry(marker.into()).or_insert_with(Vec::new).push(
-                        Vec::from(&parts[1..])
-                            .into_iter()
-                            .map(|v| v.into())
-                            .collect(),
-                    );
-                    map
-                }),
+                .fold(
+                    BTreeMap::default(),
+                    |mut map: BTreeMap<String, Vec<Vec<String>>>, parts| {
+                        let marker = parts[0];
+                        map.entry(marker.into()).or_default().push(
+                            Vec::from(&parts[1..])
+                                .into_iter()
+                                .map(|v| v.into())
+                                .collect(),
+                        );
+                        map
+                    },
+                ),
         )
     }
 

src/haystack/defs/namespace.rs

@@ -71,3 +71,9 @@ impl Display for Filter {
         self.or.fmt(f)
     }
 }
+
+impl Visitable for Filter {
+    fn accept_visitor(&self, visitor: &mut impl Visitor) {
+        self.or.accept_visitor(visitor);
+    }
+}

src/haystack/filter/mod.rs

@@ -10,11 +10,38 @@ use crate::val::Symbol;
 use std::collections::HashSet;
 use std::fmt::{Display, Formatter, Result};
 
+/// A visitable that accepts a visitor.
+pub trait Visitable {
+    fn accept_visitor(&self, visitor: &mut impl Visitor);
+}
+
+/// A visitor trait used for working with a generated filter AST.
+pub trait Visitor {
+    fn visit_cond_or(&mut self, node: &Or);
+
+    fn visit_cond_and(&mut self, node: &And);
+
+    fn visit_parens(&mut self, node: &Parens);
+
+    fn visit_has(&mut self, node: &Has);
+
+    fn visit_missing(&mut self, node: &Missing);
+
+    fn visit_is_a(&mut self, node: &IsA);
+
+    fn visit_wildcard_equals(&mut self, node: &WildcardEq);
+
+    fn visit_relation(&mut self, node: &Relation);
+
+    fn visit_cmp(&mut self, node: &Cmp);
+}
+
 /// A Haystack Filter Or expression
 #[derive(PartialEq, PartialOrd, Clone, Debug)]
 pub struct Or {
     pub ands: Vec<And>,
 }
+
 impl Display for Or {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         self.ands
@@ -37,6 +64,12 @@ impl Eval for Or {
     }
 }
 
+impl Visitable for Or {
+    fn accept_visitor(&self, visitor: &mut impl Visitor) {
+        visitor.visit_cond_or(self);
+    }
+}
+
 /// A Haystack Filter And expression
 #[derive(PartialEq, PartialOrd, Clone, Debug)]
 pub struct And {
@@ -65,6 +98,12 @@ impl Display for And {
     }
 }
 
+impl Visitable for And {
+    fn accept_visitor(&self, visitor: &mut impl Visitor) {
+        visitor.visit_cond_and(self);
+    }
+}
+
 /// A Haystack Filter terminal
 #[derive(PartialEq, PartialOrd, Clone, Debug)]
 pub enum Term {
@@ -105,6 +144,20 @@ impl Display for Term {
     }
 }
 
+impl Visitable for Term {
+    fn accept_visitor(&self, visitor: &mut impl Visitor) {
+        match self {
+            Term::Parens(parens) => parens.accept_visitor(visitor),
+            Term::Has(has) => has.accept_visitor(visitor),
+            Term::Missing(missing) => missing.accept_visitor(visitor),
+            Term::IsA(isa) => isa.accept_visitor(visitor),
+            Term::WildcardEq(wildcard_eq) => wildcard_eq.accept_visitor(visitor),
+            Term::Relation(rel) => rel.accept_visitor(visitor),
+            Term::Cmp(cmp) => cmp.accept_visitor(visitor),
+        }
+    }
+}
+
 /// Filter compare operators
 #[derive(PartialEq, Eq, PartialOrd, Clone, Debug)]
 pub enum CmpOp {
@@ -170,6 +223,12 @@ impl Display for Cmp {
     }
 }
 
+impl Visitable for Cmp {
+    fn accept_visitor(&self, visitor: &mut impl Visitor) {
+        visitor.visit_cmp(self);
+    }
+}
+
 /// Missing term
 #[derive(PartialEq, Eq, PartialOrd, Clone, Debug)]
 pub struct Missing {
@@ -188,6 +247,12 @@ impl Display for Missing {
     }
 }
 
+impl Visitable for Missing {
+    fn accept_visitor(&self, visitor: &mut impl Visitor) {
+        visitor.visit_missing(self);
+    }
+}
+
 /// Parenthesis term
 #[derive(PartialEq, PartialOrd, Clone, Debug)]
 pub struct Parens {
@@ -207,6 +272,12 @@ impl Display for Parens {
     }
 }
 
+impl Visitable for Parens {
+    fn accept_visitor(&self, visitor: &mut impl Visitor) {
+        visitor.visit_parens(self);
+    }
+}
+
 /// Has term
 #[derive(PartialEq, Eq, PartialOrd, Clone, Debug)]
 pub struct Has {
@@ -224,6 +295,12 @@ impl Display for Has {
     }
 }
 
+impl Visitable for Has {
+    fn accept_visitor(&self, visitor: &mut impl Visitor) {
+        visitor.visit_has(self);
+    }
+}
+
 /// Is A term
 #[derive(PartialEq, Eq, PartialOrd, Clone, Debug)]
 pub struct IsA {
@@ -242,6 +319,12 @@ impl Display for IsA {
     }
 }
 
+impl Visitable for IsA {
+    fn accept_visitor(&self, visitor: &mut impl Visitor) {
+        visitor.visit_is_a(self);
+    }
+}
+
 /// Wildcard equality
 #[derive(PartialEq, Eq, PartialOrd, Clone, Debug)]
 pub struct WildcardEq {
@@ -290,6 +373,12 @@ impl Display for WildcardEq {
     }
 }
 
+impl Visitable for WildcardEq {
+    fn accept_visitor(&self, visitor: &mut impl Visitor) {
+        visitor.visit_wildcard_equals(self);
+    }
+}
+
 /// Relation
 #[derive(PartialEq, Eq, PartialOrd, Clone, Debug)]
 pub struct Relation {
@@ -326,3 +415,9 @@ impl Display for Relation {
         }
     }
 }
+
+impl Visitable for Relation {
+    fn accept_visitor(&self, visitor: &mut impl Visitor) {
+        visitor.visit_relation(self);
+    }
+}

src/haystack/filter/nodes.rs

@@ -10,7 +10,7 @@ use std::{
 };
 
 /// Coordinate latitude and longitude
-////
+///
 /// # Example
 /// Create a coord value
 /// ```
@@ -69,6 +69,7 @@ impl PartialEq for Coord {
 
 impl Eq for Coord {}
 
+#[allow(clippy::non_canonical_partial_ord_impl)]
 impl PartialOrd for Coord {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         self.lat.partial_cmp(&other.lat).and_then(|ord| {

src/haystack/val/coord.rs

@@ -152,6 +152,7 @@ impl DerefMut for Dict {
     }
 }
 
+#[allow(clippy::non_canonical_partial_ord_impl)]
 impl PartialOrd for Dict {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         self.value.partial_cmp(&other.value)

src/haystack/val/dict.rs

@@ -132,6 +132,7 @@ impl PartialEq for Number {
 
 impl Eq for Number {}
 
+#[allow(clippy::non_canonical_partial_ord_impl)]
 impl PartialOrd for Number {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         if self.unit == other.unit {

src/haystack/val/number.rs

@@ -55,6 +55,7 @@ impl PartialEq for Ref {
 }
 
 /// Implement partial ordering used in sorting for Ref
+#[allow(clippy::non_canonical_partial_ord_impl)]
 impl PartialOrd for Ref {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         self.value.partial_cmp(&other.value)

src/haystack/val/reference.rs

@@ -2,3 +2,4 @@
 
 mod test_filter_defs;
 mod test_haystack_filter;
+mod test_haystack_filter_visitor;