Struct BoxConditionalConsumer

Source

pub struct BoxConditionalConsumer<T> { /* private fields */ }

Expand description

BoxConditionalConsumer struct

A conditional readonly consumer that only executes when a predicate is satisfied. Uses BoxConsumer and BoxPredicate for single ownership semantics.

This type is typically created by calling BoxConsumer::when() and is designed to work with the or_else() method to create if-then-else logic.

§Features

Single Ownership: Not cloneable, consumes self on use
Conditional Execution: Only consumes when predicate returns true
Chainable: Can add or_else branch to create if-then-else logic
Implements Consumer: Can be used anywhere a Consumer is expected
Readonly: Neither modifies itself nor input values

§Examples

§Basic Conditional Execution

use prism3_function::{Consumer, BoxConsumer};

let consumer = BoxConsumer::new(|x: &i32| {
    println!("Positive: {}", x);
});
let conditional = consumer.when(|x: &i32| *x > 0);

conditional.accept(&5);  // Prints: Positive: 5
conditional.accept(&-5); // Does nothing

§With or_else Branch

use prism3_function::{Consumer, BoxConsumer};

let consumer = BoxConsumer::new(|x: &i32| {
    println!("Positive: {}", x);
})
.when(|x: &i32| *x > 0)
.or_else(|x: &i32| {
    println!("Non-positive: {}", x);
});

consumer.accept(&5);  // Prints: Positive: 5
consumer.accept(&-5); // Prints: Non-positive: -5

§Author

Haixing Hu

Implementations§

Source §

impl<T> BoxConditionalConsumer<T>
where T: 'static,

Source

pub fn and_then<C>(self, next: C) -> BoxConsumer<T>
where C: Consumer<T> + 'static,

Chains another consumer in sequence

Combines the current conditional consumer with another consumer into a new consumer that implements the following semantics:

When the returned consumer is called with an argument:

First, it checks the predicate of this conditional consumer
If the predicate is satisfied, it executes the internal consumer of this conditional consumer
Then, regardless of whether the predicate was satisfied, it unconditionally executes the next consumer

In other words, this creates a consumer that conditionally executes the first action (based on the predicate), and then always executes the second action.

§Parameters

next - The next consumer to execute (always executed)

§Returns

Returns a new combined consumer

§Examples

use std::sync::atomic::{AtomicI32, Ordering};

let result = AtomicI32::new(0);

let consumer1 = BoxConsumer::new(|x: &i32| {
    result.fetch_add(*x, Ordering::SeqCst);
});

let consumer2 = BoxConsumer::new(|x: &i32| {
    result.fetch_add(2 * (*x), Ordering::SeqCst);
});

let conditional = consumer1.when(|x| *x > 0);
let chained = conditional.and_then(consumer2);

chained.accept(&5);  // result = 5 + (2*5) = 15
result.store(0, Ordering::SeqCst);  // reset
chained.accept(&-5); // result = 0 + (2*-5) = -10 (not -15!)