serde_pickle/
value_impls.rs

1// Copyright (c) 2015-2024 Georg Brandl.  Licensed under the Apache License,
2// Version 2.0 <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0>
3// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at
4// your option. This file may not be copied, modified, or distributed except
5// according to those terms.
6
7//! Serializer/Deserializer implementations for `value::Value`.
8
9use num_bigint::BigInt;
10use num_traits::ToPrimitive;
11use serde::de::Visitor;
12use serde::ser::Serialize;
13use serde::{de, forward_to_deserialize_any, ser};
14use std::collections::{btree_map, BTreeMap};
15use std::fmt;
16use std::result::Result as StdResult;
17use std::vec;
18
19use crate::error::{Error, ErrorCode, Result};
20use crate::value::{HashableValue, Value};
21
22impl<'de> de::Deserialize<'de> for Value {
23    #[inline]
24    fn deserialize<D: de::Deserializer<'de>>(deser: D) -> StdResult<Value, D::Error> {
25        struct ValueVisitor;
26
27        impl<'de> Visitor<'de> for ValueVisitor {
28            type Value = Value;
29
30            #[inline]
31            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
32                formatter.write_str("a value")
33            }
34
35            #[inline]
36            fn visit_bool<E>(self, value: bool) -> StdResult<Value, E> {
37                Ok(Value::Bool(value))
38            }
39
40            #[inline]
41            fn visit_i64<E>(self, value: i64) -> StdResult<Value, E> {
42                Ok(Value::I64(value))
43            }
44
45            #[inline]
46            fn visit_u64<E>(self, value: u64) -> StdResult<Value, E> {
47                if value < 0x8000_0000_0000_0000 {
48                    Ok(Value::I64(value as i64))
49                } else {
50                    Ok(Value::Int(BigInt::from(value)))
51                }
52            }
53
54            #[inline]
55            fn visit_f64<E>(self, value: f64) -> StdResult<Value, E> {
56                Ok(Value::F64(value))
57            }
58
59            #[inline]
60            fn visit_str<E: de::Error>(self, value: &str) -> StdResult<Value, E> {
61                self.visit_string(String::from(value))
62            }
63
64            #[inline]
65            fn visit_string<E>(self, value: String) -> StdResult<Value, E> {
66                Ok(Value::String(value))
67            }
68
69            #[inline]
70            fn visit_bytes<E: de::Error>(self, value: &[u8]) -> StdResult<Value, E> {
71                self.visit_byte_buf(value.to_vec())
72            }
73
74            #[inline]
75            fn visit_byte_buf<E: de::Error>(self, value: Vec<u8>) -> StdResult<Value, E> {
76                Ok(Value::Bytes(value))
77            }
78
79            #[inline]
80            fn visit_none<E>(self) -> StdResult<Value, E> {
81                Ok(Value::None)
82            }
83
84            #[inline]
85            fn visit_some<D: de::Deserializer<'de>>(self, deser: D) -> StdResult<Value, D::Error> {
86                de::Deserialize::deserialize(deser)
87            }
88
89            #[inline]
90            fn visit_unit<E>(self) -> StdResult<Value, E> {
91                Ok(Value::None)
92            }
93
94            #[inline]
95            fn visit_seq<V: de::SeqAccess<'de>>(self, mut visitor: V) -> StdResult<Value, V::Error> {
96                let mut values = Vec::new();
97                while let Some(elem) = visitor.next_element()? {
98                    values.push(elem);
99                }
100                Ok(Value::List(values))
101            }
102
103            #[inline]
104            fn visit_map<V: de::MapAccess<'de>>(self, mut visitor: V) -> StdResult<Value, V::Error> {
105                let mut values = BTreeMap::new();
106                while let Some((key, value)) = visitor.next_entry()? {
107                    values.insert(key, value);
108                }
109                Ok(Value::Dict(values))
110            }
111        }
112
113        deser.deserialize_any(ValueVisitor)
114    }
115}
116
117impl<'de> de::Deserialize<'de> for HashableValue {
118    #[inline]
119    fn deserialize<D: de::Deserializer<'de>>(deser: D) -> StdResult<HashableValue, D::Error> {
120        struct ValueVisitor;
121
122        impl<'de> Visitor<'de> for ValueVisitor {
123            type Value = HashableValue;
124
125            #[inline]
126            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
127                formatter.write_str("a hashable value")
128            }
129
130            #[inline]
131            fn visit_bool<E>(self, value: bool) -> StdResult<HashableValue, E> {
132                Ok(HashableValue::Bool(value))
133            }
134
135            #[inline]
136            fn visit_i64<E>(self, value: i64) -> StdResult<HashableValue, E> {
137                Ok(HashableValue::I64(value))
138            }
139
140            #[inline]
141            fn visit_u64<E>(self, value: u64) -> StdResult<HashableValue, E> {
142                if value < 0x8000_0000_0000_0000 {
143                    Ok(HashableValue::I64(value as i64))
144                } else {
145                    Ok(HashableValue::Int(BigInt::from(value)))
146                }
147            }
148
149            #[inline]
150            fn visit_f64<E>(self, value: f64) -> StdResult<HashableValue, E> {
151                Ok(HashableValue::F64(value))
152            }
153
154            #[inline]
155            fn visit_str<E: de::Error>(self, value: &str) -> StdResult<HashableValue, E> {
156                self.visit_string(String::from(value))
157            }
158
159            #[inline]
160            fn visit_string<E>(self, value: String) -> StdResult<HashableValue, E> {
161                Ok(HashableValue::String(value))
162            }
163
164            #[inline]
165            fn visit_bytes<E: de::Error>(self, value: &[u8]) -> StdResult<HashableValue, E> {
166                self.visit_byte_buf(value.to_vec())
167            }
168
169            #[inline]
170            fn visit_byte_buf<E: de::Error>(self, value: Vec<u8>) -> StdResult<HashableValue, E> {
171                Ok(HashableValue::Bytes(value))
172            }
173
174            #[inline]
175            fn visit_none<E>(self) -> StdResult<HashableValue, E> {
176                Ok(HashableValue::None)
177            }
178
179            #[inline]
180            fn visit_some<D: de::Deserializer<'de>>(self, deser: D) -> StdResult<HashableValue, D::Error> {
181                de::Deserialize::deserialize(deser)
182            }
183
184            #[inline]
185            fn visit_unit<E>(self) -> StdResult<HashableValue, E> {
186                Ok(HashableValue::None)
187            }
188
189            #[inline]
190            fn visit_seq<V: de::SeqAccess<'de>>(self, mut visitor: V) -> StdResult<HashableValue, V::Error> {
191                let mut values = Vec::new();
192                while let Some(elem) = visitor.next_element()? {
193                    values.push(elem);
194                }
195                Ok(HashableValue::Tuple(values))
196            }
197        }
198
199        deser.deserialize_any(ValueVisitor)
200    }
201}
202
203/// Deserializes a decoded value into any serde supported value.
204pub struct Deserializer {
205    value: Option<Value>,
206}
207
208impl Deserializer {
209    /// Creates a new deserializer instance for deserializing the specified JSON value.
210    pub fn new(value: Value) -> Deserializer {
211        Deserializer { value: Some(value) }
212    }
213}
214
215impl<'de: 'a, 'a> de::Deserializer<'de> for &'a mut Deserializer {
216    type Error = Error;
217
218    fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
219        let value = match self.value.take() {
220            Some(value) => value,
221            None => {
222                return Err(Error::Syntax(ErrorCode::EOFWhileParsing));
223            }
224        };
225
226        match value {
227            Value::None => visitor.visit_unit(),
228            Value::Bool(v) => visitor.visit_bool(v),
229            Value::I64(v) => visitor.visit_i64(v),
230            Value::Int(v) => {
231                if let Some(i) = v.to_i64() {
232                    visitor.visit_i64(i)
233                } else {
234                    Err(Error::Syntax(ErrorCode::InvalidValue("integer too large".into())))
235                }
236            }
237            Value::F64(v) => visitor.visit_f64(v),
238            Value::Bytes(v) => visitor.visit_byte_buf(v),
239            Value::String(v) => visitor.visit_string(v),
240            Value::List(v) => {
241                let len = v.len();
242                visitor.visit_seq(SeqDeserializer { de: self, iter: v.into_iter(), len })
243            }
244            Value::Tuple(v) => {
245                visitor.visit_seq(SeqDeserializer { de: self, len: v.len(), iter: v.into_iter() })
246            }
247            Value::Set(v) | Value::FrozenSet(v) => {
248                let v: Vec<_> = v.into_iter().map(HashableValue::into_value).collect();
249                visitor.visit_seq(SeqDeserializer { de: self, len: v.len(), iter: v.into_iter() })
250            }
251            Value::Dict(v) => {
252                let len = v.len();
253                visitor.visit_map(MapDeserializer { de: self, iter: v.into_iter(), value: None, len })
254            }
255        }
256    }
257
258    #[inline]
259    fn deserialize_option<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
260        match self.value {
261            Some(Value::None) => visitor.visit_none(),
262            Some(_) => visitor.visit_some(self),
263            None => Err(Error::Syntax(ErrorCode::EOFWhileParsing)),
264        }
265    }
266
267    #[inline]
268    fn deserialize_newtype_struct<V: Visitor<'de>>(
269        self, _name: &'static str, visitor: V,
270    ) -> Result<V::Value> {
271        visitor.visit_newtype_struct(self)
272    }
273
274    #[inline]
275    fn deserialize_enum<V: Visitor<'de>>(
276        self, _name: &'static str, _variants: &'static [&'static str], visitor: V,
277    ) -> Result<V::Value> {
278        visitor.visit_enum(self)
279    }
280
281    forward_to_deserialize_any! {
282        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
283        bytes byte_buf map unit_struct tuple_struct struct identifier
284        tuple ignored_any
285    }
286}
287
288impl<'de: 'a, 'a> de::EnumAccess<'de> for &'a mut Deserializer {
289    type Error = Error;
290    type Variant = Self;
291
292    fn variant_seed<T: de::DeserializeSeed<'de>>(self, seed: T) -> Result<(T::Value, Self::Variant)> {
293        match self.value.take() {
294            Some(Value::Tuple(mut v)) => {
295                if v.len() == 2 {
296                    let args = v.pop();
297                    self.value = v.pop();
298                    let res = seed.deserialize(&mut *self)?;
299                    self.value = args;
300                    Ok((res, self))
301                } else {
302                    self.value = v.pop();
303                    let res = seed.deserialize(&mut *self)?;
304                    Ok((res, self))
305                }
306            }
307            Some(Value::Dict(v)) => {
308                if v.len() != 1 {
309                    Err(Error::Syntax(ErrorCode::Structure(
310                        "enum variants must have one dict entry".into(),
311                    )))
312                } else {
313                    let (name, args) = v.into_iter().next().unwrap();
314                    self.value = Some(name.into_value());
315                    let val = seed.deserialize(&mut *self)?;
316                    self.value = Some(args);
317                    Ok((val, self))
318                }
319            }
320            s @ Some(Value::String(_)) => {
321                self.value = s;
322                let val = seed.deserialize(&mut *self)?;
323                Ok((val, self))
324            }
325            _ => Err(Error::Syntax(ErrorCode::Structure(
326                "enums must be represented as dicts or tuples".into(),
327            ))),
328        }
329    }
330}
331
332impl<'de: 'a, 'a> de::VariantAccess<'de> for &'a mut Deserializer {
333    type Error = Error;
334
335    fn unit_variant(self) -> Result<()> {
336        Ok(())
337    }
338
339    fn newtype_variant_seed<T: de::DeserializeSeed<'de>>(self, seed: T) -> Result<T::Value> {
340        seed.deserialize(self)
341    }
342
343    fn tuple_variant<V: Visitor<'de>>(self, _len: usize, visitor: V) -> Result<V::Value> {
344        de::Deserializer::deserialize_any(self, visitor)
345    }
346
347    fn struct_variant<V: Visitor<'de>>(
348        self, _fields: &'static [&'static str], visitor: V,
349    ) -> Result<V::Value> {
350        de::Deserializer::deserialize_any(self, visitor)
351    }
352}
353
354struct SeqDeserializer<'a> {
355    de: &'a mut Deserializer,
356    iter: vec::IntoIter<Value>,
357    len: usize,
358}
359
360impl<'de: 'a, 'a> de::SeqAccess<'de> for SeqDeserializer<'a> {
361    type Error = Error;
362
363    fn next_element_seed<T: de::DeserializeSeed<'de>>(&mut self, seed: T) -> Result<Option<T::Value>> {
364        match self.iter.next() {
365            Some(value) => {
366                self.len -= 1;
367                self.de.value = Some(value);
368                Ok(Some(seed.deserialize(&mut *self.de)?))
369            }
370            None => Ok(None),
371        }
372    }
373
374    fn size_hint(&self) -> Option<usize> {
375        Some(self.len)
376    }
377}
378
379struct MapDeserializer<'a> {
380    de: &'a mut Deserializer,
381    iter: btree_map::IntoIter<HashableValue, Value>,
382    value: Option<Value>,
383    len: usize,
384}
385
386impl<'de: 'a, 'a> de::MapAccess<'de> for MapDeserializer<'a> {
387    type Error = Error;
388
389    fn next_key_seed<T: de::DeserializeSeed<'de>>(&mut self, seed: T) -> Result<Option<T::Value>> {
390        match self.iter.next() {
391            Some((key, value)) => {
392                self.len -= 1;
393                self.value = Some(value);
394                self.de.value = Some(key.into_value());
395                Ok(Some(seed.deserialize(&mut *self.de)?))
396            }
397            None => Ok(None),
398        }
399    }
400
401    fn next_value_seed<T: de::DeserializeSeed<'de>>(&mut self, seed: T) -> Result<T::Value> {
402        let value = self.value.take().unwrap();
403        self.de.value = Some(value);
404        seed.deserialize(&mut *self.de)
405    }
406
407    fn size_hint(&self) -> Option<usize> {
408        Some(self.len)
409    }
410}
411
412/// Create a `serde::Serializer` that serializes a `Serialize`e into a `Value`.
413pub struct Serializer;
414
415impl Default for Serializer {
416    fn default() -> Self {
417        Serializer
418    }
419}
420
421pub struct SerializeSeq<'a> {
422    ser: &'a mut Serializer,
423    state: Vec<Value>,
424}
425
426impl<'a> ser::SerializeSeq for SerializeSeq<'a> {
427    type Ok = Value;
428    type Error = Error;
429
430    #[inline]
431    fn serialize_element<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
432        self.state.push(value.serialize(&mut *self.ser)?);
433        Ok(())
434    }
435
436    #[inline]
437    fn end(self) -> Result<Value> {
438        Ok(Value::List(self.state))
439    }
440}
441
442impl<'a> ser::SerializeTuple for SerializeSeq<'a> {
443    type Ok = Value;
444    type Error = Error;
445
446    #[inline]
447    fn serialize_element<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
448        ser::SerializeSeq::serialize_element(self, value)
449    }
450
451    #[inline]
452    fn end(self) -> Result<Value> {
453        Ok(Value::Tuple(self.state))
454    }
455}
456
457impl<'a> ser::SerializeTupleStruct for SerializeSeq<'a> {
458    type Ok = Value;
459    type Error = Error;
460
461    #[inline]
462    fn serialize_field<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
463        ser::SerializeSeq::serialize_element(self, value)
464    }
465
466    #[inline]
467    fn end(self) -> Result<Value> {
468        Ok(Value::Tuple(self.state))
469    }
470}
471
472pub struct SerializeTupleVariant<'a> {
473    ser: &'a mut Serializer,
474    variant: &'a str,
475    state: Vec<Value>,
476}
477
478impl<'a> ser::SerializeTupleVariant for SerializeTupleVariant<'a> {
479    type Ok = Value;
480    type Error = Error;
481
482    #[inline]
483    fn serialize_field<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
484        self.state.push(value.serialize(&mut *self.ser)?);
485        Ok(())
486    }
487
488    #[inline]
489    fn end(self) -> Result<Value> {
490        let mut d = BTreeMap::new();
491        d.insert(HashableValue::String(self.variant.into()), Value::List(self.state));
492        Ok(Value::Dict(d))
493    }
494}
495
496pub struct SerializeMap<'a> {
497    ser: &'a mut Serializer,
498    variant: &'a str,
499    key: Option<HashableValue>,
500    state: BTreeMap<HashableValue, Value>,
501}
502
503impl<'a> ser::SerializeMap for SerializeMap<'a> {
504    type Ok = Value;
505    type Error = Error;
506
507    #[inline]
508    fn serialize_key<T: Serialize + ?Sized>(&mut self, key: &T) -> Result<()> {
509        let key = key.serialize(&mut *self.ser)?;
510        self.key = Some(key.into_hashable()?);
511        Ok(())
512    }
513
514    #[inline]
515    fn serialize_value<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
516        let value = value.serialize(&mut *self.ser)?;
517        let key = self.key.take().unwrap();
518        self.state.insert(key, value);
519        Ok(())
520    }
521
522    #[inline]
523    fn end(self) -> Result<Value> {
524        Ok(Value::Dict(self.state))
525    }
526}
527
528impl<'a> ser::SerializeStruct for SerializeMap<'a> {
529    type Ok = Value;
530    type Error = Error;
531
532    #[inline]
533    fn serialize_field<T: Serialize + ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()> {
534        let key = key.serialize(&mut *self.ser)?;
535        let key = key.into_hashable()?;
536        let value = value.serialize(&mut *self.ser)?;
537        self.state.insert(key, value);
538        Ok(())
539    }
540
541    #[inline]
542    fn end(self) -> Result<Value> {
543        Ok(Value::Dict(self.state))
544    }
545}
546
547impl<'a> ser::SerializeStructVariant for SerializeMap<'a> {
548    type Ok = Value;
549    type Error = Error;
550
551    #[inline]
552    fn serialize_field<T: Serialize + ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()> {
553        ser::SerializeStruct::serialize_field(self, key, value)
554    }
555
556    #[inline]
557    fn end(self) -> Result<Value> {
558        let mut d = BTreeMap::new();
559        d.insert(HashableValue::String(self.variant.into()), Value::Dict(self.state));
560        Ok(Value::Dict(d))
561    }
562}
563
564impl<'a> ser::Serializer for &'a mut Serializer {
565    type Ok = Value;
566    type Error = Error;
567
568    type SerializeSeq = SerializeSeq<'a>;
569    type SerializeTuple = Self::SerializeSeq;
570    type SerializeTupleStruct = Self::SerializeSeq;
571    type SerializeTupleVariant = SerializeTupleVariant<'a>;
572    type SerializeMap = SerializeMap<'a>;
573    type SerializeStruct = Self::SerializeMap;
574    type SerializeStructVariant = Self::SerializeMap;
575
576    #[inline]
577    fn serialize_bool(self, value: bool) -> Result<Value> {
578        Ok(Value::Bool(value))
579    }
580
581    #[inline]
582    fn serialize_i8(self, v: i8) -> Result<Value> {
583        self.serialize_i64(v.into())
584    }
585
586    #[inline]
587    fn serialize_i16(self, v: i16) -> Result<Value> {
588        self.serialize_i64(v.into())
589    }
590
591    #[inline]
592    fn serialize_i32(self, v: i32) -> Result<Value> {
593        self.serialize_i64(v.into())
594    }
595
596    #[inline]
597    fn serialize_i64(self, value: i64) -> Result<Value> {
598        Ok(Value::I64(value))
599    }
600
601    #[inline]
602    fn serialize_u8(self, v: u8) -> Result<Value> {
603        self.serialize_u64(v.into())
604    }
605
606    #[inline]
607    fn serialize_u16(self, v: u16) -> Result<Value> {
608        self.serialize_u64(v.into())
609    }
610
611    #[inline]
612    fn serialize_u32(self, v: u32) -> Result<Value> {
613        self.serialize_u64(v.into())
614    }
615
616    #[inline]
617    fn serialize_u64(self, value: u64) -> Result<Value> {
618        Ok(if value < 0x8000_0000_0000_0000 {
619            Value::I64(value as i64)
620        } else {
621            Value::Int(BigInt::from(value))
622        })
623    }
624
625    #[inline]
626    fn serialize_f32(self, value: f32) -> Result<Value> {
627        self.serialize_f64(value.into())
628    }
629
630    #[inline]
631    fn serialize_f64(self, value: f64) -> Result<Value> {
632        Ok(Value::F64(value))
633    }
634
635    #[inline]
636    fn serialize_char(self, value: char) -> Result<Value> {
637        let mut s = String::new();
638        s.push(value);
639        Ok(Value::String(s))
640    }
641
642    #[inline]
643    fn serialize_str(self, value: &str) -> Result<Value> {
644        Ok(Value::String(String::from(value)))
645    }
646
647    #[inline]
648    fn serialize_bytes(self, value: &[u8]) -> Result<Value> {
649        Ok(Value::Bytes(value.to_vec()))
650    }
651
652    #[inline]
653    fn serialize_unit(self) -> Result<Value> {
654        Ok(Value::None)
655    }
656
657    #[inline]
658    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
659        Ok(Value::None)
660    }
661
662    #[inline]
663    fn serialize_unit_variant(
664        self, _name: &'static str, _variant_index: u32, variant: &'static str,
665    ) -> Result<Value> {
666        Ok(Value::String(variant.into()))
667    }
668
669    #[inline]
670    fn serialize_newtype_struct<T: Serialize + ?Sized>(
671        self, _name: &'static str, value: &T,
672    ) -> Result<Value> {
673        value.serialize(self)
674    }
675
676    #[inline]
677    fn serialize_newtype_variant<T: Serialize + ?Sized>(
678        self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T,
679    ) -> Result<Value> {
680        let mut d = BTreeMap::new();
681        d.insert(HashableValue::String(variant.into()), to_value(&value)?);
682        Ok(Value::Dict(d))
683    }
684
685    #[inline]
686    fn serialize_none(self) -> Result<Value> {
687        self.serialize_unit()
688    }
689
690    #[inline]
691    fn serialize_some<V: Serialize + ?Sized>(self, value: &V) -> Result<Value> {
692        value.serialize(self)
693    }
694
695    #[inline]
696    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
697        Ok(SerializeSeq { ser: self, state: vec![] })
698    }
699
700    #[inline]
701    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
702        Ok(SerializeSeq { ser: self, state: Vec::with_capacity(len) })
703    }
704
705    #[inline]
706    fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct> {
707        self.serialize_tuple(len)
708    }
709
710    #[inline]
711    fn serialize_tuple_variant(
712        self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize,
713    ) -> Result<Self::SerializeTupleVariant> {
714        Ok(SerializeTupleVariant { ser: self, variant, state: Vec::with_capacity(len) })
715    }
716
717    #[inline]
718    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
719        Ok(SerializeMap { ser: self, variant: "", key: None, state: BTreeMap::new() })
720    }
721
722    #[inline]
723    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
724        Ok(SerializeMap { ser: self, variant: "", key: None, state: BTreeMap::new() })
725    }
726
727    #[inline]
728    fn serialize_struct_variant(
729        self, _name: &'static str, _variant_index: u32, variant: &'static str, _len: usize,
730    ) -> Result<Self::SerializeStructVariant> {
731        Ok(SerializeMap { ser: self, variant, key: None, state: BTreeMap::new() })
732    }
733}
734
735/// Serialize any serde serializable object into a `value::Value`.
736pub fn to_value<T: Serialize + ?Sized>(value: &T) -> Result<Value> {
737    value.serialize(&mut Serializer)
738}
739
740/// Deserialize a `value::Value` from any serde deserializable object.
741pub fn from_value<'de, T: de::Deserialize<'de>>(value: Value) -> Result<T> {
742    let mut de = Deserializer::new(value);
743    de::Deserialize::deserialize(&mut de)
744}
serde_pickle/value_impls.rs

serde_pickle/
value_impls.rs
