Trait ConnectionHandler 

pub trait ConnectionHandler: Send + 'static {
    type Action: Debug + Send + 'static;
    type Event: Debug + Send + 'static;

    // Required methods
    fn handle_action(&mut self, action: Self::Action);
    fn poll(
        &mut self,
        cx: &mut Context<'_>,
    ) -> Poll<ConnectionHandlerEvent<Self::Event>>;

    // Provided methods
    fn connection_keep_alive(&self) -> bool { ... }
    fn poll_close(&mut self, _: &mut Context<'_>) -> Poll<Option<Self::Event>> { ... }
    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 { ... }
}

Required Associated Types

type Action: Debug + Send + 'static

type Event: Debug + Send + 'static

Required Methods

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

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

Provided Methods

fn connection_keep_alive(&self) -> bool

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

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,

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl ConnectionHandler for DummyHandler

type Action = Infallible

type Event = Infallible

impl ConnectionHandler for PendingConnectionHandler

type Action = Infallible

type Event = Infallible

impl<L, R> ConnectionHandler for Either<L, R>

where L: ConnectionHandler, R: ConnectionHandler,

type Action = Either<<L as ConnectionHandler>::Action, <R as ConnectionHandler>::Action>

type Event = Either<<L as ConnectionHandler>::Event, <R as ConnectionHandler>::Event>

impl<THandler1, THandler2> ConnectionHandler for ConnectionHandlerSelect<THandler1, THandler2>

where THandler1: ConnectionHandler, THandler2: ConnectionHandler,

type Action = Either<<THandler1 as ConnectionHandler>::Action, <THandler2 as ConnectionHandler>::Action>

type Event = Either<<THandler1 as ConnectionHandler>::Event, <THandler2 as ConnectionHandler>::Event>

impl<THandler, O, TMap> ConnectionHandler for MapAction<THandler, O, TMap>

where THandler: ConnectionHandler, O: Debug + Send + Clone + 'static, TMap: Send + 'static + Fn(O) -> Option<THandler::Action>,

type Action = O

type Event = <THandler as ConnectionHandler>::Event

impl<THandler, O, TMap> ConnectionHandler for MapEvent<THandler, TMap>

where THandler: ConnectionHandler, O: Debug + Send + Clone + 'static, TMap: Send + 'static + FnMut(THandler::Event) -> O,

type Action = <THandler as ConnectionHandler>::Action

type Event = O