Struct DualTransport

pub struct DualTransport<L, R, H> { /* private fields */ }

A transport that dispatches requests to one of two inner transports based on a handler.

This type allows RPC clients to dynamically select between two different transports at runtime depending on the request. It is Send + Sync and implements Transport via the Service trait.

This is useful for building clients that abstract over multiple backends or protocols, routing requests flexibly without having to commit to a single transport implementation.

All higher-level types can use DualTransport internally to support multiple transport strategies.

Implementations

impl<L, R, H> DualTransport<L, R, H>

pub const fn new(left: L, right: R, handler: H) -> Self

Instantiate a new dual transport from a suitable transport.

pub const fn new_handler<F>(left: L, right: R, f: F) -> DualTransport<L, R, F>

where F: Fn(RequestPacket, L, R) -> TransportFut<'static> + Send + Sync,

Create a new dual transport with a function handler.

Trait Implementations

impl<L: Clone, R: Clone, H: Clone> Clone for DualTransport<L, R, H>

fn clone(&self) -> DualTransport<L, R, H>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<L: Debug, R: Debug, H: Debug> Debug for DualTransport<L, R, H>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<L, R, H> Service<RequestPacket> for DualTransport<L, R, H>

where L: Service<RequestPacket, Future = TransportFut<'static>, Error = TransportError> + Send + Sync + Clone + 'static, R: Service<RequestPacket, Future = TransportFut<'static>, Error = TransportError> + Send + Sync + Clone + 'static, H: DualTransportHandler<L, R> + 'static,

type Response = ResponsePacket

Responses given by the service.

type Error = RpcError<TransportErrorKind>

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<ResponsePacket, RpcError<TransportErrorKind>>> + Send>>

The future response value.

fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: RequestPacket) -> Self::Future

Process the request and return the response asynchronously.