Struct ArcConditionalBiConsumer 

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

ArcConditionalBiConsumer struct

A conditional bi-consumer that wraps an ArcBiConsumer and only executes when a predicate is satisfied. Based on Arc for thread-safe shared ownership.

Features

• Shared Ownership: Cloneable through Arc, allows multiple owners
• Thread Safe: Implements Send + Sync, can be safely used concurrently
• Conditional Execution: Only consumes when predicate returns true
• Implements BiConsumer: Can be used anywhere a BiConsumer is expected
• Readonly: Neither modifies itself nor input values

Author

Haixing Hu

Implementations

impl<T, U> ArcConditionalBiConsumer<T, U>

pub fn and_then<C>(&self, next: C) -> ArcBiConsumer<T, U>

where T: 'static, U: 'static, C: BiConsumer<T, U> + Send + Sync + 'static,

Chains another bi-consumer in sequence

Combines the current conditional bi-consumer with another bi-consumer into a new bi-consumer that implements the following semantics:

When the returned bi-consumer is called with two arguments:

1. First, it checks the predicate of this conditional bi-consumer
2. If the predicate is satisfied, it executes the internal bi-consumer of this conditional bi-consumer
3. Then, regardless of whether the predicate was satisfied, it unconditionally executes the next bi-consumer

In other words, this creates a bi-consumer that conditionally executes the first action (based on the predicate), and then always executes the second action.

Parameters

• next - The next bi-consumer to execute (always executed)

Returns

Returns a new combined bi-consumer

Examples

use std::sync::atomic::{AtomicI32, Ordering};
use std::sync::Arc;
use qubit_function::{BiConsumer, ArcBiConsumer};

let result = Arc::new(AtomicI32::new(0));
let result1 = std::sync::Arc::clone(&result);
let consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
    result1.fetch_add(*x + *y, Ordering::SeqCst);
});

let consumer2 = consumer.when(|x: &i32, y: &i32| *x > 0 && *y > 0);
let result2 = std::sync::Arc::clone(&result);
let chained = consumer2.and_then(ArcBiConsumer::new(move |x: &i32, y: &i32| {
    result2.fetch_add(2 * (*x + *y), Ordering::SeqCst);
}));

chained.accept(&5, &3);  // result = (5+3) + 2*(5+3) = 24
result.store(0, Ordering::SeqCst);  // reset
chained.accept(&-5, &3); // result = 0 + 2*(-5+3) = -4 (not -8!)
assert_eq!(result.load(Ordering::SeqCst), -4);

pub fn or_else<C>(&self, else_consumer: C) -> ArcBiConsumer<T, U>

where T: 'static, U: 'static, C: BiConsumer<T, U> + Send + Sync + 'static,

Adds an else branch

Executes the original bi-consumer when the condition is satisfied, otherwise executes else_consumer.

Parameters

• else_consumer - The bi-consumer for the else branch

Returns

Returns a new bi-consumer with if-then-else logic

Trait Implementations

impl<T, U> BiConsumer<T, U> for ArcConditionalBiConsumer<T, U>

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

Performs the readonly consumption operation

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

where Self: 'static,

Converts to BoxBiConsumer

fn into_rc(self) -> RcBiConsumer<T, U>

where Self: 'static,

Converts to RcBiConsumer

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

Converts readonly bi-consumer to a closure

fn into_arc(self) -> ArcBiConsumer<T, U>

where Self: Sized + Send + Sync + 'static,

Converts to ArcBiConsumer

fn into_once(self) -> BoxBiConsumerOnce<T, U>

where Self: Sized + 'static,

Convert to BiConsumerOnce

fn to_box(&self) -> BoxBiConsumer<T, U>

where Self: Clone + 'static,

Converts to BoxBiConsumer (without consuming self)

fn to_rc(&self) -> RcBiConsumer<T, U>

where Self: Clone + 'static,

Converts to RcBiConsumer (without consuming self)

fn to_arc(&self) -> ArcBiConsumer<T, U>

where Self: Clone + Send + Sync + 'static,

Converts to ArcBiConsumer (without consuming self)

fn to_fn(&self) -> impl Fn(&T, &U)

where Self: Clone + 'static,

Converts to a closure (without consuming self)

fn to_once(&self) -> BoxBiConsumerOnce<T, U>

where Self: Clone + 'static,

Convert to BiConsumerOnce without consuming self

impl<T, U> Clone for ArcConditionalBiConsumer<T, U>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.