Merge branch 'feature/code_cleanup'

src/select/cmp.rs

@@ -0,0 +1,335 @@
+use array_tool::vec::{Intersect, Union};
+use serde_json::Value;
+
+pub(super) trait Cmp {
+    fn cmp_bool(&self, v1: bool, v2: bool) -> bool;
+
+    fn cmp_f64(&self, v1: f64, v2: f64) -> bool;
+
+    fn cmp_string(&self, v1: &str, v2: &str) -> bool;
+
+    fn cmp_json<'a>(&self, v1: &[&'a Value], v2: &[&'a Value]) -> Vec<&'a Value>;
+
+    fn default(&self) -> bool {
+        false
+    }
+}
+
+pub(super) struct CmpEq;
+
+impl Cmp for CmpEq {
+    fn cmp_bool(&self, v1: bool, v2: bool) -> bool {
+        v1 == v2
+    }
+
+    fn cmp_f64(&self, v1: f64, v2: f64) -> bool {
+        (v1 - v2).abs() == 0_f64
+    }
+
+    fn cmp_string(&self, v1: &str, v2: &str) -> bool {
+        v1 == v2
+    }
+
+    fn cmp_json<'a>(&self, v1: &[&'a Value], v2: &[&'a Value]) -> Vec<&'a Value> {
+        v1.to_vec().intersect(v2.to_vec())
+    }
+}
+
+pub(super) struct CmpNe;
+
+impl Cmp for CmpNe {
+    fn cmp_bool(&self, v1: bool, v2: bool) -> bool {
+        v1 != v2
+    }
+
+    fn cmp_f64(&self, v1: f64, v2: f64) -> bool {
+        (v1 - v2).abs() != 0_f64
+    }
+
+    fn cmp_string(&self, v1: &str, v2: &str) -> bool {
+        v1 != v2
+    }
+
+    fn cmp_json<'a>(&self, v1: &[&'a Value], v2: &[&'a Value]) -> Vec<&'a Value> {
+        v1.to_vec().intersect_if(v2.to_vec(), |a, b| a != b)
+    }
+}
+
+pub(super) struct CmpGt;
+
+impl Cmp for CmpGt {
+    fn cmp_bool(&self, v1: bool, v2: bool) -> bool {
+        v1 & !v2
+    }
+
+    fn cmp_f64(&self, v1: f64, v2: f64) -> bool {
+        v1 > v2
+    }
+
+    fn cmp_string(&self, v1: &str, v2: &str) -> bool {
+        v1 > v2
+    }
+
+    fn cmp_json<'a>(&self, _: &[&'a Value], _: &[&'a Value]) -> Vec<&'a Value> {
+        Vec::new()
+    }
+}
+
+pub(super) struct CmpGe;
+
+impl Cmp for CmpGe {
+    fn cmp_bool(&self, v1: bool, v2: bool) -> bool {
+        v1 >= v2
+    }
+
+    fn cmp_f64(&self, v1: f64, v2: f64) -> bool {
+        v1 >= v2
+    }
+
+    fn cmp_string(&self, v1: &str, v2: &str) -> bool {
+        v1 >= v2
+    }
+
+    fn cmp_json<'a>(&self, _: &[&'a Value], _: &[&'a Value]) -> Vec<&'a Value> {
+        Vec::new()
+    }
+}
+
+pub(super) struct CmpLt;
+
+impl Cmp for CmpLt {
+    fn cmp_bool(&self, v1: bool, v2: bool) -> bool {
+        !v1 & v2
+    }
+
+    fn cmp_f64(&self, v1: f64, v2: f64) -> bool {
+        v1 < v2
+    }
+
+    fn cmp_string(&self, v1: &str, v2: &str) -> bool {
+        v1 < v2
+    }
+
+    fn cmp_json<'a>(&self, _: &[&'a Value], _: &[&'a Value]) -> Vec<&'a Value> {
+        Vec::new()
+    }
+}
+
+pub(super) struct CmpLe;
+
+impl Cmp for CmpLe {
+    fn cmp_bool(&self, v1: bool, v2: bool) -> bool {
+        v1 <= v2
+    }
+
+    fn cmp_f64(&self, v1: f64, v2: f64) -> bool {
+        v1 <= v2
+    }
+
+    fn cmp_string(&self, v1: &str, v2: &str) -> bool {
+        v1 <= v2
+    }
+
+    fn cmp_json<'a>(&self, _: &[&'a Value], _: &[&'a Value]) -> Vec<&'a Value> {
+        Vec::new()
+    }
+}
+
+pub(super) struct CmpAnd;
+
+impl Cmp for CmpAnd {
+    fn cmp_bool(&self, v1: bool, v2: bool) -> bool {
+        v1 && v2
+    }
+
+    fn cmp_f64(&self, _v1: f64, _v2: f64) -> bool {
+        true
+    }
+
+    fn cmp_string(&self, v1: &str, v2: &str) -> bool {
+        !v1.is_empty() && !v2.is_empty()
+    }
+
+    fn cmp_json<'a>(&self, v1: &[&'a Value], v2: &[&'a Value]) -> Vec<&'a Value> {
+        v1.to_vec().intersect(v2.to_vec())
+    }
+}
+
+pub(super) struct CmpOr;
+
+impl Cmp for CmpOr {
+    fn cmp_bool(&self, v1: bool, v2: bool) -> bool {
+        v1 || v2
+    }
+
+    fn cmp_f64(&self, _v1: f64, _v2: f64) -> bool {
+        true
+    }
+
+    fn cmp_string(&self, v1: &str, v2: &str) -> bool {
+        !v1.is_empty() || !v2.is_empty()
+    }
+
+    fn cmp_json<'a>(&self, v1: &[&'a Value], v2: &[&'a Value]) -> Vec<&'a Value> {
+        v1.to_vec().union(v2.to_vec())
+    }
+}
+
+
+#[cfg(test)]
+mod cmp_inner_tests {
+    use serde_json::Value;
+
+    use select::cmp::*;
+
+    #[test]
+    fn cmp_eq() {
+        let cmp_fn = CmpEq;
+        assert_eq!(cmp_fn.default(), false);
+        assert_eq!(cmp_fn.cmp_bool(true, false), false);
+        assert_eq!(cmp_fn.cmp_bool(true, true), true);
+        assert_eq!(cmp_fn.cmp_f64(0.1, 0.1), true);
+        assert_eq!(cmp_fn.cmp_f64(0.1, 0.2), false);
+        assert_eq!(cmp_fn.cmp_string("1", "1"), true);
+        assert_eq!(cmp_fn.cmp_string("1", "2"), false);
+    }
+
+    #[test]
+    fn cmp_ne() {
+        let cmp_fn = CmpNe;
+        assert_eq!(cmp_fn.default(), false);
+        assert_eq!(cmp_fn.cmp_bool(true, false), true);
+        assert_eq!(cmp_fn.cmp_bool(true, true), false);
+        assert_eq!(cmp_fn.cmp_f64(0.1, 0.1), false);
+        assert_eq!(cmp_fn.cmp_f64(0.1, 0.2), true);
+        assert_eq!(cmp_fn.cmp_string("1", "1"), false);
+        assert_eq!(cmp_fn.cmp_string("1", "2"), true);
+    }
+
+    #[test]
+    fn cmp_gt() {
+        let cmp_fn = CmpGt;
+        assert_eq!(cmp_fn.default(), false);
+        assert_eq!(cmp_fn.cmp_bool(true, false), true);
+        assert_eq!(cmp_fn.cmp_bool(true, true), false);
+        assert_eq!(cmp_fn.cmp_f64(0.2, 0.1), true);
+        assert_eq!(cmp_fn.cmp_f64(0.1, 0.2), false);
+        assert_eq!(cmp_fn.cmp_string("a", "a"), false);
+        assert_eq!(cmp_fn.cmp_string("b", "a"), true);
+        assert_eq!(cmp_fn.cmp_string("1", "2"), false);
+    }
+
+    #[test]
+    fn cmp_ge() {
+        let cmp_fn = CmpGe;
+        assert_eq!(cmp_fn.default(), false);
+        assert_eq!(cmp_fn.cmp_bool(true, false), true);
+        assert_eq!(cmp_fn.cmp_bool(true, true), true);
+        assert_eq!(cmp_fn.cmp_f64(0.2, 0.1), true);
+        assert_eq!(cmp_fn.cmp_f64(0.1, 0.1), true);
+        assert_eq!(cmp_fn.cmp_f64(0.1, 0.2), false);
+        assert_eq!(cmp_fn.cmp_string("1", "1"), true);
+        assert_eq!(cmp_fn.cmp_string("ab", "a"), true);
+        assert_eq!(cmp_fn.cmp_string("1", "2"), false);
+    }
+
+    #[test]
+    fn cmp_lt() {
+        let cmp_fn = CmpLt;
+        assert_eq!(cmp_fn.default(), false);
+        assert_eq!(cmp_fn.cmp_bool(true, false), false);
+        assert_eq!(cmp_fn.cmp_bool(false, true), true);
+        assert_eq!(cmp_fn.cmp_bool(true, true), false);
+        assert_eq!(cmp_fn.cmp_bool(false, false), false);
+        assert_eq!(cmp_fn.cmp_f64(0.1, 0.2), true);
+        assert_eq!(cmp_fn.cmp_f64(0.1, 0.1), false);
+        assert_eq!(cmp_fn.cmp_f64(0.2, 0.1), false);
+        assert_eq!(cmp_fn.cmp_string("a", "a"), false);
+        assert_eq!(cmp_fn.cmp_string("ab", "b"), true);
+        assert_eq!(cmp_fn.cmp_string("1", "2"), true);
+    }
+
+    #[test]
+    fn cmp_le() {
+        let cmp_fn = CmpLe;
+        assert_eq!(cmp_fn.default(), false);
+        assert_eq!(cmp_fn.cmp_bool(true, false), false);
+        assert_eq!(cmp_fn.cmp_bool(false, true), true);
+        assert_eq!(cmp_fn.cmp_bool(true, true), true);
+        assert_eq!(cmp_fn.cmp_bool(false, false), true);
+        assert_eq!(cmp_fn.cmp_f64(0.1, 0.2), true);
+        assert_eq!(cmp_fn.cmp_f64(0.1, 0.1), true);
+        assert_eq!(cmp_fn.cmp_f64(0.2, 0.1), false);
+        assert_eq!(cmp_fn.cmp_string("a", "a"), true);
+        assert_eq!(cmp_fn.cmp_string("ab", "b"), true);
+        assert_eq!(cmp_fn.cmp_string("abd", "abc"), false);
+        assert_eq!(cmp_fn.cmp_string("1", "2"), true);
+    }
+
+    #[test]
+    fn cmp_and() {
+        let cmp_fn = CmpAnd;
+        assert_eq!(cmp_fn.default(), false);
+        assert_eq!(cmp_fn.cmp_bool(true, false), false);
+        assert_eq!(cmp_fn.cmp_bool(false, true), false);
+        assert_eq!(cmp_fn.cmp_bool(true, true), true);
+        assert_eq!(cmp_fn.cmp_bool(false, false), false);
+        assert_eq!(cmp_fn.cmp_f64(0.0, 0.0), true);
+        assert_eq!(cmp_fn.cmp_string("a", "a"), true);
+    }
+
+    #[test]
+    fn cmp_or() {
+        let cmp_fn = CmpOr;
+        assert_eq!(cmp_fn.default(), false);
+        assert_eq!(cmp_fn.cmp_bool(true, false), true);
+        assert_eq!(cmp_fn.cmp_bool(false, true), true);
+        assert_eq!(cmp_fn.cmp_bool(true, true), true);
+        assert_eq!(cmp_fn.cmp_bool(false, false), false);
+        assert_eq!(cmp_fn.cmp_f64(0.0, 0.0), true);
+        assert_eq!(cmp_fn.cmp_string("a", "a"), true);
+    }
+
+    #[test]
+    fn cmp_json() {
+        let v1 = Value::Bool(true);
+        let v2 = Value::String("1".to_string());
+        let left = [&v1, &v2];
+        let right = [&v1, &v2];
+        let empty: Vec<&Value> = Vec::new();
+
+        assert_eq!(CmpEq.cmp_json(&left, &right), left.to_vec());
+        assert_eq!(CmpNe.cmp_json(&left, &right), left.to_vec());
+        assert_eq!(CmpGt.cmp_json(&left, &right), empty);
+        assert_eq!(CmpGe.cmp_json(&left, &right), empty);
+        assert_eq!(CmpLt.cmp_json(&left, &right), empty);
+        assert_eq!(CmpLe.cmp_json(&left, &right), empty);
+        assert_eq!(CmpAnd.cmp_json(&left, &right), left.to_vec());
+        assert_eq!(CmpOr.cmp_json(&left, &right), left.to_vec());
+
+        assert_eq!(
+            CmpEq.cmp_json(&[&Value::Bool(true)], &[&Value::Bool(true)]),
+            vec![&Value::Bool(true)]
+        );
+        assert_eq!(
+            CmpEq.cmp_json(&[&Value::Bool(true)], &[&Value::Bool(false)]),
+            empty
+        );
+        assert_eq!(
+            CmpNe.cmp_json(&[&Value::Bool(true)], &[&Value::Bool(true)]),
+            empty
+        );
+        assert_eq!(
+            CmpNe.cmp_json(&[&Value::Bool(false)], &[&Value::Bool(true)]),
+            vec![&Value::Bool(false)]
+        );
+        assert_eq!(
+            CmpAnd.cmp_json(&[&Value::Bool(true)], &[&Value::Bool(true)]),
+            vec![&Value::Bool(true)]
+        );
+        assert_eq!(
+            CmpOr.cmp_json(&[&Value::Bool(true)], &[&Value::Bool(false)]),
+            vec![&Value::Bool(true), &Value::Bool(false)]
+        );
+    }
+}

