Skip to content

Commit 0fca04e

Browse files
dtolnaydtolnay
committed
Merge pull request 2471 from tbu-/pr_more_ranges
2 parents 92bfc8d + e76e87a commit 0fca04e

File tree

3 files changed

+359
-4
lines changed

3 files changed

+359
-4
lines changed

‎serde/src/de/impls.rs‎

Lines changed: 313 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2256,9 +2256,9 @@ impl<'de> Deserialize<'de> for SystemTime {
22562256
//
22572257
// #[derive(Deserialize)]
22582258
// #[serde(deny_unknown_fields)]
2259-
// struct Range {
2260-
// start: u64,
2261-
// end: u32,
2259+
// struct Range<Idx> {
2260+
// start: Idx,
2261+
// end: Idx,
22622262
// }
22632263
impl<'de, Idx> Deserialize<'de> for Range<Idx>
22642264
where
@@ -2432,6 +2432,316 @@ mod range {
24322432

24332433
////////////////////////////////////////////////////////////////////////////////
24342434

2435+
// Similar to:
2436+
//
2437+
// #[derive(Deserialize)]
2438+
// #[serde(deny_unknown_fields)]
2439+
// struct RangeFrom<Idx> {
2440+
// start: Idx,
2441+
// }
2442+
impl<'de, Idx> Deserialize<'de> for RangeFrom<Idx>
2443+
where
2444+
Idx: Deserialize<'de>,
2445+
{
2446+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2447+
where
2448+
D: Deserializer<'de>,
2449+
{
2450+
let start = try!(deserializer.deserialize_struct(
2451+
"RangeFrom",
2452+
range_from::FIELDS,
2453+
range_from::RangeFromVisitor {
2454+
expecting: "struct RangeFrom",
2455+
phantom: PhantomData,
2456+
},
2457+
));
2458+
Ok(start..)
2459+
}
2460+
}
2461+
2462+
mod range_from {
2463+
use lib::*;
2464+
2465+
use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
2466+
2467+
pub const FIELDS: &'static [&'static str] = &["end"];
2468+
2469+
// If this were outside of the serde crate, it would just use:
2470+
//
2471+
// #[derive(Deserialize)]
2472+
// #[serde(field_identifier, rename_all = "lowercase")]
2473+
enum Field {
2474+
End,
2475+
}
2476+
2477+
impl<'de> Deserialize<'de> for Field {
2478+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2479+
where
2480+
D: Deserializer<'de>,
2481+
{
2482+
struct FieldVisitor;
2483+
2484+
impl<'de> Visitor<'de> for FieldVisitor {
2485+
type Value = Field;
2486+
2487+
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2488+
formatter.write_str("`end`")
2489+
}
2490+
2491+
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2492+
where
2493+
E: Error,
2494+
{
2495+
match value {
2496+
"end" => Ok(Field::End),
2497+
_ => Err(Error::unknown_field(value, FIELDS)),
2498+
}
2499+
}
2500+
2501+
fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2502+
where
2503+
E: Error,
2504+
{
2505+
match value {
2506+
b"end" => Ok(Field::End),
2507+
_ => {
2508+
let value = ::__private::from_utf8_lossy(value);
2509+
Err(Error::unknown_field(&*value, FIELDS))
2510+
}
2511+
}
2512+
}
2513+
}
2514+
2515+
deserializer.deserialize_identifier(FieldVisitor)
2516+
}
2517+
}
2518+
2519+
pub struct RangeFromVisitor<Idx> {
2520+
pub expecting: &'static str,
2521+
pub phantom: PhantomData<Idx>,
2522+
}
2523+
2524+
impl<'de, Idx> Visitor<'de> for RangeFromVisitor<Idx>
2525+
where
2526+
Idx: Deserialize<'de>,
2527+
{
2528+
type Value = Idx;
2529+
2530+
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2531+
formatter.write_str(self.expecting)
2532+
}
2533+
2534+
fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
2535+
where
2536+
A: SeqAccess<'de>,
2537+
{
2538+
let end: Idx = match try!(seq.next_element()) {
2539+
Some(value) => value,
2540+
None => {
2541+
return Err(Error::invalid_length(0, &self));
2542+
}
2543+
};
2544+
Ok(end)
2545+
}
2546+
2547+
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2548+
where
2549+
A: MapAccess<'de>,
2550+
{
2551+
let mut end: Option<Idx> = None;
2552+
while let Some(key) = try!(map.next_key()) {
2553+
match key {
2554+
Field::End => {
2555+
if end.is_some() {
2556+
return Err(<A::Error as Error>::duplicate_field("end"));
2557+
}
2558+
end = Some(try!(map.next_value()));
2559+
}
2560+
}
2561+
}
2562+
let end = match end {
2563+
Some(end) => end,
2564+
None => return Err(<A::Error as Error>::missing_field("end")),
2565+
};
2566+
Ok(end)
2567+
}
2568+
}
2569+
}
2570+
2571+
////////////////////////////////////////////////////////////////////////////////
2572+
2573+
// Similar to:
2574+
//
2575+
// #[derive(Deserialize)]
2576+
// #[serde(deny_unknown_fields)]
2577+
// struct RangeTo<Idx> {
2578+
// start: Idx,
2579+
// }
2580+
impl<'de, Idx> Deserialize<'de> for RangeTo<Idx>
2581+
where
2582+
Idx: Deserialize<'de>,
2583+
{
2584+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2585+
where
2586+
D: Deserializer<'de>,
2587+
{
2588+
let end = try!(deserializer.deserialize_struct(
2589+
"RangeTo",
2590+
range_to::FIELDS,
2591+
range_to::RangeToVisitor {
2592+
expecting: "struct RangeTo",
2593+
phantom: PhantomData,
2594+
},
2595+
));
2596+
Ok(..end)
2597+
}
2598+
}
2599+
2600+
mod range_to {
2601+
use lib::*;
2602+
2603+
use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
2604+
2605+
pub const FIELDS: &'static [&'static str] = &["start"];
2606+
2607+
// If this were outside of the serde crate, it would just use:
2608+
//
2609+
// #[derive(Deserialize)]
2610+
// #[serde(field_identifier, rename_all = "lowercase")]
2611+
enum Field {
2612+
Start,
2613+
}
2614+
2615+
impl<'de> Deserialize<'de> for Field {
2616+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2617+
where
2618+
D: Deserializer<'de>,
2619+
{
2620+
struct FieldVisitor;
2621+
2622+
impl<'de> Visitor<'de> for FieldVisitor {
2623+
type Value = Field;
2624+
2625+
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2626+
formatter.write_str("`start`")
2627+
}
2628+
2629+
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2630+
where
2631+
E: Error,
2632+
{
2633+
match value {
2634+
"start" => Ok(Field::Start),
2635+
_ => Err(Error::unknown_field(value, FIELDS)),
2636+
}
2637+
}
2638+
2639+
fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2640+
where
2641+
E: Error,
2642+
{
2643+
match value {
2644+
b"start" => Ok(Field::Start),
2645+
_ => {
2646+
let value = ::__private::from_utf8_lossy(value);
2647+
Err(Error::unknown_field(&*value, FIELDS))
2648+
}
2649+
}
2650+
}
2651+
}
2652+
2653+
deserializer.deserialize_identifier(FieldVisitor)
2654+
}
2655+
}
2656+
2657+
pub struct RangeToVisitor<Idx> {
2658+
pub expecting: &'static str,
2659+
pub phantom: PhantomData<Idx>,
2660+
}
2661+
2662+
impl<'de, Idx> Visitor<'de> for RangeToVisitor<Idx>
2663+
where
2664+
Idx: Deserialize<'de>,
2665+
{
2666+
type Value = Idx;
2667+
2668+
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2669+
formatter.write_str(self.expecting)
2670+
}
2671+
2672+
fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
2673+
where
2674+
A: SeqAccess<'de>,
2675+
{
2676+
let start: Idx = match try!(seq.next_element()) {
2677+
Some(value) => value,
2678+
None => {
2679+
return Err(Error::invalid_length(0, &self));
2680+
}
2681+
};
2682+
Ok(start)
2683+
}
2684+
2685+
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2686+
where
2687+
A: MapAccess<'de>,
2688+
{
2689+
let mut start: Option<Idx> = None;
2690+
while let Some(key) = try!(map.next_key()) {
2691+
match key {
2692+
Field::Start => {
2693+
if start.is_some() {
2694+
return Err(<A::Error as Error>::duplicate_field("start"));
2695+
}
2696+
start = Some(try!(map.next_value()));
2697+
}
2698+
}
2699+
}
2700+
let start = match start {
2701+
Some(start) => start,
2702+
None => return Err(<A::Error as Error>::missing_field("start")),
2703+
};
2704+
Ok(start)
2705+
}
2706+
}
2707+
}
2708+
2709+
////////////////////////////////////////////////////////////////////////////////
2710+
2711+
// Similar to:
2712+
//
2713+
// #[derive(Deserialize)]
2714+
// #[serde(deny_unknown_fields)]
2715+
// struct RangeFull;
2716+
impl<'de> Deserialize<'de> for RangeFull {
2717+
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2718+
where
2719+
D: Deserializer<'de>,
2720+
{
2721+
deserializer.deserialize_unit_struct("RangeFull", RangeFullVisitor)
2722+
}
2723+
}
2724+
2725+
struct RangeFullVisitor;
2726+
2727+
impl<'de> Visitor<'de> for RangeFullVisitor {
2728+
type Value = RangeFull;
2729+
2730+
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2731+
formatter.write_str("unit")
2732+
}
2733+
2734+
#[inline]
2735+
fn visit_unit<E>(self) -> Result<Self::Value, E>
2736+
where
2737+
E: Error,
2738+
{
2739+
Ok(..)
2740+
}
2741+
}
2742+
2743+
////////////////////////////////////////////////////////////////////////////////
2744+
24352745
#[cfg(any(not(no_ops_bound), all(feature = "std", not(no_collections_bound))))]
24362746
impl<'de, T> Deserialize<'de> for Bound<T>
24372747
where

