Struct CompositeItemProcessorBuilder 

pub struct CompositeItemProcessorBuilder<P> { /* private fields */ }

Builder for creating a chain of ItemProcessors using static dispatch.

Start the chain with new, append processors with link, and finalise with build. Each call to link wraps the accumulated chain in a CompositeItemProcessor, changing the output type. Mismatched types are caught at compile time.

The built chain stores all processors by value — no heap allocations occur inside the processor itself. The type of the built value encodes the full chain structure (e.g. CompositeItemProcessor<P1, CompositeItemProcessor<P2, P3>>), similar to how Iterator adapters compose in the standard library.

Type Parameters

• P: The accumulated processor type. Starts as the first processor and is wrapped in CompositeItemProcessor with each link call.

Examples

Two processors (i32 → i32 → String):

use spring_batch_rs::core::item::{ItemProcessor, CompositeItemProcessorBuilder};
use spring_batch_rs::BatchError;

struct DoubleProcessor;
impl ItemProcessor<i32, i32> for DoubleProcessor {
    fn process(&self, item: &i32) -> Result<Option<i32>, BatchError> {
        Ok(Some(item * 2))
    }
}

struct ToStringProcessor;
impl ItemProcessor<i32, String> for ToStringProcessor {
    fn process(&self, item: &i32) -> Result<Option<String>, BatchError> {
        Ok(Some(item.to_string()))
    }
}

let composite = CompositeItemProcessorBuilder::new(DoubleProcessor)
    .link(ToStringProcessor)
    .build();

assert_eq!(composite.process(&21).unwrap(), Some("42".to_string()));

Three processors (i32 → i32 → i32 → String):

use spring_batch_rs::core::item::{ItemProcessor, CompositeItemProcessorBuilder};
use spring_batch_rs::BatchError;

struct AddOneProcessor;
impl ItemProcessor<i32, i32> for AddOneProcessor {
    fn process(&self, item: &i32) -> Result<Option<i32>, BatchError> {
        Ok(Some(item + 1))
    }
}

struct DoubleProcessor;
impl ItemProcessor<i32, i32> for DoubleProcessor {
    fn process(&self, item: &i32) -> Result<Option<i32>, BatchError> {
        Ok(Some(item * 2))
    }
}

struct ToStringProcessor;
impl ItemProcessor<i32, String> for ToStringProcessor {
    fn process(&self, item: &i32) -> Result<Option<String>, BatchError> {
        Ok(Some(item.to_string()))
    }
}

let composite = CompositeItemProcessorBuilder::new(AddOneProcessor)
    .link(DoubleProcessor)
    .link(ToStringProcessor)
    .build();

// (4 + 1) * 2 = 10 → "10"
assert_eq!(composite.process(&4).unwrap(), Some("10".to_string()));

Implementations

impl<P> CompositeItemProcessorBuilder<P>

pub fn new(first: P) -> Self

Creates a new builder with the given processor as the first in the chain.

Parameters

• first: The first processor in the chain.

Examples

use spring_batch_rs::core::item::{ItemProcessor, CompositeItemProcessorBuilder};
use spring_batch_rs::BatchError;

struct UppercaseProcessor;
impl ItemProcessor<String, String> for UppercaseProcessor {
    fn process(&self, item: &String) -> Result<Option<String>, BatchError> {
        Ok(Some(item.to_uppercase()))
    }
}

let builder = CompositeItemProcessorBuilder::new(UppercaseProcessor);
let composite = builder.build();
assert_eq!(composite.process(&"hello".to_string()).unwrap(), Some("HELLO".to_string()));

pub fn link<P2, M>( self, next: P2, ) -> CompositeItemProcessorBuilder<CompositeItemProcessor<P, P2, M>>

Appends a processor to the end of the chain.

Returns a new builder whose accumulated type is CompositeItemProcessor<P, P2>. The input/output types are verified at compile time when the chain is used.

Type Parameters

• P2: The processor type to append.
• M: The intermediate type connecting P and P2. Inferred by the compiler from the ItemProcessor impls on P and P2.

Parameters

• next: The processor to append to the chain.

Examples

use spring_batch_rs::core::item::{ItemProcessor, CompositeItemProcessorBuilder};
use spring_batch_rs::BatchError;

struct AddOneProcessor;
impl ItemProcessor<i32, i32> for AddOneProcessor {
    fn process(&self, item: &i32) -> Result<Option<i32>, BatchError> {
        Ok(Some(item + 1))
    }
}

struct ToStringProcessor;
impl ItemProcessor<i32, String> for ToStringProcessor {
    fn process(&self, item: &i32) -> Result<Option<String>, BatchError> {
        Ok(Some(item.to_string()))
    }
}

let composite = CompositeItemProcessorBuilder::new(AddOneProcessor)
    .link(ToStringProcessor)
    .build();

assert_eq!(composite.process(&41).unwrap(), Some("42".to_string()));

pub fn build(self) -> P

Builds and returns the composite processor.

Returns the accumulated processor value P. When chained via link, P will be a nested CompositeItemProcessor such as CompositeItemProcessor<P1, CompositeItemProcessor<P2, P3>>.

Pass &composite to the step builder’s .processor() method — Rust will coerce it to &dyn ItemProcessor<I, O> automatically.

Examples

use spring_batch_rs::core::item::{ItemProcessor, CompositeItemProcessorBuilder};
use spring_batch_rs::BatchError;

struct DoubleProcessor;
impl ItemProcessor<i32, i32> for DoubleProcessor {
    fn process(&self, item: &i32) -> Result<Option<i32>, BatchError> {
        Ok(Some(item * 2))
    }
}

struct AddTenProcessor;
impl ItemProcessor<i32, i32> for AddTenProcessor {
    fn process(&self, item: &i32) -> Result<Option<i32>, BatchError> {
        Ok(Some(item + 10))
    }
}

let composite = CompositeItemProcessorBuilder::new(DoubleProcessor)
    .link(AddTenProcessor)
    .build();

// 5 * 2 = 10, then 10 + 10 = 20
assert_eq!(composite.process(&5).unwrap(), Some(20));