prism3_function::consumers::bi_consumer_once

Struct BoxBiConsumerOnce

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

Expand description

BoxBiConsumerOnce struct

A one-time bi-consumer implementation based on Box<dyn FnOnce(&T, &U)> for single ownership scenarios. This is the simplest one-time bi-consumer type for truly one-time use.

§Features

Single Ownership: Not cloneable, ownership moves on use
Zero Overhead: No reference counting or locking
One-Time Use: Consumes self on first call
Builder Pattern: Method chaining consumes self naturally

§Use Cases

Choose BoxBiConsumerOnce when:

The bi-consumer is truly used only once
Building pipelines where ownership naturally flows
The consumer captures values that should be consumed
Performance is critical and sharing overhead is unacceptable

§Performance

BoxBiConsumerOnce has the best performance:

No reference counting overhead
No lock acquisition or runtime borrow checking
Direct function call through vtable
Minimal memory footprint (single pointer)

§Examples

use prism3_function::{BiConsumerOnce, BoxBiConsumerOnce};

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

§Author

Haixing Hu

Implementations§

Source §

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

Source

pub fn new<F>(f: F) -> Self
where F: FnOnce(&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: FnOnce(&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: FnOnce(&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) -> BoxConditionalBiConsumerOnce<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) -> BoxBiConsumerOnce<T, U>
where Self: Sized + 'static, T: 'static, U: 'static, C: BiConsumerOnce<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