Trait AsyncEngine 

pub trait AsyncEngine<Req: Send + Sync + 'static, Resp: AsyncEngineContextProvider, E: Data>: Send + Sync {
    // Required method
    fn generate<'life0, 'async_trait>(
        &'life0 self,
        request: Req,
    ) -> Pin<Box<dyn Future<Output = Result<Resp, E>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
}

Engine is a trait that defines the interface for a streaming engine. The synchronous Engine version is does not need to be awaited.

This is the core trait for all async engine implementations. It provides:

• Generic type parameters for request, response, and error types
• Async generation capabilities with proper error handling
• Thread-safe design with Send + Sync bounds

Type Parameters

• Req: The request type that implements Data
• Resp: The response type that implements both Data and AsyncEngineContextProvider
• E: The error type that implements Data

Implementation Notes

Implementations should ensure proper error handling and resource management. The generate method should be cancellable via the response’s context provider.

Required Methods

fn generate<'life0, 'async_trait>( &'life0 self, request: Req, ) -> Pin<Box<dyn Future<Output = Result<Resp, E>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Generate a stream of completion responses.

Implementors

impl<In: PipelineIO + Sync, Out: PipelineIO> AsyncEngine<In, Out, Error> for SegmentSource<In, Out>

impl<In: PipelineIO + Sync, Out: PipelineIO> AsyncEngine<In, Out, Error> for ServiceFrontend<In, Out>

impl<T, U> AsyncEngine<Context<AddressedRequest<T>>, Pin<Box<dyn AsyncEngineStream<U, Item = U>>>, Error> for AddressedPushRouter

where T: Data + Serialize, U: Data + for<'de> Deserialize<'de> + MaybeError,

impl<T, U> AsyncEngine<Context<T>, Pin<Box<dyn AsyncEngineStream<U, Item = U>>>, Error> for PushRouter<T, U>

where T: Data + Serialize, U: Data + for<'de> Deserialize<'de> + MaybeError,

impl<T, U> AsyncEngine<Context<T>, Pin<Box<dyn AsyncEngineStream<U, Item = U>>>, Error> for Egress<SingleIn<T>, ManyOut<U>>

where T: Data + Serialize, U: for<'de> Deserialize<'de> + Data,

impl<UpIn, UpOut, DownIn, DownOut> AsyncEngine<UpIn, UpOut, Error> for PipelineOperator<UpIn, UpOut, DownIn, DownOut>

where UpIn: PipelineIO + Sync, DownIn: PipelineIO + Sync, DownOut: PipelineIO, UpOut: PipelineIO,

A PipelineOperator is an AsyncEngine for the upstream AsyncEngine<UpIn, UpOut, Error>.