prism3_function::consumers::stateful_bi_consumer

Struct BoxStatefulBiConsumer

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

Expand description

BoxStatefulBiConsumer struct

A bi-consumer implementation based on Box<dyn FnMut(&T, &U)> for single ownership scenarios. This is the simplest and most efficient bi-consumer type when sharing is not required.

§Features

Single Ownership: Not cloneable, ownership moves on use
Zero Overhead: No reference counting or locking
Mutable State: Can modify captured environment via FnMut
Builder Pattern: Method chaining consumes self naturally

§Use Cases

Choose BoxStatefulBiConsumer when:

The bi-consumer is used only once or in a linear flow
Building pipelines where ownership naturally flows
No need to share the consumer across contexts
Performance is critical and sharing overhead is unacceptable

§Performance

BoxStatefulBiConsumer has the best performance among the three bi-consumer types:

No reference counting overhead
No lock acquisition or runtime borrow checking
Direct function call through vtable
Minimal memory footprint (single pointer)

§Examples

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

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let mut consumer = BoxStatefulBiConsumer::new(move |x: &i32, y: &i32| {
    l.lock().unwrap().push(*x + *y);
});
consumer.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

§Author

Haixing Hu

Implementations§

Source §

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

Source

pub fn new<F>(f: F) -> Self
where F: FnMut(&T, &U) + 'static,

Creates a new bi-consumer.

Wraps the provided closure in the appropriate smart pointer type for this bi-consumer implementation.

Source

pub fn new_with_name<F>(name: &str, f: F) -> Self
where F: FnMut(&T, &U) + 'static,

Creates a new named bi-consumer.

Wraps the provided closure and assigns it a name, which is useful for debugging and logging purposes.

Source

pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self
where F: FnMut(&T, &U) + 'static,

Creates a new named bi-consumer with an optional name.

Wraps the provided closure and assigns it an optional name.

Source

pub fn name(&self) -> Option<&str>

Gets the name of this bi-consumer.

§Returns

Returns Some(&str) if a name was set, None otherwise.

Source

pub fn set_name(&mut self, name: &str)

Sets the name of this bi-consumer.

§Parameters

name - The name to set for this bi-consumer

Source

pub fn noop() -> Self

Creates a no-operation bi-consumer.

Creates a bi-consumer that does nothing when called. Useful for default values or placeholder implementations.

§Returns

Returns a new bi-consumer instance that performs no operation.

Source

pub fn when(self, predicate: P) -> BoxConditionalStatefulBiConsumer<T, U>
where P: BiPredicate<T, U> + 'static,

Creates a conditional two-parameter consumer that executes based on bi-predicate result.

§Parameters

predicate - The bi-predicate to determine whether to execute the consumption operation

§Returns

Returns a conditional two-parameter consumer that only executes when the predicate returns true.

§Examples

use std::sync::Arc;
use std::sync::atomic::{AtomicI32, Ordering};
use prism3_rust_function::consumers::*;

let counter = Arc::new(AtomicI32::new(0));
let bi_consumer = BoxBiConsumer::new({
    let counter = Arc::clone(&counter);
    move |key: &String, value: &i32| {
        if key == "increment" {
            counter.fetch_add(*value, Ordering::SeqCst);
        }
    }
});

let conditional = bi_consumer.when(|key: &String, value: &i32| *value > 0);
conditional.accept(&"increment".to_string(), &5);  // counter = 5
conditional.accept(&"increment".to_string(), &-2); // not executed

Source

pub fn and_then<C>(self, after: C) -> BoxStatefulBiConsumer<T, U>
where Self: Sized + 'static, T: 'static, U: 'static, C: StatefulBiConsumer<T, U> + 'static,

Chains execution with another two-parameter consumer, executing the current consumer first, then the subsequent consumer.

§Parameters

after - The subsequent two-parameter consumer to execute after the current consumer completes

§Returns

Returns a new two-parameter consumer that executes the current consumer and the subsequent consumer in sequence.

§Examples

use std::sync::Arc;
use std::sync::atomic::{AtomicI32, Ordering};
use prism3_rust_function::consumers::*;

let counter1 = Arc::new(AtomicI32::new(0));
let counter2 = Arc::new(AtomicI32::new(0));

let bi_consumer1 = BoxBiConsumer::new({
    let counter = Arc::clone(&counter1);
    move |key: &String, value: &i32| {
        counter.fetch_add(*value, Ordering::SeqCst);
    }
});

let bi_consumer2 = BoxBiConsumer::new({
    let counter = Arc::clone(&counter2);
    move |key: &String, value: &i32| {
        counter.fetch_add(*value * 2, Ordering::SeqCst);
    }
});

let chained = bi_consumer1.and_then(bi_consumer2);
chained.accept(&"test".to_string(), &3);
// counter1 = 3, counter2 = 6