Struct RcStatefulTransformer 

pub struct RcStatefulTransformer<T, R> { /* private fields */ }

RcStatefulTransformer - single-threaded transformer wrapper

A single-threaded, clonable transformer wrapper optimized for scenarios that require sharing without thread-safety overhead.

Features

• Based on: Rc<RefCell<dyn FnMut(T) -> R>>
• Ownership: Shared ownership via reference counting (non-atomic)
• Reusability: Can be called multiple times (each call consumes its input)
• Thread Safety: Not thread-safe (no Send + Sync)
• Clonable: Cheap cloning via Rc::clone
• Statefulness: Can modify internal state between calls

Author

Haixing Hu

Implementations

impl<T, R> RcStatefulTransformer<T, R>

where T: 'static, R: 'static,

pub fn new<F>(f: F) -> Self

where F: FnMut(T) -> R + 'static,

Creates a new transformer.

Wraps the provided closure in the appropriate smart pointer type for this transformer implementation.

pub fn new_with_name<F>(name: &str, f: F) -> Self

where F: FnMut(T) -> R + 'static,

Creates a new named transformer.

Wraps the provided closure and assigns it a name, which is useful for debugging and logging purposes.

pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self

where F: FnMut(T) -> R + 'static,

Creates a new named transformer with an optional name.

Wraps the provided closure and assigns it an optional name.

pub fn name(&self) -> Option<&str>

Gets the name of this transformer.

Returns

Returns Some(&str) if a name was set, None otherwise.

pub fn set_name(&mut self, name: &str)

Sets the name of this transformer.

Parameters

• name - The name to set for this transformer

pub fn identity() -> RcStatefulTransformer<T, T>

Creates an identity transformer.

Creates a transformer that returns the input value unchanged. Useful for default values or placeholder implementations.

Returns

Returns a new transformer instance that returns the input unchanged.

pub fn when<P>(&self, predicate: P) -> RcConditionalStatefulTransformer<T, R>

where P: Predicate<T> + 'static,

pub fn and_then<S, F>(&self, after: F) -> RcStatefulTransformer<T, S>

where S: 'static, F: StatefulTransformer<R, S> + 'static,

impl<T, R> RcStatefulTransformer<T, R>

where T: 'static, R: Clone + 'static,

pub fn constant(value: R) -> RcStatefulTransformer<T, R>

Creates a constant transformer

Examples

/// rust /// use prism3_function::{RcStatefulTransformer, StatefulTransformer}; /// /// let mut constant = RcStatefulTransformer::constant("hello"); /// assert_eq!(constant.apply(123), "hello"); ///

Trait Implementations

impl<T, R> Clone for RcStatefulTransformer<T, R>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, R> Debug for RcStatefulTransformer<T, R>

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

Formats the value using the given formatter.

impl<T, R> Display for RcStatefulTransformer<T, R>

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

Formats the value using the given formatter.

impl<T, R> StatefulTransformer<T, R> for RcStatefulTransformer<T, R>

fn apply(&mut self, input: T) -> R

Applies the transformation to the input value to produce an output value

fn into_box(self) -> BoxStatefulTransformer<T, R>

where T: 'static, R: 'static,

Converts to BoxStatefulTransformer

fn into_rc(self) -> RcStatefulTransformer<T, R>

where T: 'static, R: 'static,

Converts to RcStatefulTransformer

fn into_fn(self) -> impl FnMut(T) -> R

Converts to a closure implementing FnMut(T) -> R

fn to_box(&self) -> BoxStatefulTransformer<T, R>

where T: 'static, R: 'static,

Non-consuming conversion to BoxStatefulTransformer.

fn to_rc(&self) -> RcStatefulTransformer<T, R>

where T: 'static, R: 'static,

Non-consuming conversion to RcStatefulTransformer.

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

Non-consuming conversion to a closure (FnMut(T) -> R).

fn into_once(self) -> BoxTransformerOnce<T, R>

where T: 'static, R: 'static,

Converts to BoxTransformerOnce.

fn to_once(&self) -> BoxTransformerOnce<T, R>

where T: 'static, R: 'static,

Creates a BoxTransformerOnce from a cloned transformer

fn into_arc(self) -> ArcStatefulTransformer<T, R>

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

Converts to ArcStatefulTransformer

fn to_arc(&self) -> ArcStatefulTransformer<T, R>

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

Non-consuming conversion to ArcStatefulTransformer (thread-safe).