Enum libp2p::core::network::Peer

pub enum Peer<'a, TTrans, TInEvent, TOutEvent, THandler> where
    TTrans: Transport,
    THandler: IntoConnectionHandler,  {
    Connected(ConnectedPeer<'a, TTrans, TInEvent, TOutEvent, THandler>),
    Dialing(DialingPeer<'a, TTrans, TInEvent, TOutEvent, THandler>),
    Disconnected(DisconnectedPeer<'a, TTrans, TInEvent, TOutEvent, THandler>),
    Local,
}

The possible representations of a peer in a Network, as seen by the local node.

Note: In any state there may always be a pending incoming connection attempt from the peer, however, the remote identity of a peer is only known once a connection is fully established.

Variants

Connected(ConnectedPeer<'a, TTrans, TInEvent, TOutEvent, THandler>)

At least one established connection exists to the peer.

Dialing(DialingPeer<'a, TTrans, TInEvent, TOutEvent, THandler>)

There is an ongoing dialing (i.e. outgoing connection) attempt to the peer. There may already be other established connections to the peer.

Disconnected(DisconnectedPeer<'a, TTrans, TInEvent, TOutEvent, THandler>)

There exists no established connection to the peer and there is currently no ongoing dialing (i.e. outgoing connection) attempt in progress.

Local

The peer represents the local node.

Implementations

impl<'a, TTrans, TMuxer, TInEvent, TOutEvent, THandler> Peer<'a, TTrans, TInEvent, TOutEvent, THandler> where
    TTrans: Transport<Output = (PeerId, TMuxer)> + Clone,
    TMuxer: 'static + StreamMuxer + Send + Sync,
    TInEvent: 'static + Send,
    TOutEvent: 'static + Send,
    THandler: 'static + IntoConnectionHandler + Send,
    <TTrans as Transport>::Error: 'static,
    <TTrans as Transport>::Error: Send,
    <TTrans as Transport>::Dial: 'static,
    <TTrans as Transport>::Dial: Send,
    <TMuxer as StreamMuxer>::OutboundSubstream: Send,
    <THandler as IntoConnectionHandler>::Handler: ConnectionHandler,
    <THandler as IntoConnectionHandler>::Handler: Send,
    <<THandler as IntoConnectionHandler>::Handler as ConnectionHandler>::OutboundOpenInfo: Send,
    <<THandler as IntoConnectionHandler>::Handler as ConnectionHandler>::Error: 'static,
    <<THandler as IntoConnectionHandler>::Handler as ConnectionHandler>::Error: Error,
    <<THandler as IntoConnectionHandler>::Handler as ConnectionHandler>::Error: Send,
    <<THandler as IntoConnectionHandler>::Handler as ConnectionHandler>::Substream == SubstreamRef<Arc<TMuxer>>,
    <<THandler as IntoConnectionHandler>::Handler as ConnectionHandler>::InEvent == TInEvent,
    <<THandler as IntoConnectionHandler>::Handler as ConnectionHandler>::OutEvent == TOutEvent, 

pub fn is_connected(&self) -> bool

Checks whether the peer is currently connected.

Returns true iff Peer::into_connected returns Some.

pub fn is_dialing(&self) -> bool

Checks whether the peer is currently being dialed.

Returns true iff Peer::into_dialing returns Some.

pub fn is_disconnected(&self) -> bool

Checks whether the peer is currently disconnected.

Returns true iff Peer::into_disconnected returns Some.

pub fn dial<I>(
    self,
    address: Multiaddr,
    remaining: I,
    handler: THandler
) -> Result<(ConnectionId, DialingPeer<'a, TTrans, TInEvent, TOutEvent, THandler>), ConnectionLimit> where
    I: IntoIterator<Item = Multiaddr>, 

Initiates a new dialing attempt to this peer using the given addresses.

The connection ID of the first connection attempt, i.e. to address, is returned, together with a DialingPeer for further use. The remaining addresses are tried in order in subsequent connection attempts in the context of the same dialing attempt, if the connection attempt to the first address fails.

pub fn into_connected(
    self
) -> Option<ConnectedPeer<'a, TTrans, TInEvent, TOutEvent, THandler>>

Converts the peer into a ConnectedPeer, if an established connection exists.

Succeeds if the there is at least one established connection to the peer.

pub fn into_dialing(
    self
) -> Option<DialingPeer<'a, TTrans, TInEvent, TOutEvent, THandler>>

Converts the peer into a DialingPeer, if a dialing attempt exists.

Succeeds if the there is at least one pending outgoing connection to the peer.

pub fn into_disconnected(
    self
) -> Option<DisconnectedPeer<'a, TTrans, TInEvent, TOutEvent, THandler>>

Converts the peer into a DisconnectedPeer, if neither an established connection nor a dialing attempt exists.

Trait Implementations

impl<'a, TTrans, TInEvent, TOutEvent, THandler> Debug for Peer<'a, TTrans, TInEvent, TOutEvent, THandler> where
    TTrans: Transport,
    THandler: IntoConnectionHandler, 

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

Formats the value using the given formatter.