serde_jsonrc/
raw.rs

1use std::fmt::{self, Debug, Display};
2use std::mem;
3
4use serde::de::value::BorrowedStrDeserializer;
5use serde::de::{
6    self, Deserialize, DeserializeSeed, Deserializer, IntoDeserializer, MapAccess, Unexpected,
7    Visitor,
8};
9use serde::ser::{Serialize, SerializeStruct, Serializer};
10
11use error::Error;
12
13/// Reference to a range of bytes encompassing a single valid JSON value in the
14/// input data.
15///
16/// A `RawValue` can be used to defer parsing parts of a payload until later,
17/// or to avoid parsing it at all in the case that part of the payload just
18/// needs to be transferred verbatim into a different output object.
19///
20/// When serializing, a value of this type will retain its original formatting
21/// and will not be minified or pretty-printed.
22///
23/// # Example
24///
25/// ```edition2018
26/// # use serde_derive::{Deserialize, Serialize};
27/// use serde::{Deserialize, Serialize};
28/// use serde_jsonrc::{Result, value::RawValue};
29///
30/// #[derive(Deserialize)]
31/// struct Input<'a> {
32///     code: u32,
33///     #[serde(borrow)]
34///     payload: &'a RawValue,
35/// }
36///
37/// #[derive(Serialize)]
38/// struct Output<'a> {
39///     info: (u32, &'a RawValue),
40/// }
41///
42/// // Efficiently rearrange JSON input containing separate "code" and "payload"
43/// // keys into a single "info" key holding an array of code and payload.
44/// //
45/// // This could be done equivalently using serde_jsonrc::Value as the type for
46/// // payload, but &RawValue will perform netter because it does not require
47/// // memory allocation. The correct range of bytes is borrowed from the input
48/// // data and pasted verbatim into the output.
49/// fn rearrange(input: &str) -> Result<String> {
50///     let input: Input = serde_jsonrc::from_str(input)?;
51///
52///     let output = Output {
53///         info: (input.code, input.payload),
54///     };
55///
56///     serde_jsonrc::to_string(&output)
57/// }
58///
59/// fn main() -> Result<()> {
60///     let out = rearrange(r#" {"code": 200, "payload": {}} "#)?;
61///
62///     assert_eq!(out, r#"{"info":[200,{}]}"#);
63///
64///     Ok(())
65/// }
66/// ```
67///
68/// # Ownership
69///
70/// The typical usage of `RawValue` will be in the borrowed form:
71///
72/// ```edition2018
73/// # use serde_derive::Deserialize;
74/// # use serde_jsonrc::value::RawValue;
75/// #
76/// #[derive(Deserialize)]
77/// struct SomeStruct<'a> {
78///     #[serde(borrow)]
79///     raw_value: &'a RawValue,
80/// }
81/// ```
82///
83/// The borrowed form is suitable when deserializing through
84/// [`serde_jsonrc::from_str`] and [`serde_json::from_slice`] which support
85/// borrowing from the input data without memory allocation.
86///
87/// When deserializing through [`serde_jsonrc::from_reader`] you will need to use
88/// the boxed form of `RawValue` instead. This is almost as efficient but
89/// involves buffering the raw value from the I/O stream into memory.
90///
91/// [`serde_jsonrc::from_str`]: ../fn.from_str.html
92/// [`serde_jsonrc::from_slice`]: ../fn.from_slice.html
93/// [`serde_jsonrc::from_reader`]: ../fn.from_reader.html
94///
95/// ```edition2018
96/// # use serde_derive::Deserialize;
97/// # use serde_jsonrc::value::RawValue;
98/// #
99/// #[derive(Deserialize)]
100/// struct SomeStruct {
101///     raw_value: Box<RawValue>,
102/// }
103/// ```
104///
105/// # Note
106///
107/// `RawValue` is only available if serde\_json is built with the `"raw_value"`
108/// feature.
109///
110/// ```toml
111/// [dependencies]
112/// serde_jsonrc = { version = "1.0", features = ["raw_value"] }
113/// ```
114#[repr(C)]
115pub struct RawValue {
116    json: str,
117}
118
119impl RawValue {
120    fn from_borrowed(json: &str) -> &Self {
121        unsafe { mem::transmute::<&str, &RawValue>(json) }
122    }
123
124    fn from_owned(json: Box<str>) -> Box<Self> {
125        unsafe { mem::transmute::<Box<str>, Box<RawValue>>(json) }
126    }
127}
128
129impl Clone for Box<RawValue> {
130    fn clone(&self) -> Self {
131        (**self).to_owned()
132    }
133}
134
135impl ToOwned for RawValue {
136    type Owned = Box<RawValue>;
137
138    fn to_owned(&self) -> Self::Owned {
139        RawValue::from_owned(self.json.to_owned().into_boxed_str())
140    }
141}
142
143impl Default for Box<RawValue> {
144    fn default() -> Self {
145        RawValue::from_borrowed("null").to_owned()
146    }
147}
148
149impl Debug for RawValue {
150    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
151        formatter
152            .debug_tuple("RawValue")
153            .field(&format_args!("{}", &self.json))
154            .finish()
155    }
156}
157
158impl Display for RawValue {
159    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
160        f.write_str(&self.json)
161    }
162}
163
164impl RawValue {
165    /// Convert an owned `String` of JSON data to an owned `RawValue`.
166    ///
167    /// This function is equivalent to `serde_jsonrc::from_str::<Box<RawValue>>`
168    /// except that we avoid an allocation and memcpy if both of the following
169    /// are true:
170    ///
171    /// - the input has no leading or trailing whitespace, and
172    /// - the input has capacity equal to its length.
173    pub fn from_string(json: String) -> Result<Box<Self>, Error> {
174        {
175            let borrowed = ::from_str::<&Self>(&json)?;
176            if borrowed.json.len() < json.len() {
177                return Ok(borrowed.to_owned());
178            }
179        }
180        Ok(Self::from_owned(json.into_boxed_str()))
181    }
182
183    /// Access the JSON text underlying a raw value.
184    ///
185    /// # Example
186    ///
187    /// ```edition2018
188    /// # use serde_derive::Deserialize;
189    /// use serde::Deserialize;
190    /// use serde_jsonrc::{Result, value::RawValue};
191    ///
192    /// #[derive(Deserialize)]
193    /// struct Response<'a> {
194    ///     code: u32,
195    ///     #[serde(borrow)]
196    ///     payload: &'a RawValue,
197    /// }
198    ///
199    /// fn process(input: &str) -> Result<()> {
200    ///     let response: Response = serde_jsonrc::from_str(input)?;
201    ///
202    ///     let payload = response.payload.get();
203    ///     if payload.starts_with('{') {
204    ///         // handle a payload which is a JSON map
205    ///     } else {
206    ///         // handle any other type
207    ///     }
208    ///
209    ///     Ok(())
210    /// }
211    ///
212    /// fn main() -> Result<()> {
213    ///     process(r#" {"code": 200, "payload": {}} "#)?;
214    ///     Ok(())
215    /// }
216    /// ```
217    pub fn get(&self) -> &str {
218        &self.json
219    }
220}
221
222pub const TOKEN: &'static str = "$serde_jsonrc::private::RawValue";
223
224impl Serialize for RawValue {
225    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
226    where
227        S: Serializer,
228    {
229        let mut s = serializer.serialize_struct(TOKEN, 1)?;
230        s.serialize_field(TOKEN, &self.json)?;
231        s.end()
232    }
233}
234
235impl<'de: 'a, 'a> Deserialize<'de> for &'a RawValue {
236    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
237    where
238        D: Deserializer<'de>,
239    {
240        struct ReferenceVisitor;
241
242        impl<'de> Visitor<'de> for ReferenceVisitor {
243            type Value = &'de RawValue;
244
245            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
246                write!(formatter, "any valid JSON value")
247            }
248
249            fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
250            where
251                V: MapAccess<'de>,
252            {
253                let value = visitor.next_key::<RawKey>()?;
254                if value.is_none() {
255                    return Err(de::Error::invalid_type(Unexpected::Map, &self));
256                }
257                visitor.next_value_seed(ReferenceFromString)
258            }
259        }
260
261        deserializer.deserialize_newtype_struct(TOKEN, ReferenceVisitor)
262    }
263}
264
265impl<'de> Deserialize<'de> for Box<RawValue> {
266    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
267    where
268        D: Deserializer<'de>,
269    {
270        struct BoxedVisitor;
271
272        impl<'de> Visitor<'de> for BoxedVisitor {
273            type Value = Box<RawValue>;
274
275            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
276                write!(formatter, "any valid JSON value")
277            }
278
279            fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
280            where
281                V: MapAccess<'de>,
282            {
283                let value = visitor.next_key::<RawKey>()?;
284                if value.is_none() {
285                    return Err(de::Error::invalid_type(Unexpected::Map, &self));
286                }
287                visitor.next_value_seed(BoxedFromString)
288            }
289        }
290
291        deserializer.deserialize_newtype_struct(TOKEN, BoxedVisitor)
292    }
293}
294
295struct RawKey;
296
297impl<'de> Deserialize<'de> for RawKey {
298    fn deserialize<D>(deserializer: D) -> Result<RawKey, D::Error>
299    where
300        D: Deserializer<'de>,
301    {
302        struct FieldVisitor;
303
304        impl<'de> Visitor<'de> for FieldVisitor {
305            type Value = ();
306
307            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
308                formatter.write_str("raw value")
309            }
310
311            fn visit_str<E>(self, s: &str) -> Result<(), E>
312            where
313                E: de::Error,
314            {
315                if s == TOKEN {
316                    Ok(())
317                } else {
318                    Err(de::Error::custom("unexpected raw value"))
319                }
320            }
321        }
322
323        deserializer.deserialize_identifier(FieldVisitor)?;
324        Ok(RawKey)
325    }
326}
327
328pub struct ReferenceFromString;
329
330impl<'de> DeserializeSeed<'de> for ReferenceFromString {
331    type Value = &'de RawValue;
332
333    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
334    where
335        D: Deserializer<'de>,
336    {
337        deserializer.deserialize_str(self)
338    }
339}
340
341impl<'de> Visitor<'de> for ReferenceFromString {
342    type Value = &'de RawValue;
343
344    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
345        formatter.write_str("raw value")
346    }
347
348    fn visit_borrowed_str<E>(self, s: &'de str) -> Result<Self::Value, E>
349    where
350        E: de::Error,
351    {
352        Ok(RawValue::from_borrowed(s))
353    }
354}
355
356pub struct BoxedFromString;
357
358impl<'de> DeserializeSeed<'de> for BoxedFromString {
359    type Value = Box<RawValue>;
360
361    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
362    where
363        D: Deserializer<'de>,
364    {
365        deserializer.deserialize_str(self)
366    }
367}
368
369impl<'de> Visitor<'de> for BoxedFromString {
370    type Value = Box<RawValue>;
371
372    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
373        formatter.write_str("raw value")
374    }
375
376    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
377    where
378        E: de::Error,
379    {
380        self.visit_string(s.to_owned())
381    }
382
383    fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
384    where
385        E: de::Error,
386    {
387        Ok(RawValue::from_owned(s.into_boxed_str()))
388    }
389}
390
391struct RawKeyDeserializer;
392
393impl<'de> Deserializer<'de> for RawKeyDeserializer {
394    type Error = Error;
395
396    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
397    where
398        V: de::Visitor<'de>,
399    {
400        visitor.visit_borrowed_str(TOKEN)
401    }
402
403    forward_to_deserialize_any! {
404        bool u8 u16 u32 u64 u128 i8 i16 i32 i64 i128 f32 f64 char str string seq
405        bytes byte_buf map struct option unit newtype_struct ignored_any
406        unit_struct tuple_struct tuple enum identifier
407    }
408}
409
410pub struct OwnedRawDeserializer {
411    pub raw_value: Option<String>,
412}
413
414impl<'de> MapAccess<'de> for OwnedRawDeserializer {
415    type Error = Error;
416
417    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
418    where
419        K: de::DeserializeSeed<'de>,
420    {
421        if self.raw_value.is_none() {
422            return Ok(None);
423        }
424        seed.deserialize(RawKeyDeserializer).map(Some)
425    }
426
427    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
428    where
429        V: de::DeserializeSeed<'de>,
430    {
431        seed.deserialize(self.raw_value.take().unwrap().into_deserializer())
432    }
433}
434
435pub struct BorrowedRawDeserializer<'de> {
436    pub raw_value: Option<&'de str>,
437}
438
439impl<'de> MapAccess<'de> for BorrowedRawDeserializer<'de> {
440    type Error = Error;
441
442    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
443    where
444        K: de::DeserializeSeed<'de>,
445    {
446        if self.raw_value.is_none() {
447            return Ok(None);
448        }
449        seed.deserialize(RawKeyDeserializer).map(Some)
450    }
451
452    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
453    where
454        V: de::DeserializeSeed<'de>,
455    {
456        seed.deserialize(BorrowedStrDeserializer::new(self.raw_value.take().unwrap()))
457    }
458}
serde_jsonrc/raw.rs

serde_jsonrc/
raw.rs
