serde_byte_array/
de.rs

1use crate::ByteArray;
2use core::fmt;
3use core::marker::PhantomData;
4use serde::{
5    de::{Error, Visitor},
6    Deserializer,
7};
8
9/// Types that can be deserialized via `#[serde(with = "serde_byte_array")]`.
10pub trait Deserialize<'de>: Sized {
11    #[allow(missing_docs)]
12    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
13    where
14        D: Deserializer<'de>;
15}
16
17impl<'de, const N: usize> Deserialize<'de> for [u8; N] {
18    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
19    where
20        D: Deserializer<'de>,
21    {
22        let arr: ByteArray<N> = serde::Deserialize::deserialize(deserializer)?;
23        Ok(*arr)
24    }
25}
26
27impl<'de, const N: usize> Deserialize<'de> for ByteArray<N> {
28    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
29    where
30        D: Deserializer<'de>,
31    {
32        // Via the serde::Deserialize impl for ByteArray
33        serde::Deserialize::deserialize(deserializer)
34    }
35}
36
37impl<'de, const N: usize> Deserialize<'de> for &'de ByteArray<N> {
38    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
39    where
40        D: Deserializer<'de>,
41    {
42        // Via the serde::Deserialize impl for &'de ByteArray
43        serde::Deserialize::deserialize(deserializer)
44    }
45}
46
47impl<'de, const N: usize> Deserialize<'de> for &'de [u8; N] {
48    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
49    where
50        D: Deserializer<'de>,
51    {
52        // Via the serde::Deserialize impl for ByteArray
53        <&'de ByteArray<N>>::deserialize(deserializer).map(Into::into)
54    }
55}
56
57impl<'de, T> Deserialize<'de> for Option<T>
58where
59    T: Deserialize<'de>,
60{
61    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
62    where
63        D: Deserializer<'de>,
64    {
65        struct BytesVisitor<T> {
66            out: PhantomData<T>,
67        }
68
69        impl<'de, T> Visitor<'de> for BytesVisitor<T>
70        where
71            T: Deserialize<'de>,
72        {
73            type Value = Option<T>;
74
75            fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
76                f.write_str("optional byte array")
77            }
78
79            fn visit_unit<E: Error>(self) -> Result<Self::Value, E> {
80                Ok(None)
81            }
82
83            fn visit_none<E: Error>(self) -> Result<Self::Value, E> {
84                Ok(None)
85            }
86
87            fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
88            where
89                D: Deserializer<'de>,
90            {
91                T::deserialize(deserializer).map(Some)
92            }
93        }
94
95        let visitor = BytesVisitor { out: PhantomData };
96        deserializer.deserialize_option(visitor)
97    }
98}