conjure_serde/json/de/
client.rs

1// Copyright 2018 Palantir Technologies, Inc.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14use crate::de::delegating_visitor::{DelegatingVisitor, Visitor2};
15use crate::de::null_collections_behavior::NullCollectionsBehavior;
16use crate::de::Behavior;
17use base64::engine::general_purpose::STANDARD;
18use base64::Engine;
19use serde::de::{self, Visitor};
20use serde_json::de::{IoRead, Read, SliceRead, StrRead};
21use serde_json::Error;
22use std::fmt;
23use std::io;
24
25/// Deserializes a value from a reader of JSON data.
26pub fn client_from_reader<R, T>(reader: R) -> Result<T, Error>
27where
28    R: io::Read,
29    T: de::DeserializeOwned,
30{
31    let mut de = ClientDeserializer::from_reader(reader);
32    let value = T::deserialize(&mut de)?;
33    de.end()?;
34    Ok(value)
35}
36
37/// Deserializes a value from a string of JSON data.
38pub fn client_from_str<'a, T>(s: &'a str) -> Result<T, Error>
39where
40    T: de::Deserialize<'a>,
41{
42    let mut de = ClientDeserializer::from_str(s);
43    let value = T::deserialize(&mut de)?;
44    de.end()?;
45    Ok(value)
46}
47
48/// Deserializes a value from a slice of JSON data.
49pub fn client_from_slice<'a, T>(s: &'a [u8]) -> Result<T, Error>
50where
51    T: de::Deserialize<'a>,
52{
53    let mut de = ClientDeserializer::from_slice(s);
54    let value = T::deserialize(&mut de)?;
55    de.end()?;
56    Ok(value)
57}
58
59/// A serde JSON deserializer appropriate for use by Conjure clients.
60pub struct ClientDeserializer<R>(serde_json::Deserializer<R>);
61
62impl<R> ClientDeserializer<IoRead<R>>
63where
64    R: io::Read,
65{
66    /// Creates a Conjure JSON client deserializer from an `io::Read`.
67    pub fn from_reader(reader: R) -> ClientDeserializer<IoRead<R>> {
68        ClientDeserializer(serde_json::Deserializer::from_reader(reader))
69    }
70}
71
72impl<'a> ClientDeserializer<SliceRead<'a>> {
73    /// Creates a Conjure JSON client deserializer from a `&[u8]`.
74    pub fn from_slice(bytes: &'a [u8]) -> ClientDeserializer<SliceRead<'a>> {
75        ClientDeserializer(serde_json::Deserializer::from_slice(bytes))
76    }
77}
78
79impl<'a> ClientDeserializer<StrRead<'a>> {
80    /// Creates a Conjure JSON client deserializer from a `&str`.
81    #[allow(clippy::should_implement_trait)] // match serde_json's API
82    pub fn from_str(s: &'a str) -> ClientDeserializer<StrRead<'a>> {
83        ClientDeserializer(serde_json::Deserializer::from_str(s))
84    }
85}
86
87impl<'de, R> ClientDeserializer<R>
88where
89    R: Read<'de>,
90{
91    /// Validates that the input stream is at the end or that it only has trailing whitespace.
92    pub fn end(&mut self) -> Result<(), Error> {
93        self.0.end()
94    }
95}
96
97impl<'a, 'de, R> de::Deserializer<'de> for &'a mut ClientDeserializer<R>
98where
99    R: Read<'de>,
100{
101    impl_deserialize_body!(
102        &'a mut serde_json::Deserializer<R>,
103        NullCollectionsBehavior<ValueBehavior>
104    );
105
106    // we can't delegate this due to the signature, but luckily we know the answer
107    fn is_human_readable(&self) -> bool {
108        true
109    }
110}
111
112pub enum ValueBehavior {}
113
114impl Behavior for ValueBehavior {
115    type KeyBehavior = KeyBehavior;
116
117    fn deserialize_f32<'de, D, V>(de: D, visitor: V) -> Result<V::Value, D::Error>
118    where
119        D: serde::Deserializer<'de>,
120        V: de::Visitor<'de>,
121    {
122        de.deserialize_any(DelegatingVisitor::new(F32Visitor, visitor))
123    }
124
125    fn deserialize_f64<'de, D, V>(de: D, visitor: V) -> Result<V::Value, D::Error>
126    where
127        D: serde::Deserializer<'de>,
128        V: de::Visitor<'de>,
129    {
130        de.deserialize_any(DelegatingVisitor::new(F64Visitor, visitor))
131    }
132
133    fn deserialize_bytes<'de, D, V>(de: D, visitor: V) -> Result<V::Value, D::Error>
134    where
135        D: serde::Deserializer<'de>,
136        V: de::Visitor<'de>,
137    {
138        de.deserialize_str(ByteBufVisitor(visitor))
139    }
140
141    fn deserialize_byte_buf<'de, D, V>(de: D, visitor: V) -> Result<V::Value, D::Error>
142    where
143        D: serde::Deserializer<'de>,
144        V: de::Visitor<'de>,
145    {
146        de.deserialize_str(ByteBufVisitor(visitor))
147    }
148}
149
150pub enum KeyBehavior {}
151
152impl Behavior for KeyBehavior {
153    type KeyBehavior = Self;
154
155    fn deserialize_bool<'de, D, V>(de: D, visitor: V) -> Result<V::Value, D::Error>
156    where
157        D: serde::Deserializer<'de>,
158        V: Visitor<'de>,
159    {
160        de.deserialize_str(BoolKeyVisitor(visitor))
161    }
162
163    fn deserialize_f32<'de, D, V>(de: D, visitor: V) -> Result<V::Value, D::Error>
164    where
165        D: serde::Deserializer<'de>,
166        V: de::Visitor<'de>,
167    {
168        de.deserialize_str(F32KeyVisitor(visitor))
169    }
170
171    fn deserialize_f64<'de, D, V>(de: D, visitor: V) -> Result<V::Value, D::Error>
172    where
173        D: serde::Deserializer<'de>,
174        V: de::Visitor<'de>,
175    {
176        de.deserialize_str(F64KeyVisitor(visitor))
177    }
178
179    fn deserialize_bytes<'de, D, V>(de: D, visitor: V) -> Result<V::Value, D::Error>
180    where
181        D: serde::Deserializer<'de>,
182        V: de::Visitor<'de>,
183    {
184        de.deserialize_str(ByteBufVisitor(visitor))
185    }
186
187    fn deserialize_byte_buf<'de, D, V>(de: D, visitor: V) -> Result<V::Value, D::Error>
188    where
189        D: serde::Deserializer<'de>,
190        V: de::Visitor<'de>,
191    {
192        de.deserialize_str(ByteBufVisitor(visitor))
193    }
194}
195
196macro_rules! float_visitor {
197    ($name:ident, $method:ident, $module:ident) => {
198        struct $name;
199
200        impl<'de, V> Visitor2<'de, V> for $name
201        where
202            V: Visitor<'de>,
203        {
204            fn visit_str<E>(self, visitor: V, v: &str) -> Result<V::Value, E>
205            where
206                E: de::Error,
207            {
208                match v {
209                    "NaN" => visitor.$method($module::NAN),
210                    "Infinity" => visitor.$method($module::INFINITY),
211                    "-Infinity" => visitor.$method($module::NEG_INFINITY),
212                    _ => visitor.visit_str(v),
213                }
214            }
215
216            fn visit_borrowed_str<E>(self, visitor: V, v: &'de str) -> Result<V::Value, E>
217            where
218                E: de::Error,
219            {
220                self.visit_str(visitor, v)
221            }
222
223            fn visit_string<E>(self, visitor: V, v: String) -> Result<V::Value, E>
224            where
225                E: de::Error,
226            {
227                self.visit_str(visitor, &v)
228            }
229        }
230    };
231}
232
233float_visitor!(F32Visitor, visit_f32, f32);
234float_visitor!(F64Visitor, visit_f64, f64);
235
236// NB: not using DelegatingVisitor for these since we specifically expect a string
237macro_rules! float_key_visitor {
238    ($name:ident, $method:ident, $module:ident) => {
239        struct $name<T>(T);
240
241        impl<'de, T> de::Visitor<'de> for $name<T>
242        where
243            T: de::Visitor<'de>,
244        {
245            type Value = T::Value;
246
247            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
248                formatter.write_str("a number")
249            }
250
251            fn visit_str<E>(self, v: &str) -> Result<T::Value, E>
252            where
253                E: de::Error,
254            {
255                match v {
256                    "NaN" => (self.0).$method($module::NAN),
257                    "Infinity" => (self.0).$method($module::INFINITY),
258                    "-Infinity" => (self.0).$method($module::NEG_INFINITY),
259                    v => match v.parse() {
260                        Ok(v) => (self.0).$method(v),
261                        Err(_) => Err(de::Error::invalid_value(de::Unexpected::Str(v), &self)),
262                    },
263                }
264            }
265        }
266    };
267}
268
269float_key_visitor!(F32KeyVisitor, visit_f32, f32);
270float_key_visitor!(F64KeyVisitor, visit_f64, f64);
271
272struct ByteBufVisitor<T>(T);
273
274impl<'de, T> de::Visitor<'de> for ByteBufVisitor<T>
275where
276    T: de::Visitor<'de>,
277{
278    type Value = T::Value;
279
280    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
281        formatter.write_str("a base64 string")
282    }
283
284    fn visit_str<E>(self, v: &str) -> Result<T::Value, E>
285    where
286        E: de::Error,
287    {
288        match STANDARD.decode(v) {
289            Ok(v) => self.0.visit_byte_buf(v),
290            Err(_) => Err(E::invalid_value(de::Unexpected::Str(v), &self)),
291        }
292    }
293}
294
295struct BoolKeyVisitor<T>(T);
296
297impl<'de, T> Visitor<'de> for BoolKeyVisitor<T>
298where
299    T: Visitor<'de>,
300{
301    type Value = T::Value;
302
303    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
304        formatter.write_str("a boolean")
305    }
306
307    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
308    where
309        E: de::Error,
310    {
311        match v.parse() {
312            Ok(v) => self.0.visit_bool(v),
313            Err(_) => Err(E::invalid_value(de::Unexpected::Str(v), &self)),
314        }
315    }
316}
conjure_serde/json/de/client.rs

conjure_serde/json/de/
client.rs
