Struct netservices::resource::NetAccept

pub struct NetAccept<S: NetSession, L: NetListener<Stream = S::Connection> = TcpListener> { /* private fields */ }

A reactor-manageable network listener (TCP, but not limiting to) which can be aware of additional encryption, authentication and other forms of transport-layer protocols which will be automatically injected into accepted connections.

Implementations

impl<L: NetListener<Stream = S::Connection>, S: NetSession> NetAccept<S, L>

pub fn bind(addr: &impl ToSocketAddrs) -> Result<Self>

Binds listener to the provided socket address(es) with a given context.

The session_context object provides information for encryption, authentication and other protocols which are a part of the application- specific transport layer and are automatically injected into the new sessions constructed by this listener before they are inserted into the reactor and notifications are delivered to reactor::Handler. The injection is made by calling [NetSession::accept] method.

pub fn local_addr(&self) -> SocketAddr

Returns the local net::SocketAddr on which listener accepts connections.

Trait Implementations

impl<L: NetListener<Stream = S::Connection>, S: NetSession> AsRawFd for NetAccept<S, L>

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl<S: Debug + NetSession, L: Debug + NetListener<Stream = S::Connection>> Debug for NetAccept<S, L>

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

Formats the value using the given formatter.

impl<L: NetListener<Stream = S::Connection>, S> Resource for NetAccept<S, L>where
    S: Send + NetSession,

type Id = SocketAddr

Resource identifier type.

type Event = ListenerEvent<S>

Events which resource may generate upon receiving I/O from the reactor via Self::handle_io. These events are passed to the reactor crate::Handler.

fn id(&self) -> Self::Id

Method returning the ResourceId.

fn interests(&self) -> IoType

Method informing the reactor which types of events this resource is subscribed for.

fn handle_io(&mut self, io: Io) -> Option<Self::Event>

Method called by the reactor when an I/O event is received for this resource in a result of poll syscall.

impl<L: NetListener<Stream = S::Connection>, S: NetSession> Write for NetAccept<S, L>

fn write(&mut self, _buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

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

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

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

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl<L: NetListener<Stream = S::Connection>, S: NetSession> WriteAtomic for NetAccept<S, L>

fn is_ready_to_write(&self) -> bool

Checks whether resource can be written to without blocking.

fn empty_write_buf(&mut self) -> Result<bool>

Empties any write buffers in a non-blocking way. If a non-blocking operation is not possible, errors with io::ErrorKind::WouldBlock kind of io::Error.

fn write_or_buf(&mut self, _: &[u8]) -> Result<()>

Writes to the resource in a non-blocking way, buffering the data if necessary - or failing with a system-level error.

fn write_atomic(&mut self, buf: &[u8]) -> Result<(), WriteError>

Atomic non-blocking I/O write operation, which must either write the whole buffer to a resource without blocking - or fail with WriteError::NotReady error.