Struct libp2p_core::nodes::raw_swarm::RawSwarm

pub struct RawSwarm<TTrans, TInEvent, TOutEvent, THandler, THandlerErr> where
    TTrans: Transport,  { /* fields omitted */ }

Implementation of Stream that handles the nodes.

Methods

impl<TTrans, TInEvent, TOutEvent, TMuxer, THandler, THandlerErr> RawSwarm<TTrans, TInEvent, TOutEvent, THandler, THandlerErr> where     TTrans: Transport + Clone,     TMuxer: StreamMuxer,     THandler: IntoNodeHandler + Send + 'static,     THandler::Handler: NodeHandler<Substream = Substream<TMuxer>, InEvent = TInEvent, OutEvent = TOutEvent, Error = THandlerErr> + Send + 'static,     <THandler::Handler as NodeHandler>::OutboundOpenInfo: Send + 'static,     THandlerErr: Error + Send + 'static,

pub fn new(transport: TTrans, local_peer_id: PeerId) -> Self

Creates a new node events stream.

pub fn transport(&self) -> &TTrans

Returns the transport passed when building this object.

pub fn listen_on(     &mut self,     addr: Multiaddr ) -> Result<Multiaddr, TransportError<TTrans::Error>>

Start listening on the given multiaddress.

pub fn listeners(     &self ) -> impl Iterator<Item = &Multiaddr>

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

pub fn nat_traversal<'a>(     &'a self,     observed_addr: &'a Multiaddr ) -> impl Iterator<Item = Multiaddr> + 'a where     TMuxer: 'a,     THandler: 'a,

Call this function in order to know which address remotes should dial in order to access your local node.

observed_addr should be an address a remote observes you as, which can be obtained for example with the identify protocol.

For each listener, calls nat_traversal with the observed address and returns the outcome.

pub fn local_peer_id(&self) -> &PeerId

Returns the peer id of the local node.

This is the same value as was passed to new().

pub fn dial(     &mut self,     addr: Multiaddr,     handler: THandler ) -> Result<(), TransportError<TTrans::Error>> where     TTrans: Transport<Output = (PeerId, TMuxer)>,     TTrans::Error: Send + 'static,     TTrans::Dial: Send + 'static,     TMuxer: StreamMuxer + Send + Sync + 'static,     TMuxer::OutboundSubstream: Send,     TMuxer::Substream: Send,     TInEvent: Send + 'static,     TOutEvent: Send + 'static,

Dials a multiaddress without knowing the peer ID we're going to obtain.

The second parameter is the handler to use if we manage to reach a node.

pub fn num_incoming_negotiated(&self) -> usize

Deprecated:

Use incoming_negotiated().count() instead

Returns the number of incoming connections that are currently in the process of being negotiated.

We don't know anything about these connections yet, so all we can do is know how many of them we have.

pub fn incoming_negotiated(     &self ) -> impl Iterator<Item = IncomingInfo>

Returns the list of incoming connections that are currently in the process of being negotiated. We don't know the PeerId of these nodes yet.

pub fn broadcast_event(&mut self, event: &TInEvent) where     TInEvent: Clone,

Sends an event to all nodes.

pub fn peer(     &mut self,     peer_id: PeerId ) -> Peer<TTrans, TInEvent, TOutEvent, THandler, THandlerErr>

Grants access to a struct that represents a peer.

pub fn poll(     &mut self ) -> Async<RawSwarmEvent<TTrans, TInEvent, TOutEvent, THandler, THandlerErr>> where     TTrans: Transport<Output = (PeerId, TMuxer)>,     TTrans::Error: Send + 'static,     TTrans::Dial: Send + 'static,     TTrans::ListenerUpgrade: Send + 'static,     TMuxer: StreamMuxer + Send + Sync + 'static,     TMuxer::OutboundSubstream: Send,     TMuxer::Substream: Send,     TInEvent: Send + 'static,     TOutEvent: Send + 'static,     THandler: IntoNodeHandler + Send + 'static,     THandler::Handler: NodeHandler<Substream = Substream<TMuxer>, InEvent = TInEvent, OutEvent = TOutEvent, Error = THandlerErr> + Send + 'static,     <THandler::Handler as NodeHandler>::OutboundOpenInfo: Send + 'static,     THandlerErr: Error + Send + 'static,

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

Trait Implementations

impl<TTrans: Debug, TInEvent: Debug, TOutEvent: Debug, THandler: Debug, THandlerErr: Debug> Debug for RawSwarm<TTrans, TInEvent, TOutEvent, THandler, THandlerErr> where     TTrans: Transport,     TTrans::Error: Debug,

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

Formats the value using the given formatter.