deltoid/
result.rs

1//!
2
3use crate::{Apply, Core, Delta, DeltaResult, FromDelta, IntoDelta};
4use serde::{Deserialize, Serialize};
5use std::fmt::Debug;
6
7impl<T, E> Core for Result<T, E>
8where T: Clone + Debug + PartialEq + Core + for<'de> Deserialize<'de> + Serialize,
9      E: Clone + Debug + PartialEq + Core + for<'de> Deserialize<'de> + Serialize,
10{
11    type Delta = ResultDelta<T, E>;
12}
13
14impl<T, E> Apply for Result<T, E>
15where T: Apply + FromDelta + for<'de> Deserialize<'de> + Serialize,
16      E: Apply + FromDelta + for<'de> Deserialize<'de> + Serialize
17{
18    fn apply(&self, delta: Self::Delta) -> DeltaResult<Self> {
19        match (self, &delta/*TODO: match by value*/) {
20            (Result::Ok(ok), ResultDelta::None) => Ok(Ok(ok.clone())),
21            (Result::Ok(ok), ResultDelta::OkDelta(delta)) => {
22                Ok(Ok(ok.apply(delta.clone(/*TODO: rm*/))?))
23            },
24            (Result::Ok(_ok), delta @ ResultDelta::ErrDelta(_)) => {
25                Ok(Self::from_delta(delta.clone())?)
26            },
27            (Result::Err(err), ResultDelta::None) => Ok(Err(err.clone())),
28            (Result::Err(_err), delta @ ResultDelta::OkDelta(_)) => {
29                Ok(Self::from_delta(delta.clone())?)
30            },
31            (Result::Err(err), ResultDelta::ErrDelta(delta)) => {
32                Ok(Err(err.apply(delta.clone(/*TODO: rm*/))?))
33            },
34        }
35    }
36}
37
38impl<T, E> Delta for Result<T, E>
39where T: Delta + IntoDelta + for<'de> Deserialize<'de> + Serialize,
40      E: Delta + IntoDelta + for<'de> Deserialize<'de> + Serialize
41{
42    fn delta(&self, rhs: &Self) -> DeltaResult<Self::Delta> {
43        match (self, rhs) {
44            (Ok(lhs), Ok(rhs)) if lhs == rhs => Ok(ResultDelta::None),
45            (Ok(lhs), Ok(rhs)) =>
46                Ok(ResultDelta::OkDelta(lhs.delta(rhs)?)),
47            (Ok(_lhs), Err(rhs)) =>
48                Ok(ResultDelta::ErrDelta(rhs.clone().into_delta()?)),
49            (Err(_lhs), Ok(rhs)) =>
50                Ok(ResultDelta::OkDelta(rhs.clone().into_delta()?)),
51            (Err(lhs), Err(rhs)) if lhs == rhs => Ok(ResultDelta::None),
52            (Err(_lhs), Err(rhs)) =>
53                Ok(ResultDelta::ErrDelta(rhs.clone().into_delta()?)),
54        }
55    }
56}
57
58impl<T, E> FromDelta for Result<T, E>
59where T: Clone + Debug + PartialEq + FromDelta
60    + for<'de> Deserialize<'de>
61    + Serialize,
62      E: Clone + Debug + PartialEq + FromDelta
63    + for<'de> Deserialize<'de>
64    + Serialize
65{
66    fn from_delta(delta: Self::Delta) -> DeltaResult<Self> {
67        match delta {
68            ResultDelta::None => Err(ExpectedValue!("ResultDelta<T, E>")),
69            ResultDelta::OkDelta(delta) =>
70                Ok(Self::Ok(<T>::from_delta(delta)?)),
71            ResultDelta::ErrDelta(delta) =>
72                Ok(Self::Err(<E>::from_delta(delta)?)),
73        }
74    }
75}
76
77impl<T, E> IntoDelta for Result<T, E>
78where T: Clone + Debug + PartialEq + IntoDelta
79    + for<'de> Deserialize<'de>
80    + Serialize,
81      E: Clone + Debug + PartialEq + IntoDelta
82    + for<'de> Deserialize<'de>
83    + Serialize
84{
85    fn into_delta(self) -> DeltaResult<Self::Delta> {
86        match self {
87            Ok(ok)   => Ok(ResultDelta::OkDelta(ok.into_delta()?)),
88            Err(err) => Ok(ResultDelta::ErrDelta(err.into_delta()?)),
89        }
90    }
91}
92
93
94
95#[derive(Clone, PartialEq)]
96#[derive(serde_derive::Deserialize, serde_derive::Serialize)]
97pub enum ResultDelta<T: Core, E: Core> {
98    OkDelta(<T as Core>::Delta),
99    ErrDelta(<E as Core>::Delta),
100    None
101}
102
103impl<T, E> std::fmt::Debug for ResultDelta<T, E>
104where T: Core, E: Core {
105    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
106        match &self {
107            Self::OkDelta(ok)   => write!(f, "ResultDelta::Ok({:#?})",  ok),
108            Self::ErrDelta(err) => write!(f, "ResultDelta::Err({:#?})", err),
109            Self::None          => write!(f, "ResultDelta::None"),
110        }
111    }
112}
113
114
115#[allow(non_snake_case)]
116#[cfg(test)]
117mod tests {
118    use serde_json;
119    use super::*;
120
121    #[test]
122    fn Result_Ok__delta__same_values() -> DeltaResult<()> {
123        let foo = String::from("foo");
124        let bar = String::from("foo");
125        let box0 = Ok(foo);
126        let box1 = Ok(bar);
127        let delta: <Result<String, ()> as Core>::Delta = box0.delta(&box1)?;
128        let json_string = serde_json::to_string(&delta)
129            .expect("Could not serialize to json");
130        println!("json_string: \"{}\"", json_string);
131        assert_eq!(json_string, "\"None\"");
132        let delta1: <Result<String, ()> as Core>::Delta = serde_json::from_str(
133            &json_string
134        ).expect("Could not deserialize from json");
135        assert_eq!(delta, delta1);
136        Ok(())
137    }
138
139    #[test]
140    fn Result_Ok__delta__different_values() -> DeltaResult<()> {
141        let foo = String::from("foo");
142        let bar = String::from("bar");
143        let box0 = Ok(foo);
144        let box1 = Ok(bar);
145        let delta: <Result<String, ()> as Core>::Delta = box0.delta(&box1)?;
146        let json_string = serde_json::to_string(&delta)
147            .expect("Could not serialize to json");
148        println!("json_string: \"{}\"", json_string);
149        assert_eq!(json_string, "{\"OkDelta\":\"bar\"}");
150        let delta1: <Result<String, ()> as Core>::Delta = serde_json::from_str(
151            &json_string
152        ).expect("Could not deserialize from json");
153        assert_eq!(delta, delta1);
154        Ok(())
155    }
156
157    #[test]
158    fn Result_Ok__apply__same_values() -> DeltaResult<()> {
159        let foo = String::from("foo");
160        let bar = String::from("foo");
161        let box0 = Ok(foo);
162        let box1 = Ok(bar);
163        let delta: <Result<String, ()> as Core>::Delta = box0.delta(&box1)?;
164        let box2 = box0.apply(delta)?;
165        assert_eq!(box1, box2);
166        Ok(())
167    }
168
169    #[test]
170    fn Result_Ok__apply__different_values() -> DeltaResult<()> {
171        let foo = String::from("foo");
172        let bar = String::from("bar");
173        let box0 = Ok(foo);
174        let box1 = Ok(bar);
175        let delta: <Result<String, ()> as Core>::Delta = box0.delta(&box1)?;
176        let box2 = box0.apply(delta)?;
177        assert_eq!(box1, box2);
178        Ok(())
179    }
180
181    #[test]
182    fn Result_Err__delta__same_values() -> DeltaResult<()> {
183        let foo = String::from("foo");
184        let bar = String::from("foo");
185        let box0 = Err(foo);
186        let box1 = Err(bar);
187        let delta: <Result<(), String> as Core>::Delta = box0.delta(&box1)?;
188        let json_string = serde_json::to_string(&delta)
189            .expect("Could not serialize to json");
190        println!("json_string: \"{}\"", json_string);
191        assert_eq!(json_string, "\"None\"");
192        let delta1: <Result<(), String> as Core>::Delta = serde_json::from_str(
193            &json_string
194        ).expect("Could not deserialize from json");
195        assert_eq!(delta, delta1);
196        Ok(())
197    }
198
199    #[test]
200    fn Result_Err__delta__different_values() -> DeltaResult<()> {
201        let foo = String::from("foo");
202        let bar = String::from("bar");
203        let box0 = Err(foo);
204        let box1 = Err(bar);
205        let delta: <Result<(), String> as Core>::Delta = box0.delta(&box1)?;
206        let json_string = serde_json::to_string(&delta)
207            .expect("Could not serialize to json");
208        println!("json_string: \"{}\"", json_string);
209        assert_eq!(json_string, "{\"ErrDelta\":\"bar\"}");
210        let delta1: <Result<(), String> as Core>::Delta = serde_json::from_str(
211            &json_string
212        ).expect("Could not deserialize from json");
213        assert_eq!(delta, delta1);
214        Ok(())
215    }
216
217    #[test]
218    fn Result_Err__apply__same_values() -> DeltaResult<()> {
219        let foo = String::from("foo");
220        let bar = String::from("foo");
221        let box0 = Err(foo);
222        let box1 = Err(bar);
223        let delta: <Result<(), String> as Core>::Delta = box0.delta(&box1)?;
224        let box2 = box0.apply(delta)?;
225        assert_eq!(box1, box2);
226        Ok(())
227    }
228
229    #[test]
230    fn Result_Err__apply__different_values() -> DeltaResult<()> {
231        let foo = String::from("foo");
232        let bar = String::from("bar");
233        let box0 = Err(foo);
234        let box1 = Err(bar);
235        let delta: <Result<(), String> as Core>::Delta = box0.delta(&box1)?;
236        let box2 = box0.apply(delta)?;
237        assert_eq!(box1, box2);
238        Ok(())
239    }
240}
deltoid/result.rs

deltoid/
result.rs
