Struct ElementSerializer

pub struct ElementSerializer<'w, 'k, W: Write> {
    pub ser: ContentSerializer<'w, 'k, W>,
    pub(super) key: XmlName<'k>,
}

A serializer used to serialize element with specified name. Unlike the ContentSerializer, this serializer never uses variant names of enum variants, and because of that it is unable to serialize any enum values, except unit variants.

This serializer is used for an ordinary fields in structs, which are not special fields named $text (TEXT_KEY) or $value (VALUE_KEY). $text field should be serialized using SimpleTypeSerializer and $value field should be serialized using ContentSerializer.

This serializer does the following:

• numbers converted to a decimal representation and serialized as <key>value</key>;
• booleans serialized ether as <key>true</key> or <key>false</key>;
• strings and characters are serialized as <key>value</key>. In particular, an empty string is serialized as <key/>;
• None is serialized as <key/>;
• Some and newtypes are serialized as an inner type using the same serializer;
• units (()) and unit structs are serialized as <key/>;
• sequences, tuples and tuple structs are serialized as repeated <key> tag. In particular, empty sequence is serialized to nothing;
• structs are serialized as a sequence of fields wrapped in a <key> tag. Each field is serialized recursively using either ElementSerializer, ContentSerializer ($value fields), or SimpleTypeSerializer ($text fields). In particular, the empty struct is serialized as <key/>;
• maps are serialized as a sequence of entries wrapped in a <key> tag. If key is serialized to a special name, the same rules as for struct fields are applied. In particular, the empty map is serialized as <key/>;
• enums:
  • unit variants are serialized as <key>variant</key>;
  • other variants are not supported (DeError::Unsupported is returned);

Usage of empty tags depends on the ContentSerializer::expand_empty_elements setting.

Fields

ser: ContentSerializer<'w, 'k, W>

The inner serializer that contains the settings and mostly do the actual work

key: XmlName<'k>

Tag name used to wrap serialized types except enum variants which uses the variant name

Trait Implementations

impl<'w, 'k, W: Write> SerializeSeq for ElementSerializer<'w, 'k, W>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = DeError

Must match the Error type of our Serializer.

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

where T: ?Sized + Serialize,

Serialize a sequence element.

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

Finish serializing a sequence.

impl<'w, 'k, W: Write> SerializeTuple for ElementSerializer<'w, 'k, W>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = DeError

Must match the Error type of our Serializer.

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

where T: ?Sized + Serialize,

Serialize a tuple element.

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

Finish serializing a tuple.

impl<'w, 'k, W: Write> SerializeTupleStruct for ElementSerializer<'w, 'k, W>

type Ok = ()

Must match the Ok type of our Serializer.

type Error = DeError

Must match the Error type of our Serializer.

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

where T: ?Sized + Serialize,

Serialize a tuple struct field.

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

Finish serializing a tuple struct.

impl<'w, 'k, W: Write> Serializer for ElementSerializer<'w, 'k, W>

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

By serde contract we should serialize key of None values. If someone wants to skip the field entirely, he should use #[serde(skip_serializing_if = "Option::is_none")].

In XML when we serialize field, we write field name as:

• element name, or
• attribute name

and field value as

• content of the element, or
• attribute value

So serialization of None works the same as serialization of ()

fn serialize_unit_variant( self, name: &'static str, variant_index: u32, variant: &'static str, ) -> Result<Self::Ok, Self::Error>

Writes a tag with name Self::key and content of unit variant inside. If variant is a special $text value, then empty tag <key/> is written. Otherwise a <key>variant</key> is written.

fn serialize_newtype_variant<T: ?Sized + Serialize>( self, name: &'static str, _variant_index: u32, variant: &'static str, _value: &T, ) -> Result<Self::Ok, Self::Error>

Always returns DeError::Unsupported. Newtype variants can be serialized only in $value fields, which is serialized using ContentSerializer.

fn serialize_tuple_variant( self, name: &'static str, _variant_index: u32, variant: &'static str, _len: usize, ) -> Result<Self::SerializeTupleVariant, Self::Error>

Always returns DeError::Unsupported. Tuple variants can be serialized only in $value fields, which is serialized using ContentSerializer.

fn serialize_struct_variant( self, name: &'static str, _variant_index: u32, variant: &'static str, _len: usize, ) -> Result<Self::SerializeStructVariant, Self::Error>

