[−][src]Struct libp2p::swarm::ExpandedSwarm
Contains the state of the network, plus the way it should behave.
Methods
impl<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where
TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static,
THandler: IntoProtocolsHandler + Send + 'static,
THandlerErr: Error + Send + 'static,
TInEvent: 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 == THandlerErr,
[src]
TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static,
THandler: IntoProtocolsHandler + Send + 'static,
THandlerErr: Error + Send + 'static,
TInEvent: 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 == THandlerErr,
pub fn new<TTransport, TMuxer>(
transport: TTransport,
behaviour: TBehaviour,
local_peer_id: PeerId
) -> ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, 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, THandlerErr, 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 listen_on(
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>,
addr: Multiaddr
) -> Result<ListenerId, TransportError<Error>>
[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, 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, THandlerErr, TConnInfo>,
id: ListenerId
) -> Result<(), ()>
[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, 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, THandlerErr, TConnInfo>,
addr: Multiaddr
) -> Result<(), TransportError<Error>>
[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>,
addr: Multiaddr
) -> Result<(), TransportError<Error>>
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, THandlerErr, TConnInfo>,
peer_id: PeerId
)
[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>,
peer_id: PeerId
)
Tries to reach the given peer using the elements in the topology.
Has no effect if we are already connected to that peer, or if no address is known for the peer.
pub fn listeners(
me: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>
) -> impl Iterator<Item = &Multiaddr>
[src]
me: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, 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, THandlerErr, TConnInfo>
) -> impl Iterator<Item = &Multiaddr>
[src]
me: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, 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, THandlerErr, TConnInfo>
) -> &PeerId
[src]
me: &ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>
) -> &PeerId
Returns the peer ID of the swarm passed as parameter.
pub fn add_external_address(
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>,
addr: Multiaddr
)
[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, 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, THandlerErr, TConnInfo>,
peer_id: &PeerId
) -> Option<TConnInfo>
[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>,
peer_id: &PeerId
) -> Option<TConnInfo>
Returns the connection info of a node, or None
if we're not connected to it.
pub fn ban_peer_id(
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>,
peer_id: PeerId
)
[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, 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, THandlerErr, TConnInfo>,
peer_id: PeerId
)
[src]
me: &mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>,
peer_id: PeerId
)
Unbans a peer.
pub async fn next_event(
&'_ mut self
) -> SwarmEvent<<TBehaviour as NetworkBehaviour>::OutEvent>
[src]
&'_ mut self
) -> SwarmEvent<<TBehaviour as NetworkBehaviour>::OutEvent>
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, THandlerErr, TConnInfo> Deref for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>
[src]
type Target = TBehaviour
The resulting type after dereferencing.
fn deref(
&self
) -> &<ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Deref>::Target
[src]
&self
) -> &<ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Deref>::Target
impl<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> DerefMut for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>
[src]
fn deref_mut(
&mut self
) -> &mut <ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Deref>::Target
[src]
&mut self
) -> &mut <ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Deref>::Target
impl<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> Stream for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where
TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static,
THandler: IntoProtocolsHandler + Send + 'static,
THandlerErr: Error + Send + 'static,
TInEvent: 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 == THandlerErr,
[src]
TBehaviour: NetworkBehaviour<ProtocolsHandler = THandler>,
TConnInfo: ConnectionInfo<PeerId = PeerId> + Debug + Clone + Send + 'static,
THandler: IntoProtocolsHandler + Send + 'static,
THandlerErr: Error + Send + 'static,
TInEvent: 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 == THandlerErr,
type Item = <TBehaviour as NetworkBehaviour>::OutEvent
Values yielded by the stream.
fn poll_next(
self: Pin<&mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>>,
cx: &mut Context
) -> Poll<Option<<ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Stream>::Item>>
[src]
self: Pin<&mut ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>>,
cx: &mut Context
) -> Poll<Option<<ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Stream>::Item>>
fn size_hint(&self) -> (usize, Option<usize>)
[src]
impl<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> Unpin for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>
[src]
Auto Trait Implementations
impl<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo = PeerId> !RefUnwindSafe for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>
impl<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> Send for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where
TBehaviour: Send,
TConnInfo: Send,
THandler: Send,
THandlerErr: Send,
TInEvent: Send,
TOutEvent: Send,
TBehaviour: Send,
TConnInfo: Send,
THandler: Send,
THandlerErr: Send,
TInEvent: Send,
TOutEvent: Send,
impl<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo = PeerId> !Sync for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>
impl<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo = PeerId> !UnwindSafe for ExpandedSwarm<TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, 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 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 compat(self) -> Compat<Self> where
Self: Unpin,
[src]
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>,