src/select/expr_term.rs

@@ -0,0 +1,227 @@
+use serde_json::{Number, Value};
+use select::cmp::*;
+use select::{FilterKey, to_f64};
+
+#[derive(Debug, PartialEq)]
+pub(super) enum ExprTerm<'a> {
+    String(String),
+    Number(Number),
+    Bool(bool),
+    Json(Option<Vec<&'a Value>>, Option<FilterKey>, Vec<&'a Value>),
+}
+
+impl<'a> ExprTerm<'a> {
+    fn cmp<C1: Cmp, C2: Cmp>(
+        &self,
+        other: &Self,
+        cmp_fn: &C1,
+        reverse_cmp_fn: &C2,
+    ) -> ExprTerm<'a> {
+        match &self {
+            ExprTerm::String(s1) => match &other {
+                ExprTerm::String(s2) => ExprTerm::Bool(cmp_fn.cmp_string(s1, s2)),
+                ExprTerm::Json(_, _, _) => other.cmp(&self, reverse_cmp_fn, cmp_fn),
+                _ => ExprTerm::Bool(cmp_fn.default()),
+            },
+            ExprTerm::Number(n1) => match &other {
+                ExprTerm::Number(n2) => ExprTerm::Bool(cmp_fn.cmp_f64(to_f64(n1), to_f64(n2))),
+                ExprTerm::Json(_, _, _) => other.cmp(&self, reverse_cmp_fn, cmp_fn),
+                _ => ExprTerm::Bool(cmp_fn.default()),
+            },
+            ExprTerm::Bool(b1) => match &other {
+                ExprTerm::Bool(b2) => ExprTerm::Bool(cmp_fn.cmp_bool(*b1, *b2)),
+                ExprTerm::Json(_, _, _) => other.cmp(&self, reverse_cmp_fn, cmp_fn),
+                _ => ExprTerm::Bool(cmp_fn.default()),
+            },
+            ExprTerm::Json(rel, fk1, vec1) => {
+                let ret: Vec<&Value> = match &other {
+                    ExprTerm::String(s2) => vec1
+                        .iter()
+                        .filter(|v1| match v1 {
+                            Value::String(s1) => cmp_fn.cmp_string(s1, s2),
+                            Value::Object(map1) => {
+                                if let Some(FilterKey::String(k)) = fk1 {
+                                    if let Some(Value::String(s1)) = map1.get(k) {
+                                        return cmp_fn.cmp_string(s1, s2);
+                                    }
+                                }
+                                cmp_fn.default()
+                            }
+                            _ => cmp_fn.default(),
+                        })
+                        .cloned()
+                        .collect(),
+                    ExprTerm::Number(n2) => vec1
+                        .iter()
+                        .filter(|v1| match v1 {
+                            Value::Number(n1) => cmp_fn.cmp_f64(to_f64(n1), to_f64(n2)),
+                            Value::Object(map1) => {
+                                if let Some(FilterKey::String(k)) = fk1 {
+                                    if let Some(Value::Number(n1)) = map1.get(k) {
+                                        return cmp_fn.cmp_f64(to_f64(n1), to_f64(n2));
+                                    }
+                                }
+                                cmp_fn.default()
+                            }
+                            _ => cmp_fn.default(),
+                        })
+                        .cloned()
+                        .collect(),
+                    ExprTerm::Bool(b2) => vec1
+                        .iter()
+                        .filter(|v1| match v1 {
+                            Value::Bool(b1) => cmp_fn.cmp_bool(*b1, *b2),
+                            Value::Object(map1) => {
+                                if let Some(FilterKey::String(k)) = fk1 {
+                                    if let Some(Value::Bool(b1)) = map1.get(k) {
+                                        return cmp_fn.cmp_bool(*b1, *b2);
+                                    }
+                                }
+                                cmp_fn.default()
+                            }
+                            _ => cmp_fn.default(),
+                        })
+                        .cloned()
+                        .collect(),
+                    ExprTerm::Json(parent, _, vec2) => {
+                        if let Some(vec1) = rel {
+                            cmp_fn.cmp_json(vec1, vec2)
+                        } else if let Some(vec2) = parent {
+                            cmp_fn.cmp_json(vec1, vec2)
+                        } else {
+                            cmp_fn.cmp_json(vec1, vec2)
+                        }
+                    }
+                };
+
+                if ret.is_empty() {
+                    ExprTerm::Bool(cmp_fn.default())
+                } else if let Some(rel) = rel {
+                    if let ExprTerm::Json(_, _, _) = &other {
+                        ExprTerm::Json(Some(rel.to_vec()), None, ret)
+                    } else {
+                        let mut tmp = Vec::new();
+                        for rel_value in rel {
+                            if let Value::Object(map) = rel_value {
+                                for map_value in map.values() {
+                                    for result_value in &ret {
+                                        if map_value.eq(*result_value) {
+                                            tmp.push(*rel_value);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        ExprTerm::Json(Some(tmp), None, ret)
+                    }
+                } else {
+                    ExprTerm::Json(None, None, ret)
+                }
+            }
+        }
+    }
+
+    pub fn eq(&self, other: &Self, ret: &mut Option<ExprTerm<'a>>) {
+        debug!("eq - {:?} : {:?}", &self, &other);
+        let _ = ret.take();
+        let tmp = self.cmp(other, &CmpEq, &CmpEq);
+        debug!("eq = {:?}", tmp);
+        *ret = Some(tmp);
+    }
+
+    pub fn ne(&self, other: &Self, ret: &mut Option<ExprTerm<'a>>) {
+        debug!("ne - {:?} : {:?}", &self, &other);
+        let _ = ret.take();
+        let tmp = self.cmp(other, &CmpNe, &CmpNe);
+        debug!("ne = {:?}", tmp);
+        *ret = Some(tmp);
+    }
+
+    pub fn gt(&self, other: &Self, ret: &mut Option<ExprTerm<'a>>) {
+        debug!("gt - {:?} : {:?}", &self, &other);
+        let _ = ret.take();
+        let tmp = self.cmp(other, &CmpGt, &CmpLt);
+        debug!("gt = {:?}", tmp);
+        *ret = Some(tmp);
+    }
+
+    pub fn ge(&self, other: &Self, ret: &mut Option<ExprTerm<'a>>) {
+        debug!("ge - {:?} : {:?}", &self, &other);
+        let _ = ret.take();
+        let tmp = self.cmp(other, &CmpGe, &CmpLe);
+        debug!("ge = {:?}", tmp);
+        *ret = Some(tmp);
+    }
+
+    pub fn lt(&self, other: &Self, ret: &mut Option<ExprTerm<'a>>) {
+        debug!("lt - {:?} : {:?}", &self, &other);
+        let _ = ret.take();
+        let tmp = self.cmp(other, &CmpLt, &CmpGt);
+        debug!("lt = {:?}", tmp);
+        *ret = Some(tmp);
+    }
+
+    pub fn le(&self, other: &Self, ret: &mut Option<ExprTerm<'a>>) {
+        debug!("le - {:?} : {:?}", &self, &other);
+        let _ = ret.take();
+        let tmp = self.cmp(other, &CmpLe, &CmpGe);
+        debug!("le = {:?}", tmp);
+        *ret = Some(tmp);
+    }
+
+    pub fn and(&self, other: &Self, ret: &mut Option<ExprTerm<'a>>) {
+        debug!("and - {:?} : {:?}", &self, &other);
+        let _ = ret.take();
+        let tmp = self.cmp(other, &CmpAnd, &CmpAnd);
+        debug!("and = {:?}", tmp);
+        *ret = Some(tmp);
+    }
+
+    pub fn or(&self, other: &Self, ret: &mut Option<ExprTerm<'a>>) {
+        debug!("or - {:?} : {:?}", &self, &other);
+        let _ = ret.take();
+        let tmp = self.cmp(other, &CmpOr, &CmpOr);
+        debug!("or = {:?}", tmp);
+        *ret = Some(tmp);
+    }
+}
+
+impl<'a> Into<ExprTerm<'a>> for &Vec<&'a Value> {
+    fn into(self) -> ExprTerm<'a> {
+        if self.len() == 1 {
+            match &self[0] {
+                Value::Number(v) => return ExprTerm::Number(v.clone()),
+                Value::String(v) => return ExprTerm::String(v.clone()),
+                Value::Bool(v) => return ExprTerm::Bool(*v),
+                _ => {}
+            }
+        }
+
+        ExprTerm::Json(None, None, self.to_vec())
+    }
+}
+
+
+#[cfg(test)]
+mod expr_term_inner_tests {
+    use serde_json::{Number, Value};
+    use select::expr_term::ExprTerm;
+
+    #[test]
+    fn value_vec_into() {
+        let v = Value::Bool(true);
+        let vec = &vec![&v];
+        let term: ExprTerm = vec.into();
+        assert_eq!(term, ExprTerm::Bool(true));
+
+        let v = Value::String("a".to_string());
+        let vec = &vec![&v];
+        let term: ExprTerm = vec.into();
+        assert_eq!(term, ExprTerm::String("a".to_string()));
+
+        let v = serde_json::from_str("1.0").unwrap();
+        let vec = &vec![&v];
+        let term: ExprTerm = vec.into();
+        assert_eq!(term, ExprTerm::Number(Number::from_f64(1.0).unwrap()));
+    }
+}

src/select/value_walker.rs

@@ -0,0 +1,99 @@
+use serde_json::Value;
+use std::collections::HashSet;
+
+pub(super) struct ValueWalker;
+
+impl<'a> ValueWalker {
+    pub fn all_with_num(vec: &[&'a Value], tmp: &mut Vec<&'a Value>, index: f64) {
+        Self::walk(vec, tmp, &|v| if v.is_array() {
+            if let Some(item) = v.get(index as usize) {
+                Some(vec![item])
+            } else {
+                None
+            }
+        } else {
+            None
+        });
+    }
+
+    pub fn all_with_str(vec: &[&'a Value], tmp: &mut Vec<&'a Value>, key: &str, is_filter: bool) {
+        if is_filter {
+            Self::walk(vec, tmp, &|v| match v {
+                Value::Object(map) if map.contains_key(key) => Some(vec![v]),
+                _ => None,
+            });
+        } else {
+            Self::walk(vec, tmp, &|v| match v {
+                Value::Object(map) => match map.get(key) {
+                    Some(v) => Some(vec![v]),
+                    _ => None,
+                },
+                _ => None,
+            });
+        }
+    }
+
+    pub fn all(vec: &[&'a Value], tmp: &mut Vec<&'a Value>) {
+        Self::walk(vec, tmp, &|v| match v {
+            Value::Array(vec) => Some(vec.iter().collect()),
+            Value::Object(map) => {
+                let mut tmp = Vec::new();
+                for (_, v) in map {
+                    tmp.push(v);
+                }
+                Some(tmp)
+            }
+            _ => None,
+        });
+    }
+
+    fn walk<F>(vec: &[&'a Value], tmp: &mut Vec<&'a Value>, fun: &F) where F: Fn(&Value) -> Option<Vec<&Value>> {
+        for v in vec {
+            Self::_walk(v, tmp, fun);
+        }
+    }
+
+    fn _walk<F>(v: &'a Value, tmp: &mut Vec<&'a Value>, fun: &F) where F: Fn(&Value) -> Option<Vec<&Value>> {
+        if let Some(mut ret) = fun(v) {
+            tmp.append(&mut ret);
+        }
+
+        match v {
+            Value::Array(vec) => {
+                for v in vec {
+                    Self::_walk(v, tmp, fun);
+                }
+            }
+            Value::Object(map) => {
+                for (_, v) in map {
+                    Self::_walk(&v, tmp, fun);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    pub fn walk_dedup(v: &'a Value,
+                      tmp: &mut Vec<&'a Value>,
+                      key: &str,
+                      visited: &mut HashSet<*const Value>, ) {
+        match v {
+            Value::Object(map) => {
+                if map.contains_key(key) {
+                    let ptr = v as *const Value;
+                    if !visited.contains(&ptr) {
+                        visited.insert(ptr);
+                        tmp.push(v)
+                    }
+                }
+            }
+            Value::Array(vec) => {
+                for v in vec {
+                    Self::walk_dedup(v, tmp, key, visited);
+                }
+            }
+            _ => {}
+        }
+    }
+}
+