Struct XmlItemReaderBuilder 

pub struct XmlItemReaderBuilder<I: DeserializeOwned> { /* private fields */ }

Available on crate feature xml only.

A builder for creating XML item readers.

This builder helps configure XML readers with:

• A tag name to identify items in the XML
• Buffer capacity for performance tuning
• Various input sources (files, in-memory data, etc.)

Examples

use spring_batch_rs::item::xml::XmlItemReaderBuilder;
use spring_batch_rs::core::item::ItemReader;
use serde::Deserialize;
use std::io::Cursor;

// Define a structure that matches our XML format
#[derive(Debug, Deserialize)]
struct Person {
    #[serde(rename = "@id")]
    id: i32,
    name: String,
    age: i32,
}

// Create some XML data
let xml_data = r#"
<people>
  <person id="1">
    <name>Alice</name>
    <age>30</age>
  </person>
  <person id="2">
    <name>Bob</name>
    <age>25</age>
  </person>
</people>
"#;

// Create a reader from an in-memory buffer
let cursor = Cursor::new(xml_data);
let reader = XmlItemReaderBuilder::<Person>::new()
    .tag("person")
    .from_reader(cursor);

// Read all persons from the XML
let mut persons = Vec::new();
let mut person_count = 0;
while let Some(person) = reader.read().unwrap() {
    persons.push(person);
    person_count += 1;
}

assert_eq!(person_count, 2);
assert_eq!(persons[0].id, 1);
assert_eq!(persons[0].name, "Alice");
assert_eq!(persons[1].name, "Bob");

Implementations

impl<I: DeserializeOwned> XmlItemReaderBuilder<I>

pub fn new() -> Self

Creates a new XML item reader builder.

By default, it will:

• Look for XML elements matching the type name
• Use a buffer capacity of 1024 bytes

Examples

use spring_batch_rs::item::xml::XmlItemReaderBuilder;
use serde::Deserialize;

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

let builder = XmlItemReaderBuilder::<Person>::new();

pub fn capacity(self, capacity: usize) -> Self

Sets the buffer capacity for the XML reader.

Higher capacity can improve performance for larger XML documents but will use more memory.

Examples

use spring_batch_rs::item::xml::XmlItemReaderBuilder;
use serde::Deserialize;

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

// Increase buffer capacity for better performance with large files
let builder = XmlItemReaderBuilder::<Person>::new()
    .capacity(4096);

pub fn tag<S: AsRef<str>>(self, tag_name: S) -> Self

Sets the XML tag name to search for items.

This method specifies which XML element represents a single item. The reader will look for elements with this tag name and deserialize them into the target type.

Examples

use spring_batch_rs::item::xml::XmlItemReaderBuilder;
use serde::Deserialize;

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

// Look for <person> elements in the XML
let builder = XmlItemReaderBuilder::<Person>::new()
    .tag("person");

pub fn from_reader<R: Read + 'static>(self, reader: R) -> XmlItemReader<R, I>

Creates an XML item reader from a reader.

This allows reading from any source that implements the Read trait, such as files, network streams, or in-memory buffers.

Examples

use spring_batch_rs::item::xml::XmlItemReaderBuilder;
use spring_batch_rs::core::item::ItemReader;
use serde::Deserialize;
use std::io::Cursor;

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

// Create XML data with two persons
let xml_data = r#"
<people>
  <person>
    <name>Alice</name>
    <age>30</age>
  </person>
  <person>
    <name>Bob</name>
    <age>25</age>
  </person>
</people>
"#;

// Create a reader from an in-memory buffer
let cursor = Cursor::new(xml_data);
let reader = XmlItemReaderBuilder::<Person>::new()
    .tag("person")
    .from_reader(cursor);

// Read and process each person
let first_person = reader.read().unwrap().unwrap();
assert_eq!(first_person.name, "Alice");
assert_eq!(first_person.age, 30);

let second_person = reader.read().unwrap().unwrap();
assert_eq!(second_person.name, "Bob");
assert_eq!(second_person.age, 25);

// No more persons
assert!(reader.read().unwrap().is_none());

pub fn from_path<P: AsRef<Path>>( self, path: P, ) -> Result<XmlItemReader<File, I>, BatchError>

Creates an XML item reader from a file path.

Examples

use spring_batch_rs::item::xml::XmlItemReaderBuilder;
use spring_batch_rs::core::item::ItemReader;
use serde::Deserialize;
use std::path::Path;

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

// Read from an XML file
let reader = XmlItemReaderBuilder::<Person>::new()
    .tag("person")
    .from_path("data/persons.xml")
    .unwrap();

// Process each person from the file
while let Some(person) = reader.read().unwrap() {
    println!("Read person: {} (id: {})", person.name, person.id);
}

Trait Implementations

impl<I: DeserializeOwned> Default for XmlItemReaderBuilder<I>

fn default() -> Self

Returns the “default value” for a type.