Struct BoxConditionalBiConsumer

Source

pub struct BoxConditionalBiConsumer<T, U> { /* private fields */ }

Expand description

BoxConditionalBiConsumer struct

A conditional readonly bi-consumer that only executes when a predicate is satisfied. Uses BoxBiConsumer and BoxBiPredicate for single ownership semantics.

This type is typically created by calling BoxBiConsumer::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 BiConsumer: Can be used anywhere a BiConsumer is expected
Readonly: Neither modifies itself nor input values

§Examples

§Basic Conditional Execution

use prism3_function::{BiConsumer, BoxBiConsumer};

let consumer = BoxBiConsumer::new(|x: &i32, y: &i32| {
    println!("Both positive: {} + {} = {}", x, y, x + y);
});
let conditional = consumer.when(|x: &i32, y: &i32| *x > 0 && *y > 0);

conditional.accept(&5, &3);  // Prints: Both positive: 5 + 3 = 8
conditional.accept(&-5, &3); // Does nothing

§With or_else Branch

use prism3_function::{BiConsumer, BoxBiConsumer};

let consumer = BoxBiConsumer::new(|x: &i32, y: &i32| {
    println!("Both positive: {} + {} = {}", x, y, x + y);
})
.when(|x: &i32, y: &i32| *x > 0 && *y > 0)
.or_else(|x: &i32, y: &i32| {
    println!("Not both positive: {} and {}", x, y);
});

consumer.accept(&5, &3);  // Prints: Both positive: 5 + 3 = 8
consumer.accept(&-5, &3); // Prints: Not both positive: -5 and 3

§Author

Haixing Hu

Implementations§

Source §

impl<T, U> BoxConditionalBiConsumer<T, U>
where T: 'static, U: 'static,

Source

pub fn and_then<C>(self, next: C) -> BoxBiConsumer<T, U>
where C: BiConsumer<T, U> + 'static,

Chains another bi-consumer in sequence

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

When the returned bi-consumer is called with two arguments:

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

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

§Parameters

next - The next bi-consumer to execute (always executed)

§Returns

Returns a new combined bi-consumer

§Examples

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

let result = AtomicI32::new(0);

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

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

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

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