Struct XmlItemWriterBuilder 

pub struct XmlItemWriterBuilder<O> { /* private fields */ }

Available on crate feature xml only.

Builder for creating XML item writers.

This builder allows you to configure XML writers with:

• A root tag for the XML document
• An item tag for each written element
• Various output destinations (file, in-memory buffer, etc.)

Examples

use spring_batch_rs::item::xml::xml_writer::XmlItemWriterBuilder;
use spring_batch_rs::core::item::ItemWriter;
use serde::Serialize;
use std::io::Cursor;

#[derive(Serialize)]
struct Address {
    street: String,
    city: String,
    country: String,
}

#[derive(Serialize)]
struct Person {
    #[serde(rename = "@id")]
    id: i32,
    name: String,
    age: i32,
    address: Address,
}

// Create a buffer for our output
let buffer = Cursor::new(Vec::new());

// Create a writer using the builder pattern
let writer = XmlItemWriterBuilder::<Person>::new()
    .root_tag("directory")
    .item_tag("person")
    .from_writer(buffer);

// Create a person with nested address
let person = Person {
    id: 1,
    name: "Alice".to_string(),
    age: 30,
    address: Address {
        street: "123 Main St".to_string(),
        city: "Springfield".to_string(),
        country: "USA".to_string(),
    },
};

// Write the person to XML
writer.open().unwrap();
writer.write(&[person]).unwrap();
writer.close().unwrap();

Implementations

impl<O> XmlItemWriterBuilder<O>

pub fn new() -> Self

Creates a new XmlItemWriterBuilder with default values.

The default root tag is “root” and the default item tag is derived from the type name of the serialized items.

Examples

use spring_batch_rs::item::xml::xml_writer::XmlItemWriterBuilder;
use serde::Serialize;

#[derive(Serialize)]
struct Record {
    field: String,
}

let builder = XmlItemWriterBuilder::<Record>::new();

pub fn root_tag(self, root_tag: &str) -> Self

Sets the root tag for the XML document.

The root tag wraps all items in the XML document.

Examples

use spring_batch_rs::item::xml::xml_writer::XmlItemWriterBuilder;
use serde::Serialize;

#[derive(Serialize)]
struct Person {
    name: String,
}

let builder = XmlItemWriterBuilder::<Person>::new()
    .root_tag("people");

pub fn item_tag(self, item_tag: &str) -> Self

Sets the item tag for each XML element.

Each item in the collection will be wrapped with this tag. If not specified, it will default to the lowercase name of the item type.

Examples

use spring_batch_rs::item::xml::xml_writer::XmlItemWriterBuilder;
use serde::Serialize;

#[derive(Serialize)]
struct Person {
    name: String,
}

let builder = XmlItemWriterBuilder::<Person>::new()
    .root_tag("people")
    .item_tag("person");

pub fn from_path<P: AsRef<Path>>( self, path: P, ) -> Result<XmlItemWriter<O>, BatchError>

Creates an XmlItemWriter from a file path.

Examples

use spring_batch_rs::item::xml::xml_writer::XmlItemWriterBuilder;
use serde::Serialize;
use tempfile::NamedTempFile;

#[derive(Serialize)]
struct Person {
    name: String,
    age: i32,
}

// Create a temporary file for testing
let temp_file = NamedTempFile::new().unwrap();
let writer = XmlItemWriterBuilder::<Person>::new()
    .root_tag("people")
    .item_tag("person")
    .from_path(temp_file.path())
    .unwrap();

pub fn from_writer<W: Write>(self, wtr: W) -> XmlItemWriter<O, W>

Creates an XmlItemWriter from a writer.

This is useful for writing to in-memory buffers, network streams, or other custom writers.

Examples

use spring_batch_rs::item::xml::xml_writer::XmlItemWriterBuilder;
use spring_batch_rs::core::item::ItemWriter;
use serde::Serialize;
use std::io::Cursor;

#[derive(Serialize)]
struct Person {
    name: String,
    age: i32,
}

// Create a writer that writes to an in-memory buffer
let buffer = Cursor::new(Vec::new());
let writer = XmlItemWriterBuilder::<Person>::new()
    .root_tag("people")
    .item_tag("person")
    .from_writer(buffer);

// Now we can use the writer to write XML data
writer.open().unwrap();
writer.write(&[Person { name: "Alice".to_string(), age: 30 }]).unwrap();
writer.close().unwrap();

Trait Implementations

impl<O: Default> Default for XmlItemWriterBuilder<O>

fn default() -> XmlItemWriterBuilder<O>

Returns the “default value” for a type.