     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

    //! Module with system specific types.
    //!
    //! Required types:
    //!
    //! * `Event`: a type alias for the system specific event, e.g. `kevent` or
    //!            `epoll_event`.
    //! * `event`: a module with various helper functions for `Event`, see
    //!            [`crate::event::Event`] for the required functions.
    //! * `Events`: collection of `Event`s, see [`crate::Events`].
    //! * `IoSourceState`: state for the `IoSource` type.
    //! * `Selector`: selector used to register event sources and poll for events,
    //!               see [`crate::Poll`] and [`crate::Registry`] for required
    //!               methods.
    //! * `tcp` and `udp` modules: see the [`crate::net`] module.
    //! * `Waker`: see [`crate::Waker`].

    cfg_os_poll! {
        macro_rules! debug_detail {
            (
                $type: ident ($event_type: ty), $test: path,
                $($(#[$target: meta])* $libc: ident :: $flag: ident),+ $(,)*
            ) => {
                struct $type($event_type);

                impl fmt::Debug for $type {
                    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                        let mut written_one = false;
                        $(
                            $(#[$target])*
                            #[allow(clippy::bad_bit_mask)] // Apparently some flags are zero.
                            {
                                // Windows doesn't use `libc` but the `afd` module.
                                if $test(&self.0, &$libc :: $flag) {
                                    if !written_one {
                                        write!(f, "{}", stringify!($flag))?;
                                        written_one = true;
                                    } else {
                                        write!(f, "|{}", stringify!($flag))?;
                                    }
                                }
                            }
                        )+
                        if !written_one {
                            write!(f, "(empty)")
                        } else {
                            Ok(())
                        }
                    }
                }
            };
        }
    }

    #[cfg(unix)]
    cfg_os_poll! {
        mod unix;
        pub use self::unix::*;
    }

    #[cfg(windows)]
    cfg_os_poll! {
        mod windows;
        pub use self::windows::*;
    }

    cfg_not_os_poll! {
        mod shell;
        pub(crate) use self::shell::*;

        #[cfg(unix)]
        cfg_any_os_ext! {
            mod unix;
            pub use self::unix::SourceFd;
        }

        #[cfg(unix)]
        cfg_net! {
            pub use self::unix::SocketAddr;
        }
    }