Skip to main content

substrate_data/schema/plain/
wrappers.rs

1//! The schemas of `Option` and `Box`: their content's.
2
3use crate::binary::{Decoder, Writer};
4use crate::frame::{Packer, Unpacker};
5use crate::model::borrowed::ValueRef;
6use crate::model::value::Value;
7use crate::schema::{Reader, Schema, Shape};
8
9impl<T: Schema> Schema for Option<T> {
10    fn shape() -> Shape {
11        Shape::Optional(T::shape)
12    }
13    fn read(v: &ValueRef<'_>, cx: &mut Reader<'_>) -> Option<Self> {
14        if v.is_null() {
15            Some(None)
16        } else {
17            T::read(v, cx).map(Some)
18        }
19    }
20    fn write(&self) -> Value {
21        self.as_ref().map_or(Value::Null, T::write)
22    }
23    fn encode(&self, w: &mut Writer) {
24        match self {
25            Some(v) => v.encode(w),
26            None => {
27                w.null();
28            }
29        }
30    }
31    fn decode(d: &mut Decoder<'_>) -> Option<Self> {
32        if d.null() {
33            Some(None)
34        } else {
35            T::decode(d).map(Some)
36        }
37    }
38    fn pack(&self, p: &mut Packer) {
39        p.put_bool(self.is_some());
40        if let Some(v) = self {
41            v.pack(p);
42        }
43    }
44    fn unpack(u: &mut Unpacker<'_>) -> Option<Self> {
45        if u.bool()? {
46            T::unpack(u).map(Some)
47        } else {
48            Some(None)
49        }
50    }
51    fn absent() -> Option<Self> {
52        Some(None)
53    }
54    fn skip(&self) -> bool {
55        self.is_none()
56    }
57}
58
59impl<T: Schema> Schema for Box<T> {
60    fn shape() -> Shape {
61        T::shape()
62    }
63    fn read(v: &ValueRef<'_>, cx: &mut Reader<'_>) -> Option<Self> {
64        T::read(v, cx).map(Box::new)
65    }
66    fn write(&self) -> Value {
67        (**self).write()
68    }
69    fn encode(&self, w: &mut Writer) {
70        (**self).encode(w);
71    }
72    fn decode(d: &mut Decoder<'_>) -> Option<Self> {
73        T::decode(d).map(Box::new)
74    }
75    fn pack(&self, p: &mut Packer) {
76        (**self).pack(p);
77    }
78    fn unpack(u: &mut Unpacker<'_>) -> Option<Self> {
79        T::unpack(u).map(Box::new)
80    }
81    fn absent() -> Option<Self> {
82        T::absent().map(Box::new)
83    }
84    fn skip(&self) -> bool {
85        (**self).skip()
86    }
87}