flow_value/de/
text_repr.rs

1use crate::{Value, value_type::Variant};
2use base64::prelude::*;
3use serde::de::VariantAccess;
4use std::borrow::Cow;
5
6pub struct TextRepr(Value);
7
8impl From<TextRepr> for Value {
9    fn from(v: TextRepr) -> Value {
10        v.0
11    }
12}
13
14struct EnumVisitor;
15
16impl<'de> serde::de::Visitor<'de> for EnumVisitor {
17    type Value = Value;
18
19    fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
20        f.write_str("any valid value")
21    }
22
23    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
24    where
25        A: serde::de::EnumAccess<'de>,
26    {
27        let (ty, a) = data.variant::<Variant>()?;
28        match ty {
29            Variant::Null => {
30                let num = a.newtype_variant::<u64>()?;
31                if num != 0 {
32                    return Err(serde::de::Error::invalid_value(
33                        serde::de::Unexpected::Unsigned(num),
34                        &"0",
35                    ));
36                }
37                Ok(Value::Null)
38            }
39            Variant::String => Ok(Value::String(a.newtype_variant()?)),
40            Variant::Bool => Ok(Value::Bool(a.newtype_variant()?)),
41            Variant::U64 => Ok(Value::U64(number_from_str(a)?)),
42            Variant::I64 => Ok(Value::I64(number_from_str(a)?)),
43            Variant::F64 => Ok(Value::F64(number_from_str(a)?)),
44            Variant::Decimal => Ok(Value::Decimal(number_from_str(a)?)),
45            Variant::I128 => Ok(Value::I128(number_from_str(a)?)),
46            Variant::U128 => Ok(Value::U128(number_from_str(a)?)),
47            Variant::B32 => Ok(Value::B32(b58_str_32(a)?)),
48            Variant::B64 => Ok(Value::B64(b58_str_64(a)?)),
49            Variant::Bytes => Ok(Value::Bytes(b64_str(a)?)),
50            Variant::Array => Ok(Value::Array(a.newtype_variant::<Array>()?.0)),
51            Variant::Map => Ok(Value::Map(a.newtype_variant::<Map>()?.0)),
52        }
53    }
54}
55
56struct MapVisitor;
57
58impl<'de> serde::de::Visitor<'de> for MapVisitor {
59    type Value = crate::Map;
60
61    fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
62        f.write_str("map")
63    }
64
65    fn visit_map<A>(self, mut a: A) -> Result<Self::Value, A::Error>
66    where
67        A: serde::de::MapAccess<'de>,
68    {
69        let mut map = crate::Map::new();
70        if let Some(len) = a.size_hint() {
71            map.reserve(len);
72        }
73        while let Some((k, v)) = a.next_entry::<crate::Key, TextRepr>()? {
74            map.insert(k, v.into());
75        }
76        Ok(map)
77    }
78}
79
80struct Map(crate::Map);
81
82impl<'de> serde::Deserialize<'de> for Map {
83    fn deserialize<D>(d: D) -> Result<Self, D::Error>
84    where
85        D: serde::Deserializer<'de>,
86    {
87        Ok(Map(d.deserialize_map(MapVisitor)?))
88    }
89}
90
91struct ArrayVisitor;
92
93impl<'de> serde::de::Visitor<'de> for ArrayVisitor {
94    type Value = Vec<Value>;
95
96    fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
97        f.write_str("array")
98    }
99
100    fn visit_seq<A>(self, mut a: A) -> Result<Self::Value, A::Error>
101    where
102        A: serde::de::SeqAccess<'de>,
103    {
104        let mut vec = Vec::new();
105        if let Some(len) = a.size_hint() {
106            vec.reserve(len);
107        }
108        while let Some(v) = a.next_element::<TextRepr>()? {
109            vec.push(v.into());
110        }
111        Ok(vec)
112    }
113}
114
115struct Array(Vec<Value>);
116
117impl<'de> serde::Deserialize<'de> for Array {
118    fn deserialize<D>(d: D) -> Result<Self, D::Error>
119    where
120        D: serde::Deserializer<'de>,
121    {
122        Ok(Array(d.deserialize_seq(ArrayVisitor)?))
123    }
124}
125
126fn number_from_str<'de, A, T>(a: A) -> Result<T, A::Error>
127where
128    A: VariantAccess<'de>,
129    T: std::str::FromStr,
130{
131    let s = a.newtype_variant::<Cow<'_, str>>()?;
132    s.parse::<T>()
133        .map_err(|_| serde::de::Error::custom(format!("invalid number: {s}")))
134}
135
136fn b58_str_32<'de, A>(a: A) -> Result<[u8; 32], A::Error>
137where
138    A: VariantAccess<'de>,
139{
140    let s = a.newtype_variant::<Cow<'_, str>>()?;
141    let mut data = [0u8; 32];
142    five8::decode_32(s.as_bytes(), &mut data)
143        .map_err(|_| serde::de::Error::custom("invalid base58"))?;
144    Ok(data)
145}
146
147fn b58_str_64<'de, A>(a: A) -> Result<[u8; 64], A::Error>
148where
149    A: VariantAccess<'de>,
150{
151    let s = a.newtype_variant::<Cow<'_, str>>()?;
152    let mut data = [0u8; 64];
153    five8::decode_64(s.as_bytes(), &mut data)
154        .map_err(|_| serde::de::Error::custom("invalid base58"))?;
155    Ok(data)
156}
157
158fn b64_str<'de, A>(a: A) -> Result<bytes::Bytes, A::Error>
159where
160    A: VariantAccess<'de>,
161{
162    let s = a.newtype_variant::<Cow<'_, str>>()?;
163    BASE64_STANDARD
164        .decode(s.as_bytes())
165        .map_err(|_| serde::de::Error::custom("invalid base64"))
166        .map(Into::into)
167}
168
169impl<'de> serde::Deserialize<'de> for TextRepr {
170    fn deserialize<D>(d: D) -> Result<Self, D::Error>
171    where
172        D: serde::Deserializer<'de>,
173    {
174        let value = d.deserialize_enum(crate::TOKEN, crate::value_type::keys::ALL, EnumVisitor)?;
175        Ok(TextRepr(value))
176    }
177}
flow_value/de/text_repr.rs

flow_value/de/
text_repr.rs
