[−][src]Struct libp2p::swarm::ExpandedSwarm
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>,
TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static,
THandleErr: Error + Send + 'static,
THandler: IntoProtocolsHandler + Send + 'static,
TInEvent: Clone + Send + 'static,
TOutEvent: Send + 'static,
<THandler as IntoProtocolsHandler>::Handler: ProtocolsHandler,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InEvent == TInEvent,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutEvent == TOutEvent,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::Error == THandleErr, [src]
TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static,
THandleErr: Error + Send + 'static,
THandler: IntoProtocolsHandler + Send + 'static,
TInEvent: Clone + Send + 'static,
TOutEvent: Send + 'static,
<THandler as IntoProtocolsHandler>::Handler: ProtocolsHandler,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InEvent == TInEvent,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutEvent == TOutEvent,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::Error == THandleErr,
pub fn new<TTransport, TMuxer>(
transport: TTransport,
behaviour: TBehaviour,
local_peer_id: PeerId
) -> ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where
TMuxer: StreamMuxer + Send + Sync + 'static,
TTransport: Transport<Output = (TConnInfo, TMuxer)> + Clone + Send + Sync + 'static,
<TMuxer as StreamMuxer>::OutboundSubstream: Send,
<TMuxer as StreamMuxer>::OutboundSubstream: 'static,
<TMuxer as StreamMuxer>::OutboundSubstream: Send,
<TMuxer as StreamMuxer>::OutboundSubstream: 'static,
<TMuxer as StreamMuxer>::Substream: Send,
<TMuxer as StreamMuxer>::Substream: 'static,
<TTransport as Transport>::Error: Send,
<TTransport as Transport>::Error: Sync,
<TTransport as Transport>::Error: 'static,
<TTransport as Transport>::Listener: Send,
<TTransport as Transport>::Listener: 'static,
<TTransport as Transport>::ListenerUpgrade: Send,
<TTransport as Transport>::ListenerUpgrade: 'static,
<TTransport as Transport>::Dial: Send,
<TTransport as Transport>::Dial: 'static, [src]
transport: TTransport,
behaviour: TBehaviour,
local_peer_id: PeerId
) -> ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where
TMuxer: StreamMuxer + Send + Sync + 'static,
TTransport: Transport<Output = (TConnInfo, TMuxer)> + Clone + Send + Sync + 'static,
<TMuxer as StreamMuxer>::OutboundSubstream: Send,
<TMuxer as StreamMuxer>::OutboundSubstream: 'static,
<TMuxer as StreamMuxer>::OutboundSubstream: Send,
<TMuxer as StreamMuxer>::OutboundSubstream: 'static,
<TMuxer as StreamMuxer>::Substream: Send,
<TMuxer as StreamMuxer>::Substream: 'static,
<TTransport as Transport>::Error: Send,
<TTransport as Transport>::Error: Sync,
<TTransport as Transport>::Error: 'static,
<TTransport as Transport>::Listener: Send,
<TTransport as Transport>::Listener: 'static,
<TTransport as Transport>::ListenerUpgrade: Send,
<TTransport as Transport>::ListenerUpgrade: 'static,
<TTransport as Transport>::Dial: Send,
<TTransport as Transport>::Dial: 'static,
Builds a new Swarm.
pub fn network_info(
me: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>
) -> NetworkInfo[src]
me: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>
) -> NetworkInfo
Returns information about the [Network] underlying the Swarm.
pub fn listen_on(
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
addr: Multiaddr
) -> Result<ListenerId, TransportError<Error>>[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
addr: Multiaddr
) -> Result<ListenerId, TransportError<Error>>
Starts listening on the given address.
Returns an error if the address is not supported.
pub fn remove_listener(
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
id: ListenerId
) -> Result<(), ()>[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
id: ListenerId
) -> Result<(), ()>
Remove some listener.
Returns Ok(()) if there was a listener with this ID.
pub fn dial_addr(
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
addr: Multiaddr
) -> Result<(), ConnectionLimit>[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
addr: Multiaddr
) -> Result<(), ConnectionLimit>
Tries to dial the given address.
Returns an error if the address is not supported.
pub fn dial(
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
peer_id: &PeerId
) -> Result<bool, ConnectionLimit>[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
peer_id: &PeerId
) -> Result<bool, ConnectionLimit>
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: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>
) -> impl Iterator<Item = &Multiaddr>[src]
me: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>
) -> impl Iterator<Item = &Multiaddr>
Returns an iterator that produces the list of addresses we're listening on.
pub fn external_addresses(
me: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>
) -> impl Iterator<Item = &Multiaddr>[src]
me: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>
) -> impl Iterator<Item = &Multiaddr>
Returns an iterator that produces the list of addresses that other nodes can use to reach us.
pub fn local_peer_id(
me: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>
) -> &PeerId[src]
me: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>
) -> &PeerId
Returns the peer ID of the swarm passed as parameter.
pub fn add_external_address(
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
addr: Multiaddr
)[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
addr: Multiaddr
)
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 ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
peer_id: &PeerId
) -> Option<TConnInfo>[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
peer_id: &PeerId
) -> Option<TConnInfo>
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 ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
peer_id: PeerId
)[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
peer_id: PeerId
)
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 ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
peer_id: PeerId
)[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>,
peer_id: PeerId
)
Unbans a peer.
pub async fn next_event(
&'_ mut self
) -> SwarmEvent<<TBehaviour as NetworkBehaviour>::OutEvent, THandleErr>[src]
&'_ mut self
) -> SwarmEvent<<TBehaviour as NetworkBehaviour>::OutEvent, THandleErr>
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 as NetworkBehaviour>::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
TConnInfo: ConnectionInfo<PeerId = PeerId>,
THandler: IntoProtocolsHandler, [src]
TConnInfo: ConnectionInfo<PeerId = PeerId>,
THandler: IntoProtocolsHandler,
type Target = TBehaviour
The resulting type after dereferencing.
fn deref(
&self
) -> &<ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> as Deref>::Target[src]
&self
) -> &<ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> as Deref>::Target
impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> DerefMut for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where
TConnInfo: ConnectionInfo<PeerId = PeerId>,
THandler: IntoProtocolsHandler, [src]
TConnInfo: ConnectionInfo<PeerId = PeerId>,
THandler: IntoProtocolsHandler,
fn deref_mut(
&mut self
) -> &mut <ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> as Deref>::Target[src]
&mut self
) -> &mut <ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> as Deref>::Target
impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> FusedStream for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where
TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static,
THandler: IntoProtocolsHandler + Send + 'static,
TInEvent: Clone + Send + 'static,
TOutEvent: Send + 'static,
<THandler as IntoProtocolsHandler>::Handler: ProtocolsHandler,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InEvent == TInEvent,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutEvent == TOutEvent, [src]
TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static,
THandler: IntoProtocolsHandler + Send + 'static,
TInEvent: Clone + Send + 'static,
TOutEvent: Send + 'static,
<THandler as IntoProtocolsHandler>::Handler: ProtocolsHandler,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InEvent == TInEvent,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutEvent == TOutEvent,
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>,
TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static,
THandler: IntoProtocolsHandler + Send + 'static,
TInEvent: Clone + Send + 'static,
TOutEvent: Send + 'static,
<THandler as IntoProtocolsHandler>::Handler: ProtocolsHandler,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InEvent == TInEvent,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutEvent == TOutEvent, [src]
TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static,
THandler: IntoProtocolsHandler + Send + 'static,
TInEvent: Clone + Send + 'static,
TOutEvent: Send + 'static,
<THandler as IntoProtocolsHandler>::Handler: ProtocolsHandler,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InEvent == TInEvent,
<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutEvent == TOutEvent,
type Item = <TBehaviour as NetworkBehaviour>::OutEvent
Values yielded by the stream.
fn poll_next(
self: Pin<&mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>>,
cx: &mut Context
) -> Poll<Option<<ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> as Stream>::Item>>[src]
self: Pin<&mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo>>,
cx: &mut Context
) -> Poll<Option<<ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> as Stream>::Item>>
fn size_hint(&self) -> (usize, Option<usize>)[src]
impl<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> Unpin for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, TConnInfo> where
TConnInfo: ConnectionInfo<PeerId = PeerId>,
THandler: IntoProtocolsHandler, [src]
TConnInfo: ConnectionInfo<PeerId = PeerId>,
THandler: IntoProtocolsHandler,
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,
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]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T[src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<T> Same<T> for T
type Output = T
Should always be Self
impl<T> StreamExt for T where
T: Stream + ?Sized, [src]
T: Stream + ?Sized,
fn next(&mut self) -> Next<Self> where
Self: Unpin, [src]
Self: Unpin,
fn into_future(self) -> StreamFuture<Self> where
Self: Unpin, [src]
Self: Unpin,
fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T, [src]
F: FnMut(Self::Item) -> T,
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]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
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]
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future, [src]
F: FnMut(Self::Item) -> Fut,
Fut: Future,
fn collect<C>(self) -> Collect<Self, C> where
C: Default + Extend<Self::Item>, [src]
C: Default + Extend<Self::Item>,
fn concat(self) -> Concat<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default, [src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
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]
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
fn flatten(self) -> Flatten<Self> where
Self::Item: Stream, [src]
Self::Item: Stream,
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]
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>, [src]
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
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]
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
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]
Self: UnwindSafe,
fn boxed<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a + Send>> where
Self: Send + 'a, [src]
Self: Send + 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a>> where
Self: 'a, [src]
Self: 'a,
fn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future, [src]
Self::Item: Future,
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future, [src]
Self::Item: Future,
fn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream, [src]
St: Stream,
fn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>, [src]
St: Stream<Item = Self::Item>,
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]
S: Sink<Self::Ok>,
Self: TryStream<Error = <S as Sink<Self::Ok>>::Error>,
fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>, [src]
Self: Sink<Item>,
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item), [src]
F: FnMut(&Self::Item),
fn left_stream<B>(self) -> Either<Self, B> where
B: Stream<Item = Self::Item>, [src]
B: Stream<Item = Self::Item>,
fn right_stream<B>(self) -> Either<B, Self> where
B: Stream<Item = Self::Item>, [src]
B: Stream<Item = Self::Item>,
fn poll_next_unpin(&mut self, cx: &mut Context) -> Poll<Option<Self::Item>> where
Self: Unpin, [src]
Self: Unpin,
fn select_next_some(&mut self) -> SelectNextSome<Self> where
Self: Unpin + FusedStream, [src]
Self: Unpin + FusedStream,
impl<T> StreamExt for T where
T: Stream + ?Sized, [src]
T: Stream + ?Sized,
fn next(&mut self) -> NextFuture<Self> where
Self: Unpin, [src]
Self: Unpin,
fn take(self, n: usize) -> Take<Self>[src]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, [src]
P: FnMut(&Self::Item) -> bool,
fn step_by(self, step: usize) -> StepBy<Self>[src]
fn chain<U>(self, other: U) -> Chain<Self, U> where
U: Stream<Item = Self::Item>, [src]
U: Stream<Item = Self::Item>,
fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Stream<Item = &'a T>,
T: Clone + 'a, [src]
Self: Stream<Item = &'a T>,
T: Clone + 'a,
fn copied<'a, T>(self) -> Copied<Self> where
Self: Stream<Item = &'a T>,
T: Copy + 'a, [src]
Self: Stream<Item = &'a T>,
T: Copy + 'a,
fn cycle(self) -> Cycle<Self> where
Self: Clone, [src]
Self: Clone,
fn enumerate(self) -> Enumerate<Self>[src]
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B, [src]
F: FnMut(Self::Item) -> B,
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item), [src]
F: FnMut(&Self::Item),
fn last(self) -> LastFuture<Self, Self::Item>[src]
fn fuse(self) -> Fuse<Self>[src]
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool, [src]
P: FnMut(&Self::Item) -> bool,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>, [src]
F: FnMut(Self::Item) -> Option<B>,
fn min_by_key<B, F>(self, key_by: F) -> MinByKeyFuture<Self, Self::Item, F> where
B: Ord,
F: FnMut(&Self::Item) -> B, [src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, key_by: F) -> MaxByKeyFuture<Self, Self::Item, F> where
B: Ord,
F: FnMut(&Self::Item) -> B, [src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> MinByFuture<Self, F, Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max<F>(self) -> MaxFuture<Self, F, Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min<F>(self) -> MinFuture<Self, F, Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> MaxByFuture<Self, F, Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn nth(&mut self, n: usize) -> NthFuture<Self> where
Self: Unpin, [src]
Self: Unpin,
fn all<F>(&mut self, f: F) -> AllFuture<Self, F, Self::Item> where
F: FnMut(Self::Item) -> bool,
Self: Unpin, [src]
F: FnMut(Self::Item) -> bool,
Self: Unpin,
fn find<P>(&mut self, p: P) -> FindFuture<Self, P> where
P: FnMut(&Self::Item) -> bool,
Self: Unpin, [src]
P: FnMut(&Self::Item) -> bool,
Self: Unpin,
fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
Self: Unpin, [src]
F: FnMut(Self::Item) -> Option<B>,
Self: Unpin,
fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, F, B> where
F: FnMut(B, Self::Item) -> B, [src]
F: FnMut(B, Self::Item) -> B,
fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> where
F: FnMut(Self::Item), [src]
F: FnMut(Self::Item),
fn any<F>(&mut self, f: F) -> AnyFuture<Self, F, Self::Item> where
F: FnMut(Self::Item) -> bool,
Self: Unpin, [src]
F: FnMut(Self::Item) -> bool,
Self: Unpin,
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>, [src]
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, [src]
P: FnMut(&Self::Item) -> bool,
fn skip(self, n: usize) -> Skip<Self>[src]
fn try_fold<B, F, T, E>(&mut self, init: T, f: F) -> TryFoldFuture<Self, F, T> where
F: FnMut(B, Self::Item) -> Result<T, E>,
Self: Unpin, [src]
F: FnMut(B, Self::Item) -> Result<T, E>,
Self: Unpin,
fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<Self, F> where
F: FnMut(Self::Item) -> Result<(), E>,
Self: Unpin, [src]
F: FnMut(Self::Item) -> Result<(), E>,
Self: Unpin,
fn zip<U>(self, other: U) -> Zip<Self, U> where
U: Stream, [src]
U: Stream,
fn partial_cmp<S>(self, other: S) -> PartialCmpFuture<Self, S> where
S: Stream,
Self: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>, [src]
S: Stream,
Self: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>,
fn position<P>(&mut self, predicate: P) -> PositionFuture<Self, P> where
P: FnMut(Self::Item) -> bool,
Self: Unpin, [src]
P: FnMut(Self::Item) -> bool,
Self: Unpin,
fn cmp<S>(self, other: S) -> CmpFuture<Self, S> where
S: Stream,
Self: Stream,
Self::Item: Ord, [src]
S: Stream,
Self: Stream,
Self::Item: Ord,
fn ne<S>(self, other: S) -> NeFuture<Self, S> where
S: Stream,
Self::Item: PartialEq<<S as Stream>::Item>, [src]
S: Stream,
Self::Item: PartialEq<<S as Stream>::Item>,
fn ge<S>(self, other: S) -> GeFuture<Self, S> where
S: Stream,
Self: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>, [src]
S: Stream,
Self: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>,
fn eq<S>(self, other: S) -> EqFuture<Self, S> where
S: Stream,
Self: Stream,
Self::Item: PartialEq<<S as Stream>::Item>, [src]
S: Stream,
Self: Stream,
Self::Item: PartialEq<<S as Stream>::Item>,
fn gt<S>(self, other: S) -> GtFuture<Self, S> where
S: Stream,
Self: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>, [src]
S: Stream,
Self: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>,
fn le<S>(self, other: S) -> LeFuture<Self, S> where
S: Stream,
Self: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>, [src]
S: Stream,
Self: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>,
fn lt<S>(self, other: S) -> LtFuture<Self, S> where
S: Stream,
Self: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>, [src]
S: Stream,
Self: Stream,
Self::Item: PartialOrd<<S as Stream>::Item>,
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>[src]
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized, [src]
S: Stream<Item = Result<T, E>> + ?Sized,
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]
self: Pin<&mut S>,
cx: &mut Context
) -> Poll<Option<Result<<S as TryStream>::Ok, <S as TryStream>::Error>>>
impl<S> TryStreamExt for S where
S: TryStream + ?Sized, [src]
S: TryStream + ?Sized,
fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>, [src]
Self::Error: Into<E>,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T, [src]
F: FnMut(Self::Ok) -> T,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E, [src]
F: FnMut(Self::Error) -> E,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>, [src]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>, [src]
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok), [src]
F: FnMut(&Self::Ok),
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error), [src]
F: FnMut(&Self::Error),
fn into_stream(self) -> IntoStream<Self>[src]
fn try_next(&mut self) -> TryNext<Self> where
Self: Unpin, [src]
Self: Unpin,
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]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
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]
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
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]
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
fn try_collect<C>(self) -> TryCollect<Self, C> where
C: Default + Extend<Self::Ok>, [src]
C: Default + Extend<Self::Ok>,
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>, [src]
F: FnMut(&Self::Ok) -> Fut,
Fut: Future<Output = bool>,
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]
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
fn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>, [src]
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
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]
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
fn try_concat(self) -> TryConcat<Self> where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default, [src]
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error, [src]
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_poll_next_unpin(
&mut self,
cx: &mut Context
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin, [src]
&mut self,
cx: &mut Context
) -> Poll<Option<Result<Self::Ok, Self::Error>>> where
Self: Unpin,
fn into_async_read(self) -> IntoAsyncRead<Self> where
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>, [src]
Self: TryStreamExt<Error = Error> + Unpin,
Self::Ok: AsRef<[u8]>,
impl<S> TryStreamExt for S where
S: TryStream, [src]
S: TryStream,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
V: MultiLane<T>,