Struct ArcConditionalConsumer 

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

ArcConditionalConsumer struct

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

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 through Arc, allows multiple owners
• Thread Safe: Implements Send + Sync, can be safely used concurrently
• Conditional Execution: Only consumes when predicate returns true
• Chainable: Can add or_else branch to create if-then-else logic
• Implements Consumer: Can be used anywhere a Consumer is expected
• Readonly: Neither modifies itself nor input values

Examples

Basic Conditional Execution

use prism3_function::{Consumer, ArcConsumer};

let consumer = ArcConsumer::new(|x: &i32| {
    println!("Positive: {}", x);
});
let conditional = consumer.when(|x: &i32| *x > 0);

conditional.accept(&5);  // Prints: Positive: 5
conditional.accept(&-5); // Does nothing

With or_else Branch

use prism3_function::{Consumer, ArcConsumer};

let consumer = ArcConsumer::new(|x: &i32| {
    println!("Positive: {}", x);
})
.when(|x: &i32| *x > 0)
.or_else(|x: &i32| {
    println!("Non-positive: {}", x);
});

consumer.accept(&5);  // Prints: Positive: 5
consumer.accept(&-5); // Prints: Non-positive: -5

Author

Haixing Hu

Implementations

impl<T> ArcConditionalConsumer<T>

where T: 'static,

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

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

Chains another consumer in sequence

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

When the returned consumer is called with an argument:

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

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

Parameters

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

Returns

Returns a new combined consumer

Examples

use std::sync::atomic::{AtomicI32, Ordering};

let result = AtomicI32::new(0);

let consumer1 = ArcConsumer::new(|x: &i32| {
    result.fetch_add(*x, Ordering::SeqCst);
});

let consumer2 = ArcConsumer::new(|x: &i32| {
    result.fetch_add(2 * (*x), Ordering::SeqCst);
});

let conditional = consumer1.when(|x| *x > 0);
let chained = conditional.and_then(consumer2);

chained.accept(&5);  // result = 5 + (2*5) = 15
result.store(0, Ordering::SeqCst);  // reset
chained.accept(&-5); // result = 0 + (2*-5) = -10 (not -15!)

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

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

Adds an else branch

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

Parameters

• else_consumer - The consumer for the else branch

Returns

Returns a new consumer with if-then-else logic

Trait Implementations

impl<T> Clone for ArcConditionalConsumer<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where T: 'static,

fn accept(&self, value: &T)

Execute readonly consumption operation

fn into_box(self) -> BoxConsumer<T>

Convert to BoxConsumer

fn into_rc(self) -> RcConsumer<T>

Convert to RcConsumer

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

Convert to closure

fn into_arc(self) -> ArcConsumer<T>

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

Convert to ArcConsumer

fn into_once(self) -> BoxConsumerOnce<T>

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

Convert to ConsumerOnce

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

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

Non-consuming conversion to BoxConsumer

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

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

Non-consuming conversion to RcConsumer

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

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

Non-consuming conversion to ArcConsumer

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

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

Non-consuming conversion to a boxed closure

fn to_once(&self) -> BoxConsumerOnce<T>

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

Convert to ConsumerOnce without consuming self

impl<T> Debug for ArcConditionalConsumer<T>

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

Formats the value using the given formatter.

impl<T> Display for ArcConditionalConsumer<T>

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

Formats the value using the given formatter.