Struct BoxConditionalBiConsumerOnce 

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

BoxConditionalBiConsumerOnce struct

A conditional one-time bi-consumer that only executes when a predicate is satisfied. Uses BoxBiConsumerOnce and BoxBiPredicate for single ownership semantics.

This type is typically created by calling BoxBiConsumerOnce::when() and is designed to work with the or_else() method to create if-then-else logic.

Features

• Single Ownership: Not cloneable, consumes self on use
• Conditional Execution: Only consumes when predicate returns true
• Chainable: Can add or_else branch to create if-then-else logic
• Implements BiConsumerOnce: Can be used anywhere a BiConsumerOnce is expected

Examples

Basic Conditional Execution

use qubit_function::{BiConsumerOnce, BoxBiConsumerOnce};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l = log.clone();
let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
    l.lock().expect("mutex should not be poisoned").push(*x + *y);
});
let conditional = consumer.when(|x: &i32, y: &i32| *x > 0 && *y > 0);

conditional.accept(&5, &3);
assert_eq!(*log.lock().expect("mutex should not be poisoned"), vec![8]); // Executed

With or_else Branch

use qubit_function::{BiConsumerOnce, BoxBiConsumerOnce};
use std::sync::{Arc, Mutex};

let log = Arc::new(Mutex::new(Vec::new()));
let l1 = log.clone();
let l2 = log.clone();
let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
    l1.lock().expect("mutex should not be poisoned").push(*x + *y);
}).when(|x: &i32, y: &i32| *x > 0 && *y > 0)
  .or_else(move |x: &i32, y: &i32| {
    l2.lock().expect("mutex should not be poisoned").push(*x * *y);
});

consumer.accept(&5, &3);
assert_eq!(*log.lock().expect("mutex should not be poisoned"), vec![8]); // when branch executed

Implementations

impl<T, U> BoxConditionalBiConsumerOnce<T, U>

pub fn and_then<C>(self, next: C) -> BoxBiConsumerOnce<T, U>

where T: 'static, U: 'static, C: BiConsumerOnce<T, U> + 'static,

Chains another bi-consumer in sequence

Combines the current conditional bi-consumer with another bi-consumer into a new bi-consumer that implements the following semantics:

When the returned bi-consumer is called with two arguments:

1. First, it checks the predicate of this conditional bi-consumer
2. If the predicate is satisfied, it executes the internal bi-consumer of this conditional bi-consumer
3. Then, regardless of whether the predicate was satisfied, it unconditionally executes the next bi-consumer

In other words, this creates a bi-consumer that conditionally executes the first action (based on the predicate), and then always executes the second action.

Parameters

• next - The next bi-consumer to execute (always executed)

Returns

Returns a new combined bi-consumer

Examples

use std::sync::atomic::{AtomicI32, Ordering};
use qubit_function::BoxBiConsumer;
use qubit_function::BiConsumer;
use std::sync::Arc;

let result = Arc::new(AtomicI32::new(0));
let result1 = result.clone();
let result2 = result.clone();

let consumer1 = BoxBiConsumer::new(move |x: &i32, y: &i32| {
    result1.fetch_add(x + y, Ordering::SeqCst);
});

let consumer2 = BoxBiConsumer::new(move |x: &i32, y: &i32| {
    result2.fetch_add(2 * (x + y), Ordering::SeqCst);
});

let conditional = consumer1.when(|x: &i32, y: &i32| *x > 0 && *y > 0);
let chained = conditional.and_then(consumer2);

chained.accept(&5, &3);  // result = (5+3) + 2*(5+3) = 24
let result3 = result.clone();
result3.store(0, Ordering::SeqCst);  // reset
chained.accept(&-5, &3); // result = 0 + 2*(-5+3) = -4 (not -8!)

pub fn or_else<C>(self, else_consumer: C) -> BoxBiConsumerOnce<T, U>

where T: 'static, U: 'static, C: BiConsumerOnce<T, U> + 'static,

Adds an else branch

Executes the original bi-consumer when the condition is satisfied, otherwise executes else_consumer.

Parameters

• else_consumer - The bi-consumer for the else branch

Returns

Returns a new bi-consumer with if-then-else logic

Examples found in repository

examples/consumers/bi_consumer_once_demo.rs (lines 108-110)

