      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112

    #![cfg_attr(not(feature = "net"), allow(unreachable_pub))]

    use crate::io::driver::Ready;

    use std::fmt;
    use std::ops;

    /// Readiness event interest
    ///
    /// Specifies the readiness events the caller is interested in when awaiting on
    /// I/O resource readiness states.
    #[cfg_attr(docsrs, doc(cfg(feature = "net")))]
    #[derive(Clone, Copy, Eq, PartialEq)]
    pub struct Interest(mio::Interest);

    impl Interest {
        /// Interest in all readable events.
        ///
        /// Readable interest includes read-closed events.
        pub const READABLE: Interest = Interest(mio::Interest::READABLE);

        /// Interest in all writable events
        ///
        /// Writable interest includes write-closed events.
        pub const WRITABLE: Interest = Interest(mio::Interest::WRITABLE);

        /// Returns true if the value includes readable interest.
        ///
        /// # Examples
        ///
        /// ```
        /// use tokio::io::Interest;
        ///
        /// assert!(Interest::READABLE.is_readable());
        /// assert!(!Interest::WRITABLE.is_readable());
        ///
        /// let both = Interest::READABLE | Interest::WRITABLE;
        /// assert!(both.is_readable());
        /// ```
        pub const fn is_readable(self) -> bool {
            self.0.is_readable()
        }

        /// Returns true if the value includes writable interest.
        ///
        /// # Examples
        ///
        /// ```
        /// use tokio::io::Interest;
        ///
        /// assert!(!Interest::READABLE.is_writable());
        /// assert!(Interest::WRITABLE.is_writable());
        ///
        /// let both = Interest::READABLE | Interest::WRITABLE;
        /// assert!(both.is_writable());
        /// ```
        pub const fn is_writable(self) -> bool {
            self.0.is_writable()
        }

        /// Add together two `Interst` values.
        ///
        /// This function works from a `const` context.
        ///
        /// # Examples
        ///
        /// ```
        /// use tokio::io::Interest;
        ///
        /// const BOTH: Interest = Interest::READABLE.add(Interest::WRITABLE);
        ///
        /// assert!(BOTH.is_readable());
        /// assert!(BOTH.is_writable());
        pub const fn add(self, other: Interest) -> Interest {
            Interest(self.0.add(other.0))
        }

        // This function must be crate-private to avoid exposing a `mio` dependency.
        pub(crate) const fn to_mio(self) -> mio::Interest {
            self.0
        }

        pub(super) fn mask(self) -> Ready {
            match self {
                Interest::READABLE => Ready::READABLE | Ready::READ_CLOSED,
                Interest::WRITABLE => Ready::WRITABLE | Ready::WRITE_CLOSED,
                _ => Ready::EMPTY,
            }
        }
    }

    impl ops::BitOr for Interest {
        type Output = Self;

        #[inline]
        fn bitor(self, other: Self) -> Self {
            self.add(other)
        }
    }

    impl ops::BitOrAssign for Interest {
        #[inline]
        fn bitor_assign(&mut self, other: Self) {
            self.0 = (*self | other).0;
        }
    }

    impl fmt::Debug for Interest {
        fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
            self.0.fmt(fmt)
        }
    }