Skip to main content

BoxStatefulBiConsumer

qubit_function::consumers::stateful_bi_consumer

Struct BoxStatefulBiConsumer 

Source 
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 qubit_function::{BiConsumer, BoxStatefulBiConsumer, StatefulBiConsumer};
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>

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.

Examples found in repository?
examples/consumers/bi_consumer_demo.rs (lines 119-121)
31fn main() {
32    println!("=== BiConsumer Demo ===\n");
33
34    // 1. BoxBiConsumer - Single ownership
35    println!("1. BoxBiConsumer - Single ownership:");
36    let log = Arc::new(Mutex::new(Vec::new()));
37    let l = log.clone();
38    let box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
39        println!("  Processing: x={}, y={}", x, y);
40        l.lock().unwrap().push(*x + *y);
41    });
42    box_consumer.accept(&10, &5);
43    println!("  Result log: {:?}\n", *log.lock().unwrap());
44
45    // 2. Method chaining with BoxBiConsumer
46    println!("2. BoxBiConsumer with method chaining:");
47    let log = Arc::new(Mutex::new(Vec::new()));
48    let l1 = log.clone();
49    let l2 = log.clone();
50    let chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
51        l1.lock().unwrap().push(*x + *y);
52        println!("  After first operation: sum = {}", x + y);
53    })
54    .and_then(move |x: &i32, y: &i32| {
55        l2.lock().unwrap().push(*x * *y);
56        println!("  After second operation: product = {}", x * y);
57    });
58    chained.accept(&5, &3);
59    println!("  Final log: {:?}\n", *log.lock().unwrap());
60
61    // 3. ArcBiConsumer - Thread-safe shared ownership
62    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
63    let log = Arc::new(Mutex::new(Vec::new()));
64    let l = log.clone();
65    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
66        l.lock().unwrap().push(*x + *y);
67        println!("  Thread {:?}: sum = {}", thread::current().id(), x + y);
68    });
69
70    let consumer1 = arc_consumer.clone();
71    let consumer2 = arc_consumer.clone();
72
73    let handle1 = thread::spawn(move || {
74        let c = consumer1;
75        c.accept(&10, &5);
76    });
77
78    let handle2 = thread::spawn(move || {
79        let c = consumer2;
80        c.accept(&20, &8);
81    });
82
83    handle1.join().unwrap();
84    handle2.join().unwrap();
85    println!("  Final log: {:?}\n", *log.lock().unwrap());
86
87    // 4. RcBiConsumer - Single-threaded shared ownership
88    println!("4. RcBiConsumer - Single-threaded shared ownership:");
89    let log = Rc::new(RefCell::new(Vec::new()));
90    let l = log.clone();
91    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
92        l.borrow_mut().push(*x + *y);
93    });
94
95    let clone1 = rc_consumer.clone();
96    let clone2 = rc_consumer.clone();
97
98    clone1.accept(&5, &3);
99    println!("  After first use: {:?}", *log.borrow());
100
101    clone2.accept(&7, &2);
102    println!("  After second use: {:?}\n", *log.borrow());
103
104    // 5. Working with closures directly
105    println!("5. Working with closures directly:");
106    let log = Arc::new(Mutex::new(Vec::new()));
107    let l = log.clone();
108    let closure = move |x: &i32, y: &i32| {
109        let sum = *x + *y;
110        l.lock().unwrap().push(sum);
111    };
112    closure.accept(&10, &20);
113    println!("  After closure: {:?}\n", *log.lock().unwrap());
114
115    // 6. Conditional BiConsumer
116    println!("6. Conditional BiConsumer:");
117    let log = Arc::new(Mutex::new(Vec::new()));
118    let l = log.clone();
119    let mut conditional = BoxStatefulBiConsumer::new(move |x: &i32, y: &i32| {
120        l.lock().unwrap().push(*x + *y);
121    })
122    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
123
124    conditional.accept(&5, &3);
125    println!("  Positive values: {:?}", *log.lock().unwrap());
126
127    conditional.accept(&-5, &3);
128    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());
129
130    // 7. Conditional branch BiConsumer
131    println!("7. Conditional branch BiConsumer:");
132    let log = Arc::new(Mutex::new(Vec::new()));
133    let l1 = log.clone();
134    let l2 = log.clone();
135    let mut branch = BoxStatefulBiConsumer::new(move |x: &i32, _y: &i32| {
136        l1.lock().unwrap().push(*x);
137    })
138    .when(|x: &i32, y: &i32| *x > *y)
139    .or_else(move |_x: &i32, y: &i32| {
140        l2.lock().unwrap().push(*y);
141    });
142
143    branch.accept(&15, &10);
144    println!("  When x > y: {:?}", *log.lock().unwrap());
145
146    branch.accept(&5, &10);
147    println!("  When x <= y: {:?}\n", *log.lock().unwrap());
148
149    // 8. Accumulating statistics
150    println!("8. Accumulating statistics:");
151    let count = Arc::new(Mutex::new(0));
152    let sum = Arc::new(Mutex::new(0));
153    let c = count.clone();
154    let s = sum.clone();
155    let stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
156        *c.lock().unwrap() += 1;
157        *s.lock().unwrap() += x + y;
158    });
159
160    stats_consumer.accept(&5, &3);
161    stats_consumer.accept(&10, &2);
162    stats_consumer.accept(&7, &8);
163
164    println!("  Count: {}", *count.lock().unwrap());
165    println!("  Sum: {}\n", *sum.lock().unwrap());
166
167    // 9. Name support
168    println!("9. Name support:");
169    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
170    println!("  Initial name: {:?}", named_consumer.name());
171
172    named_consumer.set_name("sum_calculator");
173    println!("  After setting name: {:?}", named_consumer.name());
174    println!("  Display: {}\n", named_consumer);
175
176    println!("=== Demo Complete ===");
177}
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 clear_name(&mut self)

