deltoid/
range.rs

1//!
2
3use crate::{Apply, Core, Delta, DeltaResult, FromDelta, IntoDelta};
4use serde::{Deserialize, Deserializer, Serialize, Serializer};
5use serde::de;
6use serde::ser::SerializeMap;
7use std::fmt::{self, Debug};
8use std::marker::PhantomData;
9use std::ops::Range;
10
11
12impl<T> Core for Range<T>
13where T: Clone + Debug + PartialEq + Core
14    + for<'de> Deserialize<'de>
15    + Serialize
16{
17    type Delta = RangeDelta<T>;
18}
19
20impl<T> Apply for Range<T>
21where T: Apply
22    + for<'de> Deserialize<'de>
23    + Serialize
24{
25    fn apply(&self, delta: Self::Delta) -> DeltaResult<Self> {
26        match delta.0 {
27            Some(range) => Ok(range.start .. range.end),
28            None        => Ok(self.start.clone() ..  self.end.clone()),
29        }
30    }
31}
32
33impl<T> Delta for Range<T>
34where T: Delta
35    + for<'de> Deserialize<'de>
36    + Serialize
37{
38    fn delta(&self, rhs: &Self) -> DeltaResult<Self::Delta> {
39        Ok(RangeDelta(if self == rhs {
40            None
41        } else {
42            Some(rhs.clone())
43        }))
44    }
45}
46
47impl<T> FromDelta for Range<T>
48where T: Clone + Debug + PartialEq + FromDelta
49    + for<'de> Deserialize<'de>
50    + Serialize
51{
52    fn from_delta(delta: Self::Delta) -> DeltaResult<Self> {
53        Ok(delta.0.ok_or_else(|| ExpectedValue!("RangeDelta<K, V>"))?)
54    }
55}
56
57impl<T> IntoDelta for Range<T>
58where T: Clone + Debug + PartialEq + IntoDelta
59    + for<'de> Deserialize<'de>
60    + Serialize
61{
62    fn into_delta(self) -> DeltaResult<Self::Delta> {
63        Ok(RangeDelta(Some(self)))
64    }
65}
66
67
68
69#[derive(Clone, PartialEq, Hash)]
70pub struct RangeDelta<T>(#[doc(hidden)] pub Option<Range<T>>);
71
72impl<T> std::fmt::Debug for RangeDelta<T>
73where T: Core + std::fmt::Debug {
74    fn fmt(&self, f: &mut std::fmt::Formatter)
75           -> Result<(), std::fmt::Error>
76    {
77        match &self.0 {
78            Some(field) => write!(f, "RangeDelta({:#?})", field),
79            None        => write!(f, "RangeDelta(None)"),
80        }
81    }
82}
83
84impl<T> Serialize for RangeDelta<T>
85where T: Core
86    + Clone
87    + Serialize
88{
89    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
90    where S: Serializer {
91        let mut num_fields = 0;
92        if self.0.is_some() { num_fields += 1; }
93        let mut s = serializer.serialize_map(Some(num_fields))?;
94        if let Some(inner) = &self.0 {
95            s.serialize_entry("0", inner)?;
96        }
97        s.end()
98    }
99}
100
101impl<'de, T> Deserialize<'de> for RangeDelta<T>
102where T: Core
103    + Clone
104    + Deserialize<'de>
105{
106    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
107    where D: Deserializer<'de> {
108        struct DeltaVisitor<T2>(PhantomData<T2>);
109
110        impl<'de, T2> de::Visitor<'de> for DeltaVisitor<T2>
111        where T2: Core
112            + Clone
113            + Deserialize<'de>
114        {
115            type Value = RangeDelta<T2>;
116
117            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
118                formatter.write_str("a RangeDelta")
119            }
120
121            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
122            where M: de::MapAccess<'de> {
123                let mut delta: Self::Value = RangeDelta(None);
124                const EXPECTED_FIELDS: &[&str] = &["0"];
125                while let Some((key, value)) = map.next_entry()? {
126                    match (key, value) {
127                        ("0", value) =>  delta.0 = Some(value),
128                        (field_name, _) => return Err(de::Error::unknown_field(
129                            field_name, EXPECTED_FIELDS
130                        ))?,
131                    }
132                }
133                Ok(delta)
134            }
135        }
136
137        deserializer.deserialize_map(DeltaVisitor(PhantomData))
138    }
139}
140
141
142
143#[allow(non_snake_case)]
144#[cfg(test)]
145mod tests {
146    use serde_json;
147    use super::*;
148
149    #[test]
150    fn Range__delta___same_values() -> DeltaResult<()> {
151        let range0 = 1..10;
152        let range1 = 1..10;
153        let delta: <Range<usize> as Core>::Delta = range0.delta(&range1)?;
154        let json_string = serde_json::to_string(&delta)
155            .expect("Could not serialize to json");
156        println!("json_string: \"{}\"", json_string);
157        assert_eq!(json_string, "{}");
158        let delta1: <Range<usize> as Core>::Delta = serde_json::from_str(
159            &json_string
160        ).expect("Could not deserialize from json");
161        assert_eq!(delta, delta1);
162        Ok(())
163    }
164
165    #[test]
166    fn Range__delta___different_values() -> DeltaResult<()> {
167        let range0 = 1..10;
168        let range1 = 1..11;
169        let delta: <Range<usize> as Core>::Delta = range0.delta(&range1)?;
170        let json_string = serde_json::to_string(&delta)
171            .expect("Could not serialize to json");
172        println!("json_string: \"{}\"", json_string);
173        assert_eq!(json_string, "{\"0\":{\"start\":1,\"end\":11}}");
174        let delta1: <Range<usize> as Core>::Delta = serde_json::from_str(
175            &json_string
176        ).expect("Could not deserialize from json");
177        assert_eq!(delta, delta1);
178        Ok(())
179    }
180
181    #[test]
182    fn Range__apply__same_values() -> DeltaResult<()> {
183        let range0 = 1..10;
184        let range1 = 1..10;
185        let delta: <Range<usize> as Core>::Delta = range0.delta(&range1)?;
186        let range2 = range0.apply(delta)?;
187        assert_eq!(range0, range2);
188        Ok(())
189    }
190
191    #[test]
192    fn Range__apply__different_values() -> DeltaResult<()> {
193        let range0 = 1..10;
194        let range1 = 1..11;
195        let delta: <Range<usize> as Core>::Delta = range0.delta(&range1)?;
196        let range2 = range0.apply(delta)?;
197        assert_eq!(range1, range2);
198        Ok(())
199    }
200}
deltoid/range.rs

deltoid/
range.rs
