Struct ntex_io::Io

pub struct Io<F = Base>(_, _);

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: Millis)

Set io disconnect timeout in millis

pub fn take(&mut 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: Filter> Io<F>

pub fn filter(&self) -> &F

Get referece to a filter

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

Convert current io stream into sealed version

pub fn add_filter<T>(self, factory: T) -> T::Futurewhere
    T: FilterFactory<F>,

Create new filter and replace current one

pub fn map_filter<T, U, E>(self, map: U) -> Result<Io<T>, E>where
    T: Filter,
    U: FnOnce(F) -> Result<T, E>,

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 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 a peer

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_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_status_update(&self, cx: &mut Context<'_>) -> Poll<IoStatusUpdate>

Wait for status updates

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 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, err: Option<Error>)

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 write(&self, src: &[u8]) -> Result<()>

Write bytes to a buffer and wake up write task

pub fn with_write_buf<F, R>(&self, f: F) -> Result<R, Error>where
    F: FnOnce(&mut BytesVec) -> R,

Get mut access to write buffer

pub fn with_read_buf<F, R>(&self, f: F) -> Rwhere
    F: FnOnce(&mut BytesVec) -> R,

Get mut access to read buffer

pub fn start_keepalive_timer(&self, timeout: Duration)

Start keep-alive timer

pub fn stop_keepalive_timer(&self)

Stop keep-alive 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.

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<Io<F>> for Io<F>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<F> Eq for Io<F>