Struct RcConditionalStatefulConsumer 

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

RcConditionalStatefulConsumer struct

A single-threaded conditional consumer that only executes when a predicate is satisfied. Uses RcStatefulConsumer and RcPredicate for shared ownership within a single thread.

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

Features

• Shared Ownership: Cloneable via Rc, multiple owners allowed
• Single-Threaded: Not thread-safe, cannot be sent across threads
• Conditional Execution: Only consumes when predicate returns true
• No Lock Overhead: More efficient than ArcConditionalStatefulConsumer

Examples

use prism3_function::{Consumer, RcStatefulConsumer};
use std::rc::Rc;
use std::cell::RefCell;

let log = Rc::new(RefCell::new(Vec::new()));
let l = log.clone();
let conditional = RcStatefulConsumer::new(move |x: &i32| {
    l.borrow_mut().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.borrow(), vec![5]);

Author

Haixing Hu

Implementations

impl<T> RcConditionalStatefulConsumer<T>

where T: 'static,

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

where C: StatefulConsumer<T> + '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) -> RcStatefulConsumer<T>

where C: StatefulConsumer<T> + '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 RcConditionalStatefulConsumer<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> Debug for RcConditionalStatefulConsumer<T>

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

Formats the value using the given formatter.

impl<T> Display for RcConditionalStatefulConsumer<T>

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

Formats the value using the given formatter.

impl<T> StatefulConsumer<T> for RcConditionalStatefulConsumer<T>

where T: 'static,

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

Execute consumption operation

fn into_box(self) -> BoxStatefulConsumer<T>

Convert to BoxStatefulConsumer

fn into_rc(self) -> RcStatefulConsumer<T>

Convert to RcStatefulConsumer

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

Convert to closure

fn into_arc(self) -> ArcStatefulConsumer<T>

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

Convert to ArcStatefulConsumer

fn into_once(self) -> BoxConsumerOnce<T>

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

Convert to ConsumerOnce

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

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

Convert to BoxStatefulConsumer

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

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

Convert to RcStatefulConsumer

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

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

Convert to ArcStatefulConsumer

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

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

Convert to closure

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

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

Convert to ConsumerOnce without consuming self