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