pub mod bools {
use alloc::vec::Vec;
use serde::{Deserializer, Serializer, de};
pub fn serialize<S: Serializer>(values: &[bool], serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_bytes(bytemuck::must_cast_slice(values))
}
pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Vec<bool>, D::Error> {
struct Visitor;
impl de::Visitor<'_> for Visitor {
type Value = Vec<bool>;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("boolean bytes")
}
fn visit_bytes<E: de::Error>(self, bytes: &[u8]) -> Result<Self::Value, E> {
let words: &[bool] = bytemuck::checked::try_cast_slice(bytes)
.map_err(|_| E::custom("invalid boolean byte"))?;
let mut output = Vec::new();
output
.try_reserve_exact(words.len())
.map_err(|_| E::custom("allocation"))?;
output.extend_from_slice(words);
Ok(output)
}
}
deserializer.deserialize_bytes(Visitor)
}
}
pub mod nonzero_i64 {
use alloc::vec::Vec;
use core::num::NonZeroI64;
use serde::{Deserialize, Deserializer, Serializer};
pub fn serialize<S: Serializer>(
values: &[NonZeroI64],
serializer: S,
) -> Result<S::Ok, S::Error> {
crate::packed::serialize_words::<i64, S>(bytemuck::must_cast_slice(values), serializer)
}
pub fn deserialize<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Vec<NonZeroI64>, D::Error> {
crate::Packed::<i64>::deserialize(deserializer)?
.into_vec()
.into_iter()
.map(NonZeroI64::new)
.collect::<Option<Vec<_>>>()
.ok_or_else(|| serde::de::Error::custom("zero in nonzero list"))
}
}
pub mod heap_u64 {
use alloc::collections::BinaryHeap;
use serde::{Deserialize, Deserializer, Serializer};
pub fn serialize<S: Serializer>(
values: &BinaryHeap<u64>,
serializer: S,
) -> Result<S::Ok, S::Error> {
crate::packed::serialize_words(values.as_slice(), serializer)
}
pub fn deserialize<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<BinaryHeap<u64>, D::Error> {
Ok(BinaryHeap::from(
crate::Packed::<u64>::deserialize(deserializer)?.into_vec(),
))
}
}
macro_rules! finite {
($module:ident,$float:ty,$width:literal) => {
pub mod $module {
use alloc::vec::Vec;
use serde::{Deserializer, Serializer, de};
fn valid(bytes: &[u8]) -> bool {
if !bytes.len().is_multiple_of($width) {
return false;
}
let mut tail = bytes;
if $width == 4 {
let mut pairs = bytes.chunks_exact(8);
if !pairs.by_ref().all(|pair| {
let bits = u64::from_le_bytes(pair.try_into().unwrap());
((bits & 0x7f80_0000_7f80_0000) + 0x0080_0000_0080_0000)
& 0x8000_0000_8000_0000
== 0
}) {
return false;
}
tail = pairs.remainder();
}
tail.chunks_exact($width).all(|word| {
<$float>::from_le_bytes(word.try_into().expect("whole float word")).is_finite()
})
}
pub fn serialize<S: Serializer>(
values: &[$float],
serializer: S,
) -> Result<S::Ok, S::Error> {
#[cfg(target_endian = "little")]
{
let bytes = bytemuck::must_cast_slice(values);
if !valid(bytes) {
return Err(serde::ser::Error::custom("non-finite float"));
}
serializer.serialize_bytes(bytes)
}
#[cfg(target_endian = "big")]
{
serializer.serialize_bytes(&little_endian::<S::Error>(values)?)
}
}
#[cfg(any(target_endian = "big", test))]
pub(super) fn little_endian<E: serde::ser::Error>(
values: &[$float],
) -> Result<Vec<u8>, E> {
if values.iter().any(|value| !value.is_finite()) {
return Err(E::custom("non-finite float"));
}
let length = values
.len()
.checked_mul($width)
.ok_or_else(|| E::custom("length overflow"))?;
let mut bytes = Vec::new();
bytes
.try_reserve_exact(length)
.map_err(|_| E::custom("allocation"))?;
for value in values {
bytes.extend_from_slice(&value.to_le_bytes());
}
Ok(bytes)
}
pub fn deserialize<'de, D: Deserializer<'de>>(
deserializer: D,
) -> Result<Vec<$float>, D::Error> {
struct Visitor;
impl de::Visitor<'_> for Visitor {
type Value = Vec<$float>;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("finite little-endian float bytes")
}
fn visit_bytes<E: de::Error>(self, bytes: &[u8]) -> Result<Self::Value, E> {
if !valid(bytes) {
return Err(E::custom("invalid finite float bytes"));
}
let mut values = Vec::new();
values
.try_reserve_exact(bytes.len() / $width)
.map_err(|_| E::custom("allocation"))?;
values.extend(bytes.chunks_exact($width).map(|word| {
<$float>::from_le_bytes(
word.try_into().expect("validated whole float word"),
)
}));
Ok(values)
}
}
deserializer.deserialize_bytes(Visitor)
}
}
};
}
finite!(finite_f32, f32, 4);
finite!(finite_f64, f64, 8);
#[cfg(test)]
mod tests;