Struct CompositeItemProcessor 

pub struct CompositeItemProcessor<P1, P2, M> { /* private fields */ }

A composite processor that chains two processors sequentially using static dispatch.

The output of the first processor becomes the input of the second. If the first processor filters an item (returns Ok(None)), the chain stops immediately and Ok(None) is returned — the second processor is never called.

Both processors are stored by value — no heap allocation occurs inside the struct itself. This mirrors the pattern used by standard library iterator adapters such as std::iter::Chain.

Construct chains using CompositeItemProcessorBuilder rather than instantiating this struct directly.

Type Parameters

• P1: The first processor type. Must implement ItemProcessor<I, M> for some input type I and intermediate type M.
• P2: The second processor type. Must implement ItemProcessor<M, O> where M is the output type of P1 and O is the final output type.
• M: The intermediate type — output of P1, input of P2. Tracked via PhantomData so it participates in type inference without being stored.

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

// 21 * 2 = 42, then converted to "42"
assert_eq!(composite.process(&21).unwrap(), Some("42".to_string()));

Errors

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

Trait Implementations

impl<I, M, O, P1, P2> ItemProcessor<I, O> for CompositeItemProcessor<P1, P2, M>

where P1: ItemProcessor<I, M>, P2: ItemProcessor<M, O>,

fn process(&self, item: &I) -> ItemProcessorResult<O>

Applies the first processor, then — if the result is Some — applies the second. Returns Ok(None) immediately if the first processor filters the item.

Errors

Returns BatchError if either processor fails.