Skip to content

Commit d461263

Browse files
dtolnaydtolnay
authored
Merge pull request #479 from srijs/refactor/reusable-special-types
Refactor to make "special" type machinery more reusable
2 parents 7d05626 + ff4c682 commit d461263

File tree

3 files changed

+43
-84
lines changed

3 files changed

+43
-84
lines changed

‎src/ser.rs

Lines changed: 5 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -22,9 +22,6 @@ use ryu;
2222
#[cfg(feature = "arbitrary_precision")]
2323
use serde::Serialize;
2424

25-
#[cfg(feature = "arbitrary_precision")]
26-
use number::{SERDE_STRUCT_FIELD_NAME, SERDE_STRUCT_NAME};
27-
2825
/// A structure for serializing Rust values into JSON.
2926
pub struct Serializer<W, F = CompactFormatter> {
3027
writer: W,
@@ -461,19 +458,12 @@ where
461458
}
462459
}
463460

464-
#[cfg(not(feature = "arbitrary_precision"))]
465-
#[inline]
466-
fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
467-
self.serialize_map(Some(len))
468-
}
469-
470-
#[cfg(feature = "arbitrary_precision")]
471461
#[inline]
472462
fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
473-
if name == SERDE_STRUCT_NAME {
474-
Ok(Compound::Number { ser: self })
475-
} else {
476-
self.serialize_map(Some(len))
463+
match name {
464+
#[cfg(feature = "arbitrary_precision")]
465+
::number::SERDE_STRUCT_NAME => Ok(Compound::Number { ser: self }),
466+
_ => self.serialize_map(Some(len)),
477467
}
478468
}
479469

