Enum web3::EitherTransport

pub enum EitherTransport<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 EitherTransport<A, B> where
    A: BatchTransport<Batch = ABatch>,
    B: BatchTransport<Batch = BBatch>,
    A::Out: 'static,
    B::Out: 'static,
    ABatch: Future<Item = Vec<Result<Value, Error>>, Error = Error> + 'static,
    BBatch: Future<Item = Vec<Result<Value, Error>>, Error = Error> + 'static, 

type Batch = Box<dyn Future<Item = Vec<Result<Value, Error>>, Error = Error>>

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 EitherTransport<A, B>

fn clone(&self) -> EitherTransport<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 EitherTransport<A, B>

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

Formats the value using the given formatter.

impl<A, B, AStream, BStream> DuplexTransport for EitherTransport<A, B> where
    A: DuplexTransport<NotificationStream = AStream>,
    B: DuplexTransport<NotificationStream = BStream>,
    A::Out: 'static,
    B::Out: 'static,
    AStream: Stream<Item = Value, Error = Error> + 'static,
    BStream: Stream<Item = Value, Error = Error> + 'static, 

type NotificationStream = Box<dyn Stream<Item = Value, Error = Error>>

The type of stream this transport returns

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

Add a subscription to this transport

fn unsubscribe(&self, id: &SubscriptionId)

Remove a subscription from this transport

impl<A, B, AOut, BOut> Transport for EitherTransport<A, B> where
    A: Transport<Out = AOut>,
    B: Transport<Out = BOut>,
    AOut: Future<Item = Value, Error = Error> + 'static,
    BOut: Future<Item = Value, Error = Error> + 'static, 

type Out = Box<dyn Future<Item = Value, Error = Error>>

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.