Struct mio::unix::UnixReady

pub struct UnixReady(_);

Unix specific extensions to Ready

Provides additional readiness event kinds that are available on unix platforms. Unix platforms are able to provide readiness events for additional socket events, such as HUP and error.

HUP events occur when the remote end of a socket hangs up. In the TCP case, this occurs when the remote end of a TCP socket shuts down writes.

Error events occur when the socket enters an error state. In this case, the socket will also receive a readable or writable event. Reading or writing to the socket will result in an error.

Conversion traits are implemented between Ready and UnixReady. See the examples.

For high level documentation on polling and readiness, see Poll.

Examples

Most of the time, all that is needed is using bit operations

use mio::Ready;
use mio::unix::UnixReady;

let ready = Ready::readable() | UnixReady::hup();

assert!(ready.is_readable());
assert!(UnixReady::from(ready).is_hup());

Basic conversion between ready types.

use mio::Ready;
use mio::unix::UnixReady;

// Start with a portable ready
let ready = Ready::readable();

// Convert to a unix ready, adding HUP
let mut unix_ready = UnixReady::from(ready) | UnixReady::hup();

unix_ready.insert(UnixReady::error());

// `unix_ready` maintains readable interest
assert!(unix_ready.is_readable());
assert!(unix_ready.is_hup());
assert!(unix_ready.is_error());

// Convert back to `Ready`
let ready = Ready::from(unix_ready);

// Readable is maintained
assert!(ready.is_readable());

Registering readable and error interest on a socket

use mio::{Ready, Poll, PollOpt, Token};
use mio::net::TcpStream;
use mio::unix::UnixReady;

let addr = "216.58.193.68:80".parse()?;
let socket = TcpStream::connect(&addr)?;

let poll = Poll::new()?;

poll.register(&socket,
              Token(0),
              Ready::readable() | UnixReady::error(),
              PollOpt::edge())?;

Methods

impl UnixReady

pub fn aio() -> UnixReady

Returns a Ready representing AIO completion readiness

See Poll for more documentation on polling.

Examples

use mio::unix::UnixReady;

let ready = UnixReady::aio();

assert!(ready.is_aio());

pub fn error() -> UnixReady

Returns a Ready representing error readiness.

Note that only readable and writable readiness is guaranteed to be supported on all platforms. This means that error readiness should be treated as a hint. For more details, see readiness in the poll documentation.

See Poll for more documentation on polling.

Examples

use mio::unix::UnixReady;

let ready = UnixReady::error();

assert!(ready.is_error());

pub fn hup() -> UnixReady

Returns a Ready representing HUP readiness.

A HUP (or hang-up) signifies that a stream socket peer closed the connection, or shut down the writing half of the connection.

Note that only readable and writable readiness is guaranteed to be supported on all platforms. This means that hup readiness should be treated as a hint. For more details, see readiness in the poll documentation. It is also unclear if HUP readiness will remain in 0.7. See here.

See Poll for more documentation on polling.

Examples

use mio::unix::UnixReady;

let ready = UnixReady::hup();

assert!(ready.is_hup());

pub fn lio() -> UnixReady

Returns a Ready representing LIO completion readiness

See Poll for more documentation on polling.

Examples

use mio::unix::UnixReady;

let ready = UnixReady::lio();

assert!(ready.is_lio());

pub fn is_aio(&self) -> bool

Returns true if Ready contains AIO readiness

See Poll for more documentation on polling.

Examples

use mio::unix::UnixReady;

let ready = UnixReady::aio();

assert!(ready.is_aio());

pub fn is_error(&self) -> bool

Returns true if the value includes error readiness

Note that only readable and writable readiness is guaranteed to be supported on all platforms. This means that error readiness should be treated as a hint. For more details, see readiness in the poll documentation.

See Poll for more documentation on polling.

Examples

use mio::unix::UnixReady;

let ready = UnixReady::error();

assert!(ready.is_error());

pub fn is_hup(&self) -> bool

Returns true if the value includes HUP readiness

A HUP (or hang-up) signifies that a stream socket peer closed the connection, or shut down the writing half of the connection.

Note that only readable and writable readiness is guaranteed to be supported on all platforms. This means that hup readiness should be treated as a hint. For more details, see readiness in the poll documentation.

See Poll for more documentation on polling.

Examples

use mio::unix::UnixReady;

let ready = UnixReady::hup();

assert!(ready.is_hup());

pub fn is_lio(&self) -> bool

Returns true if Ready contains LIO readiness

See [Poll] for more documentation on polling.

