Skip to content

Commit 552418b

Browse files
cuvipercuviper
committed
Move extras to separate modules
1 parent 75a234c commit 552418b

File tree

6 files changed

+240
-230
lines changed

6 files changed

+240
-230
lines changed

‎src/bigint.rs

Lines changed: 6 additions & 98 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
// `Add`/`Sub` ops may flip from `BigInt` to its `BigUint` magnitude
22
#![allow(clippy::suspicious_arithmetic_impl)]
33

4-
#[cfg(any(feature = "quickcheck", feature = "arbitrary"))]
5-
use crate::std_alloc::Box;
64
use crate::std_alloc::{String, Vec};
75
use core::cmp::Ordering::{self, Equal};
86
use core::default::Default;
@@ -32,6 +30,12 @@ mod convert;
3230
mod power;
3331
mod shift;
3432

33+
#[cfg(any(feature = "quickcheck", feature = "arbitrary"))]
34+
mod arbitrary;
35+
36+
#[cfg(feature = "serde")]
37+
mod serde;
38+
3539
/// A Sign is a `BigInt`'s composing element.
3640
#[derive(PartialEq, PartialOrd, Eq, Ord, Copy, Clone, Debug, Hash)]
3741
pub enum Sign {
@@ -54,44 +58,6 @@ impl Neg for Sign {
5458
}
5559
}
5660

57-
#[cfg(feature = "serde")]
58-
impl serde::Serialize for Sign {
59-
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
60-
where
61-
S: serde::Serializer,
62-
{
63-
// Note: do not change the serialization format, or it may break
64-
// forward and backward compatibility of serialized data!
65-
match *self {
66-
Sign::Minus => (-1i8).serialize(serializer),
67-
Sign::NoSign => 0i8.serialize(serializer),
68-
Sign::Plus => 1i8.serialize(serializer),
69-
}
70-
}
71-
}
72-
73-
#[cfg(feature = "serde")]
74-
impl<'de> serde::Deserialize<'de> for Sign {
75-
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
76-
where
77-
D: serde::Deserializer<'de>,
78-
{
79-
use serde::de::Error;
80-
use serde::de::Unexpected;
81-
82-
let sign: i8 = serde::Deserialize::deserialize(deserializer)?;
83-
match sign {
84-
-1 => Ok(Sign::Minus),
85-
0 => Ok(Sign::NoSign),
86-
1 => Ok(Sign::Plus),
87-
_ => Err(D::Error::invalid_value(
88-
Unexpected::Signed(sign.into()),
89-
&"a sign of -1, 0, or 1",
90-
)),
91-
}
92-
}
93-
}
94-
9561
/// A big signed integer type.
9662
#[derive(Debug)]
9763
pub struct BigInt {
@@ -117,41 +83,6 @@ impl Clone for BigInt {
11783
}
11884
}
11985

120-
#[cfg(feature = "quickcheck")]
121-
impl quickcheck::Arbitrary for BigInt {
122-
fn arbitrary<G: quickcheck::Gen>(g: &mut G) -> Self {
123-
let positive = bool::arbitrary(g);
124-
let sign = if positive { Sign::Plus } else { Sign::Minus };
125-
Self::from_biguint(sign, BigUint::arbitrary(g))
126-
}
127-
128-
fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
129-
let sign = self.sign();
130-
let unsigned_shrink = self.data.shrink();
131-
Box::new(unsigned_shrink.map(move |x| BigInt::from_biguint(sign, x)))
132-
}
133-
}
134-
135-
#[cfg(feature = "arbitrary")]
136-
mod abitrary_impl {
137-
use super::*;
138-
use arbitrary::{Arbitrary, Result, Unstructured};
139-
140-
impl Arbitrary for BigInt {
141-
fn arbitrary(u: &mut Unstructured<'_>) -> Result<Self> {
142-
let positive = bool::arbitrary(u)?;
143-
let sign = if positive { Sign::Plus } else { Sign::Minus };
144-
Ok(Self::from_biguint(sign, BigUint::arbitrary(u)?))
145-
}
146-
147-
fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
148-
let sign = self.sign();
149-
let unsigned_shrink = self.data.shrink();
150-
Box::new(unsigned_shrink.map(move |x| BigInt::from_biguint(sign, x)))
151-
}
152-
}
153-
}
154-
15586
impl hash::Hash for BigInt {
15687
#[inline]
15788
fn hash<H: hash::Hasher>(&self, state: &mut H) {
@@ -622,29 +553,6 @@ impl IntDigits for BigInt {
622553
}
623554
}
624555

625-
#[cfg(feature = "serde")]
626-
impl serde::Serialize for BigInt {
627-
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
628-
where
629-
S: serde::Serializer,
630-
{
631-
// Note: do not change the serialization format, or it may break
632-
// forward and backward compatibility of serialized data!
633-
(self.sign, &self.data).serialize(serializer)
634-
}
635-
}
636-
637-
#[cfg(feature = "serde")]
638-
impl<'de> serde::Deserialize<'de> for BigInt {
639-
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
640-
where
641-
D: serde::Deserializer<'de>,
642-
{
643-
let (sign, data) = serde::Deserialize::deserialize(deserializer)?;
644-
Ok(BigInt::from_biguint(sign, data))
645-
}
646-
}
647-
648556
/// A generic trait for converting a value to a `BigInt`. This may return
649557
/// `None` when converting from `f32` or `f64`, and will always succeed
650558
/// when converting from any integer or unsigned primitive, or `BigUint`.

‎src/bigint/arbitrary.rs

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,34 @@
1+
use super::{BigInt, Sign};
2+
3+
use crate::std_alloc::Box;
4+
use crate::BigUint;
5+
6+
#[cfg(feature = "quickcheck")]
7+
impl quickcheck::Arbitrary for BigInt {
8+
fn arbitrary<G: quickcheck::Gen>(g: &mut G) -> Self {
9+
let positive = bool::arbitrary(g);
10+
let sign = if positive { Sign::Plus } else { Sign::Minus };
11+
Self::from_biguint(sign, BigUint::arbitrary(g))
12+
}
13+
14+
fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
15+
let sign = self.sign();
16+
let unsigned_shrink = self.data.shrink();
17+
Box::new(unsigned_shrink.map(move |x| BigInt::from_biguint(sign, x)))
18+
}
19+
}
20+
21+
#[cfg(feature = "arbitrary")]
22+
impl arbitrary::Arbitrary for BigInt {
23+
fn arbitrary(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
24+
let positive = bool::arbitrary(u)?;
25+
let sign = if positive { Sign::Plus } else { Sign::Minus };
26+
Ok(Self::from_biguint(sign, BigUint::arbitrary(u)?))
27+
}
28+
29+
fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
30+
let sign = self.sign();
31+
let unsigned_shrink = self.data.shrink();
32+
Box::new(unsigned_shrink.map(move |x| BigInt::from_biguint(sign, x)))
33+
}
34+
}