Clears the name of 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<P>(self, predicate: P) -> BoxConditionalStatefulBiConsumer<T, U>
where T: 'static, U: 'static, 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 qubit_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
Examples found in repository?
examples/consumers/bi_consumer_demo.rs (line 122)
31fn main() {
32    println!("=== BiConsumer Demo ===\n");
33
34    // 1. BoxBiConsumer - Single ownership
35    println!("1. BoxBiConsumer - Single ownership:");
36    let log = Arc::new(Mutex::new(Vec::new()));
37    let l = log.clone();
38    let box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
39        println!("  Processing: x={}, y={}", x, y);
40        l.lock().unwrap().push(*x + *y);
41    });
42    box_consumer.accept(&10, &5);
43    println!("  Result log: {:?}\n", *log.lock().unwrap());
44
45    // 2. Method chaining with BoxBiConsumer
46    println!("2. BoxBiConsumer with method chaining:");
47    let log = Arc::new(Mutex::new(Vec::new()));
48    let l1 = log.clone();
49    let l2 = log.clone();
50    let chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
51        l1.lock().unwrap().push(*x + *y);
52        println!("  After first operation: sum = {}", x + y);
53    })
54    .and_then(move |x: &i32, y: &i32| {
55        l2.lock().unwrap().push(*x * *y);
56        println!("  After second operation: product = {}", x * y);
57    });
58    chained.accept(&5, &3);
59    println!("  Final log: {:?}\n", *log.lock().unwrap());
60
61    // 3. ArcBiConsumer - Thread-safe shared ownership
62    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
63    let log = Arc::new(Mutex::new(Vec::new()));
64    let l = log.clone();
65    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
66        l.lock().unwrap().push(*x + *y);
67        println!("  Thread {:?}: sum = {}", thread::current().id(), x + y);
68    });
69
70    let consumer1 = arc_consumer.clone();
71    let consumer2 = arc_consumer.clone();
72
73    let handle1 = thread::spawn(move || {
74        let c = consumer1;
75        c.accept(&10, &5);
76    });
77
78    let handle2 = thread::spawn(move || {
79        let c = consumer2;
80        c.accept(&20, &8);
81    });
82
83    handle1.join().unwrap();
84    handle2.join().unwrap();
85    println!("  Final log: {:?}\n", *log.lock().unwrap());
86
87    // 4. RcBiConsumer - Single-threaded shared ownership
88    println!("4. RcBiConsumer - Single-threaded shared ownership:");
89    let log = Rc::new(RefCell::new(Vec::new()));
90    let l = log.clone();
91    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
92        l.borrow_mut().push(*x + *y);
93    });
94
95    let clone1 = rc_consumer.clone();
96    let clone2 = rc_consumer.clone();
97
98    clone1.accept(&5, &3);
99    println!("  After first use: {:?}", *log.borrow());
100
101    clone2.accept(&7, &2);
102    println!("  After second use: {:?}\n", *log.borrow());
103
104    // 5. Working with closures directly
105    println!("5. Working with closures directly:");
106    let log = Arc::new(Mutex::new(Vec::new()));
107    let l = log.clone();
108    let closure = move |x: &i32, y: &i32| {
109        let sum = *x + *y;
110        l.lock().unwrap().push(sum);
111    };
112    closure.accept(&10, &20);
113    println!("  After closure: {:?}\n", *log.lock().unwrap());
114
115    // 6. Conditional BiConsumer
116    println!("6. Conditional BiConsumer:");
117    let log = Arc::new(Mutex::new(Vec::new()));
118    let l = log.clone();
119    let mut conditional = BoxStatefulBiConsumer::new(move |x: &i32, y: &i32| {
120        l.lock().unwrap().push(*x + *y);
121    })
122    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
123
124    conditional.accept(&5, &3);
125    println!("  Positive values: {:?}", *log.lock().unwrap());
126
127    conditional.accept(&-5, &3);
128    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());
129
130    // 7. Conditional branch BiConsumer
131    println!("7. Conditional branch BiConsumer:");
132    let log = Arc::new(Mutex::new(Vec::new()));
133    let l1 = log.clone();
134    let l2 = log.clone();
135    let mut branch = BoxStatefulBiConsumer::new(move |x: &i32, _y: &i32| {
136        l1.lock().unwrap().push(*x);
137    })
138    .when(|x: &i32, y: &i32| *x > *y)
139    .or_else(move |_x: &i32, y: &i32| {
140        l2.lock().unwrap().push(*y);
141    });
142
143    branch.accept(&15, &10);
144    println!("  When x > y: {:?}", *log.lock().unwrap());
145
146    branch.accept(&5, &10);
147    println!("  When x <= y: {:?}\n", *log.lock().unwrap());
148
149    // 8. Accumulating statistics
150    println!("8. Accumulating statistics:");
151    let count = Arc::new(Mutex::new(0));
152    let sum = Arc::new(Mutex::new(0));
153    let c = count.clone();
154    let s = sum.clone();
155    let stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
156        *c.lock().unwrap() += 1;
157        *s.lock().unwrap() += x + y;
158    });
159
160    stats_consumer.accept(&5, &3);
161    stats_consumer.accept(&10, &2);
162    stats_consumer.accept(&7, &8);
163
164    println!("  Count: {}", *count.lock().unwrap());
165    println!("  Sum: {}\n", *sum.lock().unwrap());
166
167    // 9. Name support
168    println!("9. Name support:");
169    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
170    println!("  Initial name: {:?}", named_consumer.name());
171
172    named_consumer.set_name("sum_calculator");
173    println!("  After setting name: {:?}", named_consumer.name());
174    println!("  Display: {}\n", named_consumer);
175
176    println!("=== Demo Complete ===");
177}
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 qubit_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

