Struct BoxBiConsumer

Source

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

Expand description

BoxBiConsumer struct

A readonly bi-consumer implementation based on Box<dyn Fn(&T, &U)> for single ownership scenarios.

§Features

Single Ownership: Not cloneable, ownership moves on use
Zero Overhead: No reference counting or locking
Fully Immutable: Neither modifies itself nor input values
No Interior Mutability: No need for Mutex or RefCell

§Use Cases

Choose BoxBiConsumer when:

The readonly bi-consumer is used only once or in a linear flow
No need to share the consumer across contexts
Pure observation operations like logging

§Examples

use prism3_function::{BiConsumer, BoxBiConsumer};

let consumer = BoxBiConsumer::new(|x: &i32, y: &i32| {
    println!("Sum: {}", x + y);
});
consumer.accept(&5, &3);

§Author

Haixing Hu

Implementations§

Source §

impl<T, U> BoxBiConsumer<T, U>
where T: 'static, U: 'static,

Source

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

Creates a new bi-consumer.

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

Source

pub fn new_with_name<F>(name: &str, f: F) -> Self
where F: Fn(&T, &U) + 'static,

Creates a new named bi-consumer.

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

Source

pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self
where F: Fn(&T, &U) + 'static,

Creates a new named bi-consumer with an optional name.

Wraps the provided closure and assigns it an optional name.

Source

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

Gets the name of this bi-consumer.

§Returns

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

Source

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

Sets the name of this bi-consumer.

§Parameters

name - The name to set for this bi-consumer

Source

pub fn noop() -> Self

Creates a no-operation bi-consumer.

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

§Returns

Returns a new bi-consumer instance that performs no operation.

Source

pub fn when(self, predicate: P) -> BoxConditionalBiConsumer<T, U>
where P: BiPredicate<T, U> + 'static,

Creates a conditional two-parameter consumer that executes based on bi-predicate result.

§Parameters

predicate - The bi-predicate to determine whether to execute the consumption operation

§Returns

Returns a conditional two-parameter consumer that only executes when the predicate returns true.

§Examples

use std::sync::Arc;
use std::sync::atomic::{AtomicI32, Ordering};
use prism3_rust_function::consumers::*;

let counter = Arc::new(AtomicI32::new(0));
let bi_consumer = BoxBiConsumer::new({
    let counter = Arc::clone(&counter);
    move |key: &String, value: &i32| {
        if key == "increment" {
            counter.fetch_add(*value, Ordering::SeqCst);
        }
    }
});

let conditional = bi_consumer.when(|key: &String, value: &i32| *value > 0);
conditional.accept(&"increment".to_string(), &5);  // counter = 5
conditional.accept(&"increment".to_string(), &-2); // not executed

Source

pub fn and_then<C>(self, after: C) -> BoxBiConsumer<T, U>
where Self: Sized + 'static, T: 'static, U: 'static, C: BiConsumer<T, U> + 'static,

Chains execution with another two-parameter consumer, executing the current consumer first, then the subsequent consumer.

§Parameters

after - The subsequent two-parameter consumer to execute after the current consumer completes

§Returns

Returns a new two-parameter consumer that executes the current consumer and the subsequent consumer in sequence.

§Examples

use std::sync::Arc;
use std::sync::atomic::{AtomicI32, Ordering};
use prism3_rust_function::consumers::*;

let counter1 = Arc::new(AtomicI32::new(0));
let counter2 = Arc::new(AtomicI32::new(0));

let bi_consumer1 = BoxBiConsumer::new({
    let counter = Arc::clone(&counter1);
    move |key: &String, value: &i32| {
        counter.fetch_add(*value, Ordering::SeqCst);
    }
});

let bi_consumer2 = BoxBiConsumer::new({
    let counter = Arc::clone(&counter2);
    move |key: &String, value: &i32| {
        counter.fetch_add(*value * 2, Ordering::SeqCst);
    }
});

let chained = bi_consumer1.and_then(bi_consumer2);
chained.accept(&"test".to_string(), &3);
// counter1 = 3, counter2 = 6