serde_big_array/
const_generics.rs

1use core::fmt;
2use core::marker::PhantomData;
3use core::mem::MaybeUninit;
4use core::result;
5use serde::de::{Deserialize, Deserializer, Error, SeqAccess, Visitor};
6use serde::ser::{Serialize, SerializeTuple, Serializer};
7
8pub(crate) struct PartiallyInitialized<T, const N: usize>(
9    pub(crate) Option<MaybeUninit<[T; N]>>,
10    pub(crate) usize,
11);
12
13impl<T, const N: usize> PartiallyInitialized<T, N> {
14    #[inline]
15    pub(crate) fn new() -> Self {
16        PartiallyInitialized(Some(MaybeUninit::uninit()), 0)
17    }
18}
19
20impl<T, const N: usize> Drop for PartiallyInitialized<T, N> {
21    fn drop(&mut self) {
22        if !core::mem::needs_drop::<T>() {
23            return;
24        }
25        if let Some(arr) = &mut self.0 {
26            while self.1 > 0 {
27                self.1 -= 1;
28                let offs = self.1;
29                let p = (arr.as_mut_ptr() as *mut T).wrapping_add(offs);
30                unsafe {
31                    core::ptr::drop_in_place::<T>(p);
32                }
33            }
34        }
35    }
36}
37
38/// The big array serialization helper trait
39///
40/// ```
41/// # use serde_derive::{Serialize, Deserialize};
42/// # use serde_big_array::BigArray;
43/// #[derive(Serialize, Deserialize)]
44/// struct S {
45///     #[serde(with = "BigArray")]
46///     arr: [u8; 64],
47/// }
48/// ```
49pub trait BigArray<'de, T>: Sized {
50    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
51    where
52        S: Serializer,
53        T: Serialize;
54    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
55    where
56        D: Deserializer<'de>,
57        T: Deserialize<'de>;
58}
59
60impl<'de, T, const N: usize> BigArray<'de, T> for [T; N] {
61    fn serialize<S>(&self, serializer: S) -> result::Result<S::Ok, S::Error>
62    where
63        S: Serializer,
64        T: Serialize,
65    {
66        let mut seq = serializer.serialize_tuple(self.len())?;
67        for elem in &self[..] {
68            seq.serialize_element(elem)?;
69        }
70        seq.end()
71    }
72
73    fn deserialize<D>(deserializer: D) -> result::Result<Self, D::Error>
74    where
75        D: Deserializer<'de>,
76        T: Deserialize<'de>,
77    {
78        struct ArrayVisitor<T> {
79            element: PhantomData<T>,
80        }
81
82        impl<'de, T, const N: usize> Visitor<'de> for ArrayVisitor<[T; N]>
83        where
84            T: Deserialize<'de>,
85        {
86            type Value = [T; N];
87
88            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
89                write!(formatter, "an array of length {}", N)
90            }
91
92            fn visit_seq<A>(self, mut seq: A) -> result::Result<[T; N], A::Error>
93            where
94                A: SeqAccess<'de>,
95            {
96                unsafe {
97                    let mut arr = PartiallyInitialized::<T, N>::new();
98                    {
99                        let p = arr.0.as_mut().unwrap();
100                        for i in 0..N {
101                            let p = (p.as_mut_ptr() as *mut T).wrapping_add(i);
102                            let val = seq
103                                .next_element()?
104                                .ok_or_else(|| Error::invalid_length(i, &self))?;
105                            core::ptr::write(p, val);
106                            arr.1 += 1;
107                        }
108                    }
109                    let initialized = arr.0.take().unwrap().assume_init();
110                    Ok(initialized)
111                }
112            }
113        }
114
115        let visitor = ArrayVisitor {
116            element: PhantomData,
117        };
118        // The allow is needed to support (32 + 33) like expressions
119        #[allow(unused_parens)]
120        deserializer.deserialize_tuple(N, visitor)
121    }
122}
serde_big_array/const_generics.rs

serde_big_array/
const_generics.rs
