use spacetimedb_primitives::ColList;
use std::collections::BTreeMap;
use crate::{
AlgebraicType, AlgebraicValue, ArrayValue, MapType, MapValue, ProductValue, SumValue, ValueWithType, F32, F64,
};
use super::{Serialize, SerializeArray, SerializeMap, SerializeNamedProduct, SerializeSeqProduct, Serializer};
#[macro_export]
macro_rules! impl_serialize {
([$($generics:tt)*] $(where [$($wc:tt)*])? $typ:ty, ($self:ident, $ser:ident) => $body:expr) => {
impl<$($generics)*> $crate::ser::Serialize for $typ $(where $($wc)*)? {
fn serialize<S: $crate::ser::Serializer>($self: &Self, $ser: S) -> Result<S::Ok, S::Error> {
$body
}
}
};
}
macro_rules! impl_prim {
($(($prim:ty, $method:ident))*) => {
$(impl_serialize!([] $prim, (self, ser) => ser.$method((*self).into()));)*
};
}
impl_serialize!([] (), (self, ser) => ser.serialize_seq_product(0)?.end());
impl_prim! {
(bool, serialize_bool) (u16, serialize_u16)
(u32, serialize_u32) (u64, serialize_u64) (u128, serialize_u128) (i8, serialize_i8)
(i16, serialize_i16) (i32, serialize_i32) (i64, serialize_i64) (i128, serialize_i128)
(f32, serialize_f32) (f64, serialize_f64) (str, serialize_str)
}
impl Serialize for u8 {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_u8(*self)
}
fn __serialize_array<S: Serializer>(this: &[Self], serializer: S) -> Result<S::Ok, S::Error>
where
Self: Sized,
{
serializer.serialize_bytes(this)
}
}
impl_serialize!([] F32, (self, ser) => f32::from(*self).serialize(ser));
impl_serialize!([] F64, (self, ser) => f64::from(*self).serialize(ser));
impl_serialize!([T: Serialize] Vec<T>, (self, ser) => (**self).serialize(ser));
impl_serialize!([T: Serialize] [T], (self, ser) => T::__serialize_array(self, ser));
impl_serialize!([T: Serialize, const N: usize] [T; N], (self, ser) => T::__serialize_array(self, ser));
impl_serialize!([T: Serialize + ?Sized] Box<T>, (self, ser) => (**self).serialize(ser));
impl_serialize!([T: Serialize + ?Sized] &T, (self, ser) => (**self).serialize(ser));
impl_serialize!([] String, (self, ser) => ser.serialize_str(self));
impl_serialize!([T: Serialize] Option<T>, (self, ser) => match self {
Some(v) => ser.serialize_variant(0, Some("some"), v),
None => ser.serialize_variant(1, Some("none"), &()),
});
impl_serialize!([T: Serialize, E: Serialize] Result<T, E>, (self, ser) => match self {
Ok(v) => ser.serialize_variant(0, Some("ok"), v),
Err(e) => ser.serialize_variant(1, Some("err"), e),
});
impl_serialize!([K: Serialize, V: Serialize] BTreeMap<K, V>, (self, ser) => {
let mut map = ser.serialize_map(self.len())?;
for (k, v) in self {
map.serialize_entry(k, v)?;
}
map.end()
});
impl_serialize!([] AlgebraicValue, (self, ser) => match self {
Self::Sum(sum) => sum.serialize(ser),
Self::Product(prod) => prod.serialize(ser),
Self::Array(arr) => arr.serialize(ser),
Self::Map(map) => map.serialize(ser),
Self::Bool(v) => ser.serialize_bool(*v),
Self::I8(v) => ser.serialize_i8(*v),
Self::U8(v) => ser.serialize_u8(*v),
Self::I16(v) => ser.serialize_i16(*v),
Self::U16(v) => ser.serialize_u16(*v),
Self::I32(v) => ser.serialize_i32(*v),
Self::U32(v) => ser.serialize_u32(*v),
Self::I64(v) => ser.serialize_i64(*v),
Self::U64(v) => ser.serialize_u64(*v),
Self::I128(v) => ser.serialize_i128(*v),
Self::U128(v) => ser.serialize_u128(*v),
Self::F32(v) => ser.serialize_f32((*v).into()),
Self::F64(v) => ser.serialize_f64((*v).into()),
Self::String(v) => ser.serialize_str(v),
});
impl_serialize!([] ProductValue, (self, ser) => {
let mut tup = ser.serialize_seq_product(self.elements.len())?;
for elem in &*self.elements {
tup.serialize_element(elem)?;
}
tup.end()
});
impl_serialize!([] SumValue, (self, ser) => ser.serialize_variant(self.tag, None, &*self.value));
impl_serialize!([] ArrayValue, (self, ser) => match self {
Self::Sum(v) => v.serialize(ser),
Self::Product(v) => v.serialize(ser),
Self::Bool(v) => v.serialize(ser),
Self::I8(v) => v.serialize(ser),
Self::U8(v) => v.serialize(ser),
Self::I16(v) => v.serialize(ser),
Self::U16(v) => v.serialize(ser),
Self::I32(v) => v.serialize(ser),
Self::U32(v) => v.serialize(ser),
Self::I64(v) => v.serialize(ser),
Self::U64(v) => v.serialize(ser),
Self::I128(v) => v.serialize(ser),
Self::U128(v) => v.serialize(ser),
Self::F32(v) => v.serialize(ser),
Self::F64(v) => v.serialize(ser),
Self::String(v) => v.serialize(ser),
Self::Array(v) => v.serialize(ser),
Self::Map(v) => v.serialize(ser),
});
impl_serialize!([] ValueWithType<'_, AlgebraicValue>, (self, ser) => {
let mut ty = self.ty();
loop { break match (self.value(), ty) {
(_, &AlgebraicType::Ref(r)) => {
ty = &self.typespace()[r];
continue;
}
(AlgebraicValue::Sum(val), AlgebraicType::Sum(ty)) => self.with(ty, val).serialize(ser),
(AlgebraicValue::Product(val), AlgebraicType::Product(ty)) => self.with(ty, val).serialize(ser),
(AlgebraicValue::Array(val), AlgebraicType::Builtin(crate::BuiltinType::Array(ty))) => self.with(ty, val).serialize(ser),
(AlgebraicValue::Map(val), AlgebraicType::Builtin(crate::BuiltinType::Map(ty))) => self.with(&**ty, val).serialize(ser),
(AlgebraicValue::Bool(v), &AlgebraicType::Bool) => ser.serialize_bool(*v),
(AlgebraicValue::I8(v), &AlgebraicType::I8) => ser.serialize_i8(*v),
(AlgebraicValue::U8(v), &AlgebraicType::U8) => ser.serialize_u8(*v),
(AlgebraicValue::I16(v), &AlgebraicType::I16) => ser.serialize_i16(*v),
(AlgebraicValue::U16(v), &AlgebraicType::U16) => ser.serialize_u16(*v),
(AlgebraicValue::I32(v), &AlgebraicType::I32) => ser.serialize_i32(*v),
(AlgebraicValue::U32(v), &AlgebraicType::U32) => ser.serialize_u32(*v),
(AlgebraicValue::I64(v), &AlgebraicType::I64) => ser.serialize_i64(*v),
(AlgebraicValue::U64(v), &AlgebraicType::U64) => ser.serialize_u64(*v),
(AlgebraicValue::I128(v), &AlgebraicType::I128) => ser.serialize_i128(*v),
(AlgebraicValue::U128(v), &AlgebraicType::U128) => ser.serialize_u128(*v),
(AlgebraicValue::F32(v), &AlgebraicType::F32) => ser.serialize_f32((*v).into()),
(AlgebraicValue::F64(v), &AlgebraicType::F64) => ser.serialize_f64((*v).into()),
(AlgebraicValue::String(s), &AlgebraicType::String) => ser.serialize_str(s),
(val, ty) => panic!("mismatched value and schema : {val:?} {ty:?}"),
};
}
});
impl_serialize!(
[T: crate::Value] where [for<'a> ValueWithType<'a, T>: Serialize]
ValueWithType<'_, Vec<T>>,
(self, ser) => {
let mut vec = ser.serialize_array(self.value().len())?;
for val in self.iter() {
vec.serialize_element(&val)?;
}
vec.end()
}
);
impl_serialize!([] ValueWithType<'_, SumValue>, (self, ser) => {
let sv = self.value();
let (tag, val) = (sv.tag, &*sv.value);
let var_ty = &self.ty().variants[tag as usize]; ser.serialize_variant(tag, var_ty.name(), &self.with(&var_ty.algebraic_type, val))
});
impl_serialize!([] ValueWithType<'_, ProductValue>, (self, ser) => {
let val = &self.value().elements;
assert_eq!(val.len(), self.ty().elements.len());
let mut prod = ser.serialize_named_product(val.len())?;
for (val, el_ty) in val.iter().zip(&*self.ty().elements) {
prod.serialize_element(el_ty.name(), &self.with(&el_ty.algebraic_type, val))?
}
prod.end()
});
impl_serialize!([] ValueWithType<'_, ArrayValue>, (self, ser) => match (self.value(), &*self.ty().elem_ty) {
(ArrayValue::Sum(v), AlgebraicType::Sum(ty)) => self.with(ty, v).serialize(ser),
(ArrayValue::Product(v), AlgebraicType::Product(ty)) => self.with(ty, v).serialize(ser),
(ArrayValue::Map(v), AlgebraicType::Builtin(crate::BuiltinType::Map(m))) => self.with(&**m, v).serialize(ser),
(ArrayValue::Bool(v), &AlgebraicType::Bool) => v.serialize(ser),
(ArrayValue::I8(v), &AlgebraicType::I8) => v.serialize(ser),
(ArrayValue::U8(v), &AlgebraicType::U8) => v.serialize(ser),
(ArrayValue::I16(v), &AlgebraicType::I16) => v.serialize(ser),
(ArrayValue::U16(v), &AlgebraicType::U16) => v.serialize(ser),
(ArrayValue::I32(v), &AlgebraicType::I32) => v.serialize(ser),
(ArrayValue::U32(v), &AlgebraicType::U32) => v.serialize(ser),
(ArrayValue::I64(v), &AlgebraicType::I64) => v.serialize(ser),
(ArrayValue::U64(v), &AlgebraicType::U64) => v.serialize(ser),
(ArrayValue::I128(v), &AlgebraicType::I128) => v.serialize(ser),
(ArrayValue::U128(v), &AlgebraicType::U128) => v.serialize(ser),
(ArrayValue::F32(v), &AlgebraicType::F32) => v.serialize(ser),
(ArrayValue::F64(v), &AlgebraicType::F64) => v.serialize(ser),
(ArrayValue::String(v), &AlgebraicType::String) => v.serialize(ser),
(ArrayValue::Array(v), AlgebraicType::Builtin(crate::BuiltinType::Array(ty))) => self.with(ty, v).serialize(ser),
(val, _) if val.is_empty() => ser.serialize_array(0)?.end(),
(val, ty) => panic!("mismatched value and schema: {val:?} {ty:?}"),
});
impl_serialize!([] ValueWithType<'_, MapValue>, (self, ser) => {
let val = self.value();
let MapType { key_ty, ty } = self.ty();
let mut map = ser.serialize_map(val.len())?;
for (key, val) in val {
map.serialize_entry(&self.with(key_ty, key), &self.with(ty, val))?;
}
map.end()
});
impl_serialize!([] spacetimedb_primitives::ColId, (self, ser) => ser.serialize_u32(self.0));
impl_serialize!([] spacetimedb_primitives::TableId, (self, ser) => ser.serialize_u32(self.0));
impl_serialize!([] spacetimedb_primitives::IndexId, (self, ser) => ser.serialize_u32(self.0));
impl_serialize!([] spacetimedb_primitives::SequenceId, (self, ser) => ser.serialize_u32(self.0));
impl_serialize!([] ColList, (self, ser) => {
let mut arr = ser.serialize_array(self.len() as usize)?;
for x in self.iter() {
arr.serialize_element(&x)?;
}
arr.end()
});