Struct SerializeOptions 

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

Options for XML serialization.

Fields

pretty: bool

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

indent: &'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.

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: &'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"/>"#);

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.