1use crate::limits::{ensure, Budget, Failure, Limits, Result};
3use serde::{de, ser, Deserialize, Serialize};
4use std::collections::BTreeMap;
5use structfs_core_store::{CodecErrorKind as K, CodecOperation, Error, Format, Value};
6
7pub fn to_value_with_limits<T: Serialize + ?Sized>(
8 value: &T,
9 limits: &Limits,
10) -> std::result::Result<Value, Error> {
11 value
12 .serialize(Serializer {
13 budget: &mut Budget::new(limits),
14 depth: 0,
15 key: false,
16 })
17 .map_err(|e| e.core(&Format::VALUE, CodecOperation::Encode, limits))
18}
19pub fn from_value_with_limits<T: de::DeserializeOwned>(
20 value: Value,
21 limits: &Limits,
22) -> std::result::Result<T, Error> {
23 Budget::new(limits)
24 .tree(&value, 0)
25 .and_then(|()| T::deserialize(Deserializer(&value)))
26 .map_err(|e| e.core(&Format::VALUE, CodecOperation::Decode, limits))
27}
28pub fn to_value<T: Serialize + ?Sized>(value: &T) -> std::result::Result<Value, Error> {
29 to_value_with_limits(value, &Limits::default())
30}
31pub fn from_value<T: de::DeserializeOwned>(value: Value) -> std::result::Result<T, Error> {
32 from_value_with_limits(value, &Limits::default())
33}
34
35struct Serializer<'a, 'b> {
36 budget: &'a mut Budget<'b>,
37 depth: usize,
38 key: bool,
39}
40impl<'a, 'b> Serializer<'a, 'b> {
41 fn scalar(self, v: Value) -> Result<Value> {
42 ensure(!self.key, K::UnsupportedValue)?;
43 self.budget.node(self.depth)?;
44 Ok(v)
45 }
46 fn compound(self, len: Option<usize>, map: bool) -> Result<Compound<'a, 'b>> {
47 ensure(!self.key, K::UnsupportedValue)?;
48 self.budget.node(self.depth)?;
49 if let Some(n) = len {
50 self.budget.entries(n)?;
51 }
52 Ok(Compound {
53 serializer: self,
54 expected: len,
55 array: Vec::new(),
56 map: BTreeMap::new(),
57 key: None,
58 is_map: map,
59 variant: None,
60 })
61 }
62}
63impl<'a, 'b> ser::Serializer for Serializer<'a, 'b> {
64 type Ok = Value;
65 type Error = Failure;
66 type SerializeSeq = Compound<'a, 'b>;
67 type SerializeTuple = Compound<'a, 'b>;
68 type SerializeTupleStruct = Compound<'a, 'b>;
69 type SerializeTupleVariant = Compound<'a, 'b>;
70 type SerializeMap = Compound<'a, 'b>;
71 type SerializeStruct = Compound<'a, 'b>;
72 type SerializeStructVariant = Compound<'a, 'b>;
73 fn serialize_bool(self, v: bool) -> Result<Value> {
74 self.scalar(Value::Bool(v))
75 }
76 fn serialize_i8(self, v: i8) -> Result<Value> {
77 self.serialize_i64(v.into())
78 }
79 fn serialize_i16(self, v: i16) -> Result<Value> {
80 self.serialize_i64(v.into())
81 }
82 fn serialize_i32(self, v: i32) -> Result<Value> {
83 self.serialize_i64(v.into())
84 }
85 fn serialize_i64(self, v: i64) -> Result<Value> {
86 self.scalar(Value::Integer(v))
87 }
88 fn serialize_i128(self, v: i128) -> Result<Value> {
89 if v < 0 {
90 self.serialize_i64(v.try_into().map_err(|_| Failure(K::OutOfRange))?)
91 } else {
92 self.serialize_u64(v.try_into().map_err(|_| Failure(K::OutOfRange))?)
93 }
94 }
95 fn serialize_u8(self, v: u8) -> Result<Value> {
96 self.serialize_u64(v.into())
97 }
98 fn serialize_u16(self, v: u16) -> Result<Value> {
99 self.serialize_u64(v.into())
100 }
101 fn serialize_u32(self, v: u32) -> Result<Value> {
102 self.serialize_u64(v.into())
103 }
104 fn serialize_u64(self, v: u64) -> Result<Value> {
105 self.scalar(Value::from(v))
106 }
107 fn serialize_u128(self, v: u128) -> Result<Value> {
108 self.serialize_u64(v.try_into().map_err(|_| Failure(K::OutOfRange))?)
109 }
110 fn serialize_f32(self, v: f32) -> Result<Value> {
111 self.serialize_f64(v.into())
112 }
113 fn serialize_f64(self, v: f64) -> Result<Value> {
114 self.scalar(Value::from(v))
115 }
116 fn serialize_char(self, v: char) -> Result<Value> {
117 ensure(!self.key, K::UnsupportedValue)?;
118 self.serialize_str(v.encode_utf8(&mut [0; 4]))
119 }
120 fn serialize_str(self, v: &str) -> Result<Value> {
121 if !self.key {
122 self.budget.node(self.depth)?;
123 }
124 self.budget.payload(v.len(), false)?;
125 Ok(Value::String(v.into()))
126 }
127 fn serialize_bytes(self, v: &[u8]) -> Result<Value> {
128 ensure(!self.key, K::UnsupportedValue)?;
129 self.budget.payload(v.len(), true)?;
130 self.scalar(Value::Bytes(v.into()))
131 }
132 fn serialize_none(self) -> Result<Value> {
133 self.scalar(Value::Null)
134 }
135 fn serialize_some<T: Serialize + ?Sized>(self, v: &T) -> Result<Value> {
136 ensure(!self.key, K::UnsupportedValue)?;
137 let value = v.serialize(self)?;
138 ensure(!value.is_null(), K::AmbiguousOption)?;
139 Ok(value)
140 }
141 fn serialize_unit(self) -> Result<Value> {
142 self.scalar(Value::Null)
143 }
144 fn serialize_unit_struct(self, _: &'static str) -> Result<Value> {
145 self.serialize_unit()
146 }
147 fn serialize_unit_variant(self, _: &'static str, _: u32, v: &'static str) -> Result<Value> {
148 ensure(!self.key, K::UnsupportedValue)?;
149 self.serialize_str(v)
150 }
151 fn serialize_newtype_struct<T: Serialize + ?Sized>(
152 self,
153 _: &'static str,
154 v: &T,
155 ) -> Result<Value> {
156 v.serialize(self)
157 }
158 fn serialize_newtype_variant<T: Serialize + ?Sized>(
159 self,
160 _: &'static str,
161 _: u32,
162 k: &'static str,
163 v: &T,
164 ) -> Result<Value> {
165 let mut c = self.compound(Some(1), true)?;
166 ser::SerializeMap::serialize_entry(&mut c, k, v)?;
167 c.finish()
168 }
169 fn serialize_seq(self, n: Option<usize>) -> Result<Self::SerializeSeq> {
170 self.compound(n, false)
171 }
172 fn serialize_tuple(self, n: usize) -> Result<Self::SerializeTuple> {
173 self.compound(Some(n), false)
174 }
175 fn serialize_tuple_struct(
176 self,
177 _: &'static str,
178 n: usize,
179 ) -> Result<Self::SerializeTupleStruct> {
180 self.compound(Some(n), false)
181 }
182 fn serialize_tuple_variant(
183 self,
184 _: &'static str,
185 _: u32,
186 k: &'static str,
187 n: usize,
188 ) -> Result<Self::SerializeTupleVariant> {
189 self.variant(k, n, false)
190 }
191 fn serialize_map(self, n: Option<usize>) -> Result<Self::SerializeMap> {
192 self.compound(n, true)
193 }
194 fn serialize_struct(self, _: &'static str, n: usize) -> Result<Self::SerializeStruct> {
195 self.compound(Some(n), true)
196 }
197 fn serialize_struct_variant(
198 self,
199 _: &'static str,
200 _: u32,
201 k: &'static str,
202 n: usize,
203 ) -> Result<Self::SerializeStructVariant> {
204 self.variant(k, n, true)
205 }
206 fn is_human_readable(&self) -> bool {
207 true
208 }
209 fn collect_str<T: std::fmt::Display + ?Sized>(self, value: &T) -> Result<Value> {
210 use std::fmt::Write;
211 ensure(!self.key, K::UnsupportedValue)?;
212 struct Bounded {
213 text: String,
214 max: usize,
215 }
216 impl std::fmt::Write for Bounded {
217 fn write_str(&mut self, s: &str) -> std::fmt::Result {
218 if s.len() > self.max.saturating_sub(self.text.len()) {
219 return Err(std::fmt::Error);
220 }
221 self.text.push_str(s);
222 Ok(())
223 }
224 }
225 let max = self
226 .budget
227 .limits
228 .max_string_bytes
229 .min(self.budget.limits.max_allocation_bytes)
230 .min(self.budget.limits.max_work);
231 let mut out = Bounded {
232 text: String::new(),
233 max,
234 };
235 write!(&mut out, "{value}").map_err(|_| Failure(K::ResourceLimit))?;
236 self.serialize_str(&out.text)
237 }
238}
239impl<'a, 'b> Serializer<'a, 'b> {
240 fn variant(mut self, k: &'static str, n: usize, map: bool) -> Result<Compound<'a, 'b>> {
241 ensure(!self.key, K::UnsupportedValue)?;
242 self.budget.node(self.depth)?;
243 self.budget.entries(1)?;
244 self.budget.payload(k.len(), false)?;
245 self.depth += 1;
246 let mut c = self.compound(Some(n), map)?;
247 c.variant = Some(k);
248 Ok(c)
249 }
250}
251struct Compound<'a, 'b> {
252 serializer: Serializer<'a, 'b>,
253 expected: Option<usize>,
254 array: Vec<Value>,
255 map: BTreeMap<String, Value>,
256 key: Option<String>,
257 is_map: bool,
258 variant: Option<&'static str>,
259}
260impl Compound<'_, '_> {
261 fn element<T: Serialize + ?Sized>(&mut self, v: &T) -> Result<()> {
262 self.serializer.budget.entries(self.array.len() + 1)?;
263 let value = v.serialize(Serializer {
264 budget: self.serializer.budget,
265 depth: self.serializer.depth + 1,
266 key: false,
267 })?;
268 self.array.push(value);
269 Ok(())
270 }
271 fn finish(self) -> Result<Value> {
272 ensure(self.key.is_none(), K::TypeMismatch)?;
273 let n = if self.is_map {
274 self.map.len()
275 } else {
276 self.array.len()
277 };
278 ensure(self.expected.is_none_or(|e| e == n), K::TypeMismatch)?;
279 let v = if self.is_map {
280 Value::Map(self.map)
281 } else {
282 Value::Array(self.array)
283 };
284 Ok(if let Some(k) = self.variant {
285 Value::Map(BTreeMap::from([(k.to_owned(), v)]))
286 } else {
287 v
288 })
289 }
290}
291impl ser::SerializeMap for Compound<'_, '_> {
292 type Ok = Value;
293 type Error = Failure;
294 fn serialize_key<T: Serialize + ?Sized>(&mut self, k: &T) -> Result<()> {
295 ensure(self.key.is_none(), K::TypeMismatch)?;
296 self.serializer.budget.entries(self.map.len() + 1)?;
297 let key = k.serialize(Serializer {
298 budget: self.serializer.budget,
299 depth: self.serializer.depth,
300 key: true,
301 })?;
302 let Value::String(key) = key else {
303 return Err(Failure(K::UnsupportedValue));
304 };
305 self.serializer
306 .budget
307 .key_work(key.len(), self.map.len() + 1)?;
308 ensure(!self.map.contains_key(&key), K::DuplicateKey)?;
309 self.key = Some(key);
310 Ok(())
311 }
312 fn serialize_value<T: Serialize + ?Sized>(&mut self, v: &T) -> Result<()> {
313 let k = self.key.take().ok_or(Failure(K::TypeMismatch))?;
314 let v = v.serialize(Serializer {
315 budget: self.serializer.budget,
316 depth: self.serializer.depth + 1,
317 key: false,
318 })?;
319 self.map.insert(k, v);
320 Ok(())
321 }
322 fn end(self) -> Result<Value> {
323 self.finish()
324 }
325}
326macro_rules! seq_impl {
327 ($trait:ident,$method:ident) => {
328 impl ser::$trait for Compound<'_, '_> {
329 type Ok = Value;
330 type Error = Failure;
331 fn $method<T: Serialize + ?Sized>(&mut self, v: &T) -> Result<()> {
332 self.element(v)
333 }
334 fn end(self) -> Result<Value> {
335 self.finish()
336 }
337 }
338 };
339}
340seq_impl!(SerializeSeq, serialize_element);
341seq_impl!(SerializeTuple, serialize_element);
342seq_impl!(SerializeTupleStruct, serialize_field);
343seq_impl!(SerializeTupleVariant, serialize_field);
344macro_rules! struct_impl {
345 ($trait:ident) => {
346 impl ser::$trait for Compound<'_, '_> {
347 type Ok = Value;
348 type Error = Failure;
349 fn serialize_field<T: Serialize + ?Sized>(
350 &mut self,
351 k: &'static str,
352 v: &T,
353 ) -> Result<()> {
354 ser::SerializeMap::serialize_entry(self, k, v)
355 }
356 fn end(self) -> Result<Value> {
357 self.finish()
358 }
359 }
360 };
361}
362struct_impl!(SerializeStruct);
363struct_impl!(SerializeStructVariant);
364
365struct Deserializer<'de>(&'de Value);
366macro_rules! integer {
367 ($method:ident,$visit:ident,$ty:ty) => {
368 fn $method<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
369 let n = match self.0 {
370 Value::Integer(n) => *n as i128,
371 Value::Unsigned(n) => *n as i128,
372 _ => return Err(Failure(K::TypeMismatch)),
373 };
374 v.$visit(<$ty>::try_from(n).map_err(|_| Failure(K::OutOfRange))?)
375 }
376 };
377}
378impl<'de> de::Deserializer<'de> for Deserializer<'de> {
379 type Error = Failure;
380 fn deserialize_any<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
381 match self.0 {
382 Value::Null => v.visit_unit(),
383 Value::Bool(x) => v.visit_bool(*x),
384 Value::Integer(x) => v.visit_i64(*x),
385 Value::Unsigned(x) if *x <= i64::MAX as u64 => v.visit_i64(*x as i64),
386 Value::Unsigned(x) => v.visit_u64(*x),
387 Value::Float(x) => v.visit_f64(if x.is_nan() {
388 f64::from_bits(0x7ff8000000000000)
389 } else {
390 *x
391 }),
392 Value::String(x) => v.visit_borrowed_str(x),
393 Value::Bytes(x) => v.visit_borrowed_bytes(x),
394 Value::Array(_) => self.deserialize_seq(v),
395 Value::Map(_) => self.deserialize_map(v),
396 _ => Err(Failure(K::UnsupportedValue)),
397 }
398 }
399 integer!(deserialize_i8, visit_i8, i8);
400 integer!(deserialize_i16, visit_i16, i16);
401 integer!(deserialize_i32, visit_i32, i32);
402 integer!(deserialize_i64, visit_i64, i64);
403 integer!(deserialize_i128, visit_i128, i128);
404 integer!(deserialize_u8, visit_u8, u8);
405 integer!(deserialize_u16, visit_u16, u16);
406 integer!(deserialize_u32, visit_u32, u32);
407 integer!(deserialize_u64, visit_u64, u64);
408 integer!(deserialize_u128, visit_u128, u128);
409 fn deserialize_bool<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
410 if let Value::Bool(x) = self.0 {
411 v.visit_bool(*x)
412 } else {
413 Err(Failure(K::TypeMismatch))
414 }
415 }
416 fn deserialize_f64<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
417 if let Value::Float(_) = self.0 {
418 self.deserialize_any(v)
419 } else {
420 Err(Failure(K::TypeMismatch))
421 }
422 }
423 fn deserialize_f32<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
424 let Value::Float(x) = self.0 else {
425 return Err(Failure(K::TypeMismatch));
426 };
427 if x.is_nan() {
428 return v.visit_f32(f32::from_bits(0x7fc00000));
429 }
430 let f = *x as f32;
431 ensure((f as f64).to_bits() == x.to_bits(), K::OutOfRange)?;
432 v.visit_f32(f)
433 }
434 fn deserialize_str<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
435 if let Value::String(x) = self.0 {
436 v.visit_borrowed_str(x)
437 } else {
438 Err(Failure(K::TypeMismatch))
439 }
440 }
441 fn deserialize_string<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
442 self.deserialize_str(v)
443 }
444 fn deserialize_char<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
445 let Value::String(x) = self.0 else {
446 return Err(Failure(K::TypeMismatch));
447 };
448 let mut c = x.chars();
449 let first = c.next().ok_or(Failure(K::TypeMismatch))?;
450 ensure(c.next().is_none(), K::TypeMismatch)?;
451 v.visit_char(first)
452 }
453 fn deserialize_bytes<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
454 if let Value::Bytes(x) = self.0 {
455 v.visit_borrowed_bytes(x)
456 } else {
457 Err(Failure(K::TypeMismatch))
458 }
459 }
460 fn deserialize_byte_buf<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
461 self.deserialize_bytes(v)
462 }
463 fn deserialize_option<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
464 if self.0.is_null() {
465 v.visit_none()
466 } else {
467 v.visit_some(self)
468 }
469 }
470 fn deserialize_unit<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
471 ensure(self.0.is_null(), K::TypeMismatch)?;
472 v.visit_unit()
473 }
474 fn deserialize_unit_struct<V: de::Visitor<'de>>(
475 self,
476 _: &'static str,
477 v: V,
478 ) -> Result<V::Value> {
479 self.deserialize_unit(v)
480 }
481 fn deserialize_newtype_struct<V: de::Visitor<'de>>(
482 self,
483 _: &'static str,
484 v: V,
485 ) -> Result<V::Value> {
486 v.visit_newtype_struct(self)
487 }
488 fn deserialize_seq<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
489 let Value::Array(a) = self.0 else {
490 return Err(Failure(K::TypeMismatch));
491 };
492 let mut access = Sequence(a.iter());
493 let result = v.visit_seq(&mut access)?;
494 ensure(access.0.len() == 0, K::TypeMismatch)?;
495 Ok(result)
496 }
497 fn deserialize_tuple<V: de::Visitor<'de>>(self, n: usize, v: V) -> Result<V::Value> {
498 ensure(
499 matches!(self.0,Value::Array(a) if a.len()==n),
500 K::TypeMismatch,
501 )?;
502 self.deserialize_seq(v)
503 }
504 fn deserialize_tuple_struct<V: de::Visitor<'de>>(
505 self,
506 _: &'static str,
507 n: usize,
508 v: V,
509 ) -> Result<V::Value> {
510 self.deserialize_tuple(n, v)
511 }
512 fn deserialize_map<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
513 let Value::Map(m) = self.0 else {
514 return Err(Failure(K::TypeMismatch));
515 };
516 let mut access = Mapping {
517 iter: m.iter(),
518 pending: None,
519 };
520 let result = v.visit_map(&mut access)?;
521 ensure(
522 access.iter.len() == 0 && access.pending.is_none(),
523 K::TypeMismatch,
524 )?;
525 Ok(result)
526 }
527 fn deserialize_struct<V: de::Visitor<'de>>(
528 self,
529 _: &'static str,
530 _: &'static [&'static str],
531 v: V,
532 ) -> Result<V::Value> {
533 self.deserialize_map(v)
534 }
535 fn deserialize_enum<V: de::Visitor<'de>>(
536 self,
537 _: &'static str,
538 _: &'static [&'static str],
539 v: V,
540 ) -> Result<V::Value> {
541 let (name, payload) = match self.0 {
542 Value::String(s) => (s.as_str(), None),
543 Value::Map(m) if m.len() == 1 => {
544 let (k, v) = m.first_key_value().unwrap();
545 (k.as_str(), Some(v))
546 }
547 _ => return Err(Failure(K::TypeMismatch)),
548 };
549 v.visit_enum(Enum { name, payload })
550 }
551 fn deserialize_identifier<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
552 self.deserialize_str(v)
553 }
554 fn deserialize_ignored_any<V: de::Visitor<'de>>(self, v: V) -> Result<V::Value> {
555 v.visit_unit()
556 }
557 fn is_human_readable(&self) -> bool {
558 true
559 }
560}
561struct Sequence<'a>(std::slice::Iter<'a, Value>);
562impl<'de> de::SeqAccess<'de> for Sequence<'de> {
563 type Error = Failure;
564 fn next_element_seed<T: de::DeserializeSeed<'de>>(&mut self, s: T) -> Result<Option<T::Value>> {
565 self.0
566 .next()
567 .map(|v| s.deserialize(Deserializer(v)))
568 .transpose()
569 }
570 fn size_hint(&self) -> Option<usize> {
571 Some(self.0.len())
572 }
573}
574struct Mapping<'a> {
575 iter: std::collections::btree_map::Iter<'a, String, Value>,
576 pending: Option<&'a Value>,
577}
578impl<'de> de::MapAccess<'de> for Mapping<'de> {
579 type Error = Failure;
580 fn next_key_seed<T: de::DeserializeSeed<'de>>(&mut self, s: T) -> Result<Option<T::Value>> {
581 ensure(self.pending.is_none(), K::TypeMismatch)?;
582 if let Some((k, v)) = self.iter.next() {
583 self.pending = Some(v);
584 s.deserialize(de::value::BorrowedStrDeserializer::<Failure>::new(k))
585 .map(Some)
586 } else {
587 Ok(None)
588 }
589 }
590 fn next_value_seed<T: de::DeserializeSeed<'de>>(&mut self, s: T) -> Result<T::Value> {
591 s.deserialize(Deserializer(
592 self.pending.take().ok_or(Failure(K::TypeMismatch))?,
593 ))
594 }
595 fn size_hint(&self) -> Option<usize> {
596 Some(self.iter.len())
597 }
598}
599struct Enum<'a> {
600 name: &'a str,
601 payload: Option<&'a Value>,
602}
603impl<'de> de::EnumAccess<'de> for Enum<'de> {
604 type Error = Failure;
605 type Variant = Self;
606 fn variant_seed<T: de::DeserializeSeed<'de>>(self, s: T) -> Result<(T::Value, Self)> {
607 let n = s.deserialize(de::value::BorrowedStrDeserializer::<Failure>::new(
608 self.name,
609 ))?;
610 Ok((n, self))
611 }
612}
613impl<'de> de::VariantAccess<'de> for Enum<'de> {
614 type Error = Failure;
615 fn unit_variant(self) -> Result<()> {
616 ensure(self.payload.is_none(), K::TypeMismatch)
617 }
618 fn newtype_variant_seed<T: de::DeserializeSeed<'de>>(self, s: T) -> Result<T::Value> {
619 s.deserialize(Deserializer(self.payload.ok_or(Failure(K::TypeMismatch))?))
620 }
621 fn tuple_variant<V: de::Visitor<'de>>(self, n: usize, v: V) -> Result<V::Value> {
622 de::Deserializer::deserialize_tuple(
623 Deserializer(self.payload.ok_or(Failure(K::TypeMismatch))?),
624 n,
625 v,
626 )
627 }
628 fn struct_variant<V: de::Visitor<'de>>(
629 self,
630 _: &'static [&'static str],
631 v: V,
632 ) -> Result<V::Value> {
633 de::Deserializer::deserialize_map(
634 Deserializer(self.payload.ok_or(Failure(K::TypeMismatch))?),
635 v,
636 )
637 }
638}
639
640#[derive(Debug, Clone, PartialEq, Eq)]
642pub struct ExplicitOption<T>(pub Option<T>);
643impl<T: Serialize> Serialize for ExplicitOption<T> {
644 fn serialize<S: ser::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
645 use ser::SerializeMap;
646 let mut m = s.serialize_map(Some(if self.0.is_some() { 2 } else { 1 }))?;
647 m.serialize_entry("kind", if self.0.is_some() { "some" } else { "none" })?;
648 if let Some(v) = &self.0 {
649 m.serialize_entry("value", v)?;
650 }
651 m.end()
652 }
653}
654impl<'de, T: Deserialize<'de>> Deserialize<'de> for ExplicitOption<T> {
655 fn deserialize<D: de::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
656 struct Visitor<T>(std::marker::PhantomData<T>);
657 impl<'de, T: Deserialize<'de>> de::Visitor<'de> for Visitor<T> {
658 type Value = ExplicitOption<T>;
659 fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
660 f.write_str("an explicit option map")
661 }
662 fn visit_map<A: de::MapAccess<'de>>(
663 self,
664 mut a: A,
665 ) -> std::result::Result<Self::Value, A::Error> {
666 let mut kind: Option<String> = None;
667 let mut value: Option<T> = None;
668 while let Some(k) = a.next_key::<String>()? {
669 match k.as_str() {
670 "kind" if kind.is_none() => kind = Some(a.next_value()?),
671 "value" if value.is_none() => value = Some(a.next_value()?),
672 _ => {
673 return Err(de::Error::custom(
674 "extra or repeated explicit option field",
675 ))
676 }
677 }
678 }
679 match (kind.as_deref(), value) {
680 (Some("none"), None) => Ok(ExplicitOption(None)),
681 (Some("some"), Some(v)) => Ok(ExplicitOption(Some(v))),
682 _ => Err(de::Error::custom("invalid explicit option shape")),
683 }
684 }
685 }
686 d.deserialize_map(Visitor(std::marker::PhantomData))
687 }
688}