Struct TaskRegistry 

pub struct TaskRegistry { /* private fields */ }

Registry for task implementations.

Maps task IDs to factory functions that create task instances. This enables workflow serialization: only IDs and structure are serialized, and implementations are looked up from the registry at runtime.

Important: The registry is code, not data. It contains closures and cannot be serialized. Both serialization and deserialization sides must construct the same registry by calling the same registration functions. See module docs for the recommended pattern.

Implementations

impl TaskRegistry

pub fn new() -> TaskRegistry

Create a new empty registry.

pub fn register<T, C>(&mut self, id: &str, codec: Arc<C>, task: T)

where T: CoreTask + 'static, <T as CoreTask>::Input: Send + 'static, <T as CoreTask>::Output: Send + 'static, <T as CoreTask>::Future: Send + 'static, C: Codec + DecodeValue<<T as CoreTask>::Input> + EncodeValue<<T as CoreTask>::Output> + 'static,

Register a task implementing CoreTask.

This method accepts any type implementing CoreTask, including:

• Structs with explicit CoreTask implementation
• Closures wrapped with fn_task

For convenience with raw closures, use register_fn.

Example

use sayiir_core::prelude::*;
use std::pin::Pin;
use std::future::Future;

struct DoubleTask;
impl CoreTask for DoubleTask {
    type Input = u32;
    type Output = u32;
    type Future = Pin<Box<dyn Future<Output = Result<u32, BoxError>> + Send>>;
    fn run(&self, input: u32) -> Self::Future {
        Box::pin(async move { Ok(input * 2) })
    }
}

// Register a struct implementing CoreTask
registry.register("struct_task", codec.clone(), DoubleTask);

// Register a closure via fn_task wrapper
registry.register("closure_task", codec.clone(), fn_task(|i: u32| async move { Ok(i * 2) }));

pub fn register_with_metadata<T, C>( &mut self, id: &str, codec: Arc<C>, task: T, metadata: TaskMetadata, )

where T: CoreTask + 'static, <T as CoreTask>::Input: Send + 'static, <T as CoreTask>::Output: Send + 'static, <T as CoreTask>::Future: Send + 'static, C: Codec + DecodeValue<<T as CoreTask>::Input> + EncodeValue<<T as CoreTask>::Output> + 'static,

Register a task implementing CoreTask with metadata.

Same as register, but allows attaching metadata for timeouts, retries, and display information.

pub fn register_fn<I, O, F, Fut, C>(&mut self, id: &str, codec: Arc<C>, func: F)

where F: Fn(I) -> Fut + Send + Sync + 'static, I: Send + 'static, O: Send + 'static, Fut: Future<Output = Result<O, Box<dyn Error + Send + Sync>>> + Send + 'static, C: Codec + DecodeValue<I> + EncodeValue<O> + 'static,

Register a closure as a task (convenience method).

This is a convenience method for registering closures without needing to wrap them in fn_task.

Example

registry.register_fn("double", codec.clone(), |input: u32| async move { Ok(input * 2) });

pub fn register_fn_with_metadata<I, O, F, Fut, C>( &mut self, id: &str, codec: Arc<C>, func: F, metadata: TaskMetadata, )

where F: Fn(I) -> Fut + Send + Sync + 'static, I: Send + 'static, O: Send + 'static, Fut: Future<Output = Result<O, Box<dyn Error + Send + Sync>>> + Send + 'static, C: Codec + DecodeValue<I> + EncodeValue<O> + 'static,

Register a closure as a task with metadata.

Same as register_fn, but allows attaching metadata.

pub fn register_join<O, F, Fut, C>(&mut self, id: &str, codec: Arc<C>, func: F)

where F: Fn(BranchOutputs<C>) -> Fut + Send + Sync + 'static, O: Send + 'static, Fut: Future<Output = Result<O, Box<dyn Error + Send + Sync>>> + Send + 'static, C: Codec + EncodeValue<O> + DecodeValue<NamedBranchResults> + Send + Sync + 'static,

Register a join task using a closure.

pub fn register_join_with_metadata<O, F, Fut, C>( &mut self, id: &str, codec: Arc<C>, func: F, metadata: TaskMetadata, )

where F: Fn(BranchOutputs<C>) -> Fut + Send + Sync + 'static, O: Send + 'static, Fut: Future<Output = Result<O, Box<dyn Error + Send + Sync>>> + Send + 'static, C: Codec + EncodeValue<O> + DecodeValue<NamedBranchResults> + Send + Sync + 'static,

Register a join task using a closure with metadata.

pub fn get( &self, id: &str, ) -> Option<Box<dyn CoreTask<Output = Bytes, Future = BytesFuture, Input = Bytes> + Send + Sync>>

Get a task by ID, creating a new instance.

Returns None if the task ID is not registered.

pub fn get_metadata(&self, id: &str) -> Option<&TaskMetadata>

Get the metadata for a task by ID.

Returns None if the task ID is not registered.

pub fn get_with_metadata( &self, id: &str, ) -> Option<(Box<dyn CoreTask<Output = Bytes, Future = BytesFuture, Input = Bytes> + Send + Sync>, &TaskMetadata)>

Get both the task and its metadata by ID.

Returns None if the task ID is not registered.

pub fn set_metadata(&mut self, id: &str, metadata: TaskMetadata) -> bool

Set or update the metadata for a registered task.

Returns true if the task was found and metadata updated, false otherwise.

pub fn contains(&self, id: &str) -> bool

Check if a task ID is registered.

pub fn len(&self) -> usize

Get the number of registered tasks.

pub fn is_empty(&self) -> bool

Check if the registry is empty.

pub fn task_ids(&self) -> impl Iterator<Item = &str>

Get an iterator over registered task IDs.

pub fn with_codec<C>(codec: Arc<C>) -> RegistryBuilder<C>

where C: Codec,

Create a builder with a codec for ergonomic task registration.

Example

let registry = TaskRegistry::with_codec(codec)
    .register_fn("double", |i: u32| async move { Ok(i * 2) })
    .register_fn("add_ten", |i: u32| async move { Ok(i + 10) })
    .build();

Trait Implementations

impl Default for TaskRegistry

fn default() -> TaskRegistry

Returns the “default value” for a type.

impl RegistryBehavior for TaskRegistry

fn maybe_register<I, O, F, Fut, C>( &mut self, id: &str, codec: Arc<C>, func: &Arc<F>, )

where F: Fn(I) -> Fut + Send + Sync + 'static, I: Send + 'static, O: Send + 'static, Fut: Future<Output = Result<O, Box<dyn Error + Send + Sync>>> + Send + 'static, C: Codec + DecodeValue<I> + EncodeValue<O> + 'static,

Register a task (no-op for NoRegistry, actual registration for TaskRegistry).

fn maybe_register_join<O, F, Fut, C>( &mut self, id: &str, codec: Arc<C>, func: &Arc<F>, )

where F: Fn(BranchOutputs<C>) -> Fut + Send + Sync + 'static, O: Send + 'static, Fut: Future<Output = Result<O, Box<dyn Error + Send + Sync>>> + Send + 'static, C: Codec + EncodeValue<O> + DecodeValue<NamedBranchResults> + Send + Sync + 'static,

Register a join task (no-op for NoRegistry, actual registration for TaskRegistry).