# [−][src]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`[src]

#### `pub fn error() -> UnixReady`[src]

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`[src]

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 priority() -> UnixReady`[src]

Returns a `Ready` representing priority (`EPOLLPRI`) readiness

See `Poll` for more documentation on polling.

# Examples

    use mio::unix::UnixReady;

    let ready = UnixReady::priority();

    assert!(ready.is_priority());

#### `pub fn is_error(&self) -> bool`[src]

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`[src]

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_priority(&self) -> bool`[src]

Returns true if `Ready` contains priority (`EPOLLPRI`) readiness

See `Poll` for more documentation on polling.

# Examples

    use mio::unix::UnixReady;

    let ready = UnixReady::priority();

    assert!(ready.is_priority());

## Methods from Deref<Target = Ready>

#### `pub fn is_empty(&self) -> bool`[src]

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`[src]

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`[src]

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)`[src]

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)`[src]

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`[src]

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`[src]

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 Eq for UnixReady`[src]

### `impl Clone for UnixReady`[src]

#### `fn clone(&self) -> UnixReady`[src]

Returns a copy of the value. Read more

#### `fn clone_from(&mut self, source: &Self)`1.0.0[src]

Performs copy-assignment from `source`. Read more

### `impl PartialOrd<UnixReady> for UnixReady`[src]

#### `fn partial_cmp(&self, other: &UnixReady) -> Option<Ordering>`[src]

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

#### `fn lt(&self, other: &UnixReady) -> bool`[src]

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

#### `fn le(&self, other: &UnixReady) -> bool`[src]

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

#### `fn gt(&self, other: &UnixReady) -> bool`[src]

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

#### `fn ge(&self, other: &UnixReady) -> bool`[src]

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

### `impl PartialEq<UnixReady> for UnixReady`[src]

#### `fn eq(&self, other: &UnixReady) -> bool`[src]

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

#### `fn ne(&self, other: &UnixReady) -> bool`[src]

This method tests for `!=`.

### `impl Ord for UnixReady`[src]

#### `fn cmp(&self, other: &UnixReady) -> Ordering`[src]

This method returns an `Ordering` between `self` and `other`. Read more

#### `fn max(self, other: Self) -> Self` 1.21.0[src]

Compares and returns the maximum of two values. Read more

#### `fn min(self, other: Self) -> Self` 1.21.0[src]

Compares and returns the minimum of two values. Read more

#### `fn clamp(self, min: Self, max: Self) -> Self`[src]

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

Restrict a value to a certain interval. Read more

### `impl From<Ready> for UnixReady`[src]

#### `fn from(src: Ready) -> UnixReady`[src]

Performs the conversion.

### `impl From<UnixReady> for Ready`[src]

#### `fn from(src: UnixReady) -> Ready`[src]

Performs the conversion.

### `impl Copy for UnixReady`[src]

### `impl DerefMut for UnixReady`[src]

#### `fn deref_mut(&mut self) -> &mut Ready`[src]

Mutably dereferences the value.

### `impl Sub<UnixReady> for UnixReady`[src]

#### `type Output = UnixReady`

The resulting type after applying the `-` operator.

#### `fn sub(self, other: UnixReady) -> UnixReady`[src]

Performs the `-` operation.

### `impl BitAnd<UnixReady> for UnixReady`[src]

#### `type Output = UnixReady`

The resulting type after applying the `&` operator.

#### `fn bitand(self, other: UnixReady) -> UnixReady`[src]

Performs the `&` operation.

### `impl BitOr<UnixReady> for UnixReady`[src]

#### `type Output = UnixReady`

The resulting type after applying the `|` operator.

#### `fn bitor(self, other: UnixReady) -> UnixReady`[src]

Performs the `|` operation.

### `impl BitXor<UnixReady> for UnixReady`[src]

#### `type Output = UnixReady`

The resulting type after applying the `^` operator.

#### `fn bitxor(self, other: UnixReady) -> UnixReady`[src]

Performs the `^` operation.

### `impl Deref for UnixReady`[src]

#### `type Target = Ready`

The resulting type after dereferencing.

#### `fn deref(&self) -> &Ready`[src]

Dereferences the value.

### `impl Debug for UnixReady`[src]

#### `fn fmt(&self, fmt: &mut Formatter) -> Result`[src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

### `impl Send for UnixReady`

### `impl Unpin for UnixReady`

### `impl Sync for UnixReady`

### `impl UnwindSafe for UnixReady`

### `impl RefUnwindSafe for UnixReady`

## Blanket Implementations

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `fn to_owned(&self) -> T`[src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `fn clone_into(&self, target: &mut T)`[src]

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

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `fn into(self) -> U`[src]

Performs the conversion.

### `impl<T> From<T> for T`[src]

#### `fn from(t: T) -> T`[src]

Performs the conversion.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]

Performs the conversion.

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

####
ⓘImportant traits for &'_ mut W

### Important traits for &'_ mut W

`impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized,`
`fn borrow_mut(&mut self) -> &mut T`[src]

Mutably borrows from an owned value. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

####
ⓘImportant traits for &'_ mut W

### Important traits for &'_ mut W

`impl<'_, W> Write for &'_ mut W where
W: Write + ?Sized, impl<'_, R> Read for &'_ mut R where
R: Read + ?Sized,`
`fn borrow(&self) -> &T`[src]

Immutably borrows from an owned value. Read more

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `fn type_id(&self) -> TypeId`[src]

Gets the `TypeId` of `self`. Read more

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)