@@ -820,7 +810,7 @@ where
820810
}
821811
#[cfg(feature = "arbitrary_precision")]
822812
Compound::Number { ref mut ser, .. } => {
823-
if key == SERDE_STRUCT_FIELD_NAME {
813+
if key == ::number::SERDE_STRUCT_FIELD_NAME {
824814
try!(value.serialize(NumberStrEmitter(&mut *ser)));
825815
Ok(())
826816
} else {

‎src/value/de.rs

Lines changed: 33 additions & 51 deletions
Original file line numberDiff line numberDiff line change
@@ -23,11 +23,10 @@ use map::Map;
2323
use number::Number;
2424
use value::Value;
2525

26-
#[cfg(feature = "arbitrary_precision")]
2726
use serde::de;
2827

2928
#[cfg(feature = "arbitrary_precision")]
30-
use number::{NumberFromString, SERDE_STRUCT_FIELD_NAME};
29+
use number::NumberFromString;
3130

3231
impl<'de> Deserialize<'de> for Value {
3332
#[inline]
@@ -109,44 +108,28 @@ impl<'de> Deserialize<'de> for Value {
109108
Ok(Value::Array(vec))
110109
}
111110

112-
#[cfg(not(feature = "arbitrary_precision"))]
113-
fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
114-
where
115-
V: MapAccess<'de>,
116-
{
117-
let mut values = Map::new();
118-
119-
while let Some((key, value)) = try!(visitor.next_entry()) {
120-
values.insert(key, value);
121-
}
122-
123-
Ok(Value::Object(values))
124-
}
125-
126-
#[cfg(feature = "arbitrary_precision")]
127111
fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
128112
where
129113
V: MapAccess<'de>,
130114
{
131-
let mut key = String::new();
132-
let number = visitor.next_key_seed(NumberOrObject { key: &mut key })?;
133-
match number {
134-
Some(true) => {
115+
match visitor.next_key_seed(KeyClassifier)? {
116+
#[cfg(feature = "arbitrary_precision")]
117+
Some(KeyClass::Number) => {
135118
let number: NumberFromString = visitor.next_value()?;
136119
return Ok(Value::Number(number.value));
137120
}
138-
None => return Ok(Value::Object(Map::new())),
139-
Some(false) => {}
140-
}
121+
Some(KeyClass::Map(first_key)) => {
122+
let mut values = Map::new();
141123

142-
let mut values = Map::new();
124+
values.insert(first_key, try!(visitor.next_value()));
125+
while let Some((key, value)) = try!(visitor.next_entry()) {
126+
values.insert(key, value);
127+
}
143128

144-
values.insert(key, try!(visitor.next_value()));
145-
while let Some((key, value)) = try!(visitor.next_entry()) {
146-
values.insert(key, value);
129+
Ok(Value::Object(values))
130+
}
131+
None => return Ok(Value::Object(Map::new())),
147132
}
148-
149-
Ok(Value::Object(values))
150133
}
151134
}
152135

@@ -1303,14 +1286,16 @@ impl<'de> serde::Deserializer<'de> for MapKeyDeserializer<'de> {
13031286
}
13041287
}
13051288

1306-
#[cfg(feature = "arbitrary_precision")]
1307-
struct NumberOrObject<'a> {
1308-
key: &'a mut String,
1289+
struct KeyClassifier;
1290+
1291+
enum KeyClass {
1292+
Map(String),
1293+
#[cfg(feature = "arbitrary_precision")]
1294+
Number,
13091295
}
13101296

1311-
#[cfg(feature = "arbitrary_precision")]
1312-
impl<'a, 'de> DeserializeSeed<'de> for NumberOrObject<'a> {
1313-
type Value = bool;
1297+
impl<'de> DeserializeSeed<'de> for KeyClassifier {
1298+
type Value = KeyClass;
13141299

13151300
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
13161301
where
@@ -1320,35 +1305,32 @@ impl<'a, 'de> DeserializeSeed<'de> for NumberOrObject<'a> {
13201305
}
13211306
}
13221307

1323-
#[cfg(feature = "arbitrary_precision")]
1324-
impl<'a, 'de> Visitor<'de> for NumberOrObject<'a> {
1325-
type Value = bool;
1308+
impl<'de> Visitor<'de> for KeyClassifier {
1309+
type Value = KeyClass;
13261310

13271311
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
13281312
formatter.write_str("a string key")
13291313
}
13301314

1331-
fn visit_str<E>(self, s: &str) -> Result<bool, E>
1315+
fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
13321316
where
13331317
E: de::Error,
13341318
{
1335-
if s == SERDE_STRUCT_FIELD_NAME {
1336-
Ok(true)
1337-
} else {
1338-
self.key.push_str(s);
1339-
Ok(false)
1319+
match s {
1320+
#[cfg(feature = "arbitrary_precision")]
1321+
::number::SERDE_STRUCT_FIELD_NAME => Ok(KeyClass::Number),
1322+
_ => Ok(KeyClass::Map(s.to_owned())),
13401323
}
13411324
}
13421325

1343-
fn visit_string<E>(self, s: String) -> Result<bool, E>
1326+
fn visit_string<E>(self, s: String) -> Result<Self::Value, E>
13441327
where
13451328
E: de::Error,
13461329
{
1347-
if s == SERDE_STRUCT_FIELD_NAME {
1348-
Ok(true)
1349-
} else {
1350-
*self.key = s;
1351-
Ok(false)
1330+
match s.as_str() {
1331+
#[cfg(feature = "arbitrary_precision")]
1332+
::number::SERDE_STRUCT_FIELD_NAME => Ok(KeyClass::Number),
1333+
_ => Ok(KeyClass::Map(s)),
13521334
}
13531335
}
13541336
}

‎src/value/ser.rs

Lines changed: 5 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -17,9 +17,6 @@ use value::{to_value, Value};
1717
#[cfg(feature = "arbitrary_precision")]
1818
use serde::ser;
1919

20-
#[cfg(feature = "arbitrary_precision")]
21-
use number::{SERDE_STRUCT_FIELD_NAME, SERDE_STRUCT_NAME};
22-
2320
impl Serialize for Value {
2421
#[inline]
2522
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -228,25 +225,15 @@ impl serde::Serializer for Serializer {
228225
})
229226
}
230227

231-
#[cfg(not(feature = "arbitrary_precision"))]
232-
fn serialize_struct(
233-
self,
234-
_name: &'static str,
235-
len: usize,
236-
) -> Result<Self::SerializeStruct, Error> {
237-
self.serialize_map(Some(len))
238-
}
239-
240-
#[cfg(feature = "arbitrary_precision")]
241228
fn serialize_struct(
242229
self,
243230
name: &'static str,
244231
len: usize,
245232
) -> Result<Self::SerializeStruct, Error> {
246-
if name == SERDE_STRUCT_NAME {
247-
Ok(SerializeMap::Number { out_value: None })
248-
} else {
249-
self.serialize_map(Some(len))
233+
match name {
234+
#[cfg(feature = "arbitrary_precision")]
235+
::number::SERDE_STRUCT_NAME => Ok(SerializeMap::Number { out_value: None }),
236+
_ => self.serialize_map(Some(len)),
250237
}
251238
}
252239

@@ -605,7 +592,7 @@ impl serde::ser::SerializeStruct for SerializeMap {
605592
}
606593
#[cfg(feature = "arbitrary_precision")]
607594
SerializeMap::Number { ref mut out_value } => {
608-
if key == SERDE_STRUCT_FIELD_NAME {
595+
if key == ::number::SERDE_STRUCT_FIELD_NAME {
609596
*out_value = Some(value.serialize(NumberValueEmitter)?);
610597
Ok(())
611598
} else {

0 commit comments

Comments
 (0)