serde_json_bytes/value/
bytes.rs

1use crate::{bytestring::ByteString, map::Map, value::Value};
2use bytes::Bytes;
3use serde::de::SeqAccess;
4use serde::de::{DeserializeSeed, Deserializer, MapAccess, Visitor};
5use serde_json::Number;
6use std::fmt;
7
8impl Value {
9    pub fn from_bytes(data: Bytes) -> Result<Value, serde_json::Error> {
10        let seed = BytesSeed::new(&data);
11        let mut de = serde_json::Deserializer::from_slice(&data);
12        seed.deserialize(&mut de)
13    }
14
15    pub fn to_bytes(&self) -> Bytes {
16        self.to_string().into()
17    }
18}
19
20/// The [`DeserializeSeed`] implementation that returns [`Value`].
21///
22/// Can be used in `DeserializeSeed` implementations for types that contain `Value`.
23#[derive(Clone, Copy)]
24pub struct BytesSeed<'data> {
25    bytes: &'data Bytes,
26}
27
28impl<'data> BytesSeed<'data> {
29    pub fn new(bytes: &'data Bytes) -> Self {
30        BytesSeed { bytes }
31    }
32}
33
34impl<'de, 'data> DeserializeSeed<'de> for BytesSeed<'data> {
35    type Value = Value;
36
37    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
38    where
39        D: Deserializer<'de>,
40    {
41        deserializer.deserialize_any(self)
42    }
43}
44
45impl<'de, 'data> Visitor<'de> for BytesSeed<'data> {
46    type Value = Value;
47
48    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
49        formatter.write_str("any valid JSON value")
50    }
51
52    #[inline]
53    fn visit_bool<E>(self, value: bool) -> Result<Value, E> {
54        Ok(Value::Bool(value))
55    }
56
57    #[inline]
58    fn visit_i64<E>(self, value: i64) -> Result<Value, E> {
59        Ok(Value::Number(value.into()))
60    }
61
62    #[inline]
63    fn visit_u64<E>(self, value: u64) -> Result<Value, E> {
64        Ok(Value::Number(value.into()))
65    }
66
67    #[inline]
68    fn visit_f64<E>(self, value: f64) -> Result<Value, E> {
69        Ok(Number::from_f64(value).map_or(Value::Null, Value::Number))
70    }
71
72    #[inline]
73    fn visit_str<E>(self, value: &str) -> Result<Value, E>
74    where
75        E: serde::de::Error,
76    {
77        Ok(Value::String(value.into()))
78    }
79
80    #[inline]
81    fn visit_borrowed_str<E>(self, value: &'de str) -> Result<Self::Value, E>
82    where
83        E: serde::de::Error,
84    {
85        Ok(Value::String(ByteString::new(&self.bytes, value)))
86    }
87
88    #[inline]
89    fn visit_string<E>(self, value: String) -> Result<Value, E>
90    where
91        E: serde::de::Error,
92    {
93        Ok(Value::String(value.into()))
94    }
95
96    #[inline]
97    fn visit_none<E>(self) -> Result<Value, E> {
98        Ok(Value::Null)
99    }
100
101    #[inline]
102    fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
103    where
104        D: serde::Deserializer<'de>,
105    {
106        DeserializeSeed::deserialize(self, deserializer)
107    }
108
109    #[inline]
110    fn visit_unit<E>(self) -> Result<Value, E> {
111        Ok(Value::Null)
112    }
113
114    #[inline]
115    fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
116    where
117        V: SeqAccess<'de>,
118    {
119        let mut vec = Vec::new();
120
121        while let Some(elem) = match visitor.next_element_seed(self.clone()) {
122            Ok(v) => v,
123            Err(e) => return Err(e),
124        } {
125            vec.push(elem);
126        }
127
128        Ok(Value::Array(vec))
129    }
130
131    fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
132    where
133        V: MapAccess<'de>,
134    {
135        match visitor.next_key_seed(ByteStringSeed::new(&self.bytes))? {
136            Some(first_key) => {
137                let mut values = Map::new();
138
139                values.insert(first_key, tri!(visitor.next_value_seed(self.clone())));
140                while let Some((key, value)) =
141                    tri!(visitor.next_entry_seed(ByteStringSeed::new(&self.bytes), self.clone()))
142                {
143                    values.insert(key, value);
144                }
145
146                Ok(Value::Object(values))
147            }
148            None => Ok(Value::Object(Map::new())),
149        }
150    }
151}
152
153/// A [`DeserializeSeed`] implementation that returns [`ByteString`].
154///
155/// Can be used in `DeserializeSeed` implementations for types that contain `ByteString`.
156#[derive(Clone, Copy)]
157pub struct ByteStringSeed<'data> {
158    bytes: &'data Bytes,
159}
160
161impl<'data> ByteStringSeed<'data> {
162    pub fn new(bytes: &'data Bytes) -> Self {
163        ByteStringSeed { bytes }
164    }
165}
166
167impl<'de, 'data> DeserializeSeed<'de> for ByteStringSeed<'data> {
168    type Value = ByteString;
169
170    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
171    where
172        D: Deserializer<'de>,
173    {
174        deserializer.deserialize_str(self)
175    }
176}
177
178impl<'de, 'data> Visitor<'de> for ByteStringSeed<'data> {
179    type Value = ByteString;
180
181    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
182        formatter.write_str("any valid JSON value")
183    }
184
185    #[inline]
186    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
187    where
188        E: serde::de::Error,
189    {
190        Ok(value.into())
191    }
192
193    #[inline]
194    fn visit_borrowed_str<E>(self, value: &'de str) -> Result<Self::Value, E>
195    where
196        E: serde::de::Error,
197    {
198        Ok(ByteString::new(&self.bytes, value))
199    }
200
201    #[inline]
202    fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
203    where
204        E: serde::de::Error,
205    {
206        Ok(value.into())
207    }
208}
serde_json_bytes/value/bytes.rs

serde_json_bytes/value/
bytes.rs
