Enum vector_core::transform::Transform

pub enum Transform {
    Function(Box<dyn FunctionTransform>),
    Synchronous(Box<dyn SyncTransform>),
    Task(Box<dyn TaskTransform<EventArray>>),
}

Transforms come in two variants. Functions, or tasks.

While function transforms can be run out of order, or concurrently, task transforms act as a coordination or barrier point.

Variants

Function(Box<dyn FunctionTransform>)

Synchronous(Box<dyn SyncTransform>)

Task(Box<dyn TaskTransform<EventArray>>)

Implementations

impl Transform

pub fn function(v: impl FunctionTransform + 'static) -> Self

Create a new function transform.

These functions are “stateless” and can be run in parallel, without regard for coordination.

Note: You should prefer to implement this over TaskTransform where possible.

pub fn synchronous(v: impl SyncTransform + 'static) -> Self

Create a new synchronous transform.

This is a broader trait than the simple FunctionTransform in that it allows transforms to write to multiple outputs. Those outputs must be known in advanced and returned via TransformConfig::outputs. Attempting to send to any output not registered in advance is considered a bug and will cause a panic.

pub fn task(v: impl TaskTransform<EventArray> + 'static) -> Self

Create a new task transform.

These tasks are coordinated, and map a stream of some U to some other T.

Note: You should prefer to implement FunctionTransform over this where possible.

pub fn event_task(v: impl TaskTransform<Event> + 'static) -> Self

Create a new task transform over individual Events.

These tasks are coordinated, and map a stream of some U to some other T.

Note: You should prefer to implement FunctionTransform over this where possible.

Panics

TODO

pub fn into_task(self) -> Box<dyn TaskTransform<EventArray>>

Transmute the inner transform into a task transform.

Panics

If the transform is a FunctionTransform this will panic.