Skip to main content

deepmind_midi/program/
serde.rs

1//! `Serialize` and `Deserialize` for [`Program`], written by hand because the
2//! derive stops at arrays of 32.
3//!
4//! A program serializes as a struct of two fields: `version`, the comms
5//! protocol version, and `data`, the bytes of the unpacked dump as a byte
6//! string. In JSON that is an array of numbers; in a binary format it is the
7//! bytes. Reading one back goes through [`Program::from_bytes`], so the length
8//! rule holds for a program that came out of a file.
9
10use 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
22/// The dump bytes, serialized as a byte string rather than a sequence.
23struct 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
40/// The dump bytes, read from a byte string or a sequence into a fixed buffer.
41struct 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
91/// Which of the two fields a key names.
92enum 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
171/// Builds the program, turning a wrong length into the format's own error.
172fn 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}