Struct ArcConditionalBiConsumer 

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

ArcConditionalBiConsumer struct

A thread-safe conditional bi-consumer that only executes when a predicate is satisfied. Uses ArcBiConsumer and ArcBiPredicate for shared ownership across threads.

This type is typically created by calling ArcBiConsumer::when() and is designed to work with the or_else() method to create if-then-else logic.

Features

• Shared Ownership: Cloneable via Arc, multiple owners allowed
• Thread-Safe: Implements Send + Sync, safe for concurrent use
• Conditional Execution: Only consumes when predicate returns true
• Chainable: Can add or_else branch to create if-then-else logic

Examples

use prism3_function::{BiConsumer, ArcBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let conditional = ArcBiConsumer::new(move |x: &i32, y: &i32| {
    l.lock().unwrap().push(*x + *y);
}).when(|x: &i32, y: &i32| *x > 0 && *y > 0);

let conditional_clone = conditional.clone();

let mut value = 5;
let mut m = conditional;
m.accept(&value, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

Author

Haixing Hu

Implementations

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

where T: Send + 'static, U: Send + 'static,

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

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

Adds an else branch (thread-safe version)

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

Parameters

• else_consumer - The consumer for the else branch. Note: This parameter is passed by value and will transfer ownership. If you need to preserve the original consumer, clone it first (if it implements Clone). Must be Send, can be:
  • A closure: |x: &T, y: &U| (must be Send)
  • An ArcBiConsumer<T, U>
  • A BoxBiConsumer<T, U>
  • Any type implementing BiConsumer<T, U> + Send

Returns

Returns the composed ArcBiConsumer<T, U>

Examples

Using a closure (recommended)

use prism3_function::{BiConsumer, ArcBiConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l1 = log.clone();
let l2 = log.clone();
let mut consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
    l1.lock().unwrap().push(*x + *y);
}).when(|x: &i32, y: &i32| *x > 0 && *y > 0)
  .or_else(move |x: &i32, y: &i32| {
    l2.lock().unwrap().push(*x * *y);
});

consumer.accept(&5, &3);
assert_eq!(*log.lock().unwrap(), vec![8]);

consumer.accept(&-5, &3);
assert_eq!(*log.lock().unwrap(), vec![8, -15]);

Trait Implementations

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

where T: Send + 'static, U: Send + 'static,

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

Performs the consumption operation

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

where T: 'static, U: 'static,

Converts to BoxBiConsumer

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

where T: 'static, U: 'static,

Converts to RcBiConsumer

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

where T: Send + 'static, U: Send + 'static,

Converts to ArcBiConsumer

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

where T: 'static, U: 'static,

Converts bi-consumer to a closure

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

where Self: Sized + Clone + 'static, T: 'static, U: 'static,

Converts to BoxBiConsumer (non-consuming)

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

where Self: Sized + Clone + 'static, T: 'static, U: 'static,

Converts to RcBiConsumer (non-consuming)

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

where Self: Sized + Clone + Send + 'static, T: Send + 'static, U: Send + 'static,

Converts to ArcBiConsumer (non-consuming)

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

where Self: Sized + Clone + 'static, T: 'static, U: 'static,

Converts to closure (non-consuming)

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

fn clone(&self) -> Self

Clones the conditional consumer

Creates a new instance that shares the underlying consumer and predicate with the original instance.

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

Performs copy-assignment from source.