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