bi_consumer_demo/
bi_consumer_demo.rs

1/*******************************************************************************
2 *
3 *    Copyright (c) 2025.
4 *    3-Prism Co. Ltd.
5 *
6 *    All rights reserved.
7 *
8 ******************************************************************************/
9
10//! BiConsumer demonstration
11//!
12//! This example demonstrates the usage of BiConsumer types after
13//! refactoring to use &T, &U semantics (not modifying input values).
14
15use prism3_function::{ArcBiConsumer, BiConsumer, BoxBiConsumer, RcBiConsumer};
16use std::cell::RefCell;
17use std::rc::Rc;
18use std::sync::{Arc, Mutex};
19use std::thread;
20
21fn main() {
22    println!("=== BiConsumer Demo ===\n");
23
24    // 1. BoxBiConsumer - Single ownership
25    println!("1. BoxBiConsumer - Single ownership:");
26    let log = Arc::new(Mutex::new(Vec::new()));
27    let l = log.clone();
28    let mut box_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
29        println!("  Processing: x={}, y={}", x, y);
30        l.lock().unwrap().push(*x + *y);
31    });
32    box_consumer.accept(&10, &5);
33    println!("  Result log: {:?}\n", *log.lock().unwrap());
34
35    // 2. Method chaining with BoxBiConsumer
36    println!("2. BoxBiConsumer with method chaining:");
37    let log = Arc::new(Mutex::new(Vec::new()));
38    let l1 = log.clone();
39    let l2 = log.clone();
40    let mut chained = BoxBiConsumer::new(move |x: &i32, y: &i32| {
41        l1.lock().unwrap().push(*x + *y);
42        println!("  After first operation: sum = {}", x + y);
43    })
44    .and_then(move |x: &i32, y: &i32| {
45        l2.lock().unwrap().push(*x * *y);
46        println!("  After second operation: product = {}", x * y);
47    });
48    chained.accept(&5, &3);
49    println!("  Final log: {:?}\n", *log.lock().unwrap());
50
51    // 3. ArcBiConsumer - Thread-safe shared ownership
52    println!("3. ArcBiConsumer - Thread-safe shared ownership:");
53    let log = Arc::new(Mutex::new(Vec::new()));
54    let l = log.clone();
55    let arc_consumer = ArcBiConsumer::new(move |x: &i32, y: &i32| {
56        l.lock().unwrap().push(*x + *y);
57        println!("  Thread {:?}: sum = {}", thread::current().id(), x + y);
58    });
59
60    let consumer1 = arc_consumer.clone();
61    let consumer2 = arc_consumer.clone();
62
63    let handle1 = thread::spawn(move || {
64        let mut c = consumer1;
65        c.accept(&10, &5);
66    });
67
68    let handle2 = thread::spawn(move || {
69        let mut c = consumer2;
70        c.accept(&20, &8);
71    });
72
73    handle1.join().unwrap();
74    handle2.join().unwrap();
75    println!("  Final log: {:?}\n", *log.lock().unwrap());
76
77    // 4. RcBiConsumer - Single-threaded shared ownership
78    println!("4. RcBiConsumer - Single-threaded shared ownership:");
79    let log = Rc::new(RefCell::new(Vec::new()));
80    let l = log.clone();
81    let rc_consumer = RcBiConsumer::new(move |x: &i32, y: &i32| {
82        l.borrow_mut().push(*x + *y);
83    });
84
85    let mut clone1 = rc_consumer.clone();
86    let mut clone2 = rc_consumer.clone();
87
88    clone1.accept(&5, &3);
89    println!("  After first use: {:?}", *log.borrow());
90
91    clone2.accept(&7, &2);
92    println!("  After second use: {:?}\n", *log.borrow());
93
94    // 5. Working with closures directly
95    println!("5. Working with closures directly:");
96    let log = Arc::new(Mutex::new(Vec::new()));
97    let l = log.clone();
98    let mut closure = move |x: &i32, y: &i32| {
99        let sum = *x + *y;
100        l.lock().unwrap().push(sum);
101    };
102    closure.accept(&10, &20);
103    println!("  After closure: {:?}\n", *log.lock().unwrap());
104
105    // 6. Conditional BiConsumer
106    println!("6. Conditional BiConsumer:");
107    let log = Arc::new(Mutex::new(Vec::new()));
108    let l = log.clone();
109    let mut conditional = BoxBiConsumer::new(move |x: &i32, y: &i32| {
110        l.lock().unwrap().push(*x + *y);
111    })
112    .when(|x: &i32, y: &i32| *x > 0 && *y > 0);
113
114    conditional.accept(&5, &3);
115    println!("  Positive values: {:?}", *log.lock().unwrap());
116
117    conditional.accept(&-5, &3);
118    println!("  Negative value (unchanged): {:?}\n", *log.lock().unwrap());
119
120    // 7. Conditional branch BiConsumer
121    println!("7. Conditional branch BiConsumer:");
122    let log = Arc::new(Mutex::new(Vec::new()));
123    let l1 = log.clone();
124    let l2 = log.clone();
125    let mut branch = BoxBiConsumer::new(move |x: &i32, _y: &i32| {
126        l1.lock().unwrap().push(*x);
127    })
128    .when(|x: &i32, y: &i32| *x > *y)
129    .or_else(move |_x: &i32, y: &i32| {
130        l2.lock().unwrap().push(*y);
131    });
132
133    branch.accept(&15, &10);
134    println!("  When x > y: {:?}", *log.lock().unwrap());
135
136    branch.accept(&5, &10);
137    println!("  When x <= y: {:?}\n", *log.lock().unwrap());
138
139    // 8. Accumulating statistics
140    println!("8. Accumulating statistics:");
141    let count = Arc::new(Mutex::new(0));
142    let sum = Arc::new(Mutex::new(0));
143    let c = count.clone();
144    let s = sum.clone();
145    let mut stats_consumer = BoxBiConsumer::new(move |x: &i32, y: &i32| {
146        *c.lock().unwrap() += 1;
147        *s.lock().unwrap() += x + y;
148    });
149
150    stats_consumer.accept(&5, &3);
151    stats_consumer.accept(&10, &2);
152    stats_consumer.accept(&7, &8);
153
154    println!("  Count: {}", *count.lock().unwrap());
155    println!("  Sum: {}\n", *sum.lock().unwrap());
156
157    // 9. Name support
158    println!("9. Name support:");
159    let mut named_consumer = BoxBiConsumer::<i32, i32>::noop();
160    println!("  Initial name: {:?}", named_consumer.name());
161
162    named_consumer.set_name("sum_calculator");
163    println!("  After setting name: {:?}", named_consumer.name());
164    println!("  Display: {}\n", named_consumer);
165
166    println!("=== Demo Complete ===");
167}
bi_consumer_demo/bi_consumer_demo.rs

bi_consumer_demo/
bi_consumer_demo.rs
