Struct Handler 

pub struct Handler<TCodec>
where
    TCodec: Codec,
{ /* private fields */ }

Implementations

impl<TCodec> Handler<TCodec>

where TCodec: Codec + Send + 'static,

pub fn new(codec: TCodec, stream_timeout: Duration) -> Self

Trait Implementations

impl<TCodec> ConnectionHandler for Handler<TCodec>

where TCodec: Codec + Send + 'static,

type Action = OutboundRequest<TCodec>

type Event = Event<TCodec>

fn handle_action(&mut self, action: Self::Action)

fn poll_close(&mut self, _: &mut Context<'_>) -> Poll<Option<Self::Event>>

fn poll( &mut self, cx: &mut Context<'_>, ) -> Poll<ConnectionHandlerEvent<Self::Event>>

fn connection_keep_alive(&self) -> bool

fn select<H>(self, other: H) -> ConnectionHandlerSelect<Self, H>

where H: ConnectionHandler, Self: Sized,

fn map_event<O, F>(self, map: F) -> MapEvent<Self, F>

where Self: Sized, O: Debug + Send + 'static, F: FnMut(Self::Event) -> O + Send + 'static,

fn map_action<O, F>(self, map: F) -> MapAction<Self, O, F>

where Self: Sized, O: Debug + Send + 'static, F: FnMut(O) -> Option<Self::Action> + Send + 'static,

impl<TCodec> OutboundStreamHandler for Handler<TCodec>

where TCodec: Codec + Clone + Send + 'static,

type OutboundUpgrade = Upgrade<<TCodec as Codec>::Protocol>

type OutboundUserData = ()

fn on_fully_negotiated( &mut self, _user_data: Self::OutboundUserData, (stream, protocol): <Self::OutboundUpgrade as OutboundUpgradeSend>::Output, )

fn on_upgrade_error( &mut self, _user_data: Self::OutboundUserData, error: StreamUpgradeError<<Self::OutboundUpgrade as OutboundUpgradeSend>::Error>, )

fn poll_outbound_request( &mut self, _cx: &mut Context<'_>, ) -> Poll<SubstreamProtocol<Self::OutboundUpgrade, Self::OutboundUserData>>