Enum Either

pub enum Either<A, B> {
    Left(A),
    Right(B),
}

A wrapper over two possible transports.

This type can be used to write semi-generic code without the hassle of making all functions generic.

See the examples folder for an example how to use it.

Variants

Left(A)

First possible transport.

Right(B)

Second possible transport.

Trait Implementations

impl<A, B, ABatch, BBatch> BatchTransport for Either<A, B>

where A: BatchTransport<Batch = ABatch>, B: BatchTransport<Batch = BBatch>, A::Out: 'static + Send, B::Out: 'static + Send, ABatch: Future<Output = Result<Vec<Result<Value>>>> + 'static + Send, BBatch: Future<Output = Result<Vec<Result<Value>>>> + 'static + Send,

type Batch = Pin<Box<dyn Future<Output = Result<Vec<Result<Value, Error>>, Error>> + Send>>

The type of future this transport returns when a call is made.

fn send_batch<T>(&self, requests: T) -> Self::Batch

where T: IntoIterator<Item = (RequestId, Call)>,

Sends a batch of prepared RPC calls.

impl<A: Clone, B: Clone> Clone for Either<A, B>

fn clone(&self) -> Either<A, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, B: Debug> Debug for Either<A, B>

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

Formats the value using the given formatter.

impl<A, B, AStream, BStream> DuplexTransport for Either<A, B>

where A: DuplexTransport<NotificationStream = AStream>, B: DuplexTransport<NotificationStream = BStream>, A::Out: 'static + Send, B::Out: 'static + Send, AStream: Stream<Item = Value> + 'static + Send, BStream: Stream<Item = Value> + 'static + Send,

type NotificationStream = Pin<Box<dyn Stream<Item = Value> + Send>>

The type of stream this transport returns

fn subscribe(&self, id: SubscriptionId) -> Result<Self::NotificationStream>

Add a subscription to this transport

fn unsubscribe(&self, id: SubscriptionId) -> Result

Remove a subscription from this transport

impl<A, B, AOut, BOut> Transport for Either<A, B>

where A: Transport<Out = AOut>, B: Transport<Out = BOut>, AOut: Future<Output = Result<Value>> + 'static + Send, BOut: Future<Output = Result<Value>> + 'static + Send,

type Out = Pin<Box<dyn Future<Output = Result<Value, Error>> + Send>>

The type of future this transport returns when a call is made.

fn prepare(&self, method: &str, params: Vec<Value>) -> (RequestId, Call)

Prepare serializable RPC call for given method with parameters.

fn send(&self, id: RequestId, request: Call, options: CallOptions) -> Self::Out

Execute prepared RPC call.

fn set_max_response_bytes(&mut self, v: u64)

set the max response bytes, do nothing by default

fn execute( &self, method: &str, params: Vec<Value>, options: CallOptions, ) -> Self::Out

Execute remote method with given parameters.