ic_wire/serde_packed/
mod.rs1#[cfg(test)]
10mod tests;
11
12pub mod bools {
14 use alloc::vec::Vec;
15 use serde::{Deserializer, Serializer, de};
16 pub fn serialize<S: Serializer>(values: &[bool], serializer: S) -> Result<S::Ok, S::Error> {
20 serializer.serialize_bytes(bytemuck::must_cast_slice(values))
21 }
22
23 pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Vec<bool>, D::Error> {
27 struct Visitor;
28 impl de::Visitor<'_> for Visitor {
29 type Value = Vec<bool>;
30 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
31 f.write_str("boolean bytes")
32 }
33
34 fn visit_bytes<E: de::Error>(self, bytes: &[u8]) -> Result<Self::Value, E> {
35 let words: &[bool] = bytemuck::checked::try_cast_slice(bytes)
36 .map_err(|_| E::custom("invalid boolean byte"))?;
37 let mut output = Vec::new();
38 output
39 .try_reserve_exact(words.len())
40 .map_err(|_| E::custom("allocation"))?;
41 output.extend_from_slice(words);
42 Ok(output)
43 }
44 }
45 deserializer.deserialize_bytes(Visitor)
46 }
47}
48
49pub mod nonzero_i64 {
51 use alloc::vec::Vec;
52 use core::num::NonZeroI64;
53 use serde::{Deserialize, Deserializer, Serializer};
54 pub fn serialize<S: Serializer>(
58 values: &[NonZeroI64],
59 serializer: S,
60 ) -> Result<S::Ok, S::Error> {
61 crate::packed::serialize_words::<i64, S>(bytemuck::must_cast_slice(values), serializer)
62 }
63
64 pub fn deserialize<'de, D: Deserializer<'de>>(
69 deserializer: D,
70 ) -> Result<Vec<NonZeroI64>, D::Error> {
71 crate::Packed::<i64>::deserialize(deserializer)?
72 .into_vec()
73 .into_iter()
74 .map(NonZeroI64::new)
75 .collect::<Option<Vec<_>>>()
76 .ok_or_else(|| serde::de::Error::custom("zero in nonzero list"))
77 }
78}
79
80pub mod heap_u64 {
83 use alloc::collections::BinaryHeap;
84 use serde::{Deserialize, Deserializer, Serializer};
85 pub fn serialize<S: Serializer>(
89 values: &BinaryHeap<u64>,
90 serializer: S,
91 ) -> Result<S::Ok, S::Error> {
92 crate::packed::serialize_words(values.as_slice(), serializer)
93 }
94
95 pub fn deserialize<'de, D: Deserializer<'de>>(
99 deserializer: D,
100 ) -> Result<BinaryHeap<u64>, D::Error> {
101 Ok(BinaryHeap::from(
102 crate::Packed::<u64>::deserialize(deserializer)?.into_vec(),
103 ))
104 }
105}
106
107macro_rules! finite {
110 ($module:ident,$float:ty,$width:literal) => {
111 pub mod $module {
113 use alloc::vec::Vec;
114 use serde::{Deserializer, Serializer, de};
115 fn valid(bytes: &[u8]) -> bool {
116 if !bytes.len().is_multiple_of($width) {
117 return false;
118 }
119 let mut tail = bytes;
120 if $width == 4 {
121 let mut pairs = bytes.chunks_exact(8);
125 if !pairs.by_ref().all(|pair| {
126 let bits = u64::from_le_bytes(pair.try_into().unwrap());
127 ((bits & 0x7f80_0000_7f80_0000) + 0x0080_0000_0080_0000)
128 & 0x8000_0000_8000_0000
129 == 0
130 }) {
131 return false;
132 }
133 tail = pairs.remainder();
134 }
135 tail.chunks_exact($width).all(|word| {
136 <$float>::from_le_bytes(word.try_into().expect("whole float word")).is_finite()
137 })
138 }
139
140 pub fn serialize<S: Serializer>(
144 values: &[$float],
145 serializer: S,
146 ) -> Result<S::Ok, S::Error> {
147 if cfg!(target_endian = "little") {
148 let bytes = bytemuck::must_cast_slice(values);
149 if !valid(bytes) {
150 return Err(serde::ser::Error::custom("non-finite float"));
151 }
152 serializer.serialize_bytes(bytes)
153 } else {
154 serializer.serialize_bytes(&little_endian::<S::Error>(values)?)
155 }
156 }
157
158 pub(super) fn little_endian<E: serde::ser::Error>(
159 values: &[$float],
160 ) -> Result<Vec<u8>, E> {
161 if values.iter().any(|value| !value.is_finite()) {
162 return Err(E::custom("non-finite float"));
163 }
164 let length = values
165 .len()
166 .checked_mul($width)
167 .ok_or_else(|| E::custom("length overflow"))?;
168 let mut bytes = Vec::new();
169 bytes
170 .try_reserve_exact(length)
171 .map_err(|_| E::custom("allocation"))?;
172 for value in values {
173 bytes.extend_from_slice(&value.to_le_bytes());
174 }
175 Ok(bytes)
176 }
177
178 pub fn deserialize<'de, D: Deserializer<'de>>(
182 deserializer: D,
183 ) -> Result<Vec<$float>, D::Error> {
184 struct Visitor;
185 impl de::Visitor<'_> for Visitor {
186 type Value = Vec<$float>;
187 fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
188 f.write_str("finite little-endian float bytes")
189 }
190
191 fn visit_bytes<E: de::Error>(self, bytes: &[u8]) -> Result<Self::Value, E> {
192 if !valid(bytes) {
193 return Err(E::custom("invalid finite float bytes"));
194 }
195 let mut values = Vec::new();
196 values
197 .try_reserve_exact(bytes.len() / $width)
198 .map_err(|_| E::custom("allocation"))?;
199 values.extend(bytes.chunks_exact($width).map(|word| {
200 <$float>::from_le_bytes(
201 word.try_into().expect("validated whole float word"),
202 )
203 }));
204 Ok(values)
205 }
206 }
207 deserializer.deserialize_bytes(Visitor)
208 }
209 }
210 };
211}
212finite!(finite_f32, f32, 4);
213finite!(finite_f64, f64, 8);