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