postcard_schema/impls/
builtins_nostd.rs

1//! Implementations of the [`Schema`] trait for `core` types
2//!
3//! These implementations are always available
4
5use crate::{
6    schema::{DataModelType, DataModelVariant, NamedType, NamedValue, NamedVariant},
7    Schema,
8};
9use core::{
10    marker::PhantomData,
11    num::{
12        NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroU128, NonZeroU16,
13        NonZeroU32, NonZeroU64, NonZeroU8,
14    },
15    ops::{Range, RangeFrom, RangeInclusive, RangeTo},
16    time::Duration,
17};
18
19macro_rules! impl_schema {
20    ($($t:ty: $sdm:expr),*) => {
21        $(
22            impl Schema for $t {
23                const SCHEMA: &'static NamedType = &NamedType {
24                    name: stringify!($t),
25                    ty: &$sdm,
26                };
27            }
28        )*
29    };
30    (tuple => [$(($($generic:ident),*)),*]) => {
31        $(
32            impl<$($generic: Schema),*> Schema for ($($generic,)*) {
33                const SCHEMA: &'static NamedType = &NamedType {
34                    name: stringify!(($($generic,)*)),
35                    ty: &DataModelType::Tuple(&[$($generic::SCHEMA),*]),
36                };
37            }
38        )*
39    };
40}
41
42impl_schema![
43    u8: DataModelType::U8,
44    NonZeroU8: DataModelType::U8,
45    i8: DataModelType::I8,
46    NonZeroI8: DataModelType::I8,
47    bool: DataModelType::Bool,
48    f32: DataModelType::F32,
49    f64: DataModelType::F64,
50    char: DataModelType::Char,
51    str: DataModelType::String,
52    (): DataModelType::Unit,
53    i16: DataModelType::I16, i32: DataModelType::I32, i64: DataModelType::I64, i128: DataModelType::I128,
54    u16: DataModelType::U16, u32: DataModelType::U32, u64: DataModelType::U64, u128: DataModelType::U128,
55    NonZeroI16: DataModelType::I16, NonZeroI32: DataModelType::I32,
56    NonZeroI64: DataModelType::I64, NonZeroI128: DataModelType::I128,
57    NonZeroU16: DataModelType::U16, NonZeroU32: DataModelType::U32,
58    NonZeroU64: DataModelType::U64, NonZeroU128: DataModelType::U128
59];
60
61impl_schema!(tuple => [
62    (A),
63    (A, B),
64    (A, B, C),
65    (A, B, C, D),
66    (A, B, C, D, E),
67    (A, B, C, D, E, F)
68]);
69
70impl<T: Schema> Schema for Option<T> {
71    const SCHEMA: &'static NamedType = &NamedType {
72        name: "Option<T>",
73        ty: &DataModelType::Option(T::SCHEMA),
74    };
75}
76impl<T: Schema, E: Schema> Schema for Result<T, E> {
77    const SCHEMA: &'static NamedType = &NamedType {
78        name: "Result<T, E>",
79        ty: &DataModelType::Enum(&[
80            &NamedVariant {
81                name: "Ok",
82                ty: &DataModelVariant::TupleVariant(&[T::SCHEMA]),
83            },
84            &NamedVariant {
85                name: "Err",
86                ty: &DataModelVariant::TupleVariant(&[E::SCHEMA]),
87            },
88        ]),
89    };
90}
91
92impl<T: Schema + ?Sized> Schema for &'_ T {
93    const SCHEMA: &'static NamedType = T::SCHEMA;
94}
95
96impl<T: Schema> Schema for [T] {
97    const SCHEMA: &'static NamedType = &NamedType {
98        name: "[T]",
99        ty: &DataModelType::Seq(T::SCHEMA),
100    };
101}
102impl<T: Schema, const N: usize> Schema for [T; N] {
103    const SCHEMA: &'static NamedType = &NamedType {
104        name: "[T; N]",
105        ty: &DataModelType::Tuple(&[T::SCHEMA; N]),
106    };
107}
108
109impl<T: Schema> Schema for Range<T> {
110    const SCHEMA: &'static crate::schema::NamedType = &NamedType {
111        name: "Range<T>",
112        ty: &DataModelType::Struct(&[
113            &NamedValue {
114                name: "start",
115                ty: T::SCHEMA,
116            },
117            &NamedValue {
118                name: "end",
119                ty: T::SCHEMA,
120            },
121        ]),
122    };
123}
124
125impl<T: Schema> Schema for RangeInclusive<T> {
126    const SCHEMA: &'static crate::schema::NamedType = &NamedType {
127        name: "RangeInclusive<T>",
128        ty: &DataModelType::Struct(&[
129            &NamedValue {
130                name: "start",
131                ty: T::SCHEMA,
132            },
133            &NamedValue {
134                name: "end",
135                ty: T::SCHEMA,
136            },
137        ]),
138    };
139}
140
141impl<T: Schema> Schema for RangeFrom<T> {
142    const SCHEMA: &'static crate::schema::NamedType = &NamedType {
143        name: "RangeFrom<T>",
144        ty: &DataModelType::Struct(&[&NamedValue {
145            name: "start",
146            ty: T::SCHEMA,
147        }]),
148    };
149}
150
151impl<T: Schema> Schema for RangeTo<T> {
152    const SCHEMA: &'static crate::schema::NamedType = &NamedType {
153        name: "RangeTo<T>",
154        ty: &DataModelType::Struct(&[&NamedValue {
155            name: "end",
156            ty: T::SCHEMA,
157        }]),
158    };
159}
160
161#[cfg_attr(docsrs, doc(cfg(feature = "core-net")))]
162impl Schema for core::net::Ipv4Addr {
163    const SCHEMA: &'static NamedType = &NamedType {
164        name: "Ipv4Addr",
165        ty: &DataModelType::Struct(&[&NamedValue {
166            name: "octets",
167            ty: <[u8; 4]>::SCHEMA,
168        }]),
169    };
170}
171
172#[cfg_attr(docsrs, doc(cfg(feature = "core-net")))]
173impl Schema for core::net::Ipv6Addr {
174    const SCHEMA: &'static NamedType = &NamedType {
175        name: "Ipv6Addr",
176        ty: &DataModelType::Struct(&[&NamedValue {
177            name: "octets",
178            ty: <[u8; 16]>::SCHEMA,
179        }]),
180    };
181}
182
183#[cfg_attr(docsrs, doc(cfg(feature = "core-net")))]
184impl Schema for core::net::IpAddr {
185    const SCHEMA: &'static NamedType = &NamedType {
186        name: "IpAddr",
187        ty: &DataModelType::Enum(&[
188            &NamedVariant {
189                name: "V4",
190                ty: &DataModelVariant::NewtypeVariant(core::net::Ipv4Addr::SCHEMA),
191            },
192            &NamedVariant {
193                name: "V6",
194                ty: &DataModelVariant::NewtypeVariant(core::net::Ipv6Addr::SCHEMA),
195            },
196        ]),
197    };
198}
199
200#[cfg_attr(docsrs, doc(cfg(feature = "core-net")))]
201impl Schema for core::net::SocketAddrV4 {
202    const SCHEMA: &'static NamedType = &NamedType {
203        name: "SocketAddrV4",
204        ty: &DataModelType::Struct(&[
205            &NamedValue {
206                name: "ip",
207                ty: core::net::Ipv4Addr::SCHEMA,
208            },
209            &NamedValue {
210                name: "port",
211                ty: u16::SCHEMA,
212            },
213        ]),
214    };
215}
216
217#[cfg_attr(docsrs, doc(cfg(feature = "core-net")))]
218impl Schema for core::net::SocketAddrV6 {
219    const SCHEMA: &'static NamedType = &NamedType {
220        name: "SocketAddrV6",
221        ty: &DataModelType::Struct(&[
222            &NamedValue {
223                name: "ip",
224                ty: core::net::Ipv6Addr::SCHEMA,
225            },
226            &NamedValue {
227                name: "port",
228                ty: u16::SCHEMA,
229            },
230            &NamedValue {
231                name: "flowinfo",
232                ty: u32::SCHEMA,
233            },
234            &NamedValue {
235                name: "scope_id",
236                ty: u32::SCHEMA,
237            },
238        ]),
239    };
240}
241
242#[cfg_attr(docsrs, doc(cfg(feature = "core-net")))]
243impl Schema for core::net::SocketAddr {
244    const SCHEMA: &'static NamedType = &NamedType {
245        name: "SocketAddr",
246        ty: &DataModelType::Enum(&[
247            &NamedVariant {
248                name: "V4",
249                ty: &DataModelVariant::NewtypeVariant(core::net::SocketAddrV4::SCHEMA),
250            },
251            &NamedVariant {
252                name: "V6",
253                ty: &DataModelVariant::NewtypeVariant(core::net::SocketAddrV6::SCHEMA),
254            },
255        ]),
256    };
257}
258
259impl<T: Schema> Schema for core::num::Wrapping<T> {
260    const SCHEMA: &'static NamedType = T::SCHEMA;
261}
262
263#[cfg(feature = "core-num-saturating")]
264#[cfg_attr(docsrs, doc(cfg(feature = "core-num-saturating")))]
265impl<T: Schema> Schema for core::num::Saturating<T> {
266    const SCHEMA: &'static NamedType = T::SCHEMA;
267}
268
269impl Schema for Duration {
270    const SCHEMA: &'static NamedType = &NamedType {
271        name: "Duration",
272        ty: &DataModelType::Struct(&[
273            &NamedValue {
274                name: "secs",
275                ty: u64::SCHEMA,
276            },
277            &NamedValue {
278                name: "nanos",
279                ty: u32::SCHEMA,
280            },
281        ]),
282    };
283}
284
285impl<T: ?Sized> Schema for PhantomData<T> {
286    const SCHEMA: &'static NamedType = &NamedType {
287        name: "PhantomData",
288        ty: &DataModelType::Unit,
289    };
290}