pub struct ArcStatefulBiConsumer<T, U> { /* private fields */ }Expand description
ArcStatefulBiConsumer struct
A bi-consumer implementation based on
Arc<Mutex<dyn FnMut(&T, &U) + Send>> for thread-safe shared
ownership scenarios. This consumer can be safely cloned and shared
across multiple threads.
§Features
- Shared Ownership: Cloneable via
Arc, multiple owners allowed - Thread-Safe: Implements
Send + Sync, safe for concurrent use - Interior Mutability: Uses
Mutexfor safe mutable access - Non-Consuming API:
and_thenborrows&self, original remains usable - Cross-Thread Sharing: Can be sent to and used by other threads
§Use Cases
Choose ArcStatefulBiConsumer when:
- Need to share bi-consumer across multiple threads
- Concurrent task processing (e.g., thread pools)
- Using the same consumer in multiple places simultaneously
- Thread safety (Send + Sync) is required
§Performance Considerations
ArcStatefulBiConsumer has some overhead compared to BoxStatefulBiConsumer:
- Reference Counting: Atomic operations on clone/drop
- Mutex Locking: Each
acceptcall requires lock acquisition - Lock Contention: High concurrency may cause contention
These overheads are necessary for safe concurrent access. If thread
safety is not needed, consider using RcStatefulBiConsumer for lower
overhead in single-threaded sharing.
§Examples
use prism3_function::{BiConsumer, ArcStatefulBiConsumer};
use std::sync::{Arc, Mutex};
let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let mut consumer = ArcStatefulBiConsumer::new(move |x: &i32, y: &i32| {
l.lock().unwrap().push(*x + *y);
});
let mut clone = consumer.clone();
consumer.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);§Author
Haixing Hu
Implementations§
Source§impl<T, U> ArcStatefulBiConsumer<T, U>where
T: 'static,
U: 'static,
impl<T, U> ArcStatefulBiConsumer<T, U>where
T: 'static,
U: 'static,
Sourcepub fn new<F>(f: F) -> Self
pub fn new<F>(f: F) -> Self
Creates a new bi-consumer.
Wraps the provided closure in the appropriate smart pointer type for this bi-consumer implementation.
Sourcepub fn new_with_name<F>(name: &str, f: F) -> Self
pub fn new_with_name<F>(name: &str, f: F) -> Self
Creates a new named bi-consumer.
Wraps the provided closure and assigns it a name, which is useful for debugging and logging purposes.
Sourcepub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self
pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self
Creates a new named bi-consumer with an optional name.
Wraps the provided closure and assigns it an optional name.
Sourcepub fn noop() -> Self
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.
Sourcepub fn when<P>(&self, predicate: P) -> ArcConditionalStatefulBiConsumer<T, U>
pub fn when<P>(&self, predicate: P) -> ArcConditionalStatefulBiConsumer<T, U>
Creates a conditional bi-consumer
Wraps this bi-consumer with a bi-predicate condition, creating a new conditional bi-consumer that will only execute the original bi-consumer when the predicate evaluates to true.
§Parameters
predicate- The condition that must be satisfied for the bi-consumer to execute
§Returns
Returns a conditional bi-consumer that executes this bi-consumer only when the predicate is satisfied
§Examples
let consumer = ArcBiConsumer::new(|x: &i32, y: &i32| println!("{}", x + y));
let conditional = consumer.when(|x, y| *x > 0 && *y > 0);
conditional.accept(&5, &3); // prints: 8
conditional.accept(&-5, &3); // prints nothingSourcepub fn and_then<C>(&self, after: C) -> ArcStatefulBiConsumer<T, U>
pub fn and_then<C>(&self, after: C) -> ArcStatefulBiConsumer<T, U>
Chains another bi-consumer in sequence
Combines this bi-consumer with another bi-consumer into a new
bi-consumer that executes both bi-consumers in sequence. The returned
bi-consumer first executes this bi-consumer, then unconditionally
executes the after bi-consumer.
§Parameters
after- The bi-consumer to execute after this one (always executed)
§Returns
Returns a new bi-consumer that executes both bi-consumers in sequence
§Examples
let consumer1 = ArcBiConsumer::new(|x: &i32, y: &i32| print!("first: {}", x + y));
let consumer2 = ArcBiConsumer::new(|x: &i32, y: &i32| println!(" second: {}", x * y));
let chained = consumer1.and_then(consumer2);
chained.accept(&5, &3); // prints: first: 8 second: 15