Enum libp2p_rs::core::either::EitherOutput

pub enum EitherOutput<A, B> {
    A(A),
    B(B),
}

Variants

A(A)

B(B)

Trait Implementations

impl<A, B> Clone for EitherOutput<A, B> where
    B: Clone,
    A: Clone, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, B> ConnectionInfo for EitherOutput<A, B> where
    B: ConnectionInfo,
    A: ConnectionInfo, 

pub fn local_multiaddr(&self) -> Multiaddr

pub fn remote_multiaddr(&self) -> Multiaddr

impl<A, B> Copy for EitherOutput<A, B> where
    B: Copy,
    A: Copy, 

impl<A, B> Debug for EitherOutput<A, B> where
    B: Debug,
    A: Debug, 

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

Formats the value using the given formatter.

impl<A, B> ReadEx for EitherOutput<A, B> where
    B: ReadEx,
    A: ReadEx, 

pub fn read2<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 mut [u8]
) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    EitherOutput<A, B>: 'async_trait, 

Reads some bytes from the byte stream.

#[must_use]pub fn read_exact2<'a, 'async_trait>(
    &'a mut self,
    buf: &'a mut [u8]
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'a: 'async_trait,
    Self: 'async_trait, 

Reads the exact number of bytes requested.

#[must_use]pub fn read_fixed_u32<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Reads a fixed-length integer from the underlying IO.

#[must_use]pub fn read_varint<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Reads a variable-length integer from the underlying IO.

#[must_use]pub fn read_one_fixed<'life0, 'async_trait>(
    &'life0 mut self,
    max_size: usize
) -> Pin<Box<dyn Future<Output = Result<Vec<u8, Global>, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Reads a fixed length-prefixed message from the underlying IO.

#[must_use]pub fn read_one<'life0, 'async_trait>(
    &'life0 mut self,
    max_size: usize
) -> Pin<Box<dyn Future<Output = Result<Vec<u8, Global>, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Reads a variable length-prefixed message from the underlying IO.

impl<A, B> SecureInfo for EitherOutput<A, B> where
    B: SecureInfo,
    A: SecureInfo, 

pub fn local_peer(&self) -> PeerId

pub fn remote_peer(&self) -> PeerId

pub fn local_priv_key(&self) -> Keypair

pub fn remote_pub_key(&self) -> PublicKey

impl<A, B> SplitEx for EitherOutput<A, B> where
    B: SplitEx,
    A: SplitEx, 

type Reader = EitherReaderWriter<<A as SplitEx>::Reader, <B as SplitEx>::Reader>

read half

type Writer = EitherReaderWriter<<A as SplitEx>::Writer, <B as SplitEx>::Writer>

write half

pub fn split(
    self
) -> (<EitherOutput<A, B> as SplitEx>::Reader, <EitherOutput<A, B> as SplitEx>::Writer)

split Self to independent reader and writer

impl<A, B> StreamInfo for EitherOutput<A, B> where
    B: StreamInfo,
    A: StreamInfo, 

pub fn id(&self) -> usize

Returns the identity of the stream.

impl<A, B> StreamMuxer for EitherOutput<A, B> where
    B: StreamMuxer + Send,
    A: StreamMuxer + Send, 

pub fn open_stream<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Box<dyn ReadWriteEx + 'static, Global>, TransportError>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    EitherOutput<A, B>: 'async_trait, 

Opens a new outgoing substream.

pub fn accept_stream<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<Box<dyn ReadWriteEx + 'static, Global>, TransportError>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    EitherOutput<A, B>: 'async_trait, 

Accepts a new incoming substream.

pub fn close<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    EitherOutput<A, B>: 'async_trait, 

Closes the stream muxer, the runtime of stream muxer will then exit.

pub fn task(
    &mut self
) -> Option<Pin<Box<dyn Future<Output = ()> + 'static + Send, Global>>>

Returns a Future which represents the main loop of the stream muxer.

pub fn box_clone(&self) -> Box<dyn StreamMuxerEx + 'static, Global>

Returns the cloned Trait object.

impl<A, B> StreamMuxerEx for EitherOutput<A, B> where
    B: StreamMuxer + ConnectionInfo + SecureInfo + Debug,
    A: StreamMuxer + ConnectionInfo + SecureInfo + Debug, 

impl<A, B> WriteEx for EitherOutput<A, B> where
    B: WriteEx,
    A: WriteEx, 

pub fn write2<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    EitherOutput<A, B>: 'async_trait, 

Attempt to write bytes from buf into the object.

pub fn flush2<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    EitherOutput<A, B>: 'async_trait, 

Attempt to flush the object, ensuring that any buffered data reach their destination.

pub fn close2<'life0, 'async_trait>(
    &'life0 mut self
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    EitherOutput<A, B>: 'async_trait, 

Attempt to close the object.

#[must_use]pub fn write_all2<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Attempt to write the entire contents of data into object.

#[must_use]pub fn write_varint<'life0, 'async_trait>(
    &'life0 mut self,
    len: usize
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Writes a variable-length integer to the underlying IO.

#[must_use]pub fn write_fixed_u32<'life0, 'async_trait>(
    &'life0 mut self,
    len: usize
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Writes a fixed-length integer to the underlying IO.

#[must_use]pub fn write_one_fixed<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Send a fixed length message to the underlying IO, then flushes the writing side.

#[must_use]pub fn write_one<'life0, 'life1, 'async_trait>(
    &'life0 mut self,
    buf: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<(), Error>> + 'async_trait + Send, Global>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Send a variable length message to the underlying IO, then flushes the writing side.