Struct CompositeItemWriterBuilder 

pub struct CompositeItemWriterBuilder<W> { /* private fields */ }

Builder for creating a fan-out chain of ItemWriters using static dispatch.

Start the chain with new, append writers with add, and finalise with build. Each call to add wraps the accumulated chain in a CompositeItemWriter. The built chain stores all writers by value — no heap allocations occur inside the chain itself.

Type Parameters

• W: The accumulated writer type. Starts as the first writer and is wrapped in CompositeItemWriter with each add call.

Examples

Two writers:

use spring_batch_rs::core::item::{ItemWriter, CompositeItemWriterBuilder};
use std::rc::Rc;
use std::cell::Cell;

struct CountingWriter { count: Rc<Cell<usize>> }
impl CountingWriter {
    fn new(count: Rc<Cell<usize>>) -> Self { Self { count } }
}
impl ItemWriter<i32> for CountingWriter {
    fn write(&self, items: &[i32]) -> Result<(), spring_batch_rs::BatchError> {
        self.count.set(self.count.get() + items.len());
        Ok(())
    }
}

let c1 = Rc::new(Cell::new(0usize));
let c2 = Rc::new(Cell::new(0usize));
let composite = CompositeItemWriterBuilder::new(CountingWriter::new(c1.clone()))
    .link(CountingWriter::new(c2.clone()))
    .build();

composite.write(&[1, 2, 3]).unwrap();
assert_eq!(c1.get(), 3);
assert_eq!(c2.get(), 3);

Three writers:

use spring_batch_rs::core::item::{ItemWriter, CompositeItemWriterBuilder};
use std::rc::Rc;
use std::cell::Cell;

struct CountingWriter { count: Rc<Cell<usize>> }
impl CountingWriter {
    fn new(count: Rc<Cell<usize>>) -> Self { Self { count } }
}
impl ItemWriter<i32> for CountingWriter {
    fn write(&self, items: &[i32]) -> Result<(), spring_batch_rs::BatchError> {
        self.count.set(self.count.get() + items.len());
        Ok(())
    }
}

let c1 = Rc::new(Cell::new(0usize));
let c2 = Rc::new(Cell::new(0usize));
let c3 = Rc::new(Cell::new(0usize));
let composite = CompositeItemWriterBuilder::new(CountingWriter::new(c1.clone()))
    .link(CountingWriter::new(c2.clone()))
    .link(CountingWriter::new(c3.clone()))
    .build();

composite.write(&[1, 2]).unwrap();
assert_eq!(c1.get(), 2);
assert_eq!(c2.get(), 2);
assert_eq!(c3.get(), 2);

Implementations

impl<W> CompositeItemWriterBuilder<W>

pub fn new(first: W) -> Self

Creates a new builder with the given writer as the first delegate.

Parameters

• first: The first writer in the fan-out chain.

Examples

use spring_batch_rs::core::item::{ItemWriter, CompositeItemWriterBuilder};

struct CountingWriter { count: std::cell::Cell<usize> }
impl CountingWriter { fn new() -> Self { Self { count: std::cell::Cell::new(0) } } }
impl ItemWriter<i32> for CountingWriter {
    fn write(&self, items: &[i32]) -> Result<(), spring_batch_rs::BatchError> {
        self.count.set(self.count.get() + items.len());
        Ok(())
    }
}

let writer = CompositeItemWriterBuilder::new(CountingWriter::new()).build();
writer.write(&[1, 2, 3]).unwrap();
assert_eq!(writer.count.get(), 3, "writer should receive all items");

pub fn link<W2>( self, next: W2, ) -> CompositeItemWriterBuilder<CompositeItemWriter<W, W2>>

Appends a writer to the fan-out chain.

Returns a new builder whose accumulated type is CompositeItemWriter<W, W2>. Both writers must implement ItemWriter<T> for the same T — verified at compile time.

Parameters

• next: The writer to link into the chain.

Examples

use spring_batch_rs::core::item::{ItemWriter, CompositeItemWriterBuilder};
use std::rc::Rc;
use std::cell::Cell;

struct CountingWriter { count: Rc<Cell<usize>> }
impl CountingWriter {
    fn new(count: Rc<Cell<usize>>) -> Self { Self { count } }
}
impl ItemWriter<i32> for CountingWriter {
    fn write(&self, items: &[i32]) -> Result<(), spring_batch_rs::BatchError> {
        self.count.set(self.count.get() + items.len());
        Ok(())
    }
}

let c1 = Rc::new(Cell::new(0usize));
let c2 = Rc::new(Cell::new(0usize));
let composite = CompositeItemWriterBuilder::new(CountingWriter::new(c1.clone()))
    .link(CountingWriter::new(c2.clone()))
    .build();

composite.write(&[1, 2, 3]).unwrap();
assert_eq!(c1.get(), 3, "first writer should receive all items");
assert_eq!(c2.get(), 3, "second writer should receive all items");

pub fn build(self) -> W

Builds and returns the composite writer.

Returns the accumulated writer value W. When chained via link, W is a nested CompositeItemWriter such as CompositeItemWriter<CompositeItemWriter<W1, W2>, W3>.

Pass &composite to the step builder’s .writer() method.

Examples

use spring_batch_rs::core::item::{ItemWriter, CompositeItemWriterBuilder};
use std::rc::Rc;
use std::cell::Cell;

struct CountingWriter { count: Rc<Cell<usize>> }
impl CountingWriter {
    fn new(count: Rc<Cell<usize>>) -> Self { Self { count } }
}
impl ItemWriter<i32> for CountingWriter {
    fn write(&self, items: &[i32]) -> Result<(), spring_batch_rs::BatchError> {
        self.count.set(self.count.get() + items.len());
        Ok(())
    }
}

let c1 = Rc::new(Cell::new(0usize));
let c2 = Rc::new(Cell::new(0usize));
let composite = CompositeItemWriterBuilder::new(CountingWriter::new(c1.clone()))
    .link(CountingWriter::new(c2.clone()))
    .build();

composite.write(&[1, 2, 3]).unwrap();
assert_eq!(c1.get(), 3);
assert_eq!(c2.get(), 3);