core_json_traits/
sequences.rs

1#[cfg(feature = "alloc")]
2use alloc::{vec, vec::Vec};
3
4use crate::{Read, Stack, JsonError, Value, JsonDeserialize, JsonStructure, JsonSerialize};
5
6impl<T: 'static + Default + JsonDeserialize, const N: usize> JsonDeserialize for [T; N] {
7  fn deserialize<'read, 'parent, B: Read<'read>, S: Stack>(
8    value: Value<'read, 'parent, B, S>,
9  ) -> Result<Self, JsonError<'read, B, S>> {
10    let mut res: Self = core::array::from_fn(|_| Default::default());
11    let mut iter = value.iterate()?;
12    let mut i = 0;
13    while let Some(item) = iter.next() {
14      if i == N {
15        Err(JsonError::TypeError)?;
16      }
17      res[i] = T::deserialize(item?)?;
18      i += 1;
19    }
20    if i != N {
21      Err(JsonError::TypeError)?;
22    }
23    Ok(res)
24  }
25}
26impl<T: 'static + Default + JsonDeserialize, const N: usize> JsonStructure for [T; N] {}
27
28#[cfg(feature = "alloc")]
29impl<T: 'static + JsonDeserialize> JsonDeserialize for Vec<T> {
30  fn deserialize<'read, 'parent, B: Read<'read>, S: Stack>(
31    value: Value<'read, 'parent, B, S>,
32  ) -> Result<Self, JsonError<'read, B, S>> {
33    let mut res = vec![];
34    let mut iter = value.iterate()?;
35    while let Some(item) = iter.next() {
36      res.push(T::deserialize(item?)?);
37    }
38    Ok(res)
39  }
40}
41#[cfg(feature = "alloc")]
42impl<T: 'static + JsonDeserialize> JsonStructure for Vec<T> {}
43
44impl<T: JsonSerialize> JsonSerialize for [T] {
45  fn serialize(&self) -> impl Iterator<Item = char> {
46    core::iter::once('[')
47      .chain(
48        self
49          .iter()
50          .take(self.len().saturating_sub(1))
51          .flat_map(|elem| elem.serialize().chain(core::iter::once(','))),
52      )
53      .chain(self.get(self.len().saturating_sub(1)).into_iter().flat_map(JsonSerialize::serialize))
54      .chain(core::iter::once(']'))
55  }
56}
57impl<T: JsonSerialize, const N: usize> JsonSerialize for [T; N] {
58  fn serialize(&self) -> impl Iterator<Item = char> {
59    self.as_slice().serialize()
60  }
61}
62
63#[cfg(feature = "alloc")]
64impl<T: JsonSerialize> JsonSerialize for Vec<T> {
65  fn serialize(&self) -> impl Iterator<Item = char> {
66    self.as_slice().serialize()
67  }
68}