Trait Reactor 

pub trait Reactor {
    type UserCommand;

    // Required method
    fn on_inbound_message(
        &mut self,
        buf: &mut [u8],
        new_bytes: usize,
        decoded_msg_size: usize,
        ctx: &mut DispatchContext<'_, Self::UserCommand>,
    ) -> Result<MessageResult>;

    // Provided methods
    fn on_connected(
        &mut self,
        _ctx: &mut DispatchContext<'_, Self::UserCommand>,
        _listener: ReactorID,
    ) -> Result<()> { ... }
    fn on_readable(
        &mut self,
        ctx: &mut ReactorReableContext<'_, Self::UserCommand>,
    ) -> Result<()> { ... }
    fn on_command(
        &mut self,
        _cmd: Self::UserCommand,
        ctx: &mut DispatchContext<'_, Self::UserCommand>,
    ) -> Result<()> { ... }
    fn on_close(
        &mut self,
        _reactorid: ReactorID,
        _cmd_sender: &CmdSender<Self::UserCommand>,
    ) { ... }
}

A Reactor is assigned a unique ReactorID when adding to a ReactRuntime, and is able to receive socket messsages (via reader) and commands. process_events of a ReactRuntime instance should be periodically called in a dedicated thread. Besides socket communication, Sending command is the only thread-safe way to communicate with a Reactor. A Reactor could send socket messages (via sender), or send commands (via cmd_sender) to another Reactor with specific ReactorID. A Reactor is destroyed when the socket is closed.

Required Associated Types

type UserCommand

Required Methods

fn on_inbound_message( &mut self, buf: &mut [u8], new_bytes: usize, decoded_msg_size: usize, ctx: &mut DispatchContext<'_, Self::UserCommand>, ) -> Result<MessageResult>

It’s called by in on_readable() when either decoded_msg_size==0 (meaning message size is unknown) or decoded_msg_size <= buf.len() (meaning a full message is read).

• buf - The buffer containing all the received bytes
• new_bytes - Number of new received bytes, which are also bytes that are not processed. If previously on_inbound_message returned DropMsgSize. new_bytes is the remaining bytes.
• decoded_msg_size - the decoded message size which is return value of previous call of on_inbound_message. 0 means message having not been decoded.
• return ExpectMsgSize(msgsize) to indicate more read until full msgsize is read then call next dispatch. msgsize==0 indicates msg size is unknown. DropMsgSize(msgsize) to indiciate message is processed already. framework can drop the message after call. then msgsize will be 0 again.
• Note that when calling on_inbound_message(decoded_msg_size) -> ExpectMsgSize(expect_msg_size), if expect_msg_size!=0, it should be always > msg_size.

Provided Methods

fn on_connected( &mut self, _ctx: &mut DispatchContext<'_, Self::UserCommand>, _listener: ReactorID, ) -> Result<()>

ReactRuntime calls it when connection is established.

• ctx - The context the used for reactor to send socket message or command.
  • Note that ctx.cmd_sener can only send command to a reactor that belongs to the same ReactRuntime.
• listener - The listener ID when the reactor is created by a listener socket; otherwise, it’s INVALID_REACTOR_ID.
• return err to close socket.

fn on_readable( &mut self, ctx: &mut ReactorReableContext<'_, Self::UserCommand>, ) -> Result<()>

ReactRuntime calls it when there’s a readable event. ctx.reader could be used to read message. See MsgReader for usage. This is a default implementation which uses MsgReader to read all messages then call on_inbound_message to dispatch (default try_read_fast_read). User may override this function to implement other strategies (e.g. `try_read_fast_dispatch``).

• return Err to close socket.

fn on_command( &mut self, _cmd: Self::UserCommand, ctx: &mut DispatchContext<'_, Self::UserCommand>, ) -> Result<()>

ReactRuntime calls it when receiving a command. If no user command is used (e.g. type UserCommand=();), user may not need to override it. return Err to close the socket.

fn on_close( &mut self, _reactorid: ReactorID, _cmd_sender: &CmdSender<Self::UserCommand>, )

ReactRuntime calls it when the reactor is removed from poller and before closing the socket. The Reactor will be destroyed after this call.

Dyn Compatibility

This trait is dyn compatible.

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

Implementors

impl<AppData> Reactor for SimpleIoReactor<AppData>

type UserCommand = ()

impl<AppData> Reactor for SimpleIoService<AppData>

type UserCommand = ()