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 with_params(
    max_read_buf_size: u16,
    max_write_buf_size: u16,
    min_buf_size: u16,
    disconnect_timeout: Seconds
) -> Self

Create State instance with custom params

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

Convert State to a Framed instance

pub fn set_buffer_params(
    &self,
    max_read_buf_size: u16,
    max_write_buf_size: u16,
    min_buf_size: u16
)

Set read/write buffer sizes

By default read max buf size is 8kb, write max buf size is 8kb

pub fn set_disconnect_timeout(&self, timeout: Seconds)

Set io disconnect timeout in secs

pub fn on_disconnect(&self) -> OnDisconnect

Notify when socket get disconnected

pub fn is_io_err(&self) -> bool

Check if io error occured in read or write task

pub fn is_keepalive(&self) -> bool

Check if keep-alive timeout occured

pub fn is_dispatcher_stopped(&self) -> bool

Check is dispatcher marked stopped

pub fn is_open(&self) -> bool

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

Stop io tasks

Wake dispatcher when read or write task is stopped.

pub fn shutdown_io(&self)

Gracefully shutdown read and write io tasks

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

Take io error if any occured

pub fn reset_io_stop(&self)

Reset io stop flags

pub fn reset_keepalive(&self)

Reset keep-alive error

pub fn wake_dispatcher(&self)

Wake dispatcher task

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

Register dispatcher task

pub fn dispatcher_stopped(&self)

Mark dispatcher as stopped

pub fn read(&self) -> Read<'_>

Get api for read task

pub fn write(&self) -> Write<'_>

Get api for write task

pub fn close(&self)

Gracefully close connection

First stop dispatcher, then dispatcher stops io tasks

pub fn force_close(&self)

Force close connection

Dispatcher does not wait for uncompleted responses, but flushes io buffers.

impl State

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, 

Read incoming io stream and decode codec item.

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 then flush

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, 

Trait Implementations

impl Clone for State

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Hash for State

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, 

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

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

This method tests for !=.

impl Eq for State