Struct BoxConditionalStatefulBiConsumer 

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

BoxConditionalBiConsumer struct

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

This type is typically created by calling BoxStatefulBiConsumer::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

Examples

Basic Conditional Execution

use prism3_function::{BiConsumer, BoxStatefulBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let consumer = BoxStatefulBiConsumer::new(move |x: &i32, y: &i32| {
    l.lock().unwrap().push(*x + *y);
});
let mut conditional = consumer.when(|x: &i32, y: &i32| *x > 0 && *y > 0);

conditional.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]); // Executed

conditional.accept(&-5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]); // Not executed

With or_else Branch

use prism3_function::{BiConsumer, BoxStatefulBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l1 = log.clone();
let l2 = log.clone();
let mut consumer = BoxStatefulBiConsumer::new(move |x: &i32, y: &i32| {
    l1.lock().unwrap().push(*x + *y);
}).when(|x: &i32, y: &i32| *x > 0 && *y > 0)
  .or_else(move |x: &i32, y: &i32| {
    l2.lock().unwrap().push(*x * *y);
});

consumer.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]); // when branch executed

consumer.accept(&-5, &3);
assert_eq!(*log.lock().unwrap(), vec![8, -15]); // or_else branch executed

Author

Haixing Hu

Implementations

impl<T, U> BoxConditionalStatefulBiConsumer<T, U>

where T: 'static, U: 'static,

pub fn and_then<C>(self, next: C) -> BoxStatefulBiConsumer<T, U>

where C: StatefulBiConsumer<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:

1. First, it checks the predicate of this conditional bi-consumer
2. If the predicate is satisfied, it executes the internal bi-consumer of this conditional bi-consumer
3. 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!)

pub fn or_else<C>(self, else_consumer: C) -> BoxStatefulBiConsumer<T, U>

where C: StatefulBiConsumer<T, U> + 'static,

Adds an else branch

Executes the original bi-consumer when the condition is satisfied, otherwise executes else_consumer.

Parameters

• else_consumer - The bi-consumer for the else branch

Returns

Returns a new bi-consumer with if-then-else logic

Trait Implementations

impl<T, U> Debug for BoxConditionalStatefulBiConsumer<T, U>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, U> Display for BoxConditionalStatefulBiConsumer<T, U>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T, U> StatefulBiConsumer<T, U> for BoxConditionalStatefulBiConsumer<T, U>

where T: 'static, U: 'static,

fn accept(&mut self, first: &T, second: &U)

Performs the consumption operation

fn into_box(self) -> BoxStatefulBiConsumer<T, U>

Converts to BoxStatefulBiConsumer

fn into_rc(self) -> RcStatefulBiConsumer<T, U>

Converts to RcStatefulBiConsumer

fn into_fn(self) -> impl FnMut(&T, &U)

Converts bi-consumer to a closure

fn into_arc(self) -> ArcStatefulBiConsumer<T, U>

where Self: Sized + Send + 'static, T: 'static, U: 'static,

Converts to ArcStatefulBiConsumer

fn into_once(self) -> BoxBiConsumerOnce<T, U>

where Self: Sized + 'static, T: 'static, U: 'static,

Convert to BiConsumerOnce