Always returns DeError::Unsupported. Struct variants can be serialized only in $value fields, which is serialized using ContentSerializer.

type Ok = ()

The output type produced by this Serializer during successful serialization. Most serializers that produce text or binary output should set Ok = () and serialize into an io::Write or buffer contained within the Serializer instance. Serializers that build in-memory data structures may be simplified by using Ok to propagate the data structure around.

type Error = DeError

The error type when some error occurs during serialization.

type SerializeSeq = ElementSerializer<'w, 'k, W>

Type returned from serialize_seq for serializing the content of the sequence.

type SerializeTuple = ElementSerializer<'w, 'k, W>

Type returned from serialize_tuple for serializing the content of the tuple.

type SerializeTupleStruct = ElementSerializer<'w, 'k, W>

Type returned from serialize_tuple_struct for serializing the content of the tuple struct.

type SerializeTupleVariant = Impossible<<ElementSerializer<'w, 'k, W> as Serializer>::Ok, <ElementSerializer<'w, 'k, W> as Serializer>::Error>

Type returned from serialize_tuple_variant for serializing the content of the tuple variant.

type SerializeMap = Map<'w, 'k, W>

Type returned from serialize_map for serializing the content of the map.

type SerializeStruct = Struct<'w, 'k, W>

Type returned from serialize_struct for serializing the content of the struct.

type SerializeStructVariant = Struct<'w, 'k, W>

Type returned from serialize_struct_variant for serializing the content of the struct variant.

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

Serialize a bool value.

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

Serialize an i8 value.

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

Serialize an i16 value.

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

Serialize an i32 value.

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

Serialize an i64 value.

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

Serialize a u8 value.

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

Serialize a u16 value.

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

Serialize a u32 value.

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

Serialize a u64 value.

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

Serialize an i128 value.

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

Serialize a u128 value.

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

Serialize an f32 value.

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

Serialize an f64 value.

fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error>

Serialize a character.

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

Serialize a chunk of raw byte data.

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

Serialize a &str.

fn serialize_some<T: ?Sized + Serialize>( self, value: &T, ) -> Result<Self::Ok, Self::Error>

Serialize a Some(T) value.

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

Serialize a () value.

fn serialize_unit_struct( self, _name: &'static str, ) -> Result<Self::Ok, Self::Error>

Serialize a unit struct like struct Unit or PhantomData<T>.

fn serialize_newtype_struct<T: ?Sized + Serialize>( self, _name: &'static str, value: &T, ) -> Result<Self::Ok, Self::Error>

Serialize a newtype struct like struct Millimeters(u8).

fn serialize_seq( self, _len: Option<usize>, ) -> Result<Self::SerializeSeq, Self::Error>

Begin to serialize a variably sized sequence. This call must be followed by zero or more calls to serialize_element, then a call to end.

fn serialize_tuple( self, len: usize, ) -> Result<Self::SerializeTuple, Self::Error>

Begin to serialize a statically sized sequence whose length will be known at deserialization time without looking at the serialized data. This call must be followed by zero or more calls to serialize_element, then a call to end.

fn serialize_tuple_struct( self, _name: &'static str, len: usize, ) -> Result<Self::SerializeTupleStruct, Self::Error>

Begin to serialize a tuple struct like struct Rgb(u8, u8, u8). This call must be followed by zero or more calls to serialize_field, then a call to end.

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

Begin to serialize a map. This call must be followed by zero or more calls to serialize_key and serialize_value, then a call to end.

fn serialize_struct( self, _name: &'static str, _len: usize, ) -> Result<Self::SerializeStruct, Self::Error>

Begin to serialize a struct like struct Rgb { r: u8, g: u8, b: u8 }. This call must be followed by zero or more calls to serialize_field, then a call to end.

fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>

where I: IntoIterator, <I as IntoIterator>::Item: Serialize,

Collect an iterator as a sequence.

fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>

where K: Serialize, V: Serialize, I: IntoIterator<Item = (K, V)>,

Collect an iterator as a map.

fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>

where T: Display + ?Sized,

Serialize a string produced by an implementation of Display.

fn is_human_readable(&self) -> bool

Determine whether Serialize implementations should serialize in human-readable form.