Struct Stream

pub struct Stream<P: Protocol> { /* private fields */ }

A main stream state machine abstaction

You may use the Stream directly. But it’s recommented to either use Persistent for client connections or Accept for server-side connection processing.

Implementations

impl<P: Protocol> Stream<P>

pub fn transport(&mut self) -> Transport<'_, P::Socket>

Get a Transport object for the stream

This method is only useful if you want to manipulate buffers externally (like pushing to the buffer from another thread). Just be sure to wake up state machine after manipulating buffers.

pub fn new( sock: P::Socket, seed: P::Seed, scope: &mut Scope<'_, P::Context>, ) -> Response<Self, Void>

pub fn connected( sock: P::Socket, seed: P::Seed, scope: &mut Scope<'_, P::Context>, ) -> Response<Self, Void>

Trait Implementations

impl<P: Protocol> Accepted for Stream<P>

where <P as Protocol>::Seed: Clone,

type Seed = <P as Protocol>::Seed

type Socket = <P as Protocol>::Socket

fn accepted( sock: P::Socket, seed: <P as Protocol>::Seed, scope: &mut Scope<'_, Self::Context>, ) -> Response<Self, Void>

The constructor of the state machine from the accepted connection

impl<P: Debug + Protocol> Debug for Stream<P>

where P::Socket: Debug,

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

Formats the value using the given formatter.

impl<P: Protocol> Machine for Stream<P>

type Context = <P as Protocol>::Context

Context type for the state machine

type Seed = Void

Seed is piece of data that is needed to initialize the machine

fn create( void: Void, _scope: &mut Scope<'_, Self::Context>, ) -> Response<Self, Void>

Create a machine from some data

fn ready( self, events: EventSet, scope: &mut Scope<'_, Self::Context>, ) -> Response<Self, Self::Seed>

Socket readiness notification

fn spawned( self, _scope: &mut Scope<'_, Self::Context>, ) -> Response<Self, Self::Seed>

Called after spawn event

fn timeout( self, scope: &mut Scope<'_, Self::Context>, ) -> Response<Self, Self::Seed>

Timeout happened

fn wakeup( self, scope: &mut Scope<'_, Self::Context>, ) -> Response<Self, Self::Seed>

Message received

fn spawn_error( self, _scope: &mut Scope<'_, Self::Context>, error: SpawnError<Self::Seed>, ) -> Response<Self, Self::Seed>

Called instead of spawned, if there is no slab space