‎serde/src/lib.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -180,7 +180,7 @@ mod lib {
180180
pub use self::core::fmt::{self, Debug, Display};
181181
pub use self::core::marker::{self, PhantomData};
182182
pub use self::core::num::Wrapping;
183-
pub use self::core::ops::Range;
183+
pub use self::core::ops::{Range, RangeFrom, RangeFull, RangeTo};
184184
pub use self::core::option::{self, Option};
185185
pub use self::core::result::{self, Result};
186186

‎serde/src/ser/impls.rs‎

Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -257,6 +257,34 @@ where
257257

258258
////////////////////////////////////////////////////////////////////////////////
259259

260+
impl<Idx> Serialize for RangeFrom<Idx>
261+
where
262+
Idx: Serialize,
263+
{
264+
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
265+
where
266+
S: Serializer,
267+
{
268+
use super::SerializeStruct;
269+
let mut state = try!(serializer.serialize_struct("RangeFrom", 1));
270+
try!(state.serialize_field("start", &self.start));
271+
state.end()
272+
}
273+
}
274+
275+
////////////////////////////////////////////////////////////////////////////////
276+
277+
impl Serialize for RangeFull {
278+
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
279+
where
280+
S: Serializer,
281+
{
282+
serializer.serialize_unit_struct("RangeFull")
283+
}
284+
}
285+
286+
////////////////////////////////////////////////////////////////////////////////
287+
260288
#[cfg(not(no_range_inclusive))]
261289
impl<Idx> Serialize for RangeInclusive<Idx>
262290
where
@@ -276,6 +304,23 @@ where
276304

277305
////////////////////////////////////////////////////////////////////////////////
278306

307+
impl<Idx> Serialize for RangeTo<Idx>
308+
where
309+
Idx: Serialize,
310+
{
311+
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
312+
where
313+
S: Serializer,
314+
{
315+
use super::SerializeStruct;
316+
let mut state = try!(serializer.serialize_struct("RangeTo", 1));
317+
try!(state.serialize_field("end", &self.end));
318+
state.end()
319+
}
320+
}
321+
322+
////////////////////////////////////////////////////////////////////////////////
323+
279324
#[cfg(any(not(no_ops_bound), all(feature = "std", not(no_collections_bound))))]
280325
impl<T> Serialize for Bound<T>
281326
where

0 commit comments

Comments
 (0)