Struct RcConditionalStatefulMutator 

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

RcConditionalMutator struct

A single-threaded conditional mutator that only executes when a predicate is satisfied. Uses RcMutator and RcPredicate for shared ownership within a single thread.

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

Features

• Shared Ownership: Cloneable via Rc, multiple owners allowed
• Single-Threaded: Not thread-safe, cannot be sent across threads
• Conditional Execution: Only mutates when predicate returns true
• No Lock Overhead: More efficient than ArcConditionalMutator

Examples

use prism3_function::{Mutator, RcMutator};

let conditional = RcMutator::new(|x: &mut i32| *x *= 2)
    .when(|x: &i32| *x > 0);

let conditional_clone = conditional.clone();

let mut value = 5;
let mut m = conditional;
m.mutate(&mut value);
assert_eq!(value, 10);

Author

Haixing Hu

Implementations

impl<T> RcConditionalStatefulMutator<T>

where T: 'static,

pub fn and_then<M>(&self, next: M) -> RcStatefulMutator<T>

where M: StatefulMutator<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:

1. First, it checks the predicate of this conditional mutator
2. If the predicate is satisfied, it executes the internal mutator of this conditional mutator
3. 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 = ArcMutator::new(|x: &mut i32| {
    *x += 1;
});

let mutator2 = ArcMutator::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!)

pub fn or_else<M>(&self, else_mutator: M) -> RcStatefulMutator<T>

where M: StatefulMutator<T> + 'static,

Adds an else branch

Executes the original mutator when the condition is satisfied, otherwise executes else_mutator.

Parameters

• else_mutator - The mutator for the else branch

Returns

Returns a new mutator with if-then-else logic

Trait Implementations

impl<T> Clone for RcConditionalStatefulMutator<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for RcConditionalStatefulMutator<T>

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

Formats the value using the given formatter.

impl<T> Display for RcConditionalStatefulMutator<T>

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

Formats the value using the given formatter.

impl<T> StatefulMutator<T> for RcConditionalStatefulMutator<T>

where T: 'static,

fn apply(&mut self, value: &mut T)

Performs the mutation operation

fn into_box(self) -> BoxStatefulMutator<T>

Convert this mutator into a BoxMutator<T>.

fn into_rc(self) -> RcStatefulMutator<T>

Convert this mutator into an RcMutator<T>.

fn into_fn(self) -> impl FnMut(&mut T)

Consume the mutator and return an FnMut(&mut T) closure.

fn into_arc(self) -> ArcStatefulMutator<T>

where Self: Sized + Send + 'static, T: Send + 'static,

Convert this mutator into an ArcMutator<T>.

fn to_box(&self) -> BoxStatefulMutator<T>

where Self: Sized + Clone + 'static, T: 'static,

Create a non-consuming BoxMutator<T> that forwards to self.

fn to_rc(&self) -> RcStatefulMutator<T>

where Self: Sized + Clone + 'static, T: 'static,

Create a non-consuming RcMutator<T> that forwards to self.

fn to_arc(&self) -> ArcStatefulMutator<T>

where Self: Sized + Clone + Send + 'static, T: Send + 'static,

Create a non-consuming ArcMutator<T> that forwards to self.

fn to_fn(&self) -> impl FnMut(&mut T)

where Self: Sized + Clone + 'static, T: 'static,

Create a boxed FnMut(&mut T) closure that forwards to self.

fn into_once(self) -> BoxMutatorOnce<T>

where Self: Sized + 'static, T: 'static,

Convert this mutator into a BoxMutatorOnce<T> (consuming).

fn to_once(&self) -> BoxMutatorOnce<T>

where Self: Sized + Clone + 'static, T: 'static,

Create a non-consuming BoxMutatorOnce<T> that forwards to self.