Struct ContentSerializer 

pub struct ContentSerializer<'w, 'i, W: Write> {
    pub writer: &'w mut W,
    pub level: QuoteLevel,
    pub(super) indent: Indent<'i>,
    pub write_indent: bool,
    pub expand_empty_elements: bool,
}

A serializer used to serialize content of an element. It does not write surrounding tags. Unlike the ElementSerializer, this serializer serializes enums using variant names as tag names, i. e. as <variant>...</variant>

This serializer does the following:

• numbers converted to a decimal representation and serialized as naked strings;
• booleans serialized ether as "true" or "false";
• strings and characters are serialized as naked strings;
• None does not write anything;
• Some and newtypes are serialized as an inner type using the same serializer;
• units (()) and unit structs does not write anything;
• sequences, tuples and tuple structs are serialized without delimiters. [1, 2, 3] would be serialized as 123 (if not using indent);
• structs and maps are not supported (DeError::Unsupported is returned);
• enums:
  • unit variants are serialized as self-closed <variant/>;
  • newtype variants are serialized as inner value wrapped in <variant>...</variant>;
  • tuple variants are serialized as sequences where each element is wrapped in <variant>...</variant>;
  • struct variants are serialized as a sequence of fields wrapped in <variant>...</variant>. Each field is serialized recursively using either ElementSerializer, ContentSerializer ($value fields), or SimpleTypeSerializer ($text fields). In particular, the empty struct is serialized as <variant/>;

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

The difference between this serializer and SimpleTypeSerializer is in how sequences and maps are serialized. Unlike SimpleTypeSerializer it supports any types in sequences and serializes them as list of elements, but that has drawbacks. Sequence of primitives would be serialized without delimiters and it will be impossible to distinguish between them. Even worse, when serializing with indent, sequence of strings become one big string with additional content and it would be impossible to distinguish between content of the original strings and inserted indent characters.

Fields

writer: &'w mut W

level: QuoteLevel

Defines which XML characters need to be escaped in text content

indent: Indent<'i>

Current indentation level. Note, that Indent::None means that there is no indentation at all, but write_indent == false means only, that indent writing is disabled in this instantiation of ContentSerializer, but child serializers should have access to the actual state of indentation.

write_indent: bool

If true, then current indent will be written before writing the content, but only if content is not empty.

expand_empty_elements: bool

Implementations

impl<'w, 'i, W: Write> ContentSerializer<'w, 'i, W>

pub fn into_simple_type_serializer(self) -> SimpleTypeSerializer<'i, &'w mut W>

Turns this serializer into serializer of a text content

pub fn new_seq_element_serializer(&mut self) -> ContentSerializer<'_, '_, W>

Creates new serializer that shares state with this serializer and writes to the same underlying writer

pub(super) fn write_empty(self, name: XmlName<'_>) -> Result<(), DeError>

Writes name as self-closed tag

pub(super) fn write_wrapped<S>( self, name: XmlName<'_>, serialize: S, ) -> Result<(), DeError>

where S: for<'a> FnOnce(SimpleTypeSerializer<'i, &'a mut W>) -> Result<&'a mut W, DeError>,

Writes simple type content between name tags

pub(super) fn write_indent(&mut self) -> Result<(), DeError>

Trait Implementations

impl<'w, 'i, W: Write> SerializeSeq for ContentSerializer<'w, 'i, 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, 'i, W: Write> SerializeTuple for ContentSerializer<'w, 'i, 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, 'i, W: Write> SerializeTupleStruct for ContentSerializer<'w, 'i, 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, 'i, W: Write> Serializer for ContentSerializer<'w, 'i, W>

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

Does not write anything

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

Does not write anything

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

Does not write anything

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

If variant is a special $text variant, then do nothing, otherwise checks variant for XML name validity and writes <variant/>.

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

If variant is a special $text variant, then writes value as a xs:simpleType, otherwise checks variant for XML name validity and writes value as a new <variant> element.

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

Serializes variant as a tuple with name variant, producing

<variant><!-- 1st element of a tuple --></variant>
<variant><!-- 2nd element of a tuple --></variant>
<!-- ... -->
<variant><!-- Nth element of a tuple --></variant>

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

Serializes variant as an element with name variant, producing

<variant>
  <!-- struct fields... -->
</variant>

If struct has no fields which is represented by nested elements or a text, it may be serialized as self-closed element <variant/>.

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 = ContentSerializer<'w, 'i, W>

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

type SerializeTuple = ContentSerializer<'w, 'i, W>

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

type SerializeTupleStruct = ContentSerializer<'w, 'i, W>

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

type SerializeTupleVariant = Tuple<'w, 'i, W>

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

type SerializeMap = Impossible<<ContentSerializer<'w, 'i, W> as Serializer>::Ok, <ContentSerializer<'w, 'i, W> as Serializer>::Error>

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

type SerializeStruct = Impossible<<ContentSerializer<'w, 'i, W> as Serializer>::Ok, <ContentSerializer<'w, 'i, W> as Serializer>::Error>

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

type SerializeStructVariant = Struct<'w, 'i, 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_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.