Trait SerializeArray 

pub trait SerializeArray {
    type Ok;
    type Error: Error;

    // Required methods
    fn serialize_element<T>(&mut self, element: &T) -> Result<(), Self::Error>
       where T: Serialize + ?Sized;
    fn end(self) -> Result<Self::Ok, Self::Error>;
}

Returned from Serializer::serialize_array.

This provides a continuation of sorts where you can call serialize_element however many times and then finally the end is reached.

Required Associated Types

type Ok

Must match the Ok type of any Serializer that uses this type.

type Error: Error

Must match the Error type of any Serializer that uses this type.

Required Methods

fn serialize_element<T>(&mut self, element: &T) -> Result<(), Self::Error>

where T: Serialize + ?Sized,

Serialize an array element.

fn end(self) -> Result<Self::Ok, Self::Error>

Consumes and finalizes the array serializer returning the Self::Ok data.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl SerializeArray for SerializeArrayValue

type Ok = AlgebraicValue

type Error = <ValueSerializer as Serializer>::Error

impl<F> SerializeArray for TypedArrayFormatter<'_, '_, F>

where F: TypedWriter,

type Ok = ()

type Error = <F as TypedWriter>::Error

impl<Ok, Error> SerializeArray for Impossible<Ok, Error>

where Error: Error,

type Ok = Ok

type Error = Error

impl<S> SerializeArray for SerializeArray<S>

where S: SerializeSeq,

type Ok = <S as SerializeSeq>::Ok

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

impl<W> SerializeArray for Serializer<'_, W>

where W: BufWriter,

type Ok = ()

type Error = BsatnError