1 use super::{biguint_from_vec, BigUint};
2 
3 use crate::std_alloc::Vec;
4 
5 use core::fmt;
6 use serde::de::{SeqAccess, Visitor};
7 use serde::{Deserialize, Deserializer, Serialize, Serializer};
8 
9 impl Serialize for BigUint {
10     #[cfg(not(u64_digit))]
serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,11     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
12     where
13         S: Serializer,
14     {
15         // Note: do not change the serialization format, or it may break forward
16         // and backward compatibility of serialized data!  If we ever change the
17         // internal representation, we should still serialize in base-`u32`.
18         let data: &[u32] = &self.data;
19         data.serialize(serializer)
20     }
21 
22     #[cfg(u64_digit)]
serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,23     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
24     where
25         S: Serializer,
26     {
27         use serde::ser::SerializeSeq;
28 
29         if let Some((&last, data)) = self.data.split_last() {
30             let last_lo = last as u32;
31             let last_hi = (last >> 32) as u32;
32             let u32_len = data.len() * 2 + 1 + (last_hi != 0) as usize;
33             let mut seq = serializer.serialize_seq(Some(u32_len))?;
34             for &x in data {
35                 seq.serialize_element(&(x as u32))?;
36                 seq.serialize_element(&((x >> 32) as u32))?;
37             }
38             seq.serialize_element(&last_lo)?;
39             if last_hi != 0 {
40                 seq.serialize_element(&last_hi)?;
41             }
42             seq.end()
43         } else {
44             let data: &[u32] = &[];
45             data.serialize(serializer)
46         }
47     }
48 }
49 
50 impl<'de> Deserialize<'de> for BigUint {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,51     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
52     where
53         D: Deserializer<'de>,
54     {
55         deserializer.deserialize_seq(U32Visitor)
56     }
57 }
58 
59 struct U32Visitor;
60 
61 impl<'de> Visitor<'de> for U32Visitor {
62     type Value = BigUint;
63 
expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result64     fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
65         formatter.write_str("a sequence of unsigned 32-bit numbers")
66     }
67 
68     #[cfg(not(u64_digit))]
visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error> where S: SeqAccess<'de>,69     fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
70     where
71         S: SeqAccess<'de>,
72     {
73         let len = seq.size_hint().unwrap_or(0);
74         let mut data = Vec::with_capacity(len);
75 
76         while let Some(value) = seq.next_element::<u32>()? {
77             data.push(value);
78         }
79 
80         Ok(biguint_from_vec(data))
81     }
82 
83     #[cfg(u64_digit)]
visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error> where S: SeqAccess<'de>,84     fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
85     where
86         S: SeqAccess<'de>,
87     {
88         use crate::big_digit::BigDigit;
89         use num_integer::Integer;
90 
91         let u32_len = seq.size_hint().unwrap_or(0);
92         let len = Integer::div_ceil(&u32_len, &2);
93         let mut data = Vec::with_capacity(len);
94 
95         while let Some(lo) = seq.next_element::<u32>()? {
96             let mut value = BigDigit::from(lo);
97             if let Some(hi) = seq.next_element::<u32>()? {
98                 value |= BigDigit::from(hi) << 32;
99                 data.push(value);
100             } else {
101                 data.push(value);
102                 break;
103             }
104         }
105 
106         Ok(biguint_from_vec(data))
107     }
108 }
109