[−][src]Struct libp2p_swarm::ExpandedSwarm

pub struct ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo = PeerId> where
    THandler: IntoProtocolsHandler,
    TConnInfo: ConnectionInfo<PeerId = PeerId>,  { /* fields omitted */ }

Contains the state of the network, plus the way it should behave.

Methods

impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo, THandleErr> ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>, TInEvent: Clone + Send + 'static, TOutEvent: Send + 'static, TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static, THandler: IntoProtocolsHandler + Send + 'static, THandler::Handler: ProtocolsHandler<InEvent = TInEvent, OutEvent = TOutEvent, Error = THandleErr>, THandleErr: Error + Send + 'static, [src]

pub fn new<TTransport, TMuxer>( transport: TTransport, behaviour: TBehaviour, local_peer_id: PeerId ) -> Self where TMuxer: StreamMuxer + Send + Sync + 'static, TMuxer::OutboundSubstream: Send + 'static, <TMuxer as StreamMuxer>::OutboundSubstream: Send + 'static, <TMuxer as StreamMuxer>::Substream: Send + 'static, TTransport: Transport<Output = (TConnInfo, TMuxer)> + Clone + Send + Sync + 'static, TTransport::Error: Send + Sync + 'static, TTransport::Listener: Send + 'static, TTransport::ListenerUpgrade: Send + 'static, TTransport::Dial: Send + 'static, [src]

Builds a new Swarm.

`pub fn network_info(me: &Self) -> NetworkInfo`[src]

Returns information about the Network underlying the Swarm.

`pub fn listen_on( me: &mut Self, addr: Multiaddr ) -> Result<ListenerId, TransportError<Error>>`[src]

Starts listening on the given address.

Returns an error if the address is not supported.

`pub fn remove_listener(me: &mut Self, id: ListenerId) -> Result<(), ()>`[src]

Remove some listener.

Returns Ok(()) if there was a listener with this ID.

`pub fn dial_addr(me: &mut Self, addr: Multiaddr) -> Result<(), ConnectionLimit>`[src]

Tries to dial the given address.

Returns an error if the address is not supported.

`pub fn dial(me: &mut Self, peer_id: &PeerId) -> Result<bool, ConnectionLimit>`[src]

Tries to initiate a dialing attempt to the given peer.

If a new dialing attempt has been initiated, Ok(true) is returned.

If there is an ongoing dialing attempt, the current addresses of the peer, as reported by NetworkBehaviour::addresses_of_peer are added to the ongoing dialing attempt, ignoring duplicates. In this case no new dialing attempt is initiated.

If no new dialing attempt has been initiated, meaning there is an ongoing dialing attempt or addresses_of_peer reports no addresses, Ok(false) is returned.

`pub fn listeners(me: &Self) -> impl Iterator<Item = &Multiaddr>`[src]

Returns an iterator that produces the list of addresses we're listening on.

`pub fn external_addresses(me: &Self) -> impl Iterator<Item = &Multiaddr>`[src]

Returns an iterator that produces the list of addresses that other nodes can use to reach us.

`pub fn local_peer_id(me: &Self) -> &PeerId`[src]

Returns the peer ID of the swarm passed as parameter.

`pub fn add_external_address(me: &mut Self, addr: Multiaddr)`[src]

Adds an external address.

An external address is an address we are listening on but that accounts for things such as NAT traversal.

`pub fn connection_info(me: &mut Self, peer_id: &PeerId) -> Option<TConnInfo>`[src]

Returns the connection info for an arbitrary connection with the peer, or None if there is no connection to that peer.

`pub fn ban_peer_id(me: &mut Self, peer_id: PeerId)`[src]

Bans a peer by its peer ID.

Any incoming connection and any dialing attempt will immediately be rejected. This function has no effect is the peer is already banned.

`pub fn unban_peer_id(me: &mut Self, peer_id: PeerId)`[src]

Unbans a peer.

`pub async fn next_event<'_>( &'_ mut self ) -> SwarmEvent<TBehaviour::OutEvent, THandleErr>`[src]

Returns the next event that happens in the Swarm.

Includes events from the NetworkBehaviour but also events about the connections status.

`pub async fn next<'_>(&'_ mut self) -> TBehaviour::OutEvent`[src]

