Struct RcConditionalBiConsumer 

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

RcConditionalBiConsumer struct

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

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

Examples

use prism3_function::{BiConsumer, RcBiConsumer};
use std::rc::Rc;
use std::cell::RefCell;

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

Author

Haixing Hu

Implementations

impl<T, U> RcConditionalBiConsumer<T, U>

where T: 'static, U: 'static,

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

where C: BiConsumer<T, U> + '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. 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). Can be:
  • A closure: |x: &T, y: &U|
  • An RcBiConsumer<T, U>
  • A BoxBiConsumer<T, U>
  • Any type implementing BiConsumer<T, U>

Returns

Returns the composed RcBiConsumer<T, U>

Examples

Using a closure (recommended)

use prism3_function::{BiConsumer, RcBiConsumer};
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 = RcBiConsumer::new(move |x: &i32, y: &i32| {
    l1.borrow_mut().push(*x + *y);
}).when(|x: &i32, y: &i32| *x > 0 && *y > 0)
  .or_else(move |x: &i32, y: &i32| {
    l2.borrow_mut().push(*x * *y);
});

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

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

Trait Implementations

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

where T: 'static, U: 'static,

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

Performs the consumption operation

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

Converts to BoxBiConsumer

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

Converts to RcBiConsumer

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

Converts bi-consumer to a closure

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

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

Converts to ArcBiConsumer

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 RcConditionalBiConsumer<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.