spacetimedb_sats/ser/
impls.rs

1use super::{Serialize, SerializeArray, SerializeSeqProduct, Serializer};
2use crate::{i256, u256};
3use crate::{AlgebraicType, AlgebraicValue, ArrayValue, ProductValue, SumValue, ValueWithType, F32, F64};
4use core::ops::Bound;
5use lean_string::LeanString;
6use smallvec::SmallVec;
7use spacetimedb_primitives::{ColList, ColSet};
8use std::rc::Rc;
9use std::sync::Arc;
10
11/// Implements [`Serialize`] for a type in a simplified manner.
12///
13/// An example:
14/// ```ignore
15/// struct Foo<'a, T: Copy>(&'a T, u8);
16/// impl_serialize!(
17/// //     Type parameters  Optional where  Impl type
18/// //            v               v             v
19/// //   ----------------  --------------- ----------
20///     ['a, T: Serialize] where [T: Copy] Foo<'a, T>,
21/// //  The `serialize` implementation where `self` is serialized into `ser`
22/// //  and the expression right of `=>` is the body of `serialize`.
23///     (self, ser) => {
24///         let mut prod = ser.serialize_seq_product(2)?;
25///         prod.serialize_element(&self.0)?;
26///         prod.serialize_element(&self.1)?;
27///         prod.end()
28///     }
29/// );
30/// ```
31#[macro_export]
32macro_rules! impl_serialize {
33    ([$($generics:tt)*] $(where [$($wc:tt)*])? $typ:ty, ($self:ident, $ser:ident) => $body:expr) => {
34        impl<$($generics)*> $crate::ser::Serialize for $typ $(where $($wc)*)? {
35            fn serialize<S: $crate::ser::Serializer>($self: &Self, $ser: S) -> Result<S::Ok, S::Error> {
36                $body
37            }
38        }
39    };
40}
41
42macro_rules! impl_prim {
43    ($(($prim:ty, $method:ident))*) => {
44        $(impl_serialize!([] $prim, (self, ser) => ser.$method((*self).into()));)*
45    };
46}
47
48// All the tuple types:
49#[macro_export]
50macro_rules! count {
51    () => (0usize);
52    ( $x:tt $($xs:tt)* ) => (1usize + $crate::count!($($xs)*));
53}
54macro_rules! impl_serialize_tuple {
55    ($($ty_name:ident),*) => {
56        impl_serialize!([$($ty_name: Serialize),*] ($($ty_name,)*), (self, ser) => {
57            let mut _tup = ser.serialize_seq_product(count!($($ty_name)*))?;
58            #[allow(non_snake_case)]
59            let ($($ty_name,)*) = self;
60            $(_tup.serialize_element($ty_name)?;)*
61            _tup.end()
62        });
63    };
64}
65impl_serialize_tuple!();
66impl_serialize_tuple!(T0);
67impl_serialize_tuple!(T0, T1);
68impl_serialize_tuple!(T0, T1, T2);
69impl_serialize_tuple!(T0, T1, T2, T3);
70impl_serialize_tuple!(T0, T1, T2, T3, T4);
71impl_serialize_tuple!(T0, T1, T2, T3, T4, T5);
72impl_serialize_tuple!(T0, T1, T2, T3, T4, T5, T6);
73impl_serialize_tuple!(T0, T1, T2, T3, T4, T5, T6, T7);
74impl_serialize_tuple!(T0, T1, T2, T3, T4, T5, T6, T7, T8);
75impl_serialize_tuple!(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9);
76impl_serialize_tuple!(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10);
77impl_serialize_tuple!(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);
78
79// `u8` is implemented below as we wish to provide different `__serialize_array` impl (see below).
80impl_prim! {
81    (bool, serialize_bool)
82                       (u16, serialize_u16) (u32, serialize_u32) (u64, serialize_u64) (u128, serialize_u128) (u256, serialize_u256)
83    (i8, serialize_i8) (i16, serialize_i16) (i32, serialize_i32) (i64, serialize_i64) (i128, serialize_i128) (i256, serialize_i256)
84    (f32, serialize_f32) (f64, serialize_f64) (str, serialize_str)
85}
86
87// TODO(Centril): this special case doesn't seem well motivated.
88// Consider generalizing this to apply to all primitive types
89// so that we can move this into `impl_prim!`.
90// This will make BSATN-serializing `[u32]` faster for example.
91impl Serialize for u8 {
92    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
93        serializer.serialize_u8(*self)
94    }
95
96    fn __serialize_array<S: Serializer>(this: &[Self], serializer: S) -> Result<S::Ok, S::Error>
97    where
98        Self: Sized,
99    {
100        serializer.serialize_bytes(this)
101    }
102}
103
104impl_serialize!([] F32, (self, ser) => f32::from(*self).serialize(ser));
105impl_serialize!([] F64, (self, ser) => f64::from(*self).serialize(ser));
106impl_serialize!([T: Serialize] Vec<T>, (self, ser)  => (**self).serialize(ser));
107impl_serialize!([T: Serialize, const N: usize] SmallVec<[T; N]>, (self, ser)  => (**self).serialize(ser));
108impl_serialize!([T: Serialize] [T], (self, ser) => T::__serialize_array(self, ser));
109impl_serialize!([T: Serialize, const N: usize] [T; N], (self, ser) => T::__serialize_array(self, ser));
110impl_serialize!([T: Serialize + ?Sized] Box<T>, (self, ser) => (**self).serialize(ser));
111impl_serialize!([T: Serialize + ?Sized] Rc<T>, (self, ser) => (**self).serialize(ser));
112impl_serialize!([T: Serialize + ?Sized] Arc<T>, (self, ser) => (**self).serialize(ser));
113impl_serialize!([T: Serialize + ?Sized] &T, (self, ser) => (**self).serialize(ser));
114impl_serialize!([] String, (self, ser) => ser.serialize_str(self));
115impl_serialize!([] LeanString, (self, ser) => ser.serialize_str(self));
116impl_serialize!([T: Serialize] Option<T>, (self, ser) => match self {
117    Some(v) => ser.serialize_variant(0, Some("some"), v),
118    None => ser.serialize_variant(1, Some("none"), &()),
119});
120impl_serialize!([T: Serialize, E: Serialize] Result<T, E>, (self, ser) => match self {
121    Ok(v) => ser.serialize_variant(0, Some("ok"), v),
122    Err(e) => ser.serialize_variant(1, Some("err"), e),
123});
124impl_serialize!([T: Serialize] Bound<T>, (self, ser) => match self {
125    Bound::Included(x) => ser.serialize_variant(0, Some("included"), x),
126    Bound::Excluded(x) => ser.serialize_variant(1, Some("excluded"), x),
127    Bound::Unbounded => ser.serialize_variant(2, Some("unbounded"), &()),
128});
129impl_serialize!([] AlgebraicValue, (self, ser) => match self {
130    Self::Sum(sum) => sum.serialize(ser),
131    Self::Product(prod) => prod.serialize(ser),
132    Self::Array(arr) => arr.serialize(ser),
133    Self::Bool(v) => ser.serialize_bool(*v),
134    Self::I8(v) => ser.serialize_i8(*v),
135    Self::U8(v) => ser.serialize_u8(*v),
136    Self::I16(v) => ser.serialize_i16(*v),
137    Self::U16(v) => ser.serialize_u16(*v),
138    Self::I32(v) => ser.serialize_i32(*v),
139    Self::U32(v) => ser.serialize_u32(*v),
140    Self::I64(v) => ser.serialize_i64(*v),
141    Self::U64(v) => ser.serialize_u64(*v),
142    Self::I128(v) => ser.serialize_i128(v.0),
143    Self::U128(v) => ser.serialize_u128(v.0),
144    Self::I256(v) => ser.serialize_i256(**v),
145    Self::U256(v) => ser.serialize_u256(**v),
146    Self::F32(v) => ser.serialize_f32((*v).into()),
147    Self::F64(v) => ser.serialize_f64((*v).into()),
148    // Self::Bytes(v) => ser.serialize_bytes(v),
149    Self::String(v) => ser.serialize_str(v),
150    Self::Min | Self::Max => panic!("not defined for Min/Max"),
151});
152impl_serialize!([] ProductValue, (self, ser) => {
153    let mut tup = ser.serialize_seq_product(self.elements.len())?;
154    for elem in &*self.elements {
155        tup.serialize_element(elem)?;
156    }
157    tup.end()
158});
159impl_serialize!([] SumValue, (self, ser) => ser.serialize_variant(self.tag, None, &*self.value));
160impl_serialize!([] ArrayValue, (self, ser) => match self {
161    Self::Sum(v) => v.serialize(ser),
162    Self::Product(v) => v.serialize(ser),
163    Self::Bool(v) => v.serialize(ser),
164    Self::I8(v) => v.serialize(ser),
165    Self::U8(v) => v.serialize(ser),
166    Self::I16(v) => v.serialize(ser),
167    Self::U16(v) => v.serialize(ser),
168    Self::I32(v) => v.serialize(ser),
169    Self::U32(v) => v.serialize(ser),
170    Self::I64(v) => v.serialize(ser),
171    Self::U64(v) => v.serialize(ser),
172    Self::I128(v) => v.serialize(ser),
173    Self::U128(v) => v.serialize(ser),
174    Self::I256(v) => v.serialize(ser),
175    Self::U256(v) => v.serialize(ser),
176    Self::F32(v) => v.serialize(ser),
177    Self::F64(v) => v.serialize(ser),
178    Self::String(v) => v.serialize(ser),
179    Self::Array(v) => v.serialize(ser),
180});
181impl_serialize!([] ValueWithType<'_, AlgebraicValue>, (self, ser) => {
182    let mut ty = self.ty();
183    loop { // We're doing this because of `Ref`s.
184        break match (self.value(), ty) {
185            (_, &AlgebraicType::Ref(r)) => {
186                ty = &self.typespace()[r];
187                continue;
188            }
189            (AlgebraicValue::Sum(val), AlgebraicType::Sum(ty)) => self.with(ty, val).serialize(ser),
190            (AlgebraicValue::Product(val), AlgebraicType::Product(ty)) => self.with(ty, val).serialize(ser),
191            (AlgebraicValue::Array(val), AlgebraicType::Array(ty)) => self.with(ty, val).serialize(ser),
192            (AlgebraicValue::Bool(v), AlgebraicType::Bool) => ser.serialize_bool(*v),
193            (AlgebraicValue::I8(v), AlgebraicType::I8) => ser.serialize_i8(*v),
194            (AlgebraicValue::U8(v), AlgebraicType::U8) => ser.serialize_u8(*v),
195            (AlgebraicValue::I16(v), AlgebraicType::I16) => ser.serialize_i16(*v),
196            (AlgebraicValue::U16(v), AlgebraicType::U16) => ser.serialize_u16(*v),
197            (AlgebraicValue::I32(v), AlgebraicType::I32) => ser.serialize_i32(*v),
198            (AlgebraicValue::U32(v), AlgebraicType::U32) => ser.serialize_u32(*v),
199            (AlgebraicValue::I64(v), AlgebraicType::I64) => ser.serialize_i64(*v),
200            (AlgebraicValue::U64(v), AlgebraicType::U64) => ser.serialize_u64(*v),
201            (AlgebraicValue::I128(v), AlgebraicType::I128) => ser.serialize_i128(v.0),
202            (AlgebraicValue::U128(v), AlgebraicType::U128) => ser.serialize_u128(v.0),
203            (AlgebraicValue::I256(v), AlgebraicType::I256) => ser.serialize_i256(**v),
204            (AlgebraicValue::U256(v), AlgebraicType::U256) => ser.serialize_u256(**v),
205            (AlgebraicValue::F32(v), AlgebraicType::F32) => ser.serialize_f32((*v).into()),
206            (AlgebraicValue::F64(v), AlgebraicType::F64) => ser.serialize_f64((*v).into()),
207            (AlgebraicValue::String(s), AlgebraicType::String) => ser.serialize_str(s),
208            (val, ty) => panic!("mismatched value and schema : {val:?} {ty:?}"),
209        };
210    }
211});
212impl_serialize!(
213    [T: crate::Value] where [for<'a> ValueWithType<'a, T>: Serialize]
214    ValueWithType<'_, Box<[T]>>,
215    (self, ser) => {
216        let mut vec = ser.serialize_array(self.value().len())?;
217        for val in self.iter() {
218            vec.serialize_element(&val)?;
219        }
220        vec.end()
221    }
222);
223impl_serialize!([] ValueWithType<'_, SumValue>, (self, ser) => {
224   ser.serialize_variant_raw(self)
225});
226impl_serialize!([] ValueWithType<'_, ProductValue>, (self, ser) => {
227    ser.serialize_named_product_raw(self)
228});
229impl_serialize!([] ValueWithType<'_, ArrayValue>, (self, ser) => {
230    let mut ty = &*self.ty().elem_ty;
231    loop { // We're doing this because of `Ref`s.
232        break match (self.value(), ty) {
233            (_, &AlgebraicType::Ref(r)) => {
234                ty = &self.typespace()[r];
235                continue;
236            }
237            (ArrayValue::Sum(v), AlgebraicType::Sum(ty)) => self.with(ty, v).serialize(ser),
238            (ArrayValue::Product(v), AlgebraicType::Product(ty)) => self.with(ty, v).serialize(ser),
239            (ArrayValue::Bool(v), AlgebraicType::Bool) => v.serialize(ser),
240            (ArrayValue::I8(v), AlgebraicType::I8) => v.serialize(ser),
241            (ArrayValue::U8(v), AlgebraicType::U8) => v.serialize(ser),
242            (ArrayValue::I16(v), AlgebraicType::I16) => v.serialize(ser),
243            (ArrayValue::U16(v), AlgebraicType::U16) => v.serialize(ser),
244            (ArrayValue::I32(v), AlgebraicType::I32) => v.serialize(ser),
245            (ArrayValue::U32(v), AlgebraicType::U32) => v.serialize(ser),
246            (ArrayValue::I64(v), AlgebraicType::I64) => v.serialize(ser),
247            (ArrayValue::U64(v), AlgebraicType::U64) => v.serialize(ser),
248            (ArrayValue::I128(v), AlgebraicType::I128) => v.serialize(ser),
249            (ArrayValue::U128(v), AlgebraicType::U128) => v.serialize(ser),
250            (ArrayValue::I256(v), AlgebraicType::I256) => v.serialize(ser),
251            (ArrayValue::U256(v), AlgebraicType::U256) => v.serialize(ser),
252            (ArrayValue::F32(v), AlgebraicType::F32) => v.serialize(ser),
253            (ArrayValue::F64(v), AlgebraicType::F64) => v.serialize(ser),
254            (ArrayValue::String(v), AlgebraicType::String) => v.serialize(ser),
255            (ArrayValue::Array(v), AlgebraicType::Array(ty)) => self.with(ty, v).serialize(ser),
256            (val, _) if val.is_empty() => ser.serialize_array(0)?.end(),
257            (val, ty) => panic!("mismatched value and schema: {val:?} {ty:?}"),
258        }
259    }
260});
261
262impl_serialize!([] spacetimedb_primitives::ArgId, (self, ser) => ser.serialize_u64(self.0));
263impl_serialize!([] spacetimedb_primitives::TableId, (self, ser) => ser.serialize_u32(self.0));
264impl_serialize!([] spacetimedb_primitives::ViewId, (self, ser) => ser.serialize_u32(self.0));
265impl_serialize!([] spacetimedb_primitives::SequenceId, (self, ser) => ser.serialize_u32(self.0));
266impl_serialize!([] spacetimedb_primitives::IndexId, (self, ser) => ser.serialize_u32(self.0));
267impl_serialize!([] spacetimedb_primitives::ConstraintId, (self, ser) => ser.serialize_u32(self.0));
268impl_serialize!([] spacetimedb_primitives::ColId, (self, ser) => ser.serialize_u16(self.0));
269impl_serialize!([] spacetimedb_primitives::ScheduleId, (self, ser) => ser.serialize_u32(self.0));
270
271impl_serialize!([] ColList, (self, ser) => {
272    let mut arr = ser.serialize_array(self.len() as usize)?;
273       for x in self.iter() {
274           arr.serialize_element(&x)?;
275       }
276       arr.end()
277});
278impl_serialize!([] ColSet, (self, ser) => {
279    let list: &ColList = self;
280    list.serialize(ser)
281});
282
283#[cfg(feature = "blake3")]
284impl_serialize!([] blake3::Hash, (self, ser) => self.as_bytes().serialize(ser));
285
286impl_serialize!([] bytes::Bytes, (self, ser) => ser.serialize_bytes(self));
287
288#[cfg(feature = "bytestring")]
289impl_serialize!([] bytestring::ByteString, (self, ser) => ser.serialize_str(self));
spacetimedb_sats/ser/impls.rs

spacetimedb_sats/ser/
impls.rs