Returns the next event produced by the NetworkBehaviour.

Trait Implementations

`impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> Deref for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where THandler: IntoProtocolsHandler, TConnInfo: ConnectionInfo<PeerId = PeerId>,` [src]

`type Target = TBehaviour`

The resulting type after dereferencing.

`fn deref(&self) -> &Self::Target`[src]

`impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> DerefMut for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where THandler: IntoProtocolsHandler, TConnInfo: ConnectionInfo<PeerId = PeerId>,` [src]

`fn deref_mut(&mut self) -> &mut Self::Target`[src]

impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> FusedStream for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>, THandler: IntoProtocolsHandler + Send + 'static, TInEvent: Clone + Send + 'static, TOutEvent: Send + 'static, THandler::Handler: ProtocolsHandler<InEvent = TInEvent, OutEvent = TOutEvent>, TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static, [src]

the stream of behaviour events never terminates, so we can implement fused for it

`fn is_terminated(&self) -> bool`[src]

impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> Stream for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>, THandler: IntoProtocolsHandler + Send + 'static, TInEvent: Clone + Send + 'static, TOutEvent: Send + 'static, THandler::Handler: ProtocolsHandler<InEvent = TInEvent, OutEvent = TOutEvent>, TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static, [src]

`type Item = TBehaviour::OutEvent`

Values yielded by the stream.

`fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>>`[src]

`fn size_hint(&self) -> (usize, Option<usize>)`[src]

`impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> Unpin for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where THandler: IntoProtocolsHandler, TConnInfo: ConnectionInfo<PeerId = PeerId>,` [src]

Auto Trait Implementations

`impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo = PeerId> !RefUnwindSafe for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>`

`impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> Send for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where TBehaviour: Send, TConnInfo: Send, TInEvent: Send, TOutEvent: Send, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::Error: Send, <THandler as IntoProtocolsHandler>::Handler: ProtocolsHandler,`

`impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo = PeerId> !Sync for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>`

`impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo = PeerId> !UnwindSafe for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl<T> Same<T> for T`

`type Output = T`

Should always be Self

`impl<T> StreamExt for T where T: Stream + ?Sized,` [src]

`fn next(&mut self) -> Next<Self> where Self: Unpin,` [src]

`fn into_future(self) -> StreamFuture<Self> where Self: Unpin,` [src]

`fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T,` [src]

`fn enumerate(self) -> Enumerate<Self>`[src]

`fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src]

`fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = Option<T>>,` [src]

`fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future,` [src]

`fn collect<C>(self) -> Collect<Self, C> where C: Default + Extend<Self::Item>,` [src]

`fn concat(self) -> Concat<Self> where Self::Item: Extend<<Self::Item as IntoIterator>::Item>, Self::Item: IntoIterator, Self::Item: Default,` [src]

`fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> where F: FnMut(T, Self::Item) -> Fut, Fut: Future<Output = T>,` [src]

`fn flatten(self) -> Flatten<Self> where Self::Item: Stream,` [src]

`fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where F: FnMut(&mut S, Self::Item) -> Fut, Fut: Future<Output = Option>,` [src]

`fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src]

`fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>,` [src]

`fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>,` [src]

`fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F ) -> ForEachConcurrent<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>,` [src]

`fn take(self, n: usize) -> Take<Self>`[src]

`fn skip(self, n: usize) -> Skip<Self>`[src]

`fn fuse(self) -> Fuse<Self>`[src]

`fn by_ref(&mut self) -> &mut Self`[src]

`fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe,` [src]

`fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>> where Self: Send + 'a,` [src]

`fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>> where Self: 'a,` [src]

`fn buffered(self, n: usize) -> Buffered<Self> where Self::Item: Future,` [src]

`fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where Self::Item: Future,` [src]

`fn zip<St>(self, other: St) -> Zip<Self, St> where St: Stream,` [src]

`fn chain<St>(self, other: St) -> Chain<Self, St> where St: Stream<Item = Self::Item>,` [src]

`fn peekable(self) -> Peekable<Self>`[src]

`fn chunks(self, capacity: usize) -> Chunks<Self>`[src]

