jsonata_rs/evaluator/value/
impls.rs

1use std::{
2    hash::{Hash, Hasher},
3    ops::Index,
4};
5
6use rand::Rng;
7
8use super::Value;
9
10impl<'a> PartialEq<Value<'a>> for Value<'a> {
11    fn eq(&self, other: &Value<'a>) -> bool {
12        match (self, other) {
13            (Value::Undefined, Value::Undefined) => true,
14            (Value::Null, Value::Null) => true,
15            (Value::Number(l), Value::Number(r)) => *l == *r,
16            (Value::Bool(l), Value::Bool(r)) => *l == *r,
17            (Value::String(l), Value::String(r)) => *l == *r,
18            (Value::Array(l, ..), Value::Array(r, ..)) => *l == *r,
19            (Value::Object(l), Value::Object(r)) => *l == *r,
20            (Value::Range(l), Value::Range(r)) => *l == *r,
21            (Value::Regex(l), Value::Regex(r)) => l == r,
22            _ => false,
23        }
24    }
25}
26
27impl PartialEq<bool> for Value<'_> {
28    fn eq(&self, other: &bool) -> bool {
29        match *self {
30            Value::Bool(ref b) => *b == *other,
31            _ => false,
32        }
33    }
34}
35
36impl PartialEq<usize> for Value<'_> {
37    fn eq(&self, other: &usize) -> bool {
38        match self {
39            Value::Number(..) => self.as_usize() == *other,
40            _ => false,
41        }
42    }
43}
44
45impl PartialEq<isize> for Value<'_> {
46    fn eq(&self, other: &isize) -> bool {
47        match self {
48            Value::Number(..) => self.as_isize() == *other,
49            _ => false,
50        }
51    }
52}
53
54impl PartialEq<&str> for Value<'_> {
55    fn eq(&self, other: &&str) -> bool {
56        match self {
57            Value::String(ref s) => s == *other,
58            _ => false,
59        }
60    }
61}
62
63impl<'a> Index<&str> for Value<'a> {
64    type Output = Value<'a>;
65
66    fn index(&self, index: &str) -> &Self::Output {
67        match *self {
68            Value::Object(..) => self.get_entry(index),
69            _ => Value::undefined(),
70        }
71    }
72}
73
74impl<'a> Index<usize> for Value<'a> {
75    type Output = Value<'a>;
76
77    fn index(&self, index: usize) -> &Self::Output {
78        match *self {
79            Value::Array(..) | Value::Range(..) => self.get_member(index),
80            _ => Value::undefined(),
81        }
82    }
83}
84
85impl std::fmt::Debug for Value<'_> {
86    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
87        match self {
88            Self::Undefined => write!(f, "undefined"),
89            Self::Null => write!(f, "null"),
90            Self::Number(n) => n.fmt(f),
91            Self::Bool(b) => b.fmt(f),
92            Self::String(s) => s.fmt(f),
93            Self::Array(a, _) => a.fmt(f),
94            Self::Object(o) => o.fmt(f),
95            Self::Regex(r) => write!(f, "<regex({:?})>", r),
96            Self::Lambda { .. } => write!(f, "<lambda>"),
97            Self::NativeFn { .. } => write!(f, "<nativefn>"),
98            Self::Transformer { .. } => write!(f, "<transformer>"),
99            Self::Range(r) => write!(f, "<range({},{})>", r.start(), r.end()),
100        }
101    }
102}
103
104impl std::fmt::Display for Value<'_> {
105    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
106        match self {
107            Self::Regex(r) => write!(f, "<regex({:?})>", r),
108            _ => write!(f, "{:#?}", self),
109        }
110    }
111}
112
113impl Hash for Value<'_> {
114    fn hash<H: Hasher>(&self, state: &mut H) {
115        match self {
116            Value::Undefined => 0.hash(state),
117            Value::Null => 1.hash(state),
118            Value::Number(n) => n.to_bits().hash(state),
119            Value::Bool(b) => b.hash(state),
120            Value::String(s) => s.hash(state),
121            Value::Array(a, _) => a.hash(state),
122            Value::Object(map) => {
123                let mut keys_sorted = map.keys().collect::<Vec<_>>();
124                keys_sorted.sort();
125
126                for key in keys_sorted {
127                    key.hash(state);
128                    map.get(key).hash(state);
129                }
130            }
131            Value::Regex(r) => r.hash(state),
132            Value::Range(r) => r.hash(state),
133            Value::Lambda { .. } => generate_random_hash(state),
134            Value::NativeFn { name, .. } => name.hash(state),
135            Value::Transformer { .. } => generate_random_hash(state),
136        }
137    }
138}
139
140impl Eq for Value<'_> {}
141
142fn generate_random_hash<H: Hasher>(state: &mut H) {
143    let random_number: u64 = rand::thread_rng().gen();
144    random_number.hash(state);
145}
jsonata_rs/evaluator/value/impls.rs

jsonata_rs/evaluator/value/
impls.rs