‎src/bigint/serde.rs

Lines changed: 58 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,58 @@
1+
use super::{BigInt, Sign};
2+
3+
use serde::de::{Error, Unexpected};
4+
use serde::{Deserialize, Deserializer, Serialize, Serializer};
5+
6+
impl Serialize for Sign {
7+
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
8+
where
9+
S: Serializer,
10+
{
11+
// Note: do not change the serialization format, or it may break
12+
// forward and backward compatibility of serialized data!
13+
match *self {
14+
Sign::Minus => (-1i8).serialize(serializer),
15+
Sign::NoSign => 0i8.serialize(serializer),
16+
Sign::Plus => 1i8.serialize(serializer),
17+
}
18+
}
19+
}
20+
21+
impl<'de> Deserialize<'de> for Sign {
22+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
23+
where
24+
D: Deserializer<'de>,
25+
{
26+
let sign = i8::deserialize(deserializer)?;
27+
match sign {
28+
-1 => Ok(Sign::Minus),
29+
0 => Ok(Sign::NoSign),
30+
1 => Ok(Sign::Plus),
31+
_ => Err(D::Error::invalid_value(
32+
Unexpected::Signed(sign.into()),
33+
&"a sign of -1, 0, or 1",
34+
)),
35+
}
36+
}
37+
}
38+
39+
impl Serialize for BigInt {
40+
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
41+
where
42+
S: Serializer,
43+
{
44+
// Note: do not change the serialization format, or it may break
45+
// forward and backward compatibility of serialized data!
46+
(self.sign, &self.data).serialize(serializer)
47+
}
48+
}
49+
50+
impl<'de> Deserialize<'de> for BigInt {
51+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
52+
where
53+
D: Deserializer<'de>,
54+
{
55+
let (sign, data) = Deserialize::deserialize(deserializer)?;
56+
Ok(BigInt::from_biguint(sign, data))
57+
}
58+
}

‎src/biguint.rs

Lines changed: 6 additions & 132 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,3 @@
1-
#[cfg(any(feature = "quickcheck", feature = "arbitrary"))]
2-
use crate::std_alloc::Box;
31
use crate::std_alloc::{String, Vec};
42
use core::cmp;
53
use core::cmp::Ordering;
@@ -28,6 +26,12 @@ mod monty;
2826
mod power;
2927
mod shift;
3028

29+
#[cfg(any(feature = "quickcheck", feature = "arbitrary"))]
30+
mod arbitrary;
31+
32+
#[cfg(feature = "serde")]
33+
mod serde;
34+
3135
use self::algorithms::cmp_slice;
3236
pub(crate) use self::convert::to_str_radix_reversed;
3337

@@ -53,35 +57,6 @@ impl Clone for BigUint {
5357
}
5458
}
5559

