cognite/dto/filter/
query_value.rs

1use serde::{Deserialize, Serialize};
2
3#[derive(Serialize, Deserialize, Clone, Debug)]
4#[serde(untagged)]
5/// Raw filter value.
6pub enum RawValue {
7    /// String value.
8    String(String),
9    /// Numerical value.
10    Number(serde_json::Number),
11    /// Boolean value.
12    Boolean(bool),
13    /// String array value.
14    StringArray(Vec<String>),
15    /// Number array value.
16    NumberArray(Vec<serde_json::Number>),
17    /// Boolean array value.
18    BooleanArray(Vec<bool>),
19    /// JSON object value.
20    Object(serde_json::Value),
21}
22
23#[derive(Serialize, Deserialize, Clone, Debug)]
24#[serde(rename_all = "camelCase")]
25/// Parameterized value.
26pub struct ParameterizedPropertyValue {
27    /// Parameter reference.
28    pub parameter: String,
29}
30
31#[derive(Serialize, Deserialize, Clone, Debug)]
32#[serde(rename_all = "camelCase")]
33/// Referenced property value, use the value of a different property.
34pub struct ReferencedPropertyValue {
35    /// Property to reference.
36    pub property: Vec<String>,
37}
38
39#[derive(Serialize, Deserialize, Clone, Debug)]
40#[serde(untagged)]
41/// Value used in complex queries.
42pub enum QueryValue {
43    /// Parameterized value.
44    Parameter(ParameterizedPropertyValue),
45    /// Reference to a different property.
46    Reference(ReferencedPropertyValue),
47    /// Raw value.
48    Raw(RawValue),
49}
50
51impl<T> From<T> for QueryValue
52where
53    T: Into<RawValue>,
54{
55    fn from(value: T) -> Self {
56        QueryValue::Raw(value.into())
57    }
58}
59
60impl From<ParameterizedPropertyValue> for QueryValue {
61    fn from(value: ParameterizedPropertyValue) -> Self {
62        QueryValue::Parameter(value)
63    }
64}
65
66impl From<ReferencedPropertyValue> for QueryValue {
67    fn from(value: ReferencedPropertyValue) -> Self {
68        QueryValue::Reference(value)
69    }
70}
71
72mod from_impls {
73    use super::RawValue;
74
75    macro_rules! from_num_impl {
76        ($typ:ty) => {
77            impl From<$typ> for RawValue {
78                fn from(value: $typ) -> Self {
79                    RawValue::Number(value.into())
80                }
81            }
82
83            impl From<Vec<$typ>> for RawValue {
84                fn from(value: Vec<$typ>) -> Self {
85                    RawValue::NumberArray(value.into_iter().map(serde_json::Number::from).collect())
86                }
87            }
88
89            impl From<&[$typ]> for RawValue {
90                fn from(value: &[$typ]) -> Self {
91                    RawValue::NumberArray(
92                        value
93                            .iter()
94                            .copied()
95                            .map(serde_json::Number::from)
96                            .collect(),
97                    )
98                }
99            }
100
101            impl<const N: usize> From<&[$typ; N]> for RawValue {
102                fn from(value: &[$typ; N]) -> Self {
103                    RawValue::NumberArray(
104                        value
105                            .iter()
106                            .copied()
107                            .map(serde_json::Number::from)
108                            .collect(),
109                    )
110                }
111            }
112        };
113    }
114
115    impl From<String> for RawValue {
116        fn from(value: String) -> Self {
117            RawValue::String(value)
118        }
119    }
120
121    impl From<&str> for RawValue {
122        fn from(value: &str) -> Self {
123            RawValue::String(value.to_string())
124        }
125    }
126
127    impl From<f64> for RawValue {
128        fn from(value: f64) -> Self {
129            RawValue::Number(
130                serde_json::Number::from_f64(value)
131                    .unwrap_or_else(|| serde_json::Number::from_f64(0.0).unwrap()),
132            )
133        }
134    }
135
136    impl From<f32> for RawValue {
137        fn from(value: f32) -> Self {
138            RawValue::Number(
139                serde_json::Number::from_f64(value.into())
140                    .unwrap_or_else(|| serde_json::Number::from_f64(0.0).unwrap()),
141            )
142        }
143    }
144
145    from_num_impl!(i64);
146    from_num_impl!(i32);
147    from_num_impl!(i16);
148    from_num_impl!(u64);
149    from_num_impl!(u32);
150    from_num_impl!(u16);
151
152    impl From<bool> for RawValue {
153        fn from(value: bool) -> Self {
154            RawValue::Boolean(value)
155        }
156    }
157
158    impl From<Vec<String>> for RawValue {
159        fn from(value: Vec<String>) -> Self {
160            RawValue::StringArray(value)
161        }
162    }
163
164    impl From<&[&str]> for RawValue {
165        fn from(value: &[&str]) -> Self {
166            RawValue::StringArray(value.iter().map(|&v| v.to_owned()).collect())
167        }
168    }
169
170    impl<const N: usize> From<&[&str; N]> for RawValue {
171        fn from(value: &[&str; N]) -> Self {
172            RawValue::StringArray(value.iter().map(|&v| v.to_owned()).collect())
173        }
174    }
175
176    impl From<Vec<bool>> for RawValue {
177        fn from(value: Vec<bool>) -> Self {
178            RawValue::BooleanArray(value)
179        }
180    }
181
182    impl From<&[bool]> for RawValue {
183        fn from(value: &[bool]) -> Self {
184            RawValue::BooleanArray(value.to_owned())
185        }
186    }
187
188    impl<const N: usize> From<&[bool; N]> for RawValue {
189        fn from(value: &[bool; N]) -> Self {
190            RawValue::BooleanArray(value.to_vec())
191        }
192    }
193
194    impl From<&[f32]> for RawValue {
195        fn from(value: &[f32]) -> Self {
196            RawValue::NumberArray(
197                value
198                    .iter()
199                    .copied()
200                    .map(|v| {
201                        serde_json::Number::from_f64(v.into())
202                            .unwrap_or_else(|| serde_json::Number::from_f64(0.0).unwrap())
203                    })
204                    .collect(),
205            )
206        }
207    }
208
209    impl<const N: usize> From<&[f32; N]> for RawValue {
210        fn from(value: &[f32; N]) -> Self {
211            RawValue::NumberArray(
212                value
213                    .iter()
214                    .copied()
215                    .map(|v| {
216                        serde_json::Number::from_f64(v.into())
217                            .unwrap_or_else(|| serde_json::Number::from_f64(0.0).unwrap())
218                    })
219                    .collect(),
220            )
221        }
222    }
223
224    impl From<Vec<f32>> for RawValue {
225        fn from(value: Vec<f32>) -> Self {
226            RawValue::NumberArray(
227                value
228                    .into_iter()
229                    .map(|v| {
230                        serde_json::Number::from_f64(v.into())
231                            .unwrap_or_else(|| serde_json::Number::from_f64(0.0).unwrap())
232                    })
233                    .collect(),
234            )
235        }
236    }
237
238    impl From<&[f64]> for RawValue {
239        fn from(value: &[f64]) -> Self {
240            RawValue::NumberArray(
241                value
242                    .iter()
243                    .copied()
244                    .map(|v| {
245                        serde_json::Number::from_f64(v)
246                            .unwrap_or_else(|| serde_json::Number::from_f64(0.0).unwrap())
247                    })
248                    .collect(),
249            )
250        }
251    }
252
253    impl<const N: usize> From<&[f64; N]> for RawValue {
254        fn from(value: &[f64; N]) -> Self {
255            RawValue::NumberArray(
256                value
257                    .iter()
258                    .copied()
259                    .map(|v| {
260                        serde_json::Number::from_f64(v)
261                            .unwrap_or_else(|| serde_json::Number::from_f64(0.0).unwrap())
262                    })
263                    .collect(),
264            )
265        }
266    }
267
268    impl From<Vec<f64>> for RawValue {
269        fn from(value: Vec<f64>) -> Self {
270            RawValue::NumberArray(
271                value
272                    .into_iter()
273                    .map(|v| {
274                        serde_json::Number::from_f64(v)
275                            .unwrap_or_else(|| serde_json::Number::from_f64(0.0).unwrap())
276                    })
277                    .collect(),
278            )
279        }
280    }
281
282    impl From<serde_json::Value> for RawValue {
283        fn from(value: serde_json::Value) -> Self {
284            RawValue::Object(value)
285        }
286    }
287}
cognite/dto/filter/query_value.rs

cognite/dto/filter/
query_value.rs
