Struct ntex::framed::State

pub struct State(_);

Implementations

impl State

pub fn new() -> Self

Create State instance

pub fn from_framed<Io, U>(framed: Framed<Io, U>) -> (Io, U, Self)

Create State from Framed

pub fn into_framed<Io, U>(self, io: Io, codec: U) -> Framed<Io, U>

Convert state to a Framed instance

pub fn flags(&self) -> Flags

Get current state flags

pub fn disconnect_timeout(self, timeout: u16) -> Self

Set disconnecto timeout

pub fn set_disconnect_timeout(&self, timeout: u16)

Set disconnecto timeout

pub fn take_io_error(&self) -> Option<Error>

pub fn is_io_err(&self) -> bool

Check if io error occured in read or write task

pub fn is_io_shutdown(&self) -> bool

pub fn is_io_stop(&self) -> bool

pub fn is_write_buf_full(&self) -> bool

Check if write buff is full

pub fn is_read_buf_full(&self) -> bool

Check if read buff is full

pub fn is_read_ready(&self) -> bool

Check if read buffer has new data

pub fn is_write_ready(&self) -> bool

Check if write task is ready

pub fn enable_write_backpressure(&self)

Enable write back-persurre

pub fn is_keepalive(&self) -> bool

Check if keep-alive timeout occured

pub fn reset_keepalive(&self)

Reset keep-alive error

pub fn is_dsp_stopped(&self) -> bool

Check is dispatcher marked stopped

pub fn is_open(&self) -> bool

pub fn close(&self)

Initiate close connection procedure

pub fn shutdown(&self)

Gracefully shutdown all tasks

pub fn shutdown_io(&self)

Gracefully shutdown read and write io tasks

pub fn dsp_restart_read_task(&self)

Wake read io task if it is paused

pub fn dsp_restart_write_task(&self)

Wake write io task

pub fn dsp_read_more_data(&self, waker: &Waker)

Wake read io task if it is not ready

Only wakes if back-pressure is enabled on read task otherwise read is already awake.

pub fn dsp_enable_write_backpressure(&self, waker: &Waker)

Wait until write task flushes data to socket

Write task must be waken up separately.

pub fn dsp_service_not_ready(&self, waker: &Waker)

Service is not ready, register dispatch task and pause read io task

pub fn dsp_stop_io(&self, waker: &Waker)

Stop io tasks

pub fn dsp_wake_task(&self)

Wake dispatcher

pub fn dsp_register_task(&self, waker: &Waker)

Register dispatcher task

pub fn reset_io_stop(&self)

Reset io stop flags

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) -> R where
    F: FnOnce(&mut BytesMut) -> R, 

Get mut access to write buffer

impl State

pub fn decode_item<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 async fn next<T, U>(
    &self,
    io: &mut T,
    codec: &U
) -> Result<Option<U::Item>, Either<U::Error, Error>> where
    T: AsyncRead + AsyncWrite + Unpin,
    U: Decoder, 

pub fn poll_next<T, U>(
    &self,
    io: &mut T,
    codec: &U,
    cx: &mut Context<'_>
) -> Poll<Result<Option<U::Item>, Either<U::Error, Error>>> where
    T: AsyncRead + AsyncWrite + Unpin,
    U: Decoder, 

pub async fn send<T, U>(
    &self,
    io: &mut T,
    codec: &U,
    item: U::Item
) -> Result<(), Either<U::Error, Error>> where
    T: AsyncRead + AsyncWrite + Unpin,
    U: Encoder, 

Encode item, send to a peer and flush

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

Write item to a buf and wake up io task

Returns state of write buffer state, false is returned if write buffer if full.

pub fn write_result<U, E>(
    &self,
    item: Result<Option<U::Item>, E>,
    codec: &U
) -> Result<bool, Either<E, U::Error>> where
    U: Encoder, 

Write item to a buf and wake up io task

Trait Implementations

impl Clone for State

fn clone(&self) -> Self

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Eq for State

impl Hash for State

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl PartialEq<State> for State

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.