Struct ArcBiConsumer

Source

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

Expand description

ArcBiConsumer struct

A readonly bi-consumer implementation based on Arc<dyn Fn(&T, &U) + Send + Sync> for thread-safe shared ownership scenarios. No need for Mutex because operations are readonly.

§Features

Shared Ownership: Cloneable via Arc, multiple owners allowed
Thread-Safe: Implements Send + Sync, safe for concurrent use
No Locks: Because readonly, no need for Mutex protection
Non-Consuming API: and_then borrows &self, original remains usable

§Use Cases

Choose ArcBiConsumer when:

Need to share readonly bi-consumer across multiple threads
Pure observation operations like logging, monitoring, notifications
Need high-concurrency reads without lock overhead

§Performance Advantages

Compared to ArcBiConsumer, ArcBiConsumer has no Mutex locking overhead, resulting in better performance in high-concurrency scenarios.

§Examples

use prism3_function::{BiConsumer, ArcBiConsumer};

let consumer = ArcBiConsumer::new(|x: &i32, y: &i32| {
    println!("Sum: {}", x + y);
});
let clone = consumer.clone();

consumer.accept(&5, &3);
clone.accept(&10, &20);

§Author

Haixing Hu

Implementations§

Source §

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

Source

pub fn new<F>(f: F) -> Self
where F: Fn(&T, &U) + Send + Sync + '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: Fn(&T, &U) + Send + Sync + '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: Fn(&T, &U) + Send + Sync + '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) -> ArcConditionalBiConsumer<T, U>
where P: BiPredicate<T, U> + Send + Sync + 'static,

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 nothing

Source

pub fn and_then<C>(&self, after: C) -> ArcBiConsumer<T, U>
where T: 'static, U: 'static, C: BiConsumer<T, U> + Send + Sync + 'static,

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