fn main() {
    println!("=== BiConsumerOnce Demo ===\n");

    // 1. Basic usage
    println!("1. Basic usage:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock()
            .expect("mutex should not be poisoned")
            .push(*x + *y);
        println!("  Sum: {}", x + y);
    });
    consumer.accept(&10, &5);
    println!(
        "  Log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 2. Method chaining
    println!("2. Method chaining:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let chained = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l1.lock()
            .expect("mutex should not be poisoned")
            .push(*x + *y);
        println!("  First: sum={}", x + y);
    })
    .and_then(move |x: &i32, y: &i32| {
        l2.lock()
            .expect("mutex should not be poisoned")
            .push(*x * *y);
        println!("  Second: product={}", x * y);
    });
    chained.accept(&5, &3);
    println!(
        "  Log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 3. Conditional execution - true case
    println!("3. Conditional execution - true case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock()
            .expect("mutex should not be poisoned")
            .push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept(&5, &3);
    println!(
        "  Positive values: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 4. Conditional execution - false case
    println!("4. Conditional execution - false case:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let conditional = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock()
            .expect("mutex should not be poisoned")
            .push(*x + *y);
    })
    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
    conditional.accept(&-5, &3);
    println!(
        "  Negative value (unchanged): {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 5. Conditional branching
    println!("5. Conditional branching:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l1 = log.clone();
    let l2 = log.clone();
    let branch = BoxBiConsumerOnce::new(move |x: &i32, _y: &i32| {
        l1.lock().expect("mutex should not be poisoned").push(*x);
    })
    .when(|x: &i32, y: &i32| *x > *y)
    .or_else(move |_x: &i32, y: &i32| {
        l2.lock().expect("mutex should not be poisoned").push(*y);
    });
    branch.accept(&15, &10);
    println!(
        "  When x > y: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 6. Working with closures directly
    println!("6. Working with closures directly:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let closure = move |x: &i32, y: &i32| {
        l.lock()
            .expect("mutex should not be poisoned")
            .push(*x + *y);
        println!("  Processed: {}", x + y);
    };
    closure.accept(&10, &20);
    println!(
        "  Log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 7. Moving captured values
    println!("7. Moving captured values:");
    let data = vec![1, 2, 3, 4, 5];
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        println!("  x={}, y={}", x, y);
        println!("  Captured data: {:?}", data);
        println!("  Data sum: {}", data.iter().sum::<i32>());
    });
    consumer.accept(&5, &3);
    // data is no longer available here
    println!();

    // 8. Initialization callback
    println!("8. Initialization callback:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let init_callback = BoxBiConsumerOnce::new(move |width: &i32, height: &i32| {
        println!("  Initializing with dimensions: {}x{}", width, height);
        l.lock()
            .expect("mutex should not be poisoned")
            .push(*width * *height);
    });
    init_callback.accept(&800, &600);
    println!(
        "  Areas: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    // 9. Cleanup callback
    println!("9. Cleanup callback:");
    let cleanup = BoxBiConsumerOnce::new(|count: &i32, total: &i32| {
        println!("  Cleanup: processed {} out of {} items", count, total);
        println!(
            "  Success rate: {:.1}%",
            (*count as f64 / *total as f64) * 100.0
        );
    });
    cleanup.accept(&85, &100);
    println!();

    // 10. Name support
    println!("10. Name support:");
    let mut named_consumer = BoxBiConsumerOnce::<i32, i32>::noop();
    println!("  Initial name: {:?}", named_consumer.name());

    named_consumer.set_name("init_callback");
    println!("  After setting name: {:?}", named_consumer.name());
    println!("  Display: {}", named_consumer);
    named_consumer.accept(&1, &2);
    println!();

    // 11. Print helpers
    println!("11. Print helpers:");
    let print = BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("{}, {}", x, y));
    print.accept(&42, &10);

    let print_with =
        BoxBiConsumerOnce::new(|x: &i32, y: &i32| println!("Dimensions: {}, {}", x, y));
    print_with.accept(&800, &600);
    println!();

    // 12. Converting to function
    println!("12. Converting to function:");
    let log = Arc::new(Mutex::new(Vec::new()));
    let l = log.clone();
    let consumer = BoxBiConsumerOnce::new(move |x: &i32, y: &i32| {
        l.lock()
            .expect("mutex should not be poisoned")
            .push(*x + *y);
    });
    let func = consumer.into_fn();
    func(&7, &3);
    println!(
        "  Log: {:?}\n",
        *log.lock().expect("mutex should not be poisoned")
    );

    println!("=== Demo Complete ===");
}

Trait Implementations

impl<T, U> BiConsumerOnce<T, U> for BoxConditionalBiConsumerOnce<T, U>

fn accept(self, first: &T, second: &U)

Performs the one-time consumption operation

fn into_fn(self) -> impl FnOnce(&T, &U)

Converts to a closure

fn into_box(self) -> BoxBiConsumerOnce<T, U>

where Self: Sized + 'static,

Converts to BoxBiConsumerOnce

impl<T, U> Debug for BoxConditionalBiConsumerOnce<T, U>

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

Formats the value using the given formatter.

impl<T, U> Display for BoxConditionalBiConsumerOnce<T, U>

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

Formats the value using the given formatter.