`fn forward<S>(self, sink: S) -> Forward<Self, S> where S: Sink<Self::Ok>, Self: TryStream<Error = <S as Sink<Self::Ok>>::Error>,` [src]

`fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where Self: Sink<Item>,` [src]

`fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item),` [src]

`fn left_stream(self) -> Either<Self, B> where B: Stream<Item = Self::Item>,` [src]

`fn right_stream(self) -> Either<B, Self> where B: Stream<Item = Self::Item>,` [src]

`fn poll_next_unpin(&mut self, cx: &mut Context) -> Poll<Option<Self::Item>> where Self: Unpin,` [src]

`fn select_next_some(&mut self) -> SelectNextSome<Self> where Self: Unpin + FusedStream,` [src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

`impl<S, T, E> TryStream for S where S: Stream<Item = Result<T, E>> + ?Sized,` [src]

`type Ok = T`

The type of successful values yielded by this future

`type Error = E`

The type of failures yielded by this future

`fn try_poll_next( self: Pin<&mut S>, cx: &mut Context ) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>`[src]

`impl<S> TryStreamExt for S where S: TryStream + ?Sized,` [src]

`fn err_into<E>(self) -> ErrInto<Self, E> where Self::Error: Into<E>,` [src]

`fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where F: FnMut(Self::Ok) -> T,` [src]

`fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where F: FnMut(Self::Error) -> E,` [src]

`fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Error = Self::Error>,` [src]

`fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where F: FnMut(Self::Error) -> Fut, Fut: TryFuture<Ok = Self::Ok>,` [src]

`fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where F: FnMut(&Self::Ok),` [src]

`fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where F: FnMut(&Self::Error),` [src]

`fn into_stream(self) -> IntoStream<Self>`[src]

`fn try_next(&mut self) -> TryNext<Self> where Self: Unpin,` [src]

`fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F> where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Ok = (), Error = Self::Error>,` [src]

`fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where F: FnMut(&Self::Ok) -> Fut, Fut: TryFuture<Ok = bool, Error = Self::Error>,` [src]

`fn try_for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F ) -> TryForEachConcurrent<Self, Fut, F> where F: FnMut(Self::Ok) -> Fut, Fut: Future<Output = Result<(), Self::Error>>,` [src]

`fn try_collect<C>(self) -> TryCollect<Self, C> where C: Default + Extend<Self::Ok>,` [src]

`fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where F: FnMut(&Self::Ok) -> Fut, Fut: Future<Output = bool>,` [src]

`fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where F: FnMut(Self::Ok) -> Fut, Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,` [src]

`fn try_flatten(self) -> TryFlatten<Self> where Self::Ok: TryStream, <Self::Ok as TryStream>::Error: From<Self::Error>,` [src]

`fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F> where F: FnMut(T, Self::Ok) -> Fut, Fut: TryFuture<Ok = T, Error = Self::Error>,` [src]

[−][src]Struct libp2p_swarm::ExpandedSwarm

Methods

pub fn network_info(me: &Self) -> NetworkInfo[src]

pub fn listen_on( me: &mut Self, addr: Multiaddr) -> Result<ListenerId, TransportError<Error>>[src]

pub fn remove_listener(me: &mut Self, id: ListenerId) -> Result<(), ()>[src]

pub fn dial_addr(me: &mut Self, addr: Multiaddr) -> Result<(), ConnectionLimit>[src]

pub fn dial(me: &mut Self, peer_id: &PeerId) -> Result<bool, ConnectionLimit>[src]

pub fn listeners(me: &Self) -> impl Iterator<Item = &Multiaddr>[src]

pub fn external_addresses(me: &Self) -> impl Iterator<Item = &Multiaddr>[src]

pub fn local_peer_id(me: &Self) -> &PeerId[src]

pub fn add_external_address(me: &mut Self, addr: Multiaddr)[src]

pub fn connection_info(me: &mut Self, peer_id: &PeerId) -> Option<TConnInfo>[src]

pub fn ban_peer_id(me: &mut Self, peer_id: PeerId)[src]

pub fn unban_peer_id(me: &mut Self, peer_id: PeerId)[src]

pub async fn next_event<'_>( &'_ mut self) -> SwarmEvent<TBehaviour::OutEvent, THandleErr>[src]

