serde_html_form/de/
part.rs

1use std::borrow::Cow;
2
3use serde::{
4    de::{self, Error as _, IntoDeserializer},
5    forward_to_deserialize_any,
6};
7
8use super::Error;
9
10#[derive(PartialEq, PartialOrd, Eq, Ord, Hash)]
11pub(super) struct Part<'de>(pub Cow<'de, str>);
12
13impl<'de> IntoDeserializer<'de> for Part<'de> {
14    type Deserializer = Self;
15
16    fn into_deserializer(self) -> Self::Deserializer {
17        self
18    }
19}
20
21macro_rules! forward_parsed_value {
22    ($($ty:ident => $method:ident,)*) => {
23        $(
24            fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error>
25                where V: de::Visitor<'de>
26            {
27                match self.0.parse::<$ty>() {
28                    Ok(val) => val.into_deserializer().$method(visitor),
29                    Err(e) => Err(de::Error::custom(e))
30                }
31            }
32        )*
33    }
34}
35
36impl<'de> de::Deserializer<'de> for Part<'de> {
37    type Error = Error;
38
39    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
40    where
41        V: de::Visitor<'de>,
42    {
43        match self.0 {
44            Cow::Borrowed(value) => visitor.visit_borrowed_str(value),
45            Cow::Owned(value) => visitor.visit_string(value),
46        }
47    }
48
49    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
50    where
51        V: de::Visitor<'de>,
52    {
53        if self.0.is_empty() {
54            visitor.visit_none()
55        } else {
56            visitor.visit_some(self)
57        }
58    }
59
60    fn deserialize_enum<V>(
61        self,
62        _name: &'static str,
63        _variants: &'static [&'static str],
64        visitor: V,
65    ) -> Result<V::Value, Self::Error>
66    where
67        V: de::Visitor<'de>,
68    {
69        visitor.visit_enum(self)
70    }
71
72    fn deserialize_newtype_struct<V>(
73        self,
74        _name: &'static str,
75        visitor: V,
76    ) -> Result<V::Value, Self::Error>
77    where
78        V: de::Visitor<'de>,
79    {
80        visitor.visit_newtype_struct(self)
81    }
82
83    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
84    where
85        V: de::Visitor<'de>,
86    {
87        visitor.visit_seq(PartSeqAccess(Some(self)))
88    }
89
90    forward_to_deserialize_any! {
91        char
92        str
93        string
94        unit
95        bytes
96        byte_buf
97        unit_struct
98        tuple_struct
99        struct
100        identifier
101        tuple
102        ignored_any
103        map
104    }
105
106    forward_parsed_value! {
107        bool => deserialize_bool,
108        u8 => deserialize_u8,
109        u16 => deserialize_u16,
110        u32 => deserialize_u32,
111        u64 => deserialize_u64,
112        i8 => deserialize_i8,
113        i16 => deserialize_i16,
114        i32 => deserialize_i32,
115        i64 => deserialize_i64,
116        f32 => deserialize_f32,
117        f64 => deserialize_f64,
118    }
119}
120
121impl<'de> de::EnumAccess<'de> for Part<'de> {
122    type Error = Error;
123    type Variant = UnitOnlyVariantAccess;
124
125    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
126    where
127        V: de::DeserializeSeed<'de>,
128    {
129        let variant = seed.deserialize(self.0.into_deserializer())?;
130        Ok((variant, UnitOnlyVariantAccess))
131    }
132}
133
134struct PartSeqAccess<'de>(Option<Part<'de>>);
135
136impl<'de> de::SeqAccess<'de> for PartSeqAccess<'de> {
137    type Error = Error;
138
139    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
140    where
141        T: de::DeserializeSeed<'de>,
142    {
143        match self.0.take() {
144            Some(value) => seed.deserialize(value).map(Some),
145            None => Ok(None),
146        }
147    }
148
149    fn size_hint(&self) -> Option<usize> {
150        Some(self.0.is_some() as usize)
151    }
152}
153
154pub(crate) struct UnitOnlyVariantAccess;
155
156impl<'de> de::VariantAccess<'de> for UnitOnlyVariantAccess {
157    type Error = Error;
158
159    fn unit_variant(self) -> Result<(), Self::Error> {
160        Ok(())
161    }
162
163    fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
164    where
165        T: de::DeserializeSeed<'de>,
166    {
167        Err(Error::custom("expected unit variant"))
168    }
169
170    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
171    where
172        V: de::Visitor<'de>,
173    {
174        Err(Error::custom("expected unit variant"))
175    }
176
177    fn struct_variant<V>(
178        self,
179        _fields: &'static [&'static str],
180        _visitor: V,
181    ) -> Result<V::Value, Self::Error>
182    where
183        V: de::Visitor<'de>,
184    {
185        Err(Error::custom("expected unit variant"))
186    }
187}
serde_html_form/de/part.rs

serde_html_form/de/
part.rs
