Struct ArcReadonlyConsumer

Source

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

Expand description

ArcReadonlyConsumer struct

Readonly consumer implementation based on Arc<dyn Fn(&T) + Send + Sync>, for thread-safe shared ownership scenarios. No Mutex needed because operations are readonly.

§Features

Shared Ownership: Cloneable through Arc, allows multiple owners
Thread Safe: Implements Send + Sync, can be safely used concurrently
Lock-free: No Mutex protection needed because it’s readonly
Non-consuming API: and_then borrows &self, original object remains usable

§Use Cases

Choose ArcReadonlyConsumer when:

Need to share readonly consumer across multiple threads
Pure observation operations, such as logging, monitoring, notifications
Need high-concurrency reads with no lock overhead

§Performance Advantages

Compared to ArcConsumer, ArcReadonlyConsumer has no Mutex lock overhead, performing better in high-concurrency scenarios.

§Examples

use prism3_function::{ReadonlyConsumer, ArcReadonlyConsumer};

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

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

§Author

Hu Haixing

Implementations§

Source §

impl<T> ArcReadonlyConsumer<T>
where T: Send + Sync + 'static,

Source

pub fn new<F>(f: F) -> Self
where F: Fn(&T) + Send + Sync + 'static,

Create a new ArcReadonlyConsumer

§Type Parameters

F - Closure type

§Parameters

f - Closure to wrap

§Returns

Returns a new ArcReadonlyConsumer<T> instance

§Examples

use prism3_function::{ReadonlyConsumer, ArcReadonlyConsumer};

let consumer = ArcReadonlyConsumer::new(|x: &i32| {
    println!("Value: {}", x);
});
consumer.accept(&5);

Source

pub fn noop() -> Self

Create a no-op consumer

§Returns

Returns a no-op consumer

Source

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

Get the consumer’s name

Source

pub fn set_name(&mut self, name: impl Into<String>)

Set the consumer’s name

Source

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

Sequentially chain another ArcReadonlyConsumer

Returns a new consumer that executes the current operation first, then the next operation. Borrows &self, does not consume the original consumer.

§Parameters

next - Consumer to execute after the current operation. Note: This parameter is passed by reference, so the original consumer remains usable. Can be:
- An ArcReadonlyConsumer<T> (passed by reference)
- Any type implementing ReadonlyConsumer<T> + Send + Sync

§Returns

Returns a new combined ArcReadonlyConsumer<T>

§Examples

use prism3_function::{ReadonlyConsumer, ArcReadonlyConsumer};

let first = ArcReadonlyConsumer::new(|x: &i32| {
    println!("First: {}", x);
});
let second = ArcReadonlyConsumer::new(|x: &i32| {
    println!("Second: {}", x);
});

// second is passed by reference, so it remains usable
let chained = first.and_then(&second);

// first and second remain usable after chaining
chained.accept(&5);
first.accept(&3); // Still usable
second.accept(&7); // Still usable