Struct UniversalAdapter 

pub struct UniversalAdapter<Req, Res, Err> { /* private fields */ }

Universal adapter that can work with any framework

Implementations

impl<Req, Res, Err> UniversalAdapter<Req, Res, Err>

where Err: Error + Send + Sync + 'static,

pub fn new() -> Self

Create a new universal adapter with default configuration

pub fn with_config(config: AdapterConfig) -> Self

Create a new universal adapter with custom configuration

pub fn set_config(&mut self, config: AdapterConfig)

Update the configuration

pub fn add_default_header( &mut self, name: impl Into<Cow<'static, str>>, value: impl Into<Cow<'static, str>>, )

Add a default header

Trait Implementations

impl<Req, Res, Err> Default for UniversalAdapter<Req, Res, Err>

where Err: Error + Send + Sync + 'static,

fn default() -> Self

Returns the “default value” for a type.

impl<Req, Res, Err> StreamingAdapter for UniversalAdapter<Req, Res, Err>

where Req: Send + Sync + 'static, Res: Send + Sync + 'static, Err: Error + Send + Sync + 'static,

type Request = Req

The framework’s native request type

type Response = Res

The framework’s native response type

type Error = Err

The framework’s error type

type StreamingResponseFuture<'a> = impl Future<Output = Result<<UniversalAdapter<Req, Res, Err> as StreamingAdapter>::Response, IntegrationError>> + Send + 'a where Self: 'a

type SseResponseFuture<'a> = impl Future<Output = Result<<UniversalAdapter<Req, Res, Err> as StreamingAdapter>::Response, IntegrationError>> + Send + 'a where Self: 'a

type JsonResponseFuture<'a> = impl Future<Output = Result<<UniversalAdapter<Req, Res, Err> as StreamingAdapter>::Response, IntegrationError>> + Send + 'a where Self: 'a

type MiddlewareFuture<'a> = impl Future<Output = Result<UniversalResponse, IntegrationError>> + Send + 'a where Self: 'a

fn convert_request( &self, _request: Self::Request, ) -> IntegrationResult<UniversalRequest>

Convert framework request to universal format

fn to_response( &self, _response: UniversalResponse, ) -> IntegrationResult<Self::Response>

Convert universal response to framework format

fn create_streaming_response<'a>( &'a self, session_id: SessionId, frames: Vec<StreamFrame>, format: StreamingFormat, ) -> Self::StreamingResponseFuture<'a>

Create a streaming response with priority-based frame delivery

fn create_sse_response<'a>( &'a self, session_id: SessionId, frames: Vec<StreamFrame>, ) -> Self::SseResponseFuture<'a>

Create a Server-Sent Events response with SIMD acceleration

fn create_json_response<'a>( &'a self, data: JsonData, streaming: bool, ) -> Self::JsonResponseFuture<'a>

Create a JSON response with optional streaming

fn apply_middleware<'a>( &'a self, request: &'a UniversalRequest, response: UniversalResponse, ) -> Self::MiddlewareFuture<'a>

Handle framework-specific middleware integration

fn supports_streaming(&self) -> bool

Check if the framework supports streaming

fn supports_sse(&self) -> bool

Check if the framework supports Server-Sent Events

fn framework_name(&self) -> &'static str

Get the framework name for debugging/logging