Struct ArcStatefulConsumer 

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

ArcStatefulConsumer struct

Consumer implementation based on Arc<Mutex<dyn FnMut(&T) + Send>> for thread-safe shared ownership scenarios. This consumer can be safely cloned and shared across multiple threads.

Features

• Shared Ownership: Cloneable through Arc, allowing multiple owners
• Thread Safety: Implements Send + Sync, safe for concurrent use
• Interior Mutability: Uses Mutex for safe mutable access
• Non-Consuming API: and_then borrows &self, original object remains usable
• Cross-Thread Sharing: Can be sent to other threads and used

Use Cases

Choose ArcStatefulConsumer when:

• Need to share consumers across multiple threads
• Concurrent task processing (e.g., thread pools)
• Using the same consumer in multiple places simultaneously
• Need thread safety (Send + Sync)

Performance Considerations

ArcStatefulConsumer has some performance overhead compared to BoxStatefulConsumer:

• Reference Counting: Atomic operations on clone/drop
• Mutex Locking: Each accept call requires lock acquisition
• Lock Contention: High concurrency may cause contention

These overheads are necessary for safe concurrent access. If thread safety is not needed, consider using RcStatefulConsumer for less single-threaded sharing overhead.

Examples

use prism3_function::{Consumer, ArcStatefulConsumer};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let mut consumer = ArcStatefulConsumer::new(move |x: &i32| {
    l.lock().unwrap().push(*x * 2);
});
let mut clone = consumer.clone();

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

Author

Haixing Hu

Implementations

impl<T> ArcStatefulConsumer<T>

where T: 'static,

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

where F: FnMut(&T) + Send + '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: FnMut(&T) + Send + '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: FnMut(&T) + Send + '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) -> ArcConditionalStatefulConsumer<T>

where P: Predicate<T> + Send + Sync + '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) -> ArcStatefulConsumer<T>

where T: 'static, C: StatefulConsumer<T> + Send + Sync + '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 ArcStatefulConsumer<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 ArcStatefulConsumer<T>

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

Formats the value using the given formatter.

impl<T> Display for ArcStatefulConsumer<T>

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

Formats the value using the given formatter.

impl<T> StatefulConsumer<T> for ArcStatefulConsumer<T>

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

Execute consumption operation

fn into_box(self) -> BoxStatefulConsumer<T>

where T: 'static,

Convert to BoxStatefulConsumer

fn into_rc(self) -> RcStatefulConsumer<T>

where T: 'static,

Convert to RcStatefulConsumer

fn into_arc(self) -> ArcStatefulConsumer<T>

where T: 'static,

Convert to ArcStatefulConsumer

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

Convert to closure

fn into_once(self) -> BoxConsumerOnce<T>

where T: 'static,

Convert to ConsumerOnce

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

where T: 'static,

Convert to BoxStatefulConsumer

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

where T: 'static,

Convert to RcStatefulConsumer

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

where T: 'static,

Convert to ArcStatefulConsumer

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

Convert to closure

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

where T: 'static,

Convert to ConsumerOnce without consuming self