Struct BoxConditionalConsumerOnce 

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

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_once(&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_once(&5);
assert_eq!(*log.lock().unwrap(), vec![5]); // when branch executed

Author

Hu Haixing

Implementations

impl<T> BoxConditionalConsumerOnce<T>

where T: 'static,

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. The current conditional consumer executes first, followed by the next consumer.

Parameters

• next - The next consumer to execute. Note: This parameter is passed by value and will transfer ownership. Since BoxConsumerOnce cannot be cloned, the parameter will be consumed. Can be:
  • A closure: |x: &T|
  • A BoxConsumerOnce<T>
  • Any type implementing ConsumerOnce<T>

Returns

Returns a new BoxConsumerOnce<T>

Examples

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 cond1 = BoxConsumerOnce::new(move |x: &i32| {
    l1.lock().unwrap().push(*x * 2);
}).when(|x: &i32| *x > 0);
let cond2 = BoxConsumerOnce::new(move |x: &i32| {
    l2.lock().unwrap().push(*x + 100);
}).when(|x: &i32| *x > 10);

// Both cond1 and cond2 are moved and consumed
let chained = cond1.and_then(cond2);
chained.accept_once(&6);
assert_eq!(*log.lock().unwrap(), vec![12, 106]); // First *2 = 12, then +100 = 106
// cond1.accept_once(&3); // Would not compile - moved
// cond2.accept_once(&3); // Would not compile - moved

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

where C: ConsumerOnce<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. Note: This parameter is passed by value and will transfer ownership. Since BoxConsumerOnce cannot be cloned, the parameter will be consumed. Can be:
  • A closure: |x: &T|
  • A BoxConsumerOnce<T>
  • Any type implementing ConsumerOnce<T>

Returns

Returns the composed BoxConsumerOnce<T>

Examples

Using a closure (recommended)

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_once(&5);
assert_eq!(*log.lock().unwrap(), vec![5]); // Condition satisfied, execute first

Trait Implementations

impl<T> ConsumerOnce<T> for BoxConditionalConsumerOnce<T>

where T: 'static,

fn accept_once(self, value: &T)

Execute one-time consumption operation

fn into_box_once(self) -> BoxConsumerOnce<T>

Convert to BoxConsumerOnce

fn into_fn_once(self) -> impl FnOnce(&T)

Convert to closure