Struct libp2p_core::upgrade::OptionalUpgrade

pub struct OptionalUpgrade<T>(/* private fields */);

👎Deprecated: Will be removed without replacement because it is not used within rust-libp2p.

Upgrade that can be disabled at runtime.

Wraps around an Option<T> and makes it available or not depending on whether it contains or not an upgrade.

Implementations

impl<T> OptionalUpgrade<T>

pub fn some(inner: T) -> Self

Creates an enabled OptionalUpgrade.

pub fn none() -> Self

Creates a disabled OptionalUpgrade.

Trait Implementations

impl<T: Clone> Clone for OptionalUpgrade<T>

fn clone(&self) -> OptionalUpgrade<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for OptionalUpgrade<T>

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

Formats the value using the given formatter.

impl<C, T> InboundUpgrade<C> for OptionalUpgrade<T>

where T: InboundUpgrade<C>,

type Output = <T as InboundUpgrade<C>>::Output

Output after the upgrade has been successfully negotiated and the handshake performed.

type Error = <T as InboundUpgrade<C>>::Error

Possible error during the handshake.

type Future = <T as InboundUpgrade<C>>::Future

Future that performs the handshake with the remote.

fn upgrade_inbound(self, sock: C, info: Self::Info) -> Self::Future

After we have determined that the remote supports one of the protocols we support, this method is called to start the handshake.

impl<C, T> OutboundUpgrade<C> for OptionalUpgrade<T>

where T: OutboundUpgrade<C>,

type Output = <T as OutboundUpgrade<C>>::Output

Output after the upgrade has been successfully negotiated and the handshake performed.

type Error = <T as OutboundUpgrade<C>>::Error

Possible error during the handshake.

type Future = <T as OutboundUpgrade<C>>::Future

Future that performs the handshake with the remote.

fn upgrade_outbound(self, sock: C, info: Self::Info) -> Self::Future

After we have determined that the remote supports one of the protocols we support, this method is called to start the handshake.

impl<T> UpgradeInfo for OptionalUpgrade<T>

where T: UpgradeInfo,

type Info = <T as UpgradeInfo>::Info

Opaque type representing a negotiable protocol.

type InfoIter = Iter<<<T as UpgradeInfo>::InfoIter as IntoIterator>::IntoIter>

Iterator returned by protocol_info.

fn protocol_info(&self) -> Self::InfoIter

Returns the list of protocols that are supported. Used during the negotiation process.