56-
#[cfg(feature = "quickcheck")]
57-
impl quickcheck::Arbitrary for BigUint {
58-
fn arbitrary<G: quickcheck::Gen>(g: &mut G) -> Self {
59-
// Use arbitrary from Vec
60-
biguint_from_vec(Vec::<BigDigit>::arbitrary(g))
61-
}
62-
63-
fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
64-
// Use shrinker from Vec
65-
Box::new(self.data.shrink().map(biguint_from_vec))
66-
}
67-
}
68-
69-
#[cfg(feature = "arbitrary")]
70-
mod abitrary_impl {
71-
use super::*;
72-
use arbitrary::{Arbitrary, Result, Unstructured};
73-
74-
impl Arbitrary for BigUint {
75-
fn arbitrary(u: &mut Unstructured<'_>) -> Result<Self> {
76-
Ok(biguint_from_vec(Vec::<BigDigit>::arbitrary(u)?))
77-
}
78-
79-
fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
80-
Box::new(self.data.shrink().map(biguint_from_vec))
81-
}
82-
}
83-
}
84-
8560
impl hash::Hash for BigUint {
8661
#[inline]
8762
fn hash<H: hash::Hasher>(&self, state: &mut H) {
@@ -1251,107 +1226,6 @@ fn u32_from_u128(n: u128) -> (u32, u32, u32, u32) {
12511226
)
12521227
}
12531228

1254-
#[cfg(feature = "serde")]
1255-
impl serde::Serialize for BigUint {
1256-
#[cfg(not(u64_digit))]
1257-
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1258-
where
1259-
S: serde::Serializer,
1260-
{
1261-
// Note: do not change the serialization format, or it may break forward
1262-
// and backward compatibility of serialized data! If we ever change the
1263-
// internal representation, we should still serialize in base-`u32`.
1264-
let data: &[u32] = &self.data;
1265-
data.serialize(serializer)
1266-
}
1267-
1268-
#[cfg(u64_digit)]
1269-
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1270-
where
1271-
S: serde::Serializer,
1272-
{
1273-
use serde::ser::SerializeSeq;
1274-
if let Some((&last, data)) = self.data.split_last() {
1275-
let last_lo = last as u32;
1276-
let last_hi = (last >> 32) as u32;
1277-
let u32_len = data.len() * 2 + 1 + (last_hi != 0) as usize;
1278-
let mut seq = serializer.serialize_seq(Some(u32_len))?;
1279-
for &x in data {
1280-
seq.serialize_element(&(x as u32))?;
1281-
seq.serialize_element(&((x >> 32) as u32))?;
1282-
}
1283-
seq.serialize_element(&last_lo)?;
1284-
if last_hi != 0 {
1285-
seq.serialize_element(&last_hi)?;
1286-
}
1287-
seq.end()
1288-
} else {
1289-
let data: &[u32] = &[];
1290-
data.serialize(serializer)
1291-
}
1292-
}
1293-
}
1294-
1295-
#[cfg(feature = "serde")]
1296-
impl<'de> serde::Deserialize<'de> for BigUint {
1297-
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1298-
where
1299-
D: serde::Deserializer<'de>,
1300-
{
1301-
use serde::de::{SeqAccess, Visitor};
1302-
1303-
struct U32Visitor;
1304-
1305-
impl<'de> Visitor<'de> for U32Visitor {
1306-
type Value = BigUint;
1307-
1308-
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
1309-
formatter.write_str("a sequence of unsigned 32-bit numbers")
1310-
}
1311-
1312-
#[cfg(not(u64_digit))]
1313-
fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
1314-
where
1315-
S: SeqAccess<'de>,
1316-
{
1317-
let len = seq.size_hint().unwrap_or(0);
1318-
let mut data = Vec::with_capacity(len);
1319-
1320-
while let Some(value) = seq.next_element::<u32>()? {
1321-
data.push(value);
1322-
}
1323-
1324-
Ok(biguint_from_vec(data))
1325-
}
1326-
1327-
#[cfg(u64_digit)]
1328-
fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
1329-
where
1330-
S: SeqAccess<'de>,
1331-
{
1332-
let u32_len = seq.size_hint().unwrap_or(0);
1333-
let len = u32_len.div_ceil(&2);
1334-
let mut data = Vec::with_capacity(len);
1335-
1336-
while let Some(lo) = seq.next_element::<u32>()? {
1337-
let mut value = BigDigit::from(lo);
1338-
if let Some(hi) = seq.next_element::<u32>()? {
1339-
value |= BigDigit::from(hi) << 32;
1340-
data.push(value);
1341-
} else {
1342-
data.push(value);
1343-
break;
1344-
}
1345-
}
1346-
1347-
Ok(biguint_from_vec(data))
1348-
}
1349-
}
1350-
1351-
deserializer.deserialize_seq(U32Visitor)
1352-
}
1353-
}
1354-
13551229
#[cfg(not(u64_digit))]
13561230
#[test]
13571231
fn test_from_slice() {

0 commit comments

Comments
 (0)