Struct SerializeOptions 

pub struct SerializeOptions {
    pub pretty: bool,
    pub indent: Cow<'static, str>,
    pub float_formatter: Option<FloatFormatter>,
    pub preserve_entities: bool,
}

Options for XML serialization.

Fields

pretty: bool

Whether to pretty-print with indentation (default: false)

indent: Cow<'static, str>

Indentation string for pretty-printing (default: “ “)

float_formatter: Option<FloatFormatter>

Custom formatter for floating-point numbers (f32 and f64). If None, uses the default Display implementation.

preserve_entities: bool

Whether to preserve entity references (like ¹, \, \) in string values.

When true, entity references in strings are not escaped - the & in entity references is left as-is instead of being escaped to &. This is useful when serializing content that already contains entity references (like HTML entities in SVG).

Default: false (all & characters are escaped to &).

Implementations

impl SerializeOptions

pub fn new() -> Self

Create new default options (compact output).

pub fn pretty(self) -> Self

Enable pretty-printing with default indentation.

pub fn indent(self, indent: impl Into<Cow<'static, str>>) -> Self

Set a custom indentation string (implies pretty-printing).

pub fn float_formatter(self, formatter: FloatFormatter) -> Self

Set a custom formatter for floating-point numbers (f32 and f64).

The formatter function receives the value as f64 (f32 values are upcast) and writes the formatted output to the provided writer.

Example

fn fmt_g(value: f64, w: &mut dyn Write) -> std::io::Result<()> {
    // Format like C's %g: 6 significant digits, trim trailing zeros
    let s = format!("{:.6}", value);
    let s = s.trim_end_matches('0').trim_end_matches('.');
    write!(w, "{}", s)
}

#[derive(Facet)]
struct Point {
    #[facet(xml::attribute)]
    x: f64,
    #[facet(xml::attribute)]
    y: f64,
}

let point = Point { x: 1.5, y: 2.0 };
let options = SerializeOptions::new().float_formatter(fmt_g);
let xml = to_string_with_options(&point, &options).unwrap();
assert_eq!(xml, r#"<Point x="1.5" y="2"></Point>"#);

pub fn preserve_entities(self, preserve: bool) -> Self

Enable preservation of entity references in string values.

When enabled, entity references like ¹, \, \ are not escaped. The & in recognized entity patterns is left as-is instead of being escaped to &.

This is useful when serializing content that already contains entity references, such as HTML entities in SVG content.

Trait Implementations

impl Clone for SerializeOptions

fn clone(&self) -> SerializeOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SerializeOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SerializeOptions

fn default() -> Self

Returns the “default value” for a type.