serde_transcode/
lib.rs

1//! Transcode from one Serde format to another.
2//!
3//! This crate provides functionality to "transcode" from an arbitrary Serde
4//! `Deserializer` to an arbitrary Serde `Serializer` without needing to
5//! collect the entire input into an intermediate form in memory. For example,
6//! you could translate a stream of JSON data into a stream of CBOR data, or
7//! translate JSON into its pretty-printed form.
8//!
9//! # Examples
10//!
11//! Translate a JSON file to a pretty-printed version.
12//!
13//! ```no_run
14//! extern crate serde;
15//! extern crate serde_json;
16//! extern crate serde_transcode;
17//!
18//! use serde::Serialize;
19//! use serde_json::{Serializer, Deserializer};
20//! use std::io::{Read, Write, BufReader, BufWriter};
21//! use std::fs::File;
22//!
23//! fn main() {
24//!     let reader = BufReader::new(File::open("input.json").unwrap());
25//!     let writer = BufWriter::new(File::create("output.json").unwrap());
26//!
27//!     let mut deserializer = Deserializer::from_reader(reader);
28//!     let mut serializer = Serializer::pretty(writer);
29//!     serde_transcode::transcode(&mut deserializer, &mut serializer).unwrap();
30//!     serializer.into_inner().flush().unwrap();
31//! }
32//! ```
33#![warn(missing_docs)]
34#![doc(html_root_url="https://docs.rs/serde-transcode/1.0.1")]
35
36#[macro_use]
37extern crate serde;
38
39use serde::de;
40use serde::ser::{self, Serialize, SerializeSeq, SerializeMap};
41use std::cell::RefCell;
42use std::fmt;
43
44#[cfg(test)]
45mod test;
46
47/// Transcodes from a Serde `Deserializer` to a Serde `Serializer`.
48pub fn transcode<'de, D, S>(d: D, s: S) -> Result<S::Ok, S::Error>
49    where D: de::Deserializer<'de>,
50          S: ser::Serializer
51{
52    Transcoder::new(d).serialize(s)
53}
54
55/// A Serde transcoder.
56///
57/// In most cases, the `transcode` function should be used instead of this
58/// type.
59///
60/// # Note
61///
62/// Unlike traditional serializable types, `Transcoder`'s `Serialize`
63/// implementation is *not* idempotent, as it advances the state of its
64/// internal `Deserializer`. It should only ever be serialized once.
65pub struct Transcoder<D>(RefCell<Option<D>>);
66
67impl<'de, D> Transcoder<D>
68    where D: de::Deserializer<'de>
69{
70    /// Constructs a new `Transcoder`.
71    pub fn new(d: D) -> Transcoder<D> {
72        Transcoder(RefCell::new(Some(d)))
73    }
74}
75
76impl<'de, D> ser::Serialize for Transcoder<D>
77    where D: de::Deserializer<'de>
78{
79    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
80        where S: ser::Serializer
81    {
82        self.0
83            .borrow_mut()
84            .take()
85            .expect("Transcoder may only be serialized once")
86            .deserialize_any(Visitor(s))
87            .map_err(d2s)
88    }
89}
90
91struct Visitor<S>(S);
92
93impl<'de, S> de::Visitor<'de> for Visitor<S>
94    where S: ser::Serializer
95{
96    type Value = S::Ok;
97
98    fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
99        write!(fmt, "any value")
100    }
101
102    fn visit_bool<E>(self, v: bool) -> Result<S::Ok, E>
103        where E: de::Error
104    {
105        self.0.serialize_bool(v).map_err(s2d)
106    }
107
108    fn visit_i8<E>(self, v: i8) -> Result<S::Ok, E>
109        where E: de::Error
110    {
111        self.0.serialize_i8(v).map_err(s2d)
112    }
113
114    fn visit_i16<E>(self, v: i16) -> Result<S::Ok, E>
115        where E: de::Error
116    {
117        self.0.serialize_i16(v).map_err(s2d)
118    }
119
120    fn visit_i32<E>(self, v: i32) -> Result<S::Ok, E>
121        where E: de::Error
122    {
123        self.0.serialize_i32(v).map_err(s2d)
124    }
125
126    fn visit_i64<E>(self, v: i64) -> Result<S::Ok, E>
127        where E: de::Error
128    {
129        self.0.serialize_i64(v).map_err(s2d)
130    }
131
132    fn visit_u8<E>(self, v: u8) -> Result<S::Ok, E>
133        where E: de::Error
134    {
135        self.0.serialize_u8(v).map_err(s2d)
136    }
137
138    fn visit_u16<E>(self, v: u16) -> Result<S::Ok, E>
139        where E: de::Error
140    {
141        self.0.serialize_u16(v).map_err(s2d)
142    }
143
144    fn visit_u32<E>(self, v: u32) -> Result<S::Ok, E>
145        where E: de::Error
146    {
147        self.0.serialize_u32(v).map_err(s2d)
148    }
149
150    fn visit_u64<E>(self, v: u64) -> Result<S::Ok, E>
151        where E: de::Error
152    {
153        self.0.serialize_u64(v).map_err(s2d)
154    }
155
156    serde_if_integer128! {
157        fn visit_i128<E>(self, v: i128) -> Result<S::Ok, E>
158            where E: de::Error
159        {
160            self.0.serialize_i128(v).map_err(s2d)
161        }
162
163        fn visit_u128<E>(self, v: u128) -> Result<S::Ok, E>
164            where E: de::Error
165        {
166            self.0.serialize_u128(v).map_err(s2d)
167        }
168    }
169
170    fn visit_f32<E>(self, v: f32) -> Result<S::Ok, E>
171        where E: de::Error
172    {
173        self.0.serialize_f32(v).map_err(s2d)
174    }
175
176    fn visit_f64<E>(self, v: f64) -> Result<S::Ok, E>
177        where E: de::Error
178    {
179        self.0.serialize_f64(v).map_err(s2d)
180    }
181
182    fn visit_char<E>(self, v: char) -> Result<S::Ok, E>
183        where E: de::Error
184    {
185        self.0.serialize_char(v).map_err(s2d)
186    }
187
188    fn visit_str<E>(self, v: &str) -> Result<S::Ok, E>
189        where E: de::Error
190    {
191        self.0.serialize_str(v).map_err(s2d)
192    }
193
194    fn visit_string<E>(self, v: String) -> Result<S::Ok, E>
195        where E: de::Error
196    {
197        self.0.serialize_str(&v).map_err(s2d)
198    }
199
200    fn visit_unit<E>(self) -> Result<S::Ok, E>
201        where E: de::Error
202    {
203        self.0.serialize_unit().map_err(s2d)
204    }
205
206    fn visit_none<E>(self) -> Result<S::Ok, E>
207        where E: de::Error
208    {
209        self.0.serialize_none().map_err(s2d)
210    }
211
212    fn visit_some<D>(self, d: D) -> Result<S::Ok, D::Error>
213        where D: de::Deserializer<'de>
214    {
215        self.0.serialize_some(&Transcoder::new(d)).map_err(s2d)
216    }
217
218    fn visit_newtype_struct<D>(self, d: D) -> Result<S::Ok, D::Error>
219        where D: de::Deserializer<'de>
220    {
221        self.0.serialize_newtype_struct("<unknown>", &Transcoder::new(d)).map_err(s2d)
222    }
223
224    fn visit_seq<V>(self, mut v: V) -> Result<S::Ok, V::Error>
225        where V: de::SeqAccess<'de>
226    {
227        let mut s = self.0.serialize_seq(v.size_hint()).map_err(s2d)?;
228        while let Some(()) = v.next_element_seed(SeqSeed(&mut s))? {}
229        s.end().map_err(s2d)
230    }
231
232    fn visit_map<V>(self, mut v: V) -> Result<S::Ok, V::Error>
233        where V: de::MapAccess<'de>
234    {
235        let mut s = self.0.serialize_map(v.size_hint()).map_err(s2d)?;
236        while let Some(()) = v.next_key_seed(KeySeed(&mut s))? {
237            v.next_value_seed(ValueSeed(&mut s))?;
238        }
239        s.end().map_err(s2d)
240    }
241
242    fn visit_bytes<E>(self, v: &[u8]) -> Result<S::Ok, E>
243        where E: de::Error
244    {
245        self.0.serialize_bytes(v).map_err(s2d)
246    }
247
248    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<S::Ok, E>
249        where E: de::Error
250    {
251        self.0.serialize_bytes(&v).map_err(s2d)
252    }
253}
254
255struct SeqSeed<'a, S: 'a>(&'a mut S);
256
257impl<'de, 'a, S> de::DeserializeSeed<'de> for SeqSeed<'a, S>
258    where S: ser::SerializeSeq
259{
260    type Value = ();
261
262    fn deserialize<D>(self, deserializer: D) -> Result<(), D::Error>
263        where D: de::Deserializer<'de>
264    {
265        self.0.serialize_element(&Transcoder::new(deserializer)).map_err(s2d)
266    }
267}
268
269struct KeySeed<'a, S: 'a>(&'a mut S);
270
271impl<'de, 'a, S> de::DeserializeSeed<'de> for KeySeed<'a, S>
272    where S: ser::SerializeMap
273{
274    type Value = ();
275
276    fn deserialize<D>(self, deserializer: D) -> Result<(), D::Error>
277        where D: de::Deserializer<'de>
278    {
279        self.0.serialize_key(&Transcoder::new(deserializer)).map_err(s2d)
280    }
281}
282
283struct ValueSeed<'a, S: 'a>(&'a mut S);
284
285impl<'de, 'a, S> de::DeserializeSeed<'de> for ValueSeed<'a, S>
286    where S: ser::SerializeMap
287{
288    type Value = ();
289
290    fn deserialize<D>(self, deserializer: D) -> Result<(), D::Error>
291        where D: de::Deserializer<'de>
292    {
293        self.0.serialize_value(&Transcoder::new(deserializer)).map_err(s2d)
294    }
295}
296
297fn d2s<D, S>(d: D) -> S
298    where D: de::Error,
299          S: ser::Error
300{
301    S::custom(d.to_string())
302}
303
304fn s2d<S, D>(s: S) -> D
305    where S: ser::Error,
306          D: de::Error
307{
308    D::custom(s.to_string())
309}
serde_transcode/lib.rs

serde_transcode/
lib.rs
