Struct RcConditionalConsumer 

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

RcConditionalConsumer struct

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

This type is typically created by calling RcConsumer::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 ArcConditionalConsumer

Examples

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

let log = Rc::new(RefCell::new(Vec::new()));
let l = log.clone();
let conditional = RcConsumer::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

Hu Haixing

Implementations

impl<T> RcConditionalConsumer<T>

where T: 'static,

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

where C: Consumer<T> + 'static,

Adds an else branch (single-threaded shared 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|
  • RcConsumer<T>, BoxConsumer<T>
  • Any type implementing Consumer<T>

Returns

Returns the composed RcConsumer<T>

Examples

Using a closure (recommended)

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

let log = Rc::new(RefCell::new(Vec::new()));
let l1 = log.clone();
let l2 = log.clone();
let mut consumer = RcConsumer::new(move |x: &i32| {
    l1.borrow_mut().push(*x);
})
.when(|x: &i32| *x > 0)
.or_else(move |x: &i32| {
    l2.borrow_mut().push(-*x);
});

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

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

Trait Implementations

impl<T> Clone for RcConditionalConsumer<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 RcConditionalConsumer<T>

where T: 'static,

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

Execute 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 FnMut(&T)

Convert to closure

fn into_arc(self) -> ArcConsumer<T>

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

Convert to ArcConsumer

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