Skip to main content

radiate_utils/datatype/
from.rs

1use crate::AnyValue;
2use radiate_error::RadiateError;
3
4impl<'a> TryFrom<AnyValue<'a>> for f32 {
5    type Error = RadiateError;
6
7    fn try_from(value: AnyValue<'a>) -> Result<Self, Self::Error> {
8        match value {
9            AnyValue::Float32(v) => Ok(v),
10            AnyValue::Float64(v) => Ok(v as f32),
11            AnyValue::Int8(v) => Ok(v as f32),
12            AnyValue::Int16(v) => Ok(v as f32),
13            AnyValue::Int32(v) => Ok(v as f32),
14            AnyValue::Int64(v) => Ok(v as f32),
15            AnyValue::UInt8(v) => Ok(v as f32),
16            AnyValue::UInt16(v) => Ok(v as f32),
17            AnyValue::UInt32(v) => Ok(v as f32),
18            AnyValue::UInt64(v) => Ok(v as f32),
19            AnyValue::Bool(v) => Ok(if v { 1.0 } else { 0.0 }),
20            AnyValue::Usize(v) => Ok(v as f32),
21            AnyValue::Duration(v) => Ok(v.as_secs_f32()),
22            _ => Err(RadiateError::AnyValue(format!(
23                "Expected Float32, found {:?}",
24                value.dtype()
25            ))),
26        }
27    }
28}
29
30impl<'a> TryFrom<AnyValue<'a>> for String {
31    type Error = RadiateError;
32
33    fn try_from(value: AnyValue<'a>) -> Result<Self, Self::Error> {
34        match value {
35            AnyValue::StrOwned(v) => Ok(v.to_string()),
36            AnyValue::Str(v) => Ok(v.to_string()),
37            _ => Err(RadiateError::AnyValue(format!(
38                "Expected String, found {:?}",
39                value.dtype()
40            ))),
41        }
42    }
43}
44
45impl<'a, T> TryFrom<AnyValue<'a>> for Vec<T>
46where
47    T: TryFrom<AnyValue<'a>, Error = RadiateError>,
48{
49    type Error = RadiateError;
50
51    fn try_from(value: AnyValue<'a>) -> Result<Self, Self::Error> {
52        match value {
53            AnyValue::Vector(v) => v
54                .into_iter()
55                .map(|v| T::try_from(v))
56                .collect::<Result<Vec<T>, RadiateError>>(),
57            AnyValue::Slice(slice) => slice
58                .iter()
59                .map(|v| T::try_from(v.clone()))
60                .collect::<Result<Vec<T>, RadiateError>>(),
61            _ => Err(RadiateError::AnyValue(format!(
62                "Expected Vector, found {:?}",
63                value.dtype()
64            ))),
65        }
66    }
67}