Struct Io 

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

Interface object to the underlying I/O stream

Implementations

impl Io

pub fn new<I: IoStream, T: Into<SharedCfg>>(io: I, cfg: T) -> Self

Creates a new Io instance.

impl<F> Io<F>

pub fn get_ref(&self) -> IoRef

Get an instance of IoRef.

pub fn take(&self) -> Self

Takes the current I/O object.

After this call, the I/O object is no longer valid for use.

pub fn set_config<T: Into<SharedCfg>>(&self, cfg: T)

Updates the shared I/O configuration.

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

pub fn filter(&self) -> &F

Returns a reference to a filter.

impl<F: Filter> Io<F>

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

Convert the current I/O stream into a sealed version.

pub fn boxed(self) -> IoBoxed

Convert the current I/O stream into a boxed version.

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

where U: FilterLayer,

Adds a new processing layer to the current filter chain.

pub fn map_filter<U, R>(self, f: U) -> Io<R>

where U: FnOnce(F) -> R, R: Filter,

Wraps the current layer with a wrapper.

impl<F> Io<F>

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

where U: Decoder,

Reads from the incoming I/O stream and decodes a codec item.

pub async fn read(&self, dst: &mut [u8]) -> Result<()>

Reads bytes from this I/O stream into the specified buffer.

If there is not enough data available, waits for incoming data.

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

Waits until the I/O stream is ready for reading.

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

Waits until the I/O stream receives new data.

pub fn pause(&self)

Pauses the read task.

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

where U: Encoder,

Encodes an item and sends it to the peer, fully flushing the write buffer.

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

Wakes the write task and requests a flush of buffered data.

This is the async version of .poll_flush() method.

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

Gracefully shuts down the I/O stream.

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

Polls for read readiness.

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

Returns

The function returns:

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

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

Polls the I/O stream for availability of 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_recv_decode<U>( &self, codec: &U, cx: &mut Context<'_>, ) -> Result<Decoded<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<()>>

Wakes the write task and instructs it to flush data.

If full is true, wakes the dispatcher when all data has been flushed; otherwise, it wakes when the write buffer size falls below the low-watermark size.

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

Gracefully shuts down the I/O stream.

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

Pauses the read task.

Returns status updates.

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

Polls for available status updates.

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

Registers a dispatch task.

Methods from Deref<Target = IoRef>

pub fn id(&self) -> Id

Gets the ID.

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

Gets the I/O tag.

pub fn cfg(&self) -> &IoConfig

Gets the configuration.

pub fn shared(&self) -> SharedCfg

Gets the shared configuration.

pub fn is_closed(&self) -> bool

Checks whether the I/O stream is closed.

pub fn is_wr_backpressure(&self) -> bool

Checks whether write back-pressure is enabled.

pub fn close(&self)

Gracefully closes the connection.

Initiates the I/O stream shutdown process.

pub fn terminate(&self)

Force-closes the connection.

The dispatcher does not wait for incomplete responses. The I/O stream is terminated without any graceful period.

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

Queries filter-specific data.

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

where U: Encoder,

Encodes the item into the write buffer.

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

Encodes the slice into the write buffer.

pub fn encode_bytes<B>(&self, src: B) -> Result<()>

where BytePage: From<B>,

Writes bytes to the write buffer.

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 send_buf(&self) -> Result<()>

Sends the write buffer to the I/O layer.

Requires the underlying runtime to implement .write(); otherwise, no action is taken.

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

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

Get access to filter buffer

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

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

Get mut access to read buffer

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

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

Get mut access to source write buffer

pub fn resize_read_buf(&self, buf: &mut BytesMut)

Make sure buffer has enough free space

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 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.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<I: IoStream> From<I> for Io

fn from(io: I) -> Io

Converts to this type from the input 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<IoBoxed> for Io<Sealed>

fn from(value: IoBoxed) -> 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>