prism3_function::transformers::transformer_once

Struct BoxTransformerOnce

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

Expand description

BoxTransformerOnce - consuming transformer wrapper based on Box<dyn FnOnce>

A transformer wrapper that provides single ownership with one-time use semantics. Consumes both self and the input value.

§Features

Based on: Box<dyn FnOnce(T) -> R>
Ownership: Single ownership, cannot be cloned
Reusability: Can only be called once (consumes self and input)
Thread Safety: Not thread-safe (no Send + Sync requirement)

§Author

Haixing Hu

Implementations§

Source §

impl<T, R> BoxTransformerOnce<T, R>
where T: 'static, R: 'static,

Source

pub fn new<F>(f: F) -> Self
where F: FnOnce(T) -> R + 'static,

Creates a new transformer.

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

Source

pub fn new_with_name<F>(name: &str, f: F) -> Self
where F: FnOnce(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.

Source

pub fn new_with_optional_name<F>(f: F, name: Option<String>) -> Self
where F: FnOnce(T) -> R + 'static,

Creates a new named transformer with an optional name.

Wraps the provided closure and assigns it an optional name.

Source

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

Gets the name of this transformer.

§Returns

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

Source

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

Sets the name of this transformer.

§Parameters

name - The name to set for this transformer

Source

pub fn identity() -> BoxTransformerOnce<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.

Source

pub fn when(self, predicate: P) -> BoxConditionalTransformerOnce<T, R>
where P: Predicate<T> + 'static,

Creates a conditional transformer that executes based on predicate result.

§Parameters

predicate - The predicate to determine whether to execute the transformation operation

§Returns

Returns a conditional transformer that only executes when the predicate returns true.

§Examples

use std::sync::Arc;
use std::sync::atomic::{AtomicI32, Ordering};
use prism3_rust_function::transformers::*;

let transformer = BoxTransformer::new({
    |value: &i32| value * 2
});

let conditional = transformer.when(|value: &i32| *value > 0);
assert_eq!(conditional.transform(&5), 10);  // transformed
assert_eq!(conditional.transform(&-1), -1); // identity (unchanged)

Source

pub fn and_then<S, F>(self, after: F) -> BoxTransformerOnce<T, S>
where S: 'static, F: TransformerOnce<R, S> + 'static,

Chains execution with another transformer, executing the current transformer first, then the subsequent transformer.

§Parameters

after - The subsequent transformer to execute after the current transformer completes

§Returns

Returns a new transformer that executes the current transformer and the subsequent transformer in sequence.

§Examples

use prism3_rust_function::transformers::*;

let transformer1 = BoxTransformer::new({
    |value: &i32| value + 1
});

let transformer2 = BoxTransformer::new({
    |value: &i32| value * 2
});

let chained = transformer1.and_then(transformer2);
assert_eq!(chained.transform(&5), 12); // (5 + 1) * 2 = 12

Source §

impl<T, R> BoxTransformerOnce<T, R>
where T: 'static, R: Clone + 'static,

Source

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

Creates a constant transformer

§Examples

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