radiate_utils/datatype/
value.rs

1use super::DataType;
2use crate::SmallStr;
3use num_traits::NumCast;
4#[cfg(feature = "serde")]
5use serde::{Deserialize, Serialize, ser::SerializeStruct};
6use std::{collections::HashMap, fmt::Debug, hash::Hash, time::Duration};
7
8#[derive(Clone, Default, Debug)]
9pub enum AnyValue<'a> {
10    #[default]
11    Null,
12
13    Bool(bool),
14
15    UInt8(u8),
16    UInt16(u16),
17    UInt32(u32),
18    UInt64(u64),
19    UInt128(u128),
20
21    Int8(i8),
22    Int16(i16),
23    Int32(i32),
24    Int64(i64),
25    Int128(i128),
26
27    Float32(f32),
28    Float64(f64),
29
30    Usize(usize),
31
32    Duration(Duration),
33
34    Char(char),
35    Str(&'a str),
36    StrOwned(String),
37
38    Slice(&'a [AnyValue<'a>]),
39    Vector(Vec<AnyValue<'a>>),
40
41    Struct(SmallStr, Vec<(SmallStr, DataType, AnyValue<'a>)>),
42
43    Dict(Vec<(SmallStr, DataType, AnyValue<'a>)>),
44}
45
46impl<'a> AnyValue<'a> {
47    #[inline]
48    pub fn is_null(&self) -> bool {
49        matches!(self, Self::Null)
50    }
51
52    #[inline]
53    pub fn is_boolean(&self) -> bool {
54        matches!(self, Self::Bool(_))
55    }
56
57    #[inline]
58    pub fn is_float(&self) -> bool {
59        matches!(self, Self::Float32(_) | Self::Float64(_))
60    }
61
62    #[inline]
63    pub fn is_int(&self) -> bool {
64        matches!(
65            self,
66            Self::Int8(_)
67                | Self::Int16(_)
68                | Self::Int32(_)
69                | Self::Int64(_)
70                | Self::Int128(_)
71                | Self::UInt8(_)
72                | Self::UInt16(_)
73                | Self::UInt32(_)
74                | Self::UInt64(_)
75                | Self::UInt128(_)
76        )
77    }
78
79    #[inline]
80    pub fn is_string(&self) -> bool {
81        matches!(self, Self::Str(_) | Self::StrOwned(_))
82    }
83
84    #[inline]
85    pub fn is_nested(&self) -> bool {
86        matches!(self, Self::Dict(_) | Self::Vector(_) | Self::Slice(_))
87    }
88
89    #[inline]
90    pub fn len(&self) -> Option<usize> {
91        match self {
92            Self::Slice(vals) => Some(vals.len()),
93            Self::Vector(vals) => Some(vals.len()),
94            Self::Dict(vals) => Some(vals.len()),
95            _ => None,
96        }
97    }
98
99    #[inline]
100    pub fn is_empty(&self) -> Option<bool> {
101        match self {
102            Self::Slice(vals) => Some(vals.is_empty()),
103            Self::Vector(vals) => Some(vals.is_empty()),
104            Self::Dict(vals) => Some(vals.is_empty()),
105            _ => None,
106        }
107    }
108
109    #[inline]
110    pub fn is_numeric(&self) -> bool {
111        matches!(
112            self,
113            Self::UInt8(_)
114                | Self::UInt16(_)
115                | Self::UInt32(_)
116                | Self::UInt64(_)
117                | Self::Int8(_)
118                | Self::Int16(_)
119                | Self::Int32(_)
120                | Self::Int64(_)
121                | Self::Int128(_)
122                | Self::Float32(_)
123                | Self::Float64(_)
124                | Self::Usize(_)
125        )
126    }
127
128    #[inline]
129    pub fn type_name(&self) -> &'static str {
130        match self {
131            Self::Null => "null",
132            Self::Bool(_) => "bool",
133            Self::UInt8(_) => "u8",
134            Self::UInt16(_) => "u16",
135            Self::UInt32(_) => "u32",
136            Self::UInt64(_) => "u64",
137            Self::UInt128(_) => "u128",
138            Self::Int8(_) => "i8",
139            Self::Int16(_) => "i16",
140            Self::Int32(_) => "i32",
141            Self::Int64(_) => "i64",
142            Self::Int128(_) => "i128",
143            Self::Float32(_) => "f32",
144            Self::Float64(_) => "f64",
145            Self::Usize(_) => "usize",
146            Self::Char(_) => "char",
147            Self::Str(_) => "string",
148            Self::StrOwned(_) => "string",
149            Self::Slice(_) => "list",
150            Self::Vector(_) => "list",
151            Self::Dict(_) => "dict",
152            Self::Duration(_) => "duration",
153            Self::Struct(_, _) => "struct",
154        }
155    }
156
157    #[inline]
158    pub fn dtype(&self) -> DataType {
159        match self {
160            Self::Null => DataType::Null,
161
162            Self::Bool(_) => DataType::Boolean,
163
164            Self::UInt8(_) => DataType::UInt8,
165            Self::UInt16(_) => DataType::UInt16,
166            Self::UInt32(_) => DataType::UInt32,
167            Self::UInt64(_) => DataType::UInt64,
168            Self::UInt128(_) => DataType::UInt128,
169
170            Self::Int8(_) => DataType::Int8,
171            Self::Int16(_) => DataType::Int16,
172            Self::Int32(_) => DataType::Int32,
173            Self::Int64(_) => DataType::Int64,
174            Self::Int128(_) => DataType::Int128,
175
176            Self::Float32(_) => DataType::Float32,
177            Self::Float64(_) => DataType::Float64,
178
179            Self::Usize(_) => DataType::Usize,
180
181            Self::Duration(_) => DataType::Duration,
182
183            Self::Char(_) => DataType::Char,
184            Self::Str(_) => DataType::String,
185            Self::StrOwned(_) => DataType::String,
186
187            Self::Slice(vals) => DataType::List(
188                vals.iter()
189                    .map(|v| v.dtype())
190                    .next()
191                    .unwrap_or(DataType::Null)
192                    .into(),
193            ),
194            Self::Vector(vals) => DataType::List(
195                vals.iter()
196                    .map(|v| v.dtype())
197                    .next()
198                    .unwrap_or(DataType::Null)
199                    .into(),
200            ),
201
202            Self::Dict(vals) => DataType::Dict(
203                vals.iter()
204                    .map(|(f, s, _)| (f.clone(), s.clone()))
205                    .collect(),
206            ),
207
208            Self::Struct(field, fields) => DataType::Struct(
209                field.clone(),
210                fields
211                    .iter()
212                    .map(|(name, dtype, _)| (name.clone(), dtype.clone()))
213                    .collect(),
214            ),
215        }
216    }
217
218    pub fn cast(self, to: &DataType) -> Option<AnyValue<'a>> {
219        use DataType as D;
220
221        if self.dtype() == *to {
222            return Some(self);
223        }
224
225        match (self, to) {
226            (_, D::Null) => Some(AnyValue::Null),
227            (AnyValue::Bool(v), D::Boolean) => Some(AnyValue::Bool(v)),
228            (v, D::UInt8) => v.extract().map(AnyValue::UInt8),
229            (v, D::UInt16) => v.extract().map(AnyValue::UInt16),
230            (v, D::UInt32) => v.extract().map(AnyValue::UInt32),
231            (v, D::UInt64) => v.extract().map(AnyValue::UInt64),
232            (v, D::UInt128) => v.extract().map(AnyValue::UInt128),
233            (v, D::Int8) => v.extract().map(AnyValue::Int8),
234            (v, D::Int16) => v.extract().map(AnyValue::Int16),
235            (v, D::Int32) => v.extract().map(AnyValue::Int32),
236            (v, D::Int64) => v.extract().map(AnyValue::Int64),
237            (v, D::Int128) => v.extract().map(AnyValue::Int128),
238            (v, D::Float32) => v.extract().map(AnyValue::Float32),
239            (v, D::Float64) => v.extract().map(AnyValue::Float64),
240            (v, D::Duration) => v
241                .extract()
242                .map(|ms| AnyValue::Duration(Duration::from_millis(ms))),
243            (v, D::Char) => v.extract::<u8>().map(|b| AnyValue::Char(b as char)),
244            (v @ AnyValue::Str(_), D::String) | (v @ AnyValue::StrOwned(_), D::String) => {
245                Some(v.into_static())
246            }
247            _ => None,
248        }
249    }
250
251    /// Try to coerce to an AnyValue with static lifetime.
252    /// This can be done if it does not borrow any values.
253    #[inline]
254    pub fn into_static(self) -> AnyValue<'static> {
255        use AnyValue::*;
256        match self {
257            Null => Null,
258            Int8(v) => Int8(v),
259            Int16(v) => Int16(v),
260            Int32(v) => Int32(v),
261            Int64(v) => Int64(v),
262            Int128(v) => Int128(v),
263            UInt8(v) => UInt8(v),
264            UInt16(v) => UInt16(v),
265            UInt32(v) => UInt32(v),
266            UInt64(v) => UInt64(v),
267            UInt128(v) => UInt128(v),
268            Bool(v) => Bool(v),
269            Float32(v) => Float32(v),
270            Float64(v) => Float64(v),
271            Usize(v) => Usize(v),
272            Duration(d) => Duration(d),
273            Char(v) => Char(v),
274            Str(v) => StrOwned(v.to_string()),
275            StrOwned(v) => StrOwned(v),
276            Slice(v) => Vector(v.iter().map(|v| v.clone().into_static()).collect()),
277            Vector(v) => Vector(v.into_iter().map(AnyValue::into_static).collect()),
278            Dict(v) => Dict(
279                v.into_iter()
280                    .map(|(field, _, val)| (field, val.dtype(), val.into_static()))
281                    .collect(),
282            ),
283            Struct(field, fields) => Struct(
284                field,
285                fields
286                    .into_iter()
287                    .map(|(name, dtype, value)| (name, dtype, value.into_static()))
288                    .collect(),
289            ),
290        }
291    }
292
293    pub fn extract<T: NumCast>(&self) -> Option<T> {
294        match self {
295            AnyValue::UInt8(v) => NumCast::from(*v),
296            AnyValue::UInt16(v) => NumCast::from(*v),
297            AnyValue::UInt32(v) => NumCast::from(*v),
298            AnyValue::UInt64(v) => NumCast::from(*v),
299            AnyValue::UInt128(v) => NumCast::from(*v),
300            AnyValue::Int8(v) => NumCast::from(*v),
301            AnyValue::Int16(v) => NumCast::from(*v),
302            AnyValue::Int32(v) => NumCast::from(*v),
303            AnyValue::Int64(v) => NumCast::from(*v),
304            AnyValue::Int128(v) => NumCast::from(*v),
305            AnyValue::Float32(v) => NumCast::from(*v),
306            AnyValue::Float64(v) => NumCast::from(*v),
307            AnyValue::Usize(v) => NumCast::from(*v),
308            AnyValue::Duration(d) => NumCast::from(d.as_millis()),
309            _ => None,
310        }
311    }
312
313    pub fn into_string(self) -> Option<String> {
314        match self {
315            AnyValue::Str(s) => Some(s.to_string()),
316            AnyValue::StrOwned(s) => Some(s),
317            _ => None,
318        }
319    }
320
321    pub fn as_str(&self) -> Option<&str> {
322        match self {
323            AnyValue::Str(s) => Some(*s),
324            AnyValue::StrOwned(s) => Some(s.as_str()),
325            _ => None,
326        }
327    }
328}
329
330impl<'a> AnyValue<'a> {
331    pub fn get_index(&self, index: usize) -> Option<AnyValue<'a>> {
332        match self {
333            AnyValue::Vector(values) => values.get(index).cloned(),
334            AnyValue::Slice(values) => values.get(index).cloned(),
335            _ => None,
336        }
337    }
338
339    pub fn get_key(&self, key: &AnyValue<'a>) -> Option<AnyValue<'a>> {
340        match self {
341            AnyValue::Dict(fields) => {
342                let key_str = match key {
343                    AnyValue::Str(s) => *s,
344                    AnyValue::StrOwned(s) => s.as_str(),
345                    _ => return None,
346                };
347
348                fields
349                    .iter()
350                    .find(|(field, _, _)| field == key_str)
351                    .map(|(_, _, value)| value.clone())
352            }
353            _ => None,
354        }
355    }
356
357    pub fn get_field<T: AsRef<str>>(&self, field: T) -> Option<AnyValue<'a>> {
358        let field_str = field.as_ref();
359        match self {
360            AnyValue::Dict(fields) => fields
361                .iter()
362                .find(|(f, _, _)| f == field_str)
363                .map(|(_, _, value)| value.clone()),
364            _ => None,
365        }
366    }
367}
368
369impl<'a> PartialEq for AnyValue<'a> {
370    #[inline]
371    fn eq(&self, other: &Self) -> bool {
372        use AnyValue::*;
373        match (self, other) {
374            (Null, Null) => true,
375            (Bool(a), Bool(b)) => a == b,
376            (UInt8(a), UInt8(b)) => a == b,
377            (UInt16(a), UInt16(b)) => a == b,
378            (UInt32(a), UInt32(b)) => a == b,
379            (UInt64(a), UInt64(b)) => a == b,
380            (Int8(a), Int8(b)) => a == b,
381            (Int16(a), Int16(b)) => a == b,
382            (Int32(a), Int32(b)) => a == b,
383            (Int64(a), Int64(b)) => a == b,
384            (Int128(a), Int128(b)) => a == b,
385            (Float32(a), Float32(b)) => a == b,
386            (Float64(a), Float64(b)) => a == b,
387            (Usize(a), Usize(b)) => a == b,
388            (Duration(a), Duration(b)) => a == b,
389            (Char(a), Char(b)) => a == b,
390            (Str(a), Str(b)) => a == b,
391            (Str(a), StrOwned(b)) => *a == b.as_str(),
392            (StrOwned(a), Str(b)) => a.as_str() == *b,
393            (StrOwned(a), StrOwned(b)) => a == b,
394            (Vector(a), Vector(b)) if a.len() == b.len() => {
395                a.iter().zip(b.iter()).all(|(x, y)| x == y)
396            }
397            (Dict(a), Dict(b))
398                if a.len() == b.len()
399                    && a.iter().map(|(f, _, _)| f).eq(b.iter().map(|(f, _, _)| f)) =>
400            {
401                a.iter()
402                    .zip(b.iter())
403                    .all(|((f1, _, v1), (f2, _, v2))| f1 == f2 && v1 == v2)
404            }
405            (Struct(fa, va), Struct(fb, vb)) if fa == fb && va.len() == vb.len() => va
406                .iter()
407                .zip(vb.iter())
408                .all(|((f1, _, v1), (f2, _, v2))| f1 == f2 && v1 == v2),
409            _ => false,
410        }
411    }
412}
413
414impl<'a> Eq for AnyValue<'a> {}
415
416impl<'a> Hash for AnyValue<'a> {
417    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
418        use AnyValue::*;
419        match self {
420            Null => 0.hash(state),
421            Bool(v) => v.hash(state),
422
423            Int8(v) => v.hash(state),
424            Int16(v) => v.hash(state),
425            Int32(v) => v.hash(state),
426            Int64(v) => v.hash(state),
427            Int128(v) => v.hash(state),
428
429            UInt8(v) => v.hash(state),
430            UInt16(v) => v.hash(state),
431            UInt32(v) => v.hash(state),
432            UInt64(v) => v.hash(state),
433            UInt128(v) => v.hash(state),
434
435            Float32(v) => v.to_ne_bytes().hash(state),
436            Float64(v) => v.to_ne_bytes().hash(state),
437
438            Usize(v) => v.hash(state),
439
440            Duration(v) => v.hash(state),
441
442            Char(v) => v.hash(state),
443            Str(v) => v.hash(state),
444            StrOwned(v) => v.hash(state),
445
446            Vector(v) => v.hash(state),
447            Slice(v) => v.hash(state),
448
449            Dict(v) => v.iter().for_each(|(k, d, v)| {
450                k.hash(state);
451                d.hash(state);
452                v.hash(state);
453            }),
454            Struct(f, v) => {
455                f.hash(state);
456                v.iter().for_each(|(name, dtype, value)| {
457                    name.hash(state);
458                    dtype.hash(state);
459                    value.hash(state);
460                });
461            }
462        }
463    }
464}
465
466macro_rules! impl_from {
467    ($variant:ident, $type:ty) => {
468        impl From<$type> for AnyValue<'_> {
469            fn from(value: $type) -> Self {
470                AnyValue::$variant(value)
471            }
472        }
473    };
474}
475
476impl_from!(Bool, bool);
477impl_from!(UInt8, u8);
478impl_from!(UInt16, u16);
479impl_from!(UInt32, u32);
480impl_from!(UInt64, u64);
481impl_from!(UInt128, u128);
482impl_from!(Int8, i8);
483impl_from!(Int16, i16);
484impl_from!(Int32, i32);
485impl_from!(Int64, i64);
486impl_from!(Int128, i128);
487impl_from!(Float32, f32);
488impl_from!(Float64, f64);
489impl_from!(Usize, usize);
490impl_from!(Char, char);
491impl_from!(Duration, Duration);
492impl_from!(StrOwned, String);
493
494impl<'a> From<&'a str> for AnyValue<'a> {
495    fn from(value: &'a str) -> Self {
496        AnyValue::Str(value)
497    }
498}
499
500impl<'a> From<Vec<AnyValue<'a>>> for AnyValue<'a> {
501    fn from(v: Vec<AnyValue<'a>>) -> Self {
502        AnyValue::Vector(v)
503    }
504}
505
506impl<T, K> From<HashMap<T, K>> for AnyValue<'_>
507where
508    T: Into<String> + Clone,
509    K: Into<AnyValue<'static>> + Clone,
510{
511    fn from(map: HashMap<T, K>) -> Self {
512        AnyValue::Dict(
513            map.into_iter()
514                .map(|(k, v)| {
515                    let cloned_value = v.clone().into();
516                    let name = k.into();
517                    (SmallStr::from(name), cloned_value.dtype(), cloned_value)
518                })
519                .collect(),
520        )
521    }
522}
523
524impl<'a> FromIterator<AnyValue<'a>> for AnyValue<'a> {
525    fn from_iter<T: IntoIterator<Item = AnyValue<'a>>>(iter: T) -> Self {
526        AnyValue::Vector(iter.into_iter().collect())
527    }
528}
529
530#[inline]
531pub(crate) fn apply_zipped_slice(
532    one: &[AnyValue<'_>],
533    two: &[AnyValue<'_>],
534    f: impl Fn(&AnyValue<'_>, &AnyValue<'_>) -> Option<AnyValue<'static>>,
535) -> Option<AnyValue<'static>> {
536    if one.len() != two.len() {
537        return None;
538    }
539
540    Some(AnyValue::Vector(
541        one.iter()
542            .zip(two.iter())
543            .map(|pair| match f(pair.0, pair.1) {
544                Some(v) => v,
545                None => AnyValue::Null,
546            })
547            .collect::<Vec<AnyValue>>(),
548    ))
549}
550
551#[inline]
552pub(crate) fn apply_zipped_struct_slice(
553    one: &[(SmallStr, DataType, AnyValue<'_>)],
554    two: &[(SmallStr, DataType, AnyValue<'_>)],
555    f: impl Fn(&AnyValue<'_>, &AnyValue<'_>) -> Option<AnyValue<'static>>,
556) -> Option<AnyValue<'static>> {
557    if one.len() != two.len() {
558        return None;
559    }
560
561    if !one
562        .iter()
563        .map(|(f, _, _)| f)
564        .eq(two.iter().map(|(f, _, _)| f))
565    {
566        return None;
567    }
568
569    let mut out = Vec::with_capacity(one.len());
570    for ((fa, da, va), (_, _, vb)) in one.iter().zip(two.iter()) {
571        if va.is_null() || vb.is_null() {
572            out.push((fa.clone(), da.clone(), AnyValue::Null));
573            continue;
574        }
575
576        out.push((fa.clone(), da.clone(), f(va, vb)?));
577    }
578
579    Some(AnyValue::Dict(out))
580}
581
582#[inline]
583pub fn dedup_slice<'a>(value: &[AnyValue<'a>]) -> AnyValue<'a> {
584    let mut sorted_buff = Vec::with_capacity(value.len());
585    for v in value.iter() {
586        match sorted_buff.binary_search(v) {
587            Ok(_) => {}
588            Err(pos) => sorted_buff.insert(pos, v.clone()),
589        }
590    }
591
592    AnyValue::Vector(sorted_buff)
593}
594
595#[cfg(feature = "serde")]
596impl<'a> Serialize for AnyValue<'a> {
597    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
598    where
599        S: serde::Serializer,
600    {
601        use AnyValue::*;
602        match self {
603            Null => serializer.serialize_unit_variant("AnyValue", 0, "Null"),
604            Bool(v) => serializer.serialize_bool(*v),
605            UInt8(v) => serializer.serialize_u8(*v),
606            UInt16(v) => serializer.serialize_u16(*v),
607            UInt32(v) => serializer.serialize_u32(*v),
608            UInt64(v) => serializer.serialize_u64(*v),
609            UInt128(v) => serializer.serialize_u128(*v),
610            Int8(v) => serializer.serialize_i8(*v),
611            Int16(v) => serializer.serialize_i16(*v),
612            Int32(v) => serializer.serialize_i32(*v),
613            Int64(v) => serializer.serialize_i64(*v),
614            Int128(v) => serializer.serialize_i128(*v),
615            Float32(v) => serializer.serialize_f32(*v),
616            Float64(v) => serializer.serialize_f64(*v),
617            Usize(v) => serializer.serialize_u64(*v as u64),
618            Duration(v) => serializer.serialize_u64(v.as_millis() as u64),
619            Char(v) => serializer.serialize_char(*v),
620            Str(v) => serializer.serialize_str(v),
621            StrOwned(v) => serializer.serialize_str(v),
622            Slice(vals) => vals.serialize(serializer),
623            Vector(vals) => vals.serialize(serializer),
624            Dict(vals) => vals.serialize(serializer),
625            Struct(field, fields) => {
626                let mut state = serializer.serialize_struct("Struct", 2)?;
627                state.serialize_field("field", field)?;
628                state.serialize_field("fields", fields)?;
629                state.end()
630            }
631        }
632    }
633}
634
635#[cfg(feature = "serde")]
636impl<'a, 'de> Deserialize<'de> for AnyValue<'a> {
637    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
638    where
639        D: serde::Deserializer<'de>,
640    {
641        use AnyValue::*;
642        #[derive(Deserialize)]
643        #[serde(tag = "type", content = "value")]
644        enum AnyValueDef {
645            Null,
646            Bool(bool),
647            UInt8(u8),
648            UInt16(u16),
649            UInt32(u32),
650            UInt64(u64),
651            UInt128(u128),
652            Int8(i8),
653            Int16(i16),
654            Int32(i32),
655            Int64(i64),
656            Int128(i128),
657            Float32(f32),
658            Float64(f64),
659            Usize(usize),
660            Duration(u64),
661            Char(char),
662            Str(String),
663            StrOwned(String),
664            Slice(Vec<AnyValueDef>),
665            Vector(Vec<AnyValueDef>),
666            Dict(Vec<(SmallStr, DataType, AnyValueDef)>),
667            Struct(SmallStr, Vec<(SmallStr, DataType, AnyValueDef)>),
668        }
669
670        impl From<AnyValueDef> for AnyValue<'_> {
671            fn from(def: AnyValueDef) -> Self {
672                match def {
673                    AnyValueDef::Null => Null,
674                    AnyValueDef::Bool(v) => Bool(v),
675                    AnyValueDef::UInt8(v) => UInt8(v),
676                    AnyValueDef::UInt16(v) => UInt16(v),
677                    AnyValueDef::UInt32(v) => UInt32(v),
678                    AnyValueDef::UInt64(v) => UInt64(v),
679                    AnyValueDef::UInt128(v) => UInt128(v),
680                    AnyValueDef::Int8(v) => Int8(v),
681                    AnyValueDef::Int16(v) => Int16(v),
682                    AnyValueDef::Int32(v) => Int32(v),
683                    AnyValueDef::Int64(v) => Int64(v),
684                    AnyValueDef::Int128(v) => Int128(v),
685                    AnyValueDef::Float32(v) => Float32(v),
686                    AnyValueDef::Float64(v) => Float64(v),
687                    AnyValueDef::Usize(v) => Usize(v),
688                    AnyValueDef::Duration(ms) => Duration(std::time::Duration::from_millis(ms)),
689                    AnyValueDef::Char(v) => Char(v),
690                    AnyValueDef::Str(s) | AnyValueDef::StrOwned(s) => StrOwned(s),
691                    AnyValueDef::Slice(vals) => {
692                        Vector(vals.into_iter().map(AnyValue::from).collect())
693                    }
694                    AnyValueDef::Vector(vals) => {
695                        Vector(vals.into_iter().map(AnyValue::from).collect())
696                    }
697                    AnyValueDef::Dict(vals) => {
698                        Dict(vals.into_iter().map(|(f, d, v)| (f, d, v.into())).collect())
699                    }
700                    AnyValueDef::Struct(field, fields) => Struct(
701                        field,
702                        fields
703                            .into_iter()
704                            .map(|(name, dtype, value)| (name, dtype, value.into()))
705                            .collect(),
706                    ),
707                }
708            }
709        }
710
711        let def = AnyValueDef::deserialize(deserializer)?;
712        Ok(match def {
713            AnyValueDef::Null => Null,
714            AnyValueDef::Bool(v) => Bool(v),
715            AnyValueDef::UInt8(v) => UInt8(v),
716            AnyValueDef::UInt16(v) => UInt16(v),
717            AnyValueDef::UInt32(v) => UInt32(v),
718            AnyValueDef::UInt64(v) => UInt64(v),
719            AnyValueDef::UInt128(v) => UInt128(v),
720            AnyValueDef::Int8(v) => Int8(v),
721            AnyValueDef::Int16(v) => Int16(v),
722            AnyValueDef::Int32(v) => Int32(v),
723            AnyValueDef::Int64(v) => Int64(v),
724            AnyValueDef::Int128(v) => Int128(v),
725            AnyValueDef::Float32(v) => Float32(v),
726            AnyValueDef::Float64(v) => Float64(v),
727            AnyValueDef::Usize(v) => Usize(v),
728            AnyValueDef::Char(v) => Char(v),
729            AnyValueDef::Str(v) => StrOwned(v), // Deserialize as owned string
730            AnyValueDef::StrOwned(v) => StrOwned(v), // Deserialize as owned string
731            AnyValueDef::Duration(ms) => Duration(std::time::Duration::from_millis(ms)),
732            AnyValueDef::Slice(vals) => Vector(vals.into_iter().map(|v| v.into()).collect()),
733            AnyValueDef::Vector(vals) => Vector(vals.into_iter().map(|v| v.into()).collect()),
734            AnyValueDef::Struct(field, fields) => Struct(
735                field,
736                fields
737                    .into_iter()
738                    .map(|(name, dtype, value)| (name, dtype, value.into()))
739                    .collect(),
740            ),
741            AnyValueDef::Dict(vals) => Dict(
742                vals.into_iter()
743                    .map(|(name, dtype, value)| (name, dtype, value.into()))
744                    .collect(),
745            ),
746        })
747    }
748}
749
750#[cfg(test)]
751mod tests {
752    use super::AnyValue;
753    use super::DataType;
754
755    #[test]
756    fn test_anyvalue_type_name() {
757        let v = AnyValue::Float64(3.14);
758        assert_eq!(v.type_name(), "f64");
759    }
760
761    #[test]
762    fn test_anyvalue_cast() {
763        let v = AnyValue::Int32(42);
764        let casted = v.clone().cast(&DataType::Float64).unwrap();
765        assert_eq!(casted, AnyValue::Float64(42.0));
766    }
767}
radiate_utils/datatype/value.rs

radiate_utils/datatype/
value.rs
