deepmind_midi/program/
serde.rs1use core::fmt;
11
12use serde::de::{self, MapAccess, SeqAccess, Visitor};
13use serde::ser::SerializeStruct;
14use serde::{Deserialize, Deserializer, Serialize, Serializer};
15
16use super::Program;
17use crate::ids::ProtocolVersion;
18
19const NAME: &str = "Program";
20const FIELDS: &[&str] = &["version", "data"];
21
22struct Bytes<'a>(&'a [u8]);
24
25impl Serialize for Bytes<'_> {
26 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
27 serializer.serialize_bytes(self.0)
28 }
29}
30
31impl Serialize for Program {
32 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
33 let mut program = serializer.serialize_struct(NAME, FIELDS.len())?;
34 program.serialize_field("version", &self.version())?;
35 program.serialize_field("data", &Bytes(self.as_bytes()))?;
36 program.end()
37 }
38}
39
40struct Data {
42 bytes: [u8; Program::MAX_LEN],
43 len: usize,
44}
45
46impl<'de> Deserialize<'de> for Data {
47 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
48 struct DataVisitor;
49
50 impl<'de> Visitor<'de> for DataVisitor {
51 type Value = Data;
52
53 fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
54 write!(f, "at most {} bytes of program data", Program::MAX_LEN)
55 }
56
57 fn visit_bytes<E: de::Error>(self, bytes: &[u8]) -> Result<Data, E> {
58 let mut data = Data {
59 bytes: [0; Program::MAX_LEN],
60 len: bytes.len(),
61 };
62 if bytes.len() > Program::MAX_LEN {
63 return Err(E::invalid_length(bytes.len(), &self));
64 }
65 for (slot, byte) in data.bytes.iter_mut().zip(bytes) {
66 *slot = *byte;
67 }
68 Ok(data)
69 }
70
71 fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Data, A::Error> {
72 let mut data = Data {
73 bytes: [0; Program::MAX_LEN],
74 len: 0,
75 };
76 while let Some(byte) = seq.next_element::<u8>()? {
77 let Some(slot) = data.bytes.get_mut(data.len) else {
78 return Err(de::Error::invalid_length(data.len + 1, &self));
79 };
80 *slot = byte;
81 data.len += 1;
82 }
83 Ok(data)
84 }
85 }
86
87 deserializer.deserialize_bytes(DataVisitor)
88 }
89}
90
91enum Field {
93 Version,
94 Data,
95}
96
97impl<'de> Deserialize<'de> for Field {
98 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
99 struct FieldVisitor;
100
101 impl Visitor<'_> for FieldVisitor {
102 type Value = Field;
103
104 fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
105 f.write_str("`version` or `data`")
106 }
107
108 fn visit_str<E: de::Error>(self, key: &str) -> Result<Field, E> {
109 match key {
110 "version" => Ok(Field::Version),
111 "data" => Ok(Field::Data),
112 other => Err(de::Error::unknown_field(other, FIELDS)),
113 }
114 }
115 }
116
117 deserializer.deserialize_identifier(FieldVisitor)
118 }
119}
120
121impl<'de> Deserialize<'de> for Program {
122 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
123 struct ProgramVisitor;
124
125 impl<'de> Visitor<'de> for ProgramVisitor {
126 type Value = Program;
127
128 fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
129 f.write_str("a program: its comms protocol version and its bytes")
130 }
131
132 fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Program, A::Error> {
133 let version: ProtocolVersion = seq
134 .next_element()?
135 .ok_or_else(|| de::Error::invalid_length(0, &self))?;
136 let data: Data = seq
137 .next_element()?
138 .ok_or_else(|| de::Error::invalid_length(1, &self))?;
139 build(version, &data)
140 }
141
142 fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Program, A::Error> {
143 let mut version = None;
144 let mut data = None;
145 while let Some(key) = map.next_key()? {
146 match key {
147 Field::Version => {
148 if version.is_some() {
149 return Err(de::Error::duplicate_field("version"));
150 }
151 version = Some(map.next_value()?);
152 }
153 Field::Data => {
154 if data.is_some() {
155 return Err(de::Error::duplicate_field("data"));
156 }
157 data = Some(map.next_value()?);
158 }
159 }
160 }
161 let version = version.ok_or_else(|| de::Error::missing_field("version"))?;
162 let data: Data = data.ok_or_else(|| de::Error::missing_field("data"))?;
163 build(version, &data)
164 }
165 }
166
167 deserializer.deserialize_struct(NAME, FIELDS, ProgramVisitor)
168 }
169}
170
171fn build<E: de::Error>(version: ProtocolVersion, data: &Data) -> Result<Program, E> {
173 let bytes = data.bytes.get(..data.len).unwrap_or_default();
174 Program::from_bytes(version, bytes).map_err(E::custom)
175}