Enum web3::transports::either::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 = BoxFuture<'static, Result<Vec<Result<Value>>>>

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 = BoxStream<'static, Value>

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 = BoxFuture<'static, Result<Value>>

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) -> Self::Out

Execute prepared RPC call.

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

Execute remote method with given parameters.