prism3_function::consumers::consumer_once

Struct BoxConditionalConsumerOnce

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

Expand description

BoxConditionalConsumerOnce struct

A conditional one-time consumer that only executes when a predicate is satisfied. Uses BoxConsumerOnce and BoxPredicate for single ownership semantics.

This type is typically created by calling BoxConsumerOnce::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 ConsumerOnce: Can be used anywhere a ConsumerOnce is expected

§Examples

§Basic Conditional Execution

use prism3_function::{ConsumerOnce, BoxConsumerOnce};
use std::sync::{Arc, Mutex};

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

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

§With or_else Branch

use prism3_function::{ConsumerOnce, BoxConsumerOnce};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l1 = log.clone();
let l2 = log.clone();
let consumer = BoxConsumerOnce::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

§Author

Haixing Hu

Implementations§

Source §

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

Source

pub fn and_then<C>(self, next: C) -> BoxConsumerOnce<T>
where C: ConsumerOnce<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!)