Struct libp2p::core::nodes::collection::CollectionStream

pub struct CollectionStream<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo = PeerId, TPeerId = PeerId> { /* fields omitted */ }

Implementation of Stream that handles a collection of nodes.

Methods

impl<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId> CollectionStream<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId> where
    TConnInfo: ConnectionInfo<PeerId = TPeerId>,
    TPeerId: Eq + Hash, 

pub fn new(
    executor: Option<Box<dyn Executor + 'static + Send>>
) -> CollectionStream<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId>

Creates a new empty collection. If executor is Some, uses the given executor to spawn tasks. Otherwise, runs tasks locally.

pub fn add_reach_attempt<TFut, TMuxer>(
    &mut self,
    future: TFut,
    handler: THandler
) -> ReachAttemptId where
    TConnInfo: Send + 'static,
    TFut: Future<Output = Result<(TConnInfo, TMuxer), TReachErr>> + Send + 'static,
    THandler: IntoNodeHandler<TConnInfo> + Send + 'static,
    THandlerErr: Error + Send + 'static,
    TInEvent: Send + 'static,
    TMuxer: StreamMuxer + Send + Sync + 'static,
    TOutEvent: Send + 'static,
    TReachErr: Error + Send + 'static,
    <THandler as IntoNodeHandler<TConnInfo>>::Handler: NodeHandler,
    <THandler as IntoNodeHandler<TConnInfo>>::Handler: Send,
    <THandler as IntoNodeHandler<TConnInfo>>::Handler: 'static,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::OutboundOpenInfo: Send,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::OutboundOpenInfo: 'static,
    <TMuxer as StreamMuxer>::OutboundSubstream: Send,
    <TMuxer as StreamMuxer>::OutboundSubstream: 'static,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::Substream == SubstreamRef<Arc<TMuxer>>,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::InEvent == TInEvent,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::OutEvent == TOutEvent,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::Error == THandlerErr, 

Adds to the collection a future that tries to reach a remote.

This method spawns a task dedicated to resolving this future and processing the node's events.

pub fn interrupt(
    &mut self,
    id: ReachAttemptId
) -> Result<InterruptedReachAttempt<TInEvent, TConnInfo, TUserData>, InterruptError>

Interrupts a reach attempt.

Returns Ok if something was interrupted, and Err if the ID is not or no longer valid.

#[must_use] pub fn poll_broadcast(&mut self, event: &TInEvent, cx: &mut Context) -> Poll<()> where
    TInEvent: Clone, 

Sends an event to all nodes.

This function is "atomic", in the sense that if Poll::Pending is returned then no event has been sent to any node yet.

pub fn add_connection<TMuxer>(
    &mut self,
    conn_info: TConnInfo,
    user_data: TUserData,
    muxer: TMuxer,
    handler: <THandler as IntoNodeHandler<TConnInfo>>::Handler
) -> CollectionNodeAccept<TConnInfo, TUserData> where
    TConnInfo: Clone + Send + 'static,
    THandler: IntoNodeHandler<TConnInfo> + Send + 'static,
    THandlerErr: Error + Send + 'static,
    TInEvent: Send + 'static,
    TMuxer: StreamMuxer + Send + Sync + 'static,
    TOutEvent: Send + 'static,
    TPeerId: Clone,
    TReachErr: Error + Send + 'static,
    <THandler as IntoNodeHandler<TConnInfo>>::Handler: NodeHandler,
    <THandler as IntoNodeHandler<TConnInfo>>::Handler: Send,
    <THandler as IntoNodeHandler<TConnInfo>>::Handler: 'static,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::OutboundOpenInfo: Send,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::OutboundOpenInfo: 'static,
    <TMuxer as StreamMuxer>::OutboundSubstream: Send,
    <TMuxer as StreamMuxer>::OutboundSubstream: 'static,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::Substream == SubstreamRef<Arc<TMuxer>>,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::InEvent == TInEvent,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::OutEvent == TOutEvent,
    <<THandler as IntoNodeHandler<TConnInfo>>::Handler as NodeHandler>::Error == THandlerErr, 

Adds an existing connection to a node to the collection.

Returns whether we have replaced an existing connection, or not.

pub fn peer_mut(
    &mut self,
    id: &TPeerId
) -> Option<PeerMut<TInEvent, TUserData, TConnInfo, TPeerId>>

Grants access to an object that allows controlling a peer of the collection.

Returns None if we don't have a connection to this peer.

pub fn has_connection(&self, id: &TPeerId) -> bool

Returns true if we are connected to the given peer.

This will return true only after a NodeReached event has been produced by poll().

pub fn connections(&self) -> impl Iterator<Item = &TPeerId>

Returns a list of all the active connections.

Does not include reach attempts that haven't reached any target yet.

pub fn poll(
    &mut self,
    cx: &mut Context
) -> Poll<CollectionEvent<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId>> where
    TConnInfo: Clone, 

Provides an API similar to Stream, except that it cannot error.

Note: we use a regular poll method instead of implementing Stream in order to remove the Err variant, but also because we want the CollectionStream to stay borrowed if necessary.

Trait Implementations

impl<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId> Debug for CollectionStream<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId> where
    TConnInfo: Debug, 

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

Formats the value using the given formatter.

impl<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId> Unpin for CollectionStream<TInEvent, TOutEvent, THandler, TReachErr, THandlerErr, TUserData, TConnInfo, TPeerId>