Trait SerializeStruct

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

    // Required methods
    fn serialize_field<T>(
        &mut self,
        key: &'static str,
        value: &T,
    ) -> Result<(), Self::Error>
       where T: Serialize + ?Sized;
    fn end(self) -> Result<Self::Ok, Self::Error>;

    // Provided method
    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> { ... }
}

Returned from Serializer::serialize_struct.

Example use

use serde::ser::{Serialize, SerializeStruct, Serializer};

struct Rgb {
    r: u8,
    g: u8,
    b: u8,
}

impl Serialize for Rgb {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut rgb = serializer.serialize_struct("Rgb", 3)?;
        rgb.serialize_field("r", &self.r)?;
        rgb.serialize_field("g", &self.g)?;
        rgb.serialize_field("b", &self.b)?;
        rgb.end()
    }
}

Example implementation

The example data format presented on the website demonstrates an implementation of SerializeStruct for a basic JSON data format.

Required Associated Types

type Ok

Must match the Ok type of our Serializer.

type Error: Error

Must match the Error type of our Serializer.

Required Methods

fn serialize_field<T>( &mut self, key: &'static str, value: &T, ) -> Result<(), Self::Error>

where T: Serialize + ?Sized,

Serialize a struct field.

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

Finish serializing a struct.

Provided Methods

fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error>

Indicate that a struct field has been skipped.

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<Ok, Error> SerializeStruct for Impossible<Ok, Error>

where Error: Error,

type Ok = Ok

type Error = Error