pub struct RcBiConsumer<T, U> { /* private fields */ }Expand description
RcBiConsumer struct
A readonly bi-consumer implementation based on Rc<dyn Fn(&T, &U)>
for single-threaded shared ownership scenarios. No need for RefCell
because operations are readonly.
§Features
- Shared Ownership: Cloneable via
Rc, multiple owners allowed - Single-Threaded: Not thread-safe, cannot send across threads
- No Interior Mutability Overhead: No need for RefCell because readonly
- Non-Consuming API:
and_thenborrows&self, original remains usable
§Use Cases
Choose RcBiConsumer when:
- Need to share readonly bi-consumer within a single thread
- Pure observation operations, performance critical
- Single-threaded UI framework event handling
§Performance Advantages
RcBiConsumer has neither Arc’s atomic operation overhead nor
RefCell’s runtime borrow checking overhead, making it the best
performing among the three readonly bi-consumer types.
§Examples
use prism3_function::{BiConsumer, RcBiConsumer};
let consumer = RcBiConsumer::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> RcBiConsumer<T, U>where
T: 'static,
U: 'static,
impl<T, U> RcBiConsumer<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) -> RcConditionalBiConsumer<T, U>where
P: BiPredicate<T, U> + 'static,
pub fn when<P>(&self, predicate: P) -> RcConditionalBiConsumer<T, U>where
P: BiPredicate<T, U> + '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 nothingSourcepub fn and_then<C>(&self, after: C) -> RcBiConsumer<T, U>where
T: 'static,
U: 'static,
C: BiConsumer<T, U> + 'static,
pub fn and_then<C>(&self, after: C) -> RcBiConsumer<T, U>where
T: 'static,
U: 'static,
C: BiConsumer<T, U> + '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