Struct RcConsumer 

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

RcConsumer struct

Readonly consumer implementation based on Rc<dyn Fn(&T)> for single-threaded shared ownership scenarios. No RefCell needed because operations are readonly.

Features

• Shared Ownership: Cloneable through Rc, allows multiple owners
• Single-threaded: Not thread-safe, cannot be sent across threads
• No Interior Mutability Overhead: No RefCell needed because it’s readonly
• Non-consuming API: and_then borrows &self, original object remains usable

Use Cases

Choose RcConsumer when:

• Need to share readonly consumer within a single thread
• Pure observation operations, performance critical
• Event handling in single-threaded UI frameworks

Performance Advantages

RcConsumer has neither Arc’s atomic operation overhead nor RefCell’s runtime borrow checking overhead, making it the most performant of the three readonly consumers.

Examples

use prism3_function::{Consumer, RcConsumer};

let consumer = RcConsumer::new(|x: &i32| {
    println!("Observed: {}", x);
});
let clone = consumer.clone();

consumer.accept(&5);
clone.accept(&10);

Author

Haixing Hu

Implementations

impl<T> RcConsumer<T>

where T: 'static,

pub fn new<F>(f: F) -> Self

where F: Fn(&T) + 'static,

Creates a new consumer.

Wraps the provided closure in the appropriate smart pointer type for this consumer implementation.

pub fn new_with_name<F>(name: &str, f: F) -> Self

where F: Fn(&T) + 'static,

Creates a new named consumer.

Wraps the provided closure and assigns it a name, which is useful for debugging and logging purposes.

pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self

where F: Fn(&T) + 'static,

Creates a new named consumer with an optional name.

Wraps the provided closure and assigns it an optional name.

pub fn name(&self) -> Option<&str>

Gets the name of this consumer.

Returns

Returns Some(&str) if a name was set, None otherwise.

pub fn set_name(&mut self, name: &str)

Sets the name of this consumer.

Parameters

• name - The name to set for this consumer

pub fn noop() -> Self

Creates a no-operation consumer.

Creates a consumer that does nothing when called. Useful for default values or placeholder implementations.

Returns

Returns a new consumer instance that performs no operation.

pub fn when<P>(&self, predicate: P) -> RcConditionalConsumer<T>

where P: Predicate<T> + 'static,

Creates a conditional consumer

Wraps this consumer with a predicate condition, creating a new conditional consumer that will only execute the original consumer when the predicate evaluates to true.

Parameters

• predicate - The condition that must be satisfied for the consumer to execute

Returns

Returns a conditional consumer that executes this consumer only when the predicate is satisfied

Examples

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

conditional.accept(&5);  // prints: 5
conditional.accept(&-5); // prints nothing

pub fn and_then<C>(&self, after: C) -> RcConsumer<T>

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

Chains another consumer in sequence

Combines this consumer with another consumer into a new consumer that executes both consumers in sequence. The returned consumer first executes this consumer, then unconditionally executes the after consumer.

Parameters

• after - The consumer to execute after this one (always executed)

Returns

Returns a new consumer that executes both consumers in sequence

Examples

let consumer1 = ArcConsumer::new(|x: &i32| print!("first: {}", x));
let consumer2 = ArcConsumer::new(|x: &i32| println!(" second: {}", x));

let chained = consumer1.and_then(consumer2);

chained.accept(&5);  // prints: first: 5 second: 5

Trait Implementations

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

fn accept(&self, value: &T)

Execute readonly 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_fn(self) -> impl Fn(&T)

Convert to closure

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

where T: 'static,

Non-consuming conversion to BoxConsumer

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

where T: 'static,

Non-consuming conversion to RcConsumer

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

Non-consuming conversion to a boxed closure

fn into_once(self) -> BoxConsumerOnce<T>

where T: 'static,

Convert to ConsumerOnce

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

where T: 'static,

Convert to ConsumerOnce without consuming self

fn into_arc(self) -> ArcConsumer<T>

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

Convert to ArcConsumer

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

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

Non-consuming conversion to ArcConsumer

impl<T> Debug for RcConsumer<T>

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

Formats the value using the given formatter.

impl<T> Display for RcConsumer<T>

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

Formats the value using the given formatter.