use serde::de::{Deserialize, Deserializer, Error as _, IgnoredAny, MapAccess, SeqAccess, Visitor};
use std::collections::BTreeMap;
use std::fmt;
use std::marker::PhantomData;
const FIRST_CAPACITY: usize = 1_024;
struct Bounded<T, const MAX: usize>(Vec<T>);
impl<'de, T: Deserialize<'de>, const MAX: usize> Deserialize<'de> for Bounded<T, MAX> {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
struct Elements<T, const MAX: usize>(PhantomData<T>);
impl<'de, T: Deserialize<'de>, const MAX: usize> Visitor<'de> for Elements<T, MAX> {
type Value = Vec<T>;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "a sequence of at most {MAX} elements")
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Vec<T>, A::Error> {
let hint = seq.size_hint().unwrap_or(0);
let mut elements = Vec::with_capacity(hint.min(MAX).min(FIRST_CAPACITY));
while elements.len() < MAX {
match seq.next_element()? {
Some(element) => elements.push(element),
None => return Ok(elements),
}
}
if seq.next_element::<IgnoredAny>()?.is_some() {
return Err(A::Error::invalid_length(MAX + 1, &self));
}
Ok(elements)
}
}
deserializer
.deserialize_seq(Elements::<T, MAX>(PhantomData))
.map(Self)
}
}
pub(crate) fn seq<'de, D, T, const MAX: usize>(deserializer: D) -> Result<Vec<T>, D::Error>
where
D: Deserializer<'de>,
T: Deserialize<'de>,
{
Bounded::<T, MAX>::deserialize(deserializer).map(|bounded| bounded.0)
}
pub(crate) fn option_seq<'de, D, T, const MAX: usize>(
deserializer: D,
) -> Result<Option<Vec<T>>, D::Error>
where
D: Deserializer<'de>,
T: Deserialize<'de>,
{
Option::<Bounded<T, MAX>>::deserialize(deserializer).map(|bounded| bounded.map(|b| b.0))
}
pub(crate) fn map<'de, D, K, V, const MAX: usize>(
deserializer: D,
) -> Result<BTreeMap<K, V>, D::Error>
where
D: Deserializer<'de>,
K: Deserialize<'de> + Ord,
V: Deserialize<'de>,
{
struct Entries<K, V, const MAX: usize>(PhantomData<(K, V)>);
impl<'de, K, V, const MAX: usize> Visitor<'de> for Entries<K, V, MAX>
where
K: Deserialize<'de> + Ord,
V: Deserialize<'de>,
{
type Value = BTreeMap<K, V>;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "a map of at most {MAX} entries")
}
fn visit_map<A: MapAccess<'de>>(self, mut access: A) -> Result<BTreeMap<K, V>, A::Error> {
let mut entries = BTreeMap::new();
while let Some((key, value)) = access.next_entry()? {
entries.insert(key, value);
if entries.len() > MAX {
return Err(A::Error::invalid_length(MAX + 1, &self));
}
}
Ok(entries)
}
}
deserializer.deserialize_map(Entries::<K, V, MAX>(PhantomData))
}