Struct BoxConditionalMutatorOnce

Source

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

Expand description

BoxConditionalMutatorOnce struct

A conditional one-time mutator that only executes when a predicate is satisfied. Uses BoxMutatorOnce and BoxPredicate for single ownership semantics.

This type is typically created by calling BoxMutatorOnce::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 mutates when predicate returns true
Chainable: Can add or_else branch to create if-then-else logic
Implements MutatorOnce: Can be used anywhere a MutatorOnce is expected

§Examples

§Basic Conditional Execution

use prism3_function::{MutatorOnce, BoxMutatorOnce};

let data = vec![1, 2, 3];
let mutator = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
    x.extend(data);
});
let conditional = mutator.when(|x: &Vec<i32>| !x.is_empty());

let mut target = vec![0];
conditional.apply(&mut target);
assert_eq!(target, vec![0, 1, 2, 3]); // Executed

let mut empty = Vec::new();
let data2 = vec![4, 5];
let mutator2 = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
    x.extend(data2);
});
let conditional2 = mutator2.when(|x: &Vec<i32>| x.len() > 5);
conditional2.apply(&mut empty);
assert_eq!(empty, Vec::<i32>::new()); // Not executed

§With or_else Branch

use prism3_function::{MutatorOnce, BoxMutatorOnce};

let data1 = vec![1, 2, 3];
let data2 = vec![99];
let mutator = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
    x.extend(data1);
})
.when(|x: &Vec<i32>| !x.is_empty())
.or_else(move |x: &mut Vec<i32>| {
    x.extend(data2);
});

let mut target = vec![0];
mutator.apply(&mut target);
assert_eq!(target, vec![0, 1, 2, 3]); // when branch executed

let data3 = vec![4, 5];
let data4 = vec![99];
let mutator2 = BoxMutatorOnce::new(move |x: &mut Vec<i32>| {
    x.extend(data3);
})
.when(|x: &Vec<i32>| x.is_empty())
.or_else(move |x: &mut Vec<i32>| {
    x.extend(data4);
});

let mut target2 = vec![0];
mutator2.apply(&mut target2);
assert_eq!(target2, vec![0, 99]); // or_else branch executed

§Author

Haixing Hu

Implementations§

Source §

impl<T> BoxConditionalMutatorOnce<T>
where T: 'static,

Source

pub fn and_then<M>(self, next: M) -> BoxMutatorOnce<T>
where M: MutatorOnce<T> + 'static,

Chains another mutator in sequence

Combines the current conditional mutator with another mutator into a new mutator that implements the following semantics:

When the returned mutator is called with an argument:

First, it checks the predicate of this conditional mutator
If the predicate is satisfied, it executes the internal mutator of this conditional mutator
Then, regardless of whether the predicate was satisfied, it unconditionally executes the next mutator

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

§Parameters

next - The next mutator to execute (always executed)

§Returns

Returns a new combined mutator

§Examples

use std::sync::atomic::{AtomicI32, Ordering};

let result = AtomicI32::new(0);

let mutator1 = BoxMutator::new(|x: &mut i32| {
    *x += 1;
});

let mutator2 = BoxMutator::new(|x: &mut i32| {
    *x += 2;
});

let conditional = mutator1.when(|x| *x > 0);
let chained = conditional.and_then(mutator2);

let mut val = 5;
chained.apply(&mut val);  // val = 5 + 1 + 2 = 8
let mut val2 = -1;
chained.apply(&mut val2); // val2 = -1 + 2 = 1 (not -1 + 1 + 2!)