1use std::fmt::Display;
2
3use serde::{ser::Impossible, Serialize, Serializer};
4
5use crate::Value;
6
7use super::HooksError;
8
9impl Serialize for Value<'_> {
10 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
11 where
12 S: Serializer,
13 {
14 match self {
15 Value::Bool(v) => v.serialize(serializer),
16 Value::I8(v) => v.serialize(serializer),
17 Value::I16(v) => v.serialize(serializer),
18 Value::I32(v) => v.serialize(serializer),
19 Value::I64(v) => v.serialize(serializer),
20 Value::I128(v) => v.serialize(serializer),
21 Value::U8(v) => v.serialize(serializer),
22 Value::U16(v) => v.serialize(serializer),
23 Value::U32(v) => v.serialize(serializer),
24 Value::U64(v) => v.serialize(serializer),
25 Value::U128(v) => v.serialize(serializer),
26 Value::F32(v) => v.serialize(serializer),
27 Value::F64(v) => v.serialize(serializer),
28 Value::Char(v) => v.serialize(serializer),
29 Value::Str(v) => v.serialize(serializer),
30 Value::Bytes(v) => serializer.serialize_bytes(v),
31 Value::Unit => serializer.serialize_unit(),
32 Value::None => serializer.serialize_none(),
33 Value::UnitStruct(name) => serializer.serialize_unit_struct(name),
34 Value::UnitVariant {
35 name,
36 variant_index,
37 variant,
38 } => serializer.serialize_unit_variant(name, *variant_index, variant),
39 _ => Err(serde::ser::Error::custom(format!(
40 "{self} cannot be represented fully in Value"
41 ))),
42 }
43 }
44}
45
46impl Value<'_> {
47 pub(crate) fn check_if_can_serialize(&self) -> Result<(), HooksError> {
48 struct FauxSerializer;
49
50 #[derive(Debug, thiserror::Error)]
51 #[error("{0}")]
52 struct FauxError(String);
53
54 impl serde::ser::Error for FauxError {
55 fn custom<T>(msg: T) -> Self
56 where
57 T: Display,
58 {
59 Self(msg.to_string())
60 }
61 }
62
63 impl Serializer for FauxSerializer {
64 type Ok = ();
65 type Error = FauxError;
66 type SerializeSeq = Impossible<Self::Ok, Self::Error>;
67 type SerializeTuple = Impossible<Self::Ok, Self::Error>;
68 type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
69 type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
70 type SerializeMap = Impossible<Self::Ok, Self::Error>;
71 type SerializeStruct = Impossible<Self::Ok, Self::Error>;
72 type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
73
74 fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
75 Ok(())
76 }
77
78 fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
79 Ok(())
80 }
81
82 fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
83 Ok(())
84 }
85
86 fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
87 Ok(())
88 }
89
90 fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
91 Ok(())
92 }
93
94 fn serialize_i128(self, _v: i128) -> Result<Self::Ok, Self::Error> {
95 Ok(())
96 }
97
98 fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
99 Ok(())
100 }
101
102 fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
103 Ok(())
104 }
105
106 fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
107 Ok(())
108 }
109
110 fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
111 Ok(())
112 }
113
114 fn serialize_u128(self, _v: u128) -> Result<Self::Ok, Self::Error> {
115 Ok(())
116 }
117
118 fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
119 Ok(())
120 }
121
122 fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
123 Ok(())
124 }
125
126 fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
127 Ok(())
128 }
129
130 fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
131 Ok(())
132 }
133
134 fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
135 Ok(())
136 }
137
138 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
139 Ok(())
140 }
141
142 fn serialize_some<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
143 where
144 T: Serialize,
145 {
146 unreachable!()
147 }
148
149 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
150 Ok(())
151 }
152
153 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
154 Ok(())
155 }
156
157 fn serialize_unit_variant(
158 self,
159 _name: &'static str,
160 _variant_index: u32,
161 _variant: &'static str,
162 ) -> Result<Self::Ok, Self::Error> {
163 Ok(())
164 }
165
166 fn serialize_newtype_struct<T: ?Sized>(
167 self,
168 _name: &'static str,
169 _value: &T,
170 ) -> Result<Self::Ok, Self::Error>
171 where
172 T: Serialize,
173 {
174 unreachable!()
175 }
176
177 fn serialize_newtype_variant<T: ?Sized>(
178 self,
179 _name: &'static str,
180 _variant_index: u32,
181 _variant: &'static str,
182 _value: &T,
183 ) -> Result<Self::Ok, Self::Error>
184 where
185 T: Serialize,
186 {
187 unreachable!()
188 }
189
190 fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
191 unreachable!()
192 }
193
194 fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
195 unreachable!()
196 }
197
198 fn serialize_tuple_struct(
199 self,
200 _name: &'static str,
201 _len: usize,
202 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
203 unreachable!()
204 }
205
206 fn serialize_tuple_variant(
207 self,
208 _name: &'static str,
209 _variant_index: u32,
210 _variant: &'static str,
211 _len: usize,
212 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
213 unreachable!()
214 }
215
216 fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
217 unreachable!()
218 }
219
220 fn serialize_struct(
221 self,
222 _name: &'static str,
223 _len: usize,
224 ) -> Result<Self::SerializeStruct, Self::Error> {
225 unreachable!()
226 }
227
228 fn serialize_struct_variant(
229 self,
230 _name: &'static str,
231 _variant_index: u32,
232 _variant: &'static str,
233 _len: usize,
234 ) -> Result<Self::SerializeStructVariant, Self::Error> {
235 unreachable!()
236 }
237 }
238
239 self.serialize(FauxSerializer)
240 .map_err(|err| HooksError::ValueNotSerializable(err.0))
241 }
242}