pub async fn next<'_>(&'_ mut self) -> TBehaviour::OutEvent[src]

Trait Implementations

impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> Deref for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where THandler: IntoProtocolsHandler, TConnInfo: ConnectionInfo<PeerId = PeerId>, [src]

type Target = TBehaviour

fn deref(&self) -> &Self::Target[src]

impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> DerefMut for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where THandler: IntoProtocolsHandler, TConnInfo: ConnectionInfo<PeerId = PeerId>, [src]

fn deref_mut(&mut self) -> &mut Self::Target[src]

fn is_terminated(&self) -> bool[src]

type Item = TBehaviour::OutEvent

fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>>[src]

fn size_hint(&self) -> (usize, Option<usize>)[src]

impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> Unpin for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where THandler: IntoProtocolsHandler, TConnInfo: ConnectionInfo<PeerId = PeerId>, [src]

Auto Trait Implementations

impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo = PeerId> !RefUnwindSafe for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>

impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo = PeerId> !Sync for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>

impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo = PeerId> !UnwindSafe for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

fn borrow_mut(&mut self) -> &mut T[src]

impl<T> From<T> for T[src]

fn from(t: T) -> T[src]

impl<T, U> Into<U> for T where U: From<T>, [src]

fn into(self) -> U[src]

impl<T> Same<T> for T

type Output = T

impl<T> StreamExt for T where T: Stream + ?Sized, [src]

fn next(&mut self) -> Next<Self> where Self: Unpin, [src]

fn into_future(self) -> StreamFuture<Self> where Self: Unpin, [src]

fn map<T, F>(self, f: F) -> Map<Self, F> where F: FnMut(Self::Item) -> T, [src]

fn enumerate(self) -> Enumerate<Self>[src]

fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, [src]

fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = Option<T>>, [src]

fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future, [src]

fn collect<C>(self) -> Collect<Self, C> where C: Default + Extend<Self::Item>, [src]

fn concat(self) -> Concat<Self> where Self::Item: Extend<<Self::Item as IntoIterator>::Item>, Self::Item: IntoIterator, Self::Item: Default, [src]

fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> where F: FnMut(T, Self::Item) -> Fut, Fut: Future<Output = T>, [src]

fn flatten(self) -> Flatten<Self> where Self::Item: Stream, [src]

fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where F: FnMut(&mut S, Self::Item) -> Fut, Fut: Future<Output = Option<B>>, [src]

fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, [src]

fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, [src]

fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, [src]

fn for_each_concurrent<Fut, F>( self, limit: impl Into<Option<usize>>, f: F) -> ForEachConcurrent<Self, Fut, F> where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = ()>, [src]

fn take(self, n: usize) -> Take<Self>[src]

fn skip(self, n: usize) -> Skip<Self>[src]

fn fuse(self) -> Fuse<Self>[src]

fn by_ref(&mut self) -> &mut Self[src]

fn catch_unwind(self) -> CatchUnwind<Self> where Self: UnwindSafe, [src]

fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>> where Self: Send + 'a, [src]

fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>> where Self: 'a, [src]

fn buffered(self, n: usize) -> Buffered<Self> where Self::Item: Future, [src]

fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where Self::Item: Future, [src]

fn zip<St>(self, other: St) -> Zip<Self, St> where St: Stream, [src]

fn chain<St>(self, other: St) -> Chain<Self, St> where St: Stream<Item = Self::Item>, [src]

fn peekable(self) -> Peekable<Self>[src]

fn chunks(self, capacity: usize) -> Chunks<Self>[src]

fn forward<S>(self, sink: S) -> Forward<Self, S> where S: Sink<Self::Ok>, Self: TryStream<Error = <S as Sink<Self::Ok>>::Error>, [src]

fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where Self: Sink<Item>, [src]

fn inspect<F>(self, f: F) -> Inspect<Self, F> where F: FnMut(&Self::Item), [src]

fn left_stream<B>(self) -> Either<Self, B> where B: Stream<Item = Self::Item>, [src]

fn right_stream<B>(self) -> Either<B, Self> where B: Stream<Item = Self::Item>, [src]

fn poll_next_unpin(&mut self, cx: &mut Context) -> Poll<Option<Self::Item>> where Self: Unpin, [src]