Trait Implementations§

Source§

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

Source§

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

Formats the value using the given formatter. Read more
Source§

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

Source§

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

Formats the value using the given formatter. Read more
Source§

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

Source§

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

Performs the consumption operation Read more
Source§

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

Converts to BoxStatefulBiConsumer Read more
Source§

fn into_rc(self) -> RcStatefulBiConsumer<T, U>
where Self: 'static,

Converts to RcStatefulBiConsumer Read more
Source§

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

Converts bi-consumer to a closure Read more
Source§

fn into_once(self) -> BoxBiConsumerOnce<T, U>
where Self: 'static,

Convert to BiConsumerOnce Read more
Source§

fn into_arc(self) -> ArcStatefulBiConsumer<T, U>
where Self: Sized + Send + 'static,

Converts to ArcStatefulBiConsumer Read more

Auto Trait Implementations§

§

impl<T, U> Freeze for BoxStatefulBiConsumer<T, U>

§

impl<T, U> !RefUnwindSafe for BoxStatefulBiConsumer<T, U>

§

impl<T, U> !Send for BoxStatefulBiConsumer<T, U>

§

impl<T, U> !Sync for BoxStatefulBiConsumer<T, U>

§

impl<T, U> Unpin for BoxStatefulBiConsumer<T, U>

§

impl<T, U> UnsafeUnpin for BoxStatefulBiConsumer<T, U>

§

impl<T, U> !UnwindSafe for BoxStatefulBiConsumer<T, U>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToString for T
where T: Display + ?Sized,

Source§

fn to_string(&self) -> String

Converts the given value to a String. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.