Trait spacetimedb_lib::ser::Serializer

pub trait Serializer: Sized {
    type Ok;
    type Error: Error;
    type SerializeArray: SerializeArray<Ok = Self::Ok, Error = Self::Error>;
    type SerializeMap: SerializeMap<Ok = Self::Ok, Error = Self::Error>;
    type SerializeSeqProduct: SerializeSeqProduct<Ok = Self::Ok, Error = Self::Error>;
    type SerializeNamedProduct: SerializeNamedProduct<Ok = Self::Ok, Error = Self::Error>;

    // Required methods
    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>;
    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>;
    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>;
    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>;
    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;
    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>;
    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>;
    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>;
    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>;
    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>;
    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>;
    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>;
    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>;
    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>;
    fn serialize_array(
        self,
        len: usize
    ) -> Result<Self::SerializeArray, Self::Error>;
    fn serialize_map(self, len: usize) -> Result<Self::SerializeMap, Self::Error>;
    fn serialize_seq_product(
        self,
        len: usize
    ) -> Result<Self::SerializeSeqProduct, Self::Error>;
    fn serialize_named_product(
        self,
        len: usize
    ) -> Result<Self::SerializeNamedProduct, Self::Error>;
    fn serialize_variant<T>(
        self,
        tag: u8,
        name: Option<&str>,
        value: &T
    ) -> Result<Self::Ok, Self::Error>
       where T: Serialize + ?Sized;
}

Required Associated Types

type Ok

type Error: Error

type SerializeArray: SerializeArray<Ok = Self::Ok, Error = Self::Error>

type SerializeMap: SerializeMap<Ok = Self::Ok, Error = Self::Error>

type SerializeSeqProduct: SerializeSeqProduct<Ok = Self::Ok, Error = Self::Error>

type SerializeNamedProduct: SerializeNamedProduct<Ok = Self::Ok, Error = Self::Error>

Required Methods

fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>

fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>

fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>

fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>

fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>

fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error>

fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>

fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>

fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>

fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>

fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error>

fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>

fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>

fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>

fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>

fn serialize_array(self, len: usize) -> Result<Self::SerializeArray, Self::Error>

fn serialize_map(self, len: usize) -> Result<Self::SerializeMap, Self::Error>

fn serialize_seq_product( self, len: usize ) -> Result<Self::SerializeSeqProduct, Self::Error>

fn serialize_named_product( self, len: usize ) -> Result<Self::SerializeNamedProduct, Self::Error>

fn serialize_variant<T>( self, tag: u8, name: Option<&str>, value: &T ) -> Result<Self::Ok, Self::Error>where T: Serialize + ?Sized,

Implementors

impl Serializer for ValueSerializer

type Ok = AlgebraicValue

type Error = Infallible

type SerializeArray = SerializeArrayValue

type SerializeMap = SerializeMapValue

type SerializeSeqProduct = SerializeProductValue

type SerializeNamedProduct = ForwardNamedToSeqProduct<SerializeProductValue>

impl<S> Serializer for SerdeSerializer<S>where S: Serializer,

type Ok = <S as Serializer>::Ok

type Error = SerdeError<<S as Serializer>::Error>

type SerializeArray = SerializeArray<<S as Serializer>::SerializeSeq>

type SerializeMap = SerializeMap<<S as Serializer>::SerializeMap>

type SerializeSeqProduct = SerializeSeqProduct<<S as Serializer>::SerializeTuple>

type SerializeNamedProduct = SerializeNamedProduct<<S as Serializer>::SerializeMap>

impl<W> Serializer for Serializer<'_, W>where W: BufWriter,

type Ok = ()

type Error = BsatnError

type SerializeArray = Serializer<'_, W>

type SerializeMap = Serializer<'_, W>

type SerializeSeqProduct = Serializer<'_, W>

type SerializeNamedProduct = ForwardNamedToSeqProduct<Serializer<'_, W>>