Struct CompositeItemWriter 

pub struct CompositeItemWriter<W1, W2> { /* private fields */ }

A composite writer that fans out the same chunk to two writers sequentially using static dispatch.

Both writers receive identical slices on every write call. All four lifecycle methods (write, flush, open, close) are forwarded to first then second, short-circuiting on the first Err. If open() on first fails, second.open() is never called — lifecycle management is the step’s responsibility.

Both writers are stored by value — no heap allocation occurs inside the struct. The type encodes the full chain: CompositeItemWriter<CompositeItemWriter<W1, W2>, W3> for three writers.

Prefer constructing instances via CompositeItemWriterBuilder rather than direct struct literal syntax.

Type Parameters

• W1: The first writer type. Must implement ItemWriter<T>.
• W2: The second writer type. Must implement ItemWriter<T>.

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);

Errors

Returns BatchError if any writer in the chain returns an error.

Trait Implementations

impl<T, W1, W2> ItemWriter<T> for CompositeItemWriter<W1, W2>

where W1: ItemWriter<T>, W2: ItemWriter<T>,

fn write(&self, items: &[T]) -> ItemWriterResult

Writes items to first, then to second. Short-circuits on the first error.

Errors

Returns BatchError::ItemWriter if either writer fails.

fn flush(&self) -> ItemWriterResult

Flushes both writers regardless of errors. Returns the first error encountered.

Both first and second are always flushed, even if first fails, to avoid silently skipping buffered output in the second writer.

Errors

Returns BatchError::ItemWriter if either flush fails. If both fail, the error from first is returned.

fn open(&self) -> ItemWriterResult

Opens first, then second. Short-circuits on the first error.

Errors

Returns BatchError::ItemWriter if either open fails.

fn close(&self) -> ItemWriterResult

Closes both writers regardless of errors. Returns the first error encountered.

Both first and second are always closed, even if first fails, to avoid resource leaks.

Errors

Returns BatchError::ItemWriter if either close fails. If both fail, the error from first is returned.