fbthrift_git/
deserialize.rs

1/*
2 * Copyright (c) Meta Platforms, Inc. and affiliates.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17use std::collections::BTreeMap;
18use std::collections::BTreeSet;
19use std::collections::HashMap;
20use std::collections::HashSet;
21use std::hash::Hash;
22use std::sync::Arc;
23
24use bytes::Bytes;
25use ordered_float::OrderedFloat;
26
27use crate::protocol::should_break;
28use crate::protocol::ProtocolReader;
29use crate::Result;
30
31// Read trait. Every type that needs to be deserialized will implement this trait.
32pub trait Deserialize<P>
33where
34    P: ProtocolReader,
35{
36    fn read(p: &mut P) -> Result<Self>
37    where
38        Self: Sized;
39}
40
41impl<P, T> Deserialize<P> for Box<T>
42where
43    P: ProtocolReader,
44    T: Deserialize<P>,
45{
46    #[inline]
47    fn read(p: &mut P) -> Result<Self> {
48        T::read(p).map(Box::new)
49    }
50}
51
52impl<P, T> Deserialize<P> for Arc<T>
53where
54    P: ProtocolReader,
55    T: Deserialize<P>,
56{
57    fn read(p: &mut P) -> Result<Self> {
58        T::read(p).map(Arc::new)
59    }
60}
61
62impl<P> Deserialize<P> for ()
63where
64    P: ProtocolReader,
65{
66    #[inline]
67    fn read(_p: &mut P) -> Result<Self> {
68        Ok(())
69    }
70}
71
72impl<P> Deserialize<P> for bool
73where
74    P: ProtocolReader,
75{
76    #[inline]
77    fn read(p: &mut P) -> Result<Self> {
78        p.read_bool()
79    }
80}
81
82impl<P> Deserialize<P> for i8
83where
84    P: ProtocolReader,
85{
86    #[inline]
87    fn read(p: &mut P) -> Result<Self> {
88        p.read_byte()
89    }
90}
91
92impl<P> Deserialize<P> for i16
93where
94    P: ProtocolReader,
95{
96    #[inline]
97    fn read(p: &mut P) -> Result<Self> {
98        p.read_i16()
99    }
100}
101
102impl<P> Deserialize<P> for i32
103where
104    P: ProtocolReader,
105{
106    #[inline]
107    fn read(p: &mut P) -> Result<Self> {
108        p.read_i32()
109    }
110}
111
112impl<P> Deserialize<P> for i64
113where
114    P: ProtocolReader,
115{
116    #[inline]
117    fn read(p: &mut P) -> Result<Self> {
118        p.read_i64()
119    }
120}
121
122impl<P> Deserialize<P> for f64
123where
124    P: ProtocolReader,
125{
126    #[inline]
127    fn read(p: &mut P) -> Result<Self> {
128        p.read_double()
129    }
130}
131
132impl<P> Deserialize<P> for f32
133where
134    P: ProtocolReader,
135{
136    #[inline]
137    fn read(p: &mut P) -> Result<Self> {
138        p.read_float()
139    }
140}
141
142impl<P> Deserialize<P> for OrderedFloat<f64>
143where
144    P: ProtocolReader,
145{
146    #[inline]
147    fn read(p: &mut P) -> Result<Self> {
148        p.read_double().map(OrderedFloat)
149    }
150}
151
152impl<P> Deserialize<P> for OrderedFloat<f32>
153where
154    P: ProtocolReader,
155{
156    #[inline]
157    fn read(p: &mut P) -> Result<Self> {
158        p.read_float().map(OrderedFloat)
159    }
160}
161
162impl<P> Deserialize<P> for String
163where
164    P: ProtocolReader,
165{
166    #[inline]
167    fn read(p: &mut P) -> Result<Self> {
168        p.read_string()
169    }
170}
171
172impl<P> Deserialize<P> for Bytes
173where
174    P: ProtocolReader,
175{
176    #[inline]
177    fn read(p: &mut P) -> Result<Self> {
178        p.read_binary()
179    }
180}
181
182impl<P> Deserialize<P> for Vec<u8>
183where
184    P: ProtocolReader,
185{
186    #[inline]
187    fn read(p: &mut P) -> Result<Self> {
188        p.read_binary()
189    }
190}
191
192impl<P, T> Deserialize<P> for BTreeSet<T>
193where
194    P: ProtocolReader,
195    T: Deserialize<P> + Ord,
196{
197    fn read(p: &mut P) -> Result<Self> {
198        let (_elem_ty, len) = p.read_set_begin()?;
199        let mut bset = BTreeSet::new();
200
201        if let Some(0) = len {
202            return Ok(bset);
203        }
204
205        let mut idx = 0;
206        loop {
207            let more = p.read_set_value_begin()?;
208            if !more {
209                break;
210            }
211            let item = Deserialize::read(p)?;
212            p.read_set_value_end()?;
213            bset.insert(item);
214
215            idx += 1;
216            if should_break(len, more, idx) {
217                break;
218            }
219        }
220        p.read_set_end()?;
221        Ok(bset)
222    }
223}
224
225impl<P, T, S> Deserialize<P> for HashSet<T, S>
226where
227    P: ProtocolReader,
228    T: Deserialize<P> + Hash + Eq,
229    S: std::hash::BuildHasher + Default,
230{
231    fn read(p: &mut P) -> Result<Self> {
232        let (_elem_ty, len) = p.read_set_begin()?;
233        let mut hset =
234            HashSet::with_capacity_and_hasher(len.unwrap_or_default(), Default::default());
235
236        if let Some(0) = len {
237            return Ok(hset);
238        }
239
240        let mut idx = 0;
241        loop {
242            let more = p.read_set_value_begin()?;
243            if !more {
244                break;
245            }
246            let item = Deserialize::read(p)?;
247            p.read_set_value_end()?;
248            hset.insert(item);
249
250            idx += 1;
251            if should_break(len, more, idx) {
252                break;
253            }
254        }
255        p.read_set_end()?;
256        Ok(hset)
257    }
258}
259
260impl<P, K, V> Deserialize<P> for BTreeMap<K, V>
261where
262    P: ProtocolReader,
263    K: Deserialize<P> + Ord,
264    V: Deserialize<P>,
265{
266    fn read(p: &mut P) -> Result<Self> {
267        let (_key_ty, _val_ty, len) = p.read_map_begin()?;
268        let mut btree = BTreeMap::new();
269
270        if let Some(0) = len {
271            return Ok(btree);
272        }
273
274        let mut idx = 0;
275        loop {
276            let more = p.read_map_key_begin()?;
277            if !more {
278                break;
279            }
280            let key = Deserialize::read(p)?;
281            p.read_map_value_begin()?;
282            let val = Deserialize::read(p)?;
283            p.read_map_value_end()?;
284            btree.insert(key, val);
285
286            idx += 1;
287            if should_break(len, more, idx) {
288                break;
289            }
290        }
291        p.read_map_end()?;
292        Ok(btree)
293    }
294}
295
296impl<P, K, V, S> Deserialize<P> for HashMap<K, V, S>
297where
298    P: ProtocolReader,
299    K: Deserialize<P> + Hash + Eq,
300    V: Deserialize<P>,
301    S: std::hash::BuildHasher + Default,
302{
303    fn read(p: &mut P) -> Result<Self> {
304        let (_key_ty, _val_ty, len) = p.read_map_begin()?;
305        let mut hmap =
306            HashMap::with_capacity_and_hasher(len.unwrap_or_default(), Default::default());
307
308        if let Some(0) = len {
309            return Ok(hmap);
310        }
311
312        let mut idx = 0;
313        loop {
314            let more = p.read_map_key_begin()?;
315            if !more {
316                break;
317            }
318            let key = Deserialize::read(p)?;
319            p.read_map_value_begin()?;
320            let val = Deserialize::read(p)?;
321            p.read_map_value_end()?;
322            hmap.insert(key, val);
323
324            idx += 1;
325            if should_break(len, more, idx) {
326                break;
327            }
328        }
329        p.read_map_end()?;
330        Ok(hmap)
331    }
332}
333
334impl<P, T> Deserialize<P> for Vec<T>
335where
336    P: ProtocolReader,
337    T: Deserialize<P> + crate::ttype::GetTType, // GetTType just to exclude Vec<u8>
338{
339    /// Vec<T> is Thrift List type
340    fn read(p: &mut P) -> Result<Self> {
341        let (_elem_ty, len) = p.read_list_begin()?;
342        let mut list = Vec::with_capacity(len.unwrap_or_default());
343
344        if let Some(0) = len {
345            return Ok(list);
346        }
347
348        let mut idx = 0;
349        loop {
350            let more = p.read_list_value_begin()?;
351            if !more {
352                break;
353            }
354            let item = Deserialize::read(p)?;
355            p.read_list_value_end()?;
356            list.push(item);
357
358            idx += 1;
359            if should_break(len, more, idx) {
360                break;
361            }
362        }
363        p.read_list_end()?;
364        Ok(list)
365    }
366}
fbthrift_git/deserialize.rs

fbthrift_git/
deserialize.rs
