ssi_eip712/value/
deserialize.rs

1use serde::Deserialize;
2
3use crate::{Struct, Value};
4
5impl<'de> Deserialize<'de> for Value {
6    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7    where
8        D: serde::Deserializer<'de>,
9    {
10        struct Visitor;
11
12        impl<'de> serde::de::Visitor<'de> for Visitor {
13            type Value = Value;
14
15            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
16                write!(formatter, "an EIP-712 value")
17            }
18
19            fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
20            where
21                E: serde::de::Error,
22            {
23                Ok(Value::Bool(v))
24            }
25
26            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
27            where
28                E: serde::de::Error,
29            {
30                Ok(Value::Bytes(v))
31            }
32
33            fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
34            where
35                E: serde::de::Error,
36            {
37                Ok(Value::Bytes(v.to_vec()))
38            }
39
40            fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
41            where
42                E: serde::de::Error,
43            {
44                Ok(Value::String(v.to_string()))
45            }
46
47            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
48            where
49                E: serde::de::Error,
50            {
51                Ok(Value::String(v.to_owned()))
52            }
53
54            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
55            where
56                E: serde::de::Error,
57            {
58                Ok(Value::String(v))
59            }
60
61            fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
62            where
63                E: serde::de::Error,
64            {
65                Ok(Value::Integer(v as i64))
66            }
67
68            fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
69            where
70                E: serde::de::Error,
71            {
72                Ok(Value::Integer(v as i64))
73            }
74
75            fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
76            where
77                E: serde::de::Error,
78            {
79                Ok(Value::Integer(v as i64))
80            }
81
82            fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
83            where
84                E: serde::de::Error,
85            {
86                Ok(Value::Integer(v as i64))
87            }
88
89            fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
90            where
91                E: serde::de::Error,
92            {
93                Ok(Value::Integer(v as i64))
94            }
95
96            fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
97            where
98                E: serde::de::Error,
99            {
100                Ok(Value::Integer(v as i64))
101            }
102
103            fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
104            where
105                E: serde::de::Error,
106            {
107                Ok(Value::Integer(v))
108            }
109
110            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
111            where
112                A: serde::de::SeqAccess<'de>,
113            {
114                let mut array = Vec::with_capacity(seq.size_hint().unwrap_or_default());
115                while let Some(elem) = seq.next_element()? {
116                    array.push(elem);
117                }
118
119                Ok(Value::Array(array))
120            }
121
122            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
123            where
124                A: serde::de::MapAccess<'de>,
125            {
126                let mut struct_ = Struct::with_capacity(map.size_hint().unwrap_or_default());
127                while let Some((key, value)) = map.next_entry()? {
128                    struct_.insert(key, value);
129                }
130
131                Ok(Value::Struct(struct_))
132            }
133        }
134
135        deserializer.deserialize_any(Visitor)
136    }
137}