Struct ArcConditionalConsumer 

pub struct ArcConditionalConsumer<T> { /* private fields */ }

ArcConditionalConsumer struct

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

This type is typically created by calling ArcConsumer::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::{Consumer, ArcConsumer};
use std::sync::{Arc, Mutex};

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

let conditional_clone = conditional.clone();

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

Author

Hu Haixing

Implementations

impl<T> ArcConditionalConsumer<T>

where T: Send + 'static,

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

where C: Consumer<T> + Send + 'static, T: 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, can be:
  • Closure: |x: &T| (must be Send)
  • ArcConsumer<T>, BoxConsumer<T>
  • Any type implementing Consumer<T> + Send

Returns

Returns the composed ArcConsumer<T>

Examples

Using a closure (recommended)

use prism3_function::{Consumer, ArcConsumer};
use std::sync::{Arc, Mutex};

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

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

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

Trait Implementations

impl<T> Clone for ArcConditionalConsumer<T>

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.

impl<T> Consumer<T> for ArcConditionalConsumer<T>

where T: Send + 'static,

fn accept(&mut self, value: &T)

Execute consumption operation

fn into_box(self) -> BoxConsumer<T>

where T: 'static,

Convert to BoxConsumer

fn into_rc(self) -> RcConsumer<T>

where T: 'static,

Convert to RcConsumer

fn into_arc(self) -> ArcConsumer<T>

where T: Send + 'static,

Convert to ArcConsumer

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

where T: 'static,

Convert to closure

fn to_box(&self) -> BoxConsumer<T>

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

Convert to BoxConsumer

fn to_rc(&self) -> RcConsumer<T>

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

Convert to RcConsumer

fn to_arc(&self) -> ArcConsumer<T>

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

Convert to ArcConsumer

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

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

Convert to closure