Examples

use mio::unix::UnixReady;

let ready = UnixReady::lio();

assert!(ready.is_lio());

Methods from Deref<Target = Ready>

pub fn is_empty(&self) -> bool

Returns true if Ready is the empty set

See Poll for more documentation on polling.

Examples

use mio::Ready;

let ready = Ready::empty();
assert!(ready.is_empty());

pub fn is_readable(&self) -> bool

Returns true if the value includes readable readiness

See Poll for more documentation on polling.

Examples

use mio::Ready;

let ready = Ready::readable();

assert!(ready.is_readable());

pub fn is_writable(&self) -> bool

Returns true if the value includes writable readiness

See Poll for more documentation on polling.

Examples

use mio::Ready;

let ready = Ready::writable();

assert!(ready.is_writable());

pub fn insert<T: Into<Self>>(&mut self, other: T)

Adds all readiness represented by other into self.

This is equivalent to *self = *self | other.

Examples

use mio::Ready;

let mut readiness = Ready::empty();
readiness.insert(Ready::readable());

assert!(readiness.is_readable());

pub fn remove<T: Into<Self>>(&mut self, other: T)

Removes all options represented by other from self.

This is equivalent to *self = *self & !other.

Examples

use mio::Ready;

let mut readiness = Ready::readable();
readiness.remove(Ready::readable());

assert!(!readiness.is_readable());

pub fn contains<T: Into<Self>>(&self, other: T) -> bool

Returns true if self is a superset of other.

other may represent more than one readiness operations, in which case the function only returns true if self contains all readiness specified in other.

See Poll for more documentation on polling.

Examples

use mio::Ready;

let readiness = Ready::readable();

assert!(readiness.contains(Ready::readable()));
assert!(!readiness.contains(Ready::writable()));

use mio::Ready;

let readiness = Ready::readable() | Ready::writable();

assert!(readiness.contains(Ready::readable()));
assert!(readiness.contains(Ready::writable()));

use mio::Ready;

let readiness = Ready::readable() | Ready::writable();

assert!(!Ready::readable().contains(readiness));
assert!(readiness.contains(readiness));

pub fn as_usize(&self) -> usize

Returns a usize representation of the Ready value.

This usize representation must be treated as opaque. There is no guaranteed correlation between the returned value and platform defined constants. Also, there is no guarantee that the usize representation will remain constant across patch releases of Mio.

This function is mainly provided to allow the caller to store a readiness value in an AtomicUsize.

Examples

use mio::Ready;

let ready = Ready::readable();
let ready_usize = ready.as_usize();
let ready2 = Ready::from_usize(ready_usize);

assert_eq!(ready, ready2);

Trait Implementations

impl From<Ready> for UnixReady

fn from(src: Ready) -> UnixReady

Performs the conversion.

impl From<UnixReady> for Ready

fn from(src: UnixReady) -> Ready

Performs the conversion.

impl Clone for UnixReady

fn clone(&self) -> UnixReady

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for UnixReady

impl Eq for UnixReady

impl Ord for UnixReady

fn cmp(&self, other: &UnixReady) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

impl PartialEq<UnixReady> for UnixReady

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

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

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

This method tests for !=.

impl PartialOrd<UnixReady> for UnixReady

fn partial_cmp(&self, other: &UnixReady) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &UnixReady) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &UnixReady) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &UnixReady) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &UnixReady) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Deref for UnixReady

type Target = Ready

The resulting type after dereferencing.

fn deref(&self) -> &Ready

Dereferences the value.

impl DerefMut for UnixReady

fn deref_mut(&mut self) -> &mut Ready

Mutably dereferences the value.

impl Debug for UnixReady

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Sub<UnixReady> for UnixReady

type Output = UnixReady

The resulting type after applying the - operator.

fn sub(self, other: UnixReady) -> UnixReady

Performs the - operation.

impl BitAnd<UnixReady> for UnixReady

type Output = UnixReady

The resulting type after applying the & operator.

fn bitand(self, other: UnixReady) -> UnixReady

Performs the & operation.

impl BitOr<UnixReady> for UnixReady

type Output = UnixReady

The resulting type after applying the | operator.

fn bitor(self, other: UnixReady) -> UnixReady

Performs the | operation.

impl BitXor<UnixReady> for UnixReady

type Output = UnixReady

The resulting type after applying the ^ operator.

fn bitxor(self, other: UnixReady) -> UnixReady

Performs the ^ operation.

impl StructuralPartialEq for UnixReady

impl StructuralEq for UnixReady