Struct RcConditionalMutator 

pub struct RcConditionalMutator<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> RcConditionalMutator<T>

where T: 'static,

pub fn or_else<C>(self, else_mutator: C) -> RcMutator<T>

where C: Mutator<T> + 'static,

Adds an else branch (single-threaded shared version)

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

Parameters

• else_mutator - The mutator for the else branch. Note: This parameter is passed by value and will transfer ownership. If you need to preserve the original mutator, clone it first (if it implements Clone). Can be:
  • A closure: |x: &mut T|
  • An RcMutator<T>
  • A BoxMutator<T>
  • Any type implementing Mutator<T>

Returns

Returns the composed RcMutator<T>

Examples

Using a closure (recommended)

use prism3_function::{Mutator, RcMutator};

let mut mutator = RcMutator::new(|x: &mut i32| *x *= 2)
    .when(|x: &i32| *x > 0)
    .or_else(|x: &mut i32| *x -= 1);

let mut positive = 5;
mutator.mutate(&mut positive);
assert_eq!(positive, 10);

let mut negative = -5;
mutator.mutate(&mut negative);
assert_eq!(negative, -6);

Trait Implementations

impl<T> Clone for RcConditionalMutator<T>

fn clone(&self) -> Self

Clones the conditional mutator

Creates a new instance that shares the underlying mutator and predicate with the original instance.

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

Performs copy-assignment from source.

impl<T> Mutator<T> for RcConditionalMutator<T>

where T: 'static,

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

Performs the mutation operation

fn into_box(self) -> BoxMutator<T>

Convert this mutator into a BoxMutator<T>.

fn into_rc(self) -> RcMutator<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 to_box(&self) -> BoxMutator<T>

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

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

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

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

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

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

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

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

fn into_arc(self) -> ArcMutator<T>

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

Convert this mutator into an ArcMutator<T>.

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

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

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