Struct Io

pub struct Io<F = Base>(/* private fields */);

Interface object to underlying io stream

Implementations

impl Io

pub fn new<I: IoStream>(io: I) -> Self

Create Io instance

pub fn with_memory_pool<I: IoStream>(io: I, pool: PoolRef) -> Self

Create Io instance in specific memory pool.

impl<F> Io<F>

pub fn set_memory_pool(&self, pool: PoolRef)

Set memory pool

pub fn set_disconnect_timeout(&self, timeout: Seconds)

Set io disconnect timeout in millis

pub fn take(&self) -> Self

Clone current io object.

Current io object becomes closed.

impl<F> Io<F>

pub fn get_ref(&self) -> IoRef

Get instance of IoRef

impl<F: FilterLayer, T: Filter> Io<Layer<F, T>>

pub fn filter(&self) -> &F

Get referece to a filter

impl<F: Filter> Io<F>

pub fn seal(self) -> Io<Sealed>

Convert current io stream into sealed version

pub fn add_filter<U>(self, nf: U) -> Io<Layer<U, F>>

where U: FilterLayer,

Map current filter with new one

impl<F> Io<F>

pub async fn recv<U>( &self, codec: &U, ) -> Result<Option<U::Item>, Either<U::Error, Error>>

where U: Decoder,

Read incoming io stream and decode codec item.

pub async fn read_ready(&self) -> Result<Option<()>>

Wait until read becomes ready.

pub async fn read_notify(&self) -> Result<Option<()>>

Wait until io reads any data.

pub fn pause(&self)

Pause read task

pub async fn send<U>( &self, item: U::Item, codec: &U, ) -> Result<(), Either<U::Error, Error>>

where U: Encoder,

Encode item, send to the peer. Fully flush write buffer.

pub async fn flush(&self, full: bool) -> Result<()>

Wake write task and instruct to flush data.

This is async version of .poll_flush() method.

pub async fn shutdown(&self) -> Result<()>

Gracefully shutdown io stream

pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<Result<Option<()>>>

Polls for read readiness.

If the io stream is not currently ready for reading, this method will store a clone of the Waker from the provided Context. When the io stream becomes ready for reading, Waker::wake will be called on the waker.

Return value The function returns:

Poll::Pending if the io stream is not ready for reading. Poll::Ready(Ok(Some(())))) if the io stream is ready for reading. Poll::Ready(Ok(None)) if io stream is disconnected Some(Poll::Ready(Err(e))) if an error is encountered.

pub fn poll_read_notify(&self, cx: &mut Context<'_>) -> Poll<Result<Option<()>>>

Polls for any incoming data.

pub fn poll_recv<U>( &self, codec: &U, cx: &mut Context<'_>, ) -> Poll<Result<U::Item, RecvError<U>>>

where U: Decoder,

Decode codec item from incoming bytes stream.

Wake read task and request to read more data if data is not enough for decoding. If error get returned this method does not register waker for later wake up action.

pub fn poll_flush(&self, cx: &mut Context<'_>, full: bool) -> Poll<Result<()>>

Wake write task and instruct to flush data.

If full is true then wake up dispatcher when all data is flushed otherwise wake up when size of write buffer is lower than buffer max size.

pub fn poll_shutdown(&self, cx: &mut Context<'_>) -> Poll<Result<()>>

Gracefully shutdown io stream

pub fn poll_read_pause(&self, cx: &mut Context<'_>) -> Poll<IoStatusUpdate>

Pause read task

Returns status updates

pub fn poll_status_update(&self, cx: &mut Context<'_>) -> Poll<IoStatusUpdate>

Wait for status updates

pub fn poll_dispatch(&self, cx: &mut Context<'_>)

Register dispatch task

Methods from Deref<Target = IoRef>

pub fn memory_pool(&self) -> PoolRef

Get memory pool

pub fn is_closed(&self) -> bool

Check if io stream is closed

pub fn is_wr_backpressure(&self) -> bool

Check if write back-pressure is enabled

pub fn wake(&self)

Wake dispatcher task

pub fn close(&self)

Gracefully close connection

Notify dispatcher and initiate io stream shutdown process.

pub fn force_close(&self)

Force close connection

Dispatcher does not wait for uncompleted responses. Io stream get terminated without any graceful period.

pub fn want_shutdown(&self)

Gracefully shutdown io stream

pub fn query<T: 'static>(&self) -> QueryItem<T>

Query filter specific data

pub fn encode<U>( &self, item: U::Item, codec: &U, ) -> Result<(), <U as Encoder>::Error>

where U: Encoder,

Encode and write item to a buffer and wake up write task

pub fn decode<U>( &self, codec: &U, ) -> Result<Option<<U as Decoder>::Item>, <U as Decoder>::Error>

where U: Decoder,

Attempts to decode a frame from the read buffer

pub fn decode_item<U>( &self, codec: &U, ) -> Result<Decoded<<U as Decoder>::Item>, <U as Decoder>::Error>

where U: Decoder,

Attempts to decode a frame from the read buffer

pub fn write(&self, src: &[u8]) -> Result<()>

Write bytes to a buffer and wake up write task

pub fn with_buf<F, R>(&self, f: F) -> Result<R>

where F: FnOnce(&WriteBuf<'_>) -> R,

Get access to write buffer

pub fn with_write_buf<F, R>(&self, f: F) -> Result<R>

where F: FnOnce(&mut BytesVec) -> R,

Get mut access to source write buffer

pub fn with_read_buf<F, R>(&self, f: F) -> R

where F: FnOnce(&mut BytesVec) -> R,

Get mut access to source read buffer

pub fn notify_dispatcher(&self)

Wakeup dispatcher

pub fn notify_timeout(&self)

Wakeup dispatcher and send keep-alive error

pub fn timer_handle(&self) -> TimerHandle

current timer handle

pub fn start_timer(&self, timeout: Seconds) -> TimerHandle

Start timer

pub fn stop_timer(&self)

Stop timer

pub fn tag(&self) -> &'static str

Get tag

pub fn set_tag(&self, tag: &'static str)

Set tag

pub fn on_disconnect(&self) -> OnDisconnect

Notify when io stream get disconnected

Trait Implementations

impl<F> AsRef<IoRef> for Io<F>

fn as_ref(&self) -> &IoRef

Converts this type into a shared reference of the (usually inferred) input type.

impl<F> Debug for Io<F>

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

Formats the value using the given formatter.

impl<F> Deref for Io<F>

type Target = IoRef

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<F> Drop for Io<F>

fn drop(&mut self)

Executes the destructor for this type.

impl<F: Filter> From<Io<F>> for IoBoxed

fn from(io: Io<F>) -> Self

Converts to this type from the input type.

impl From<Io<Sealed>> for IoBoxed

fn from(io: Io<Sealed>) -> Self

Converts to this type from the input type.

impl<F> Hash for Io<F>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F> PartialEq for Io<F>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F> Eq for Io<F>