Struct BoxConditionalStatefulConsumer 

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

BoxConditionalStatefulConsumer struct

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

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

Examples

Basic Conditional Execution

use prism3_function::{Consumer, BoxStatefulConsumer};
use std::sync::{Arc, Mutex};

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

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

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

With or_else Branch

use prism3_function::{Consumer, BoxStatefulConsumer};
use std::sync::{Arc, Mutex};

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

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

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

Author

Haixing Hu

Implementations

impl<T> BoxConditionalStatefulConsumer<T>

where T: 'static,

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

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

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

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

where C: StatefulConsumer<T> + 'static,

Adds an else branch

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

Parameters

• else_consumer - The consumer for the else branch

Returns

Returns a new consumer with if-then-else logic

Trait Implementations

impl<T> Debug for BoxConditionalStatefulConsumer<T>

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

Formats the value using the given formatter.

impl<T> Display for BoxConditionalStatefulConsumer<T>

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

Formats the value using the given formatter.

impl<T> StatefulConsumer<T> for BoxConditionalStatefulConsumer<T>

where T: 'static,

fn accept(&mut self, value: &T)

Execute consumption operation

fn into_box(self) -> BoxStatefulConsumer<T>

Convert to BoxStatefulConsumer

fn into_rc(self) -> RcStatefulConsumer<T>

Convert to RcStatefulConsumer

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

Convert to closure

fn into_arc(self) -> ArcStatefulConsumer<T>

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

Convert to ArcStatefulConsumer

fn into_once(self) -> BoxConsumerOnce<T>

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

Convert to ConsumerOnce