[−][src]Struct libp2p::swarm::ExpandedSwarm

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

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

Methods

impl<TTransport, TBehaviour, TMuxer, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> ExpandedSwarm<TTransport, 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, TMuxer: StreamMuxer + Send + Sync + 'static, TOutEvent: Send + 'static, TTransport: Transport<Output = (TConnInfo, TMuxer)> + Clone, <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: '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, <THandler as IntoProtocolsHandler>::Handler: ProtocolsHandler, <THandler as IntoProtocolsHandler>::Handler: Send, <THandler as IntoProtocolsHandler>::Handler: 'static, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundOpenInfo: Send, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundOpenInfo: 'static, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol: InboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol: Send, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::Info: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::Info: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::InfoIter: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::InfoIter: 'static, <<<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::InfoIter as IntoIterator>::IntoIter: Send, <<<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::InfoIter as IntoIterator>::IntoIter: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as InboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Error: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as InboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Error: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as InboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Future: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as InboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Future: 'static, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol: OutboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol: Send, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::Info: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::Info: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::InfoIter: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::InfoIter: 'static, <<<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::InfoIter as IntoIterator>::IntoIter: Send, <<<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::InfoIter as IntoIterator>::IntoIter: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as OutboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Future: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as OutboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Future: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as OutboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Error: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as OutboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Error: 'static, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InEvent == TInEvent, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutEvent == TOutEvent, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::Substream == SubstreamRef<Arc<TMuxer>>, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::Error == THandlerErr, [src]

`pub fn new( transport: TTransport, behaviour: TBehaviour, local_peer_id: PeerId ) -> ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>`[src]

Builds a new Swarm.

`pub fn transport( me: &ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> ) -> &TTransport`[src]

Returns the transport passed when building this object.

`pub fn listen_on( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, addr: Multiaddr ) -> Result<ListenerId, TransportError<<TTransport as Transport>::Error>>`[src]

Starts listening on the given address.

Returns an error if the address is not supported.

`pub fn remove_listener( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, id: ListenerId ) -> Result<(), ()>`[src]

Remove some listener.

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

`pub fn dial_addr( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, addr: Multiaddr ) -> Result<(), TransportError<<TTransport as Transport>::Error>>`[src]

Tries to dial the given address.

Returns an error if the address is not supported.

`pub fn dial( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, peer_id: PeerId )`[src]

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<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> ) -> impl Iterator<Item = &Multiaddr>`[src]

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

`pub fn external_addresses( me: &ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> ) -> 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: &ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> ) -> &PeerId`[src]

Returns the peer ID of the swarm passed as parameter.

`pub fn add_external_address( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, 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 ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, peer_id: &PeerId ) -> Option<TConnInfo>`[src]

Returns the connection info of a node, or None if we're not connected to it.

`pub fn ban_peer_id( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, 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 ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, peer_id: PeerId )`[src]

Unbans a peer.

`pub async fn next_event( &'_ mut self ) -> SwarmEvent<<TBehaviour as NetworkBehaviour>::OutEvent>`[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 as NetworkBehaviour>::OutEvent`[src]

Returns the next event produced by the [NetworkBehaviour].

Trait Implementations

`impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> Deref for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where TTransport: Transport,` [src]

`type Target = TBehaviour`

The resulting type after dereferencing.

`fn deref( &self ) -> &<ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Deref>::Target`[src]

`impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> DerefMut for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where TTransport: Transport,` [src]

`fn deref_mut( &mut self ) -> &mut <ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Deref>::Target`[src]

impl<TTransport, TBehaviour, TMuxer, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> Stream for ExpandedSwarm<TTransport, 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, TMuxer: StreamMuxer + Send + Sync + 'static, TOutEvent: Send + 'static, TTransport: Transport<Output = (TConnInfo, TMuxer)> + Clone, <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: '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, <THandler as IntoProtocolsHandler>::Handler: ProtocolsHandler, <THandler as IntoProtocolsHandler>::Handler: Send, <THandler as IntoProtocolsHandler>::Handler: 'static, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundOpenInfo: Send, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundOpenInfo: 'static, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol: InboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol: Send, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as InboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Future: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as InboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Future: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as InboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Error: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as InboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Error: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::Info: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::Info: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::InfoIter: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::InfoIter: 'static, <<<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::InfoIter as IntoIterator>::IntoIter: Send, <<<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InboundProtocol as UpgradeInfo>::InfoIter as IntoIterator>::IntoIter: 'static, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol: OutboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol: Send, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as OutboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Future: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as OutboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Future: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as OutboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Error: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as OutboundUpgrade<Compat01As03<Negotiated<Compat<SubstreamRef<Arc<TMuxer>>>>>>>::Error: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::Info: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::Info: 'static, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::InfoIter: Send, <<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::InfoIter: 'static, <<<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::InfoIter as IntoIterator>::IntoIter: Send, <<<<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutboundProtocol as UpgradeInfo>::InfoIter as IntoIterator>::IntoIter: 'static, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::InEvent == TInEvent, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::OutEvent == TOutEvent, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::Substream == SubstreamRef<Arc<TMuxer>>, <<THandler as IntoProtocolsHandler>::Handler as ProtocolsHandler>::Error == THandlerErr, [src]

`type Item = <TBehaviour as NetworkBehaviour>::OutEvent`

Values yielded by the stream.

`fn poll_next( self: Pin<&mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>>, cx: &mut Context ) -> Poll<Option<<ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Stream>::Item>>`[src]

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

`impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> Unpin for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where TTransport: Transport,` [src]

Auto Trait Implementations

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

`impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> Send for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where TBehaviour: Send, TConnInfo: Send, THandler: Send, THandlerErr: Send, TInEvent: Send, TOutEvent: Send, TTransport: Send, <TTransport as Transport>::Error: Send, <TTransport as Transport>::Listener: Send,`

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

`impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo = PeerId> !UnwindSafe for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, 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 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> StreamExt for T where T: Stream + ?Sized,` [src]

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

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

`fn take_while(self, predicate: P) -> TakeWhile<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`fn step_by(self, step: usize) -> StepBy<Self>`[src]

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

`fn cloned<'a, T>(self) -> Cloned<Self> where Self: Stream<Item = &'a T>, T: Clone + 'a,` [src]

`fn copied<'a, T>(self) -> Copied<Self> where Self: Stream<Item = &'a T>, T: Copy + 'a,` [src]

`fn cycle(self) -> Cycle<Self> where Self: Clone,` [src]

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

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

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

`fn last(self) -> LastFuture<Self, Self::Item>`[src]

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

`fn filter(self, predicate: P) -> Filter<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where F: FnMut(Self::Item) -> Option,` [src]

`fn min_by_key<B, F>(self, key_by: F) -> MinByKeyFuture<Self, Self::Item, F> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]

`fn max_by_key<B, F>(self, key_by: F) -> MaxByKeyFuture<Self, Self::Item, F> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]

