1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
use druid::Data;
use serde::de::{Deserializer, SeqAccess, Visitor};
use serde::ser::{SerializeSeq, Serializer};
use serde::{Deserialize, Serialize};
use crate::time::Diff;
#[derive(Clone, Data, Debug, Eq, Serialize, Deserialize, PartialEq)]
pub struct FadeEffect {
pub pause: Diff,
pub fade: Diff,
}
#[derive(Clone, Data, Debug, Eq, PartialEq, Serialize, Deserialize)]
pub enum Effect {
Fade(FadeEffect),
}
#[derive(Clone, Data, Debug, Default, Eq, PartialEq)]
pub struct Effects {
fade: Option<FadeEffect>,
}
impl Effects {
pub fn add(&mut self, effect: Effect) {
match effect {
Effect::Fade(fade) => self.fade = Some(fade),
}
}
pub fn fade(&self) -> Option<&FadeEffect> {
self.fade.as_ref()
}
}
impl Serialize for Effects {
fn serialize<S: Serializer>(&self, ser: S) -> Result<S::Ok, S::Error> {
let len = if self.fade.is_some() { 1 } else { 0 };
let mut seq = ser.serialize_seq(Some(len))?;
if let Some(fade) = &self.fade {
seq.serialize_element(&Effect::Fade(fade.clone()))?;
}
seq.end()
}
}
impl<'de> Deserialize<'de> for Effects {
fn deserialize<D: Deserializer<'de>>(de: D) -> Result<Effects, D::Error> {
de.deserialize_seq(EffectsVisitor)
}
}
struct EffectsVisitor;
impl<'de> Visitor<'de> for EffectsVisitor {
type Value = Effects;
fn expecting(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
fmt.write_str("a list of effects")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut access: A) -> Result<Effects, A::Error> {
let mut ret = Effects::default();
if let Some(effect) = access.next_element()? {
match effect {
Effect::Fade(fade) => {
ret.fade = Some(fade);
}
}
}
Ok(ret)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn serde() {
let empty = Effects::default();
let written = serde_cbor::to_vec(&empty).unwrap();
let read = serde_cbor::from_slice(&written[..]).unwrap();
assert_eq!(empty, read);
let mut fade = Effects::default();
fade.add(Effect::Fade(FadeEffect {
pause: Diff::from_micros(100),
fade: Diff::from_micros(100),
}));
let written = serde_cbor::to_vec(&fade).unwrap();
let read = serde_cbor::from_slice(&written[..]).unwrap();
assert_eq!(fade, read);
}
}