`fn min_by<F>(self, compare: F) -> MinByFuture<Self, F, Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]

`fn max<F>(self) -> MaxFuture<Self, F, Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]

`fn min<F>(self) -> MinFuture<Self, F, Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]

`fn max_by<F>(self, compare: F) -> MaxByFuture<Self, F, Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]

`fn nth(&mut self, n: usize) -> NthFuture<Self> where Self: Unpin,` [src]

`fn all<F>(&mut self, f: F) -> AllFuture<Self, F, Self::Item> where F: FnMut(Self::Item) -> bool, Self: Unpin,` [src]

`fn find(&mut self, p: P) -> FindFuture<Self, P> where P: FnMut(&Self::Item) -> bool, Self: Unpin,` [src]

`fn find_map<F, B>(&mut self, f: F) -> FindMapFuture<Self, F> where F: FnMut(Self::Item) -> Option, Self: Unpin,` [src]

`fn fold<B, F>(self, init: B, f: F) -> FoldFuture<Self, F, B> where F: FnMut(B, Self::Item) -> B,` [src]

`fn for_each<F>(self, f: F) -> ForEachFuture<Self, F> where F: FnMut(Self::Item),` [src]

`fn any<F>(&mut self, f: F) -> AnyFuture<Self, F, Self::Item> where F: FnMut(Self::Item) -> bool, Self: Unpin,` [src]

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

`fn skip_while(self, predicate: P) -> SkipWhile<Self, P> where P: FnMut(&Self::Item) -> bool,` [src]

`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]

`fn try_for_each<F, E>(&mut self, f: F) -> TryForEachFuture<Self, F> where F: FnMut(Self::Item) -> Result<(), E>, Self: Unpin,` [src]

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

`fn partial_cmp<S>(self, other: S) -> PartialCmpFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn position(&mut self, predicate: P) -> PositionFuture<Self, P> where P: FnMut(Self::Item) -> bool, Self: Unpin,` [src]

`fn cmp<S>(self, other: S) -> CmpFuture<Self, S> where S: Stream, Self: Stream, Self::Item: Ord,` [src]

`fn ne<S>(self, other: S) -> NeFuture<Self, S> where S: Stream, Self::Item: PartialEq<<S as Stream>::Item>,` [src]

`fn ge<S>(self, other: S) -> GeFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn eq<S>(self, other: S) -> EqFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialEq<<S as Stream>::Item>,` [src]

`fn gt<S>(self, other: S) -> GtFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn le<S>(self, other: S) -> LeFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [src]

`fn lt<S>(self, other: S) -> LtFuture<Self, S> where S: Stream, Self: Stream, Self::Item: PartialOrd<<S as Stream>::Item>,` [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]

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

`fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where Self::Ok: TryFuture, <Self::Ok as TryFuture>::Error == Self::Error,` [src]

`fn try_poll_next_unpin( &mut self, cx: &mut Context ) -> Poll<Option<Result<Self::Ok, Self::Error>>> where Self: Unpin,` [src]

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

`fn into_async_read(self) -> IntoAsyncRead<Self> where Self: TryStreamExt<Error = Error> + Unpin, Self::Ok: AsRef<[u8]>,` [src]

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

`fn timeout(self, dur: Duration) -> TimeoutStream<Self> where Self::Error: From<Error>,` [src]

`impl<V, T> VZip<V> for T where V: MultiLane<T>,`

`fn vzip(self) -> V`

[−][src]Struct libp2p::swarm::ExpandedSwarm

Methods

pub fn new( transport: TTransport, behaviour: TBehaviour, local_peer_id: PeerId) -> ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>[src]

pub fn transport( me: &ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>) -> &TTransport[src]

pub fn listen_on( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, addr: Multiaddr) -> Result<ListenerId, TransportError<<TTransport as Transport>::Error>>[src]

pub fn remove_listener( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, id: ListenerId) -> Result<(), ()>[src]

pub fn dial_addr( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, addr: Multiaddr) -> Result<(), TransportError<<TTransport as Transport>::Error>>[src]

pub fn dial( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, peer_id: PeerId)[src]

pub fn listeners( me: &ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>) -> impl Iterator<Item = &Multiaddr>[src]

pub fn external_addresses( me: &ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>) -> impl Iterator<Item = &Multiaddr>[src]

pub fn local_peer_id( me: &ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>) -> &PeerId[src]

pub fn add_external_address( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, addr: Multiaddr)[src]

pub fn connection_info( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, peer_id: &PeerId) -> Option<TConnInfo>[src]

pub fn ban_peer_id( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, peer_id: PeerId)[src]

pub fn unban_peer_id( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, peer_id: PeerId)[src]

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

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

Trait Implementations

impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> Deref for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where TTransport: Transport, [src]

type Target = TBehaviour

fn deref( &self) -> &<ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Deref>::Target[src]

impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> DerefMut for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where TTransport: Transport, [src]

fn deref_mut( &mut self) -> &mut <ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Deref>::Target[src]

type Item = <TBehaviour as NetworkBehaviour>::OutEvent

fn poll_next( self: Pin<&mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>>, cx: &mut Context) -> Poll<Option<<ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Stream>::Item>>[src]

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

impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> Unpin for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where TTransport: Transport, [src]

Auto Trait Implementations

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

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

impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo = PeerId> !UnwindSafe for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, 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 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]

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

`pub fn new( transport: TTransport, behaviour: TBehaviour, local_peer_id: PeerId ) -> ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>`[src]

`pub fn transport( me: &ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> ) -> &TTransport`[src]

`pub fn listen_on( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, addr: Multiaddr ) -> Result<ListenerId, TransportError<<TTransport as Transport>::Error>>`[src]

`pub fn remove_listener( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, id: ListenerId ) -> Result<(), ()>`[src]

`pub fn dial_addr( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, addr: Multiaddr ) -> Result<(), TransportError<<TTransport as Transport>::Error>>`[src]

`pub fn dial( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, peer_id: PeerId )`[src]

`pub fn listeners( me: &ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> ) -> impl Iterator<Item = &Multiaddr>`[src]

`pub fn external_addresses( me: &ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> ) -> impl Iterator<Item = &Multiaddr>`[src]

`pub fn local_peer_id( me: &ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> ) -> &PeerId`[src]

`pub fn add_external_address( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, addr: Multiaddr )`[src]

`pub fn connection_info( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, peer_id: &PeerId ) -> Option<TConnInfo>`[src]

`pub fn ban_peer_id( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, peer_id: PeerId )`[src]

`pub fn unban_peer_id( me: &mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>, peer_id: PeerId )`[src]

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

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

`impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> Deref for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where TTransport: Transport,` [src]

`type Target = TBehaviour`

`fn deref( &self ) -> &<ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Deref>::Target`[src]

`impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> DerefMut for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where TTransport: Transport,` [src]

`fn deref_mut( &mut self ) -> &mut <ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Deref>::Target`[src]

`type Item = <TBehaviour as NetworkBehaviour>::OutEvent`

`fn poll_next( self: Pin<&mut ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo>>, cx: &mut Context ) -> Poll<Option<<ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> as Stream>::Item>>`[src]

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

`impl<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> Unpin for ExpandedSwarm<TTransport, TBehaviour, TInEvent, TOutEvent, THandler, THandlerErr, TConnInfo> where TTransport: Transport,` [src]

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

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

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

`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 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]

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

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

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

`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]

`fn step_by(self, step: usize) -> StepBy<Self>`[src]