From 8882cb8ea691dce28058a8ea1ffcdde1e7356abe Mon Sep 17 00:00:00 2001 From: Jakub Konka Date: Fri, 17 Jan 2020 19:39:44 +0100 Subject: [PATCH] Add auto-generated file --- lib_generated.rs | 2821 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2821 insertions(+) create mode 100644 lib_generated.rs diff --git a/lib_generated.rs b/lib_generated.rs new file mode 100644 index 0000000000..ea181be91d --- /dev/null +++ b/lib_generated.rs @@ -0,0 +1,2821 @@ +#![feature(prelude_import)] +#[prelude_import] +use std::prelude::v1::*; +#[macro_use] +extern crate std; +pub type Filesize = u64; +pub type Timestamp = u64; +#[repr(u32)] +pub enum Clockid { + Realtime, + Monotonic, + ProcessCputimeId, + ThreadCputimeId, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Clockid {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Clockid { + #[inline] + fn clone(&self) -> Clockid { + { + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Clockid { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Clockid::Realtime,) => { + let mut debug_trait_builder = f.debug_tuple("Realtime"); + debug_trait_builder.finish() + } + (&Clockid::Monotonic,) => { + let mut debug_trait_builder = f.debug_tuple("Monotonic"); + debug_trait_builder.finish() + } + (&Clockid::ProcessCputimeId,) => { + let mut debug_trait_builder = f.debug_tuple("ProcessCputimeId"); + debug_trait_builder.finish() + } + (&Clockid::ThreadCputimeId,) => { + let mut debug_trait_builder = f.debug_tuple("ThreadCputimeId"); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Clockid { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match (&*self,) { + _ => ::core::hash::Hash::hash( + &unsafe { ::core::intrinsics::discriminant_value(self) }, + state, + ), + } + } +} +impl ::core::marker::StructuralEq for Clockid {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Clockid { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + {} + } +} +impl ::core::marker::StructuralPartialEq for Clockid {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Clockid { + #[inline] + fn eq(&self, other: &Clockid) -> bool { + { + let __self_vi = unsafe { ::core::intrinsics::discriminant_value(&*self) } as u32; + let __arg_1_vi = unsafe { ::core::intrinsics::discriminant_value(&*other) } as u32; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + _ => true, + } + } else { + false + } + } + } +} +#[repr(u16)] +pub enum Errno { + Esuccess, + E2big, + Eacces, + Eaddrinuse, + Eaddrnotavail, + Eafnosupport, + Eagain, + Ealready, + Ebadf, + Ebadmsg, + Ebusy, + Ecanceled, + Echild, + Econnaborted, + Econnrefused, + Econnreset, + Edeadlk, + Edestaddrreq, + Edom, + Edquot, + Eexist, + Efault, + Efbig, + Ehostunreach, + Eidrm, + Eilseq, + Einprogress, + Eintr, + Einval, + Eio, + Eisconn, + Eisdir, + Eloop, + Emfile, + Emlink, + Emsgsize, + Emultihop, + Enametoolong, + Enetdown, + Enetreset, + Enetunreach, + Enfile, + Enobufs, + Enodev, + Enoent, + Enoexec, + Enolck, + Enolink, + Enomem, + Enomsg, + Enoprotoopt, + Enospc, + Enosys, + Enotconn, + Enotdir, + Enotempty, + Enotrecoverable, + Enotsock, + Enotsup, + Enotty, + Enxio, + Eoverflow, + Eownerdead, + Eperm, + Epipe, + Eproto, + Eprotonosupport, + Eprototype, + Erange, + Erofs, + Espipe, + Esrch, + Estale, + Etimedout, + Etxtbsy, + Exdev, + Enotcapable, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Errno {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Errno { + #[inline] + fn clone(&self) -> Errno { + { + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Errno { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Errno::Esuccess,) => { + let mut debug_trait_builder = f.debug_tuple("Esuccess"); + debug_trait_builder.finish() + } + (&Errno::E2big,) => { + let mut debug_trait_builder = f.debug_tuple("E2big"); + debug_trait_builder.finish() + } + (&Errno::Eacces,) => { + let mut debug_trait_builder = f.debug_tuple("Eacces"); + debug_trait_builder.finish() + } + (&Errno::Eaddrinuse,) => { + let mut debug_trait_builder = f.debug_tuple("Eaddrinuse"); + debug_trait_builder.finish() + } + (&Errno::Eaddrnotavail,) => { + let mut debug_trait_builder = f.debug_tuple("Eaddrnotavail"); + debug_trait_builder.finish() + } + (&Errno::Eafnosupport,) => { + let mut debug_trait_builder = f.debug_tuple("Eafnosupport"); + debug_trait_builder.finish() + } + (&Errno::Eagain,) => { + let mut debug_trait_builder = f.debug_tuple("Eagain"); + debug_trait_builder.finish() + } + (&Errno::Ealready,) => { + let mut debug_trait_builder = f.debug_tuple("Ealready"); + debug_trait_builder.finish() + } + (&Errno::Ebadf,) => { + let mut debug_trait_builder = f.debug_tuple("Ebadf"); + debug_trait_builder.finish() + } + (&Errno::Ebadmsg,) => { + let mut debug_trait_builder = f.debug_tuple("Ebadmsg"); + debug_trait_builder.finish() + } + (&Errno::Ebusy,) => { + let mut debug_trait_builder = f.debug_tuple("Ebusy"); + debug_trait_builder.finish() + } + (&Errno::Ecanceled,) => { + let mut debug_trait_builder = f.debug_tuple("Ecanceled"); + debug_trait_builder.finish() + } + (&Errno::Echild,) => { + let mut debug_trait_builder = f.debug_tuple("Echild"); + debug_trait_builder.finish() + } + (&Errno::Econnaborted,) => { + let mut debug_trait_builder = f.debug_tuple("Econnaborted"); + debug_trait_builder.finish() + } + (&Errno::Econnrefused,) => { + let mut debug_trait_builder = f.debug_tuple("Econnrefused"); + debug_trait_builder.finish() + } + (&Errno::Econnreset,) => { + let mut debug_trait_builder = f.debug_tuple("Econnreset"); + debug_trait_builder.finish() + } + (&Errno::Edeadlk,) => { + let mut debug_trait_builder = f.debug_tuple("Edeadlk"); + debug_trait_builder.finish() + } + (&Errno::Edestaddrreq,) => { + let mut debug_trait_builder = f.debug_tuple("Edestaddrreq"); + debug_trait_builder.finish() + } + (&Errno::Edom,) => { + let mut debug_trait_builder = f.debug_tuple("Edom"); + debug_trait_builder.finish() + } + (&Errno::Edquot,) => { + let mut debug_trait_builder = f.debug_tuple("Edquot"); + debug_trait_builder.finish() + } + (&Errno::Eexist,) => { + let mut debug_trait_builder = f.debug_tuple("Eexist"); + debug_trait_builder.finish() + } + (&Errno::Efault,) => { + let mut debug_trait_builder = f.debug_tuple("Efault"); + debug_trait_builder.finish() + } + (&Errno::Efbig,) => { + let mut debug_trait_builder = f.debug_tuple("Efbig"); + debug_trait_builder.finish() + } + (&Errno::Ehostunreach,) => { + let mut debug_trait_builder = f.debug_tuple("Ehostunreach"); + debug_trait_builder.finish() + } + (&Errno::Eidrm,) => { + let mut debug_trait_builder = f.debug_tuple("Eidrm"); + debug_trait_builder.finish() + } + (&Errno::Eilseq,) => { + let mut debug_trait_builder = f.debug_tuple("Eilseq"); + debug_trait_builder.finish() + } + (&Errno::Einprogress,) => { + let mut debug_trait_builder = f.debug_tuple("Einprogress"); + debug_trait_builder.finish() + } + (&Errno::Eintr,) => { + let mut debug_trait_builder = f.debug_tuple("Eintr"); + debug_trait_builder.finish() + } + (&Errno::Einval,) => { + let mut debug_trait_builder = f.debug_tuple("Einval"); + debug_trait_builder.finish() + } + (&Errno::Eio,) => { + let mut debug_trait_builder = f.debug_tuple("Eio"); + debug_trait_builder.finish() + } + (&Errno::Eisconn,) => { + let mut debug_trait_builder = f.debug_tuple("Eisconn"); + debug_trait_builder.finish() + } + (&Errno::Eisdir,) => { + let mut debug_trait_builder = f.debug_tuple("Eisdir"); + debug_trait_builder.finish() + } + (&Errno::Eloop,) => { + let mut debug_trait_builder = f.debug_tuple("Eloop"); + debug_trait_builder.finish() + } + (&Errno::Emfile,) => { + let mut debug_trait_builder = f.debug_tuple("Emfile"); + debug_trait_builder.finish() + } + (&Errno::Emlink,) => { + let mut debug_trait_builder = f.debug_tuple("Emlink"); + debug_trait_builder.finish() + } + (&Errno::Emsgsize,) => { + let mut debug_trait_builder = f.debug_tuple("Emsgsize"); + debug_trait_builder.finish() + } + (&Errno::Emultihop,) => { + let mut debug_trait_builder = f.debug_tuple("Emultihop"); + debug_trait_builder.finish() + } + (&Errno::Enametoolong,) => { + let mut debug_trait_builder = f.debug_tuple("Enametoolong"); + debug_trait_builder.finish() + } + (&Errno::Enetdown,) => { + let mut debug_trait_builder = f.debug_tuple("Enetdown"); + debug_trait_builder.finish() + } + (&Errno::Enetreset,) => { + let mut debug_trait_builder = f.debug_tuple("Enetreset"); + debug_trait_builder.finish() + } + (&Errno::Enetunreach,) => { + let mut debug_trait_builder = f.debug_tuple("Enetunreach"); + debug_trait_builder.finish() + } + (&Errno::Enfile,) => { + let mut debug_trait_builder = f.debug_tuple("Enfile"); + debug_trait_builder.finish() + } + (&Errno::Enobufs,) => { + let mut debug_trait_builder = f.debug_tuple("Enobufs"); + debug_trait_builder.finish() + } + (&Errno::Enodev,) => { + let mut debug_trait_builder = f.debug_tuple("Enodev"); + debug_trait_builder.finish() + } + (&Errno::Enoent,) => { + let mut debug_trait_builder = f.debug_tuple("Enoent"); + debug_trait_builder.finish() + } + (&Errno::Enoexec,) => { + let mut debug_trait_builder = f.debug_tuple("Enoexec"); + debug_trait_builder.finish() + } + (&Errno::Enolck,) => { + let mut debug_trait_builder = f.debug_tuple("Enolck"); + debug_trait_builder.finish() + } + (&Errno::Enolink,) => { + let mut debug_trait_builder = f.debug_tuple("Enolink"); + debug_trait_builder.finish() + } + (&Errno::Enomem,) => { + let mut debug_trait_builder = f.debug_tuple("Enomem"); + debug_trait_builder.finish() + } + (&Errno::Enomsg,) => { + let mut debug_trait_builder = f.debug_tuple("Enomsg"); + debug_trait_builder.finish() + } + (&Errno::Enoprotoopt,) => { + let mut debug_trait_builder = f.debug_tuple("Enoprotoopt"); + debug_trait_builder.finish() + } + (&Errno::Enospc,) => { + let mut debug_trait_builder = f.debug_tuple("Enospc"); + debug_trait_builder.finish() + } + (&Errno::Enosys,) => { + let mut debug_trait_builder = f.debug_tuple("Enosys"); + debug_trait_builder.finish() + } + (&Errno::Enotconn,) => { + let mut debug_trait_builder = f.debug_tuple("Enotconn"); + debug_trait_builder.finish() + } + (&Errno::Enotdir,) => { + let mut debug_trait_builder = f.debug_tuple("Enotdir"); + debug_trait_builder.finish() + } + (&Errno::Enotempty,) => { + let mut debug_trait_builder = f.debug_tuple("Enotempty"); + debug_trait_builder.finish() + } + (&Errno::Enotrecoverable,) => { + let mut debug_trait_builder = f.debug_tuple("Enotrecoverable"); + debug_trait_builder.finish() + } + (&Errno::Enotsock,) => { + let mut debug_trait_builder = f.debug_tuple("Enotsock"); + debug_trait_builder.finish() + } + (&Errno::Enotsup,) => { + let mut debug_trait_builder = f.debug_tuple("Enotsup"); + debug_trait_builder.finish() + } + (&Errno::Enotty,) => { + let mut debug_trait_builder = f.debug_tuple("Enotty"); + debug_trait_builder.finish() + } + (&Errno::Enxio,) => { + let mut debug_trait_builder = f.debug_tuple("Enxio"); + debug_trait_builder.finish() + } + (&Errno::Eoverflow,) => { + let mut debug_trait_builder = f.debug_tuple("Eoverflow"); + debug_trait_builder.finish() + } + (&Errno::Eownerdead,) => { + let mut debug_trait_builder = f.debug_tuple("Eownerdead"); + debug_trait_builder.finish() + } + (&Errno::Eperm,) => { + let mut debug_trait_builder = f.debug_tuple("Eperm"); + debug_trait_builder.finish() + } + (&Errno::Epipe,) => { + let mut debug_trait_builder = f.debug_tuple("Epipe"); + debug_trait_builder.finish() + } + (&Errno::Eproto,) => { + let mut debug_trait_builder = f.debug_tuple("Eproto"); + debug_trait_builder.finish() + } + (&Errno::Eprotonosupport,) => { + let mut debug_trait_builder = f.debug_tuple("Eprotonosupport"); + debug_trait_builder.finish() + } + (&Errno::Eprototype,) => { + let mut debug_trait_builder = f.debug_tuple("Eprototype"); + debug_trait_builder.finish() + } + (&Errno::Erange,) => { + let mut debug_trait_builder = f.debug_tuple("Erange"); + debug_trait_builder.finish() + } + (&Errno::Erofs,) => { + let mut debug_trait_builder = f.debug_tuple("Erofs"); + debug_trait_builder.finish() + } + (&Errno::Espipe,) => { + let mut debug_trait_builder = f.debug_tuple("Espipe"); + debug_trait_builder.finish() + } + (&Errno::Esrch,) => { + let mut debug_trait_builder = f.debug_tuple("Esrch"); + debug_trait_builder.finish() + } + (&Errno::Estale,) => { + let mut debug_trait_builder = f.debug_tuple("Estale"); + debug_trait_builder.finish() + } + (&Errno::Etimedout,) => { + let mut debug_trait_builder = f.debug_tuple("Etimedout"); + debug_trait_builder.finish() + } + (&Errno::Etxtbsy,) => { + let mut debug_trait_builder = f.debug_tuple("Etxtbsy"); + debug_trait_builder.finish() + } + (&Errno::Exdev,) => { + let mut debug_trait_builder = f.debug_tuple("Exdev"); + debug_trait_builder.finish() + } + (&Errno::Enotcapable,) => { + let mut debug_trait_builder = f.debug_tuple("Enotcapable"); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Errno { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match (&*self,) { + _ => ::core::hash::Hash::hash( + &unsafe { ::core::intrinsics::discriminant_value(self) }, + state, + ), + } + } +} +impl ::core::marker::StructuralEq for Errno {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Errno { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + {} + } +} +impl ::core::marker::StructuralPartialEq for Errno {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Errno { + #[inline] + fn eq(&self, other: &Errno) -> bool { + { + let __self_vi = unsafe { ::core::intrinsics::discriminant_value(&*self) } as u16; + let __arg_1_vi = unsafe { ::core::intrinsics::discriminant_value(&*other) } as u16; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + _ => true, + } + } else { + false + } + } + } +} +#[repr(transparent)] +pub struct Rights(u64); +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Rights {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Rights { + #[inline] + fn clone(&self) -> Rights { + { + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Rights { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Rights(ref __self_0_0) => { + let mut debug_trait_builder = f.debug_tuple("Rights"); + let _ = debug_trait_builder.field(&&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Rights { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Rights(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state), + } + } +} +impl ::core::marker::StructuralEq for Rights {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Rights { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Rights {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Rights { + #[inline] + fn eq(&self, other: &Rights) -> bool { + match *other { + Rights(ref __self_1_0) => match *self { + Rights(ref __self_0_0) => (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Rights) -> bool { + match *other { + Rights(ref __self_1_0) => match *self { + Rights(ref __self_0_0) => (*__self_0_0) != (*__self_1_0), + }, + } + } +} +impl Rights { + pub const FD_DATASYNC: Rights = Rights(1); + pub const FD_READ: Rights = Rights(2); + pub const FD_SEEK: Rights = Rights(4); + pub const FD_FDSTAT_SET_FLAGS: Rights = Rights(8); + pub const FD_SYNC: Rights = Rights(16); + pub const FD_TELL: Rights = Rights(32); + pub const FD_WRITE: Rights = Rights(64); + pub const FD_ADVISE: Rights = Rights(128); + pub const FD_ALLOCATE: Rights = Rights(256); + pub const PATH_CREATE_DIRECTORY: Rights = Rights(512); + pub const PATH_CREATE_FILE: Rights = Rights(1024); + pub const PATH_LINK_SOURCE: Rights = Rights(2048); + pub const PATH_LINK_TARGET: Rights = Rights(4096); + pub const PATH_OPEN: Rights = Rights(8192); + pub const FD_READDIR: Rights = Rights(16384); + pub const PATH_READLINK: Rights = Rights(32768); + pub const PATH_RENAME_SOURCE: Rights = Rights(65536); + pub const PATH_RENAME_TARGET: Rights = Rights(131072); + pub const PATH_FILESTAT_GET: Rights = Rights(262144); + pub const PATH_FILESTAT_SET_SIZE: Rights = Rights(524288); + pub const PATH_FILESTAT_SET_TIMES: Rights = Rights(1048576); + pub const FD_FILESTAT_GET: Rights = Rights(2097152); + pub const FD_FILESTAT_SET_SIZE: Rights = Rights(4194304); + pub const FD_FILESTAT_SET_TIMES: Rights = Rights(8388608); + pub const PATH_SYMLINK: Rights = Rights(16777216); + pub const PATH_REMOVE_DIRECTORY: Rights = Rights(33554432); + pub const PATH_UNLINK_FILE: Rights = Rights(67108864); + pub const POLL_FD_READWRITE: Rights = Rights(134217728); + pub const SOCK_SHUTDOWN: Rights = Rights(268435456); +} +pub type Fd = u32; +pub type Filedelta = i64; +#[repr(u8)] +pub enum Whence { + Set, + Cur, + End, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Whence {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Whence { + #[inline] + fn clone(&self) -> Whence { + { + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Whence { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Whence::Set,) => { + let mut debug_trait_builder = f.debug_tuple("Set"); + debug_trait_builder.finish() + } + (&Whence::Cur,) => { + let mut debug_trait_builder = f.debug_tuple("Cur"); + debug_trait_builder.finish() + } + (&Whence::End,) => { + let mut debug_trait_builder = f.debug_tuple("End"); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Whence { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match (&*self,) { + _ => ::core::hash::Hash::hash( + &unsafe { ::core::intrinsics::discriminant_value(self) }, + state, + ), + } + } +} +impl ::core::marker::StructuralEq for Whence {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Whence { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + {} + } +} +impl ::core::marker::StructuralPartialEq for Whence {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Whence { + #[inline] + fn eq(&self, other: &Whence) -> bool { + { + let __self_vi = unsafe { ::core::intrinsics::discriminant_value(&*self) } as u8; + let __arg_1_vi = unsafe { ::core::intrinsics::discriminant_value(&*other) } as u8; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + _ => true, + } + } else { + false + } + } + } +} +pub type Dircookie = u64; +pub type Dirnamlen = u32; +pub type Inode = u64; +#[repr(u8)] +pub enum Filetype { + Unknown, + BlockDevice, + CharacterDevice, + Directory, + RegularFile, + SocketDgram, + SocketStream, + SymbolicLink, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Filetype {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Filetype { + #[inline] + fn clone(&self) -> Filetype { + { + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Filetype { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Filetype::Unknown,) => { + let mut debug_trait_builder = f.debug_tuple("Unknown"); + debug_trait_builder.finish() + } + (&Filetype::BlockDevice,) => { + let mut debug_trait_builder = f.debug_tuple("BlockDevice"); + debug_trait_builder.finish() + } + (&Filetype::CharacterDevice,) => { + let mut debug_trait_builder = f.debug_tuple("CharacterDevice"); + debug_trait_builder.finish() + } + (&Filetype::Directory,) => { + let mut debug_trait_builder = f.debug_tuple("Directory"); + debug_trait_builder.finish() + } + (&Filetype::RegularFile,) => { + let mut debug_trait_builder = f.debug_tuple("RegularFile"); + debug_trait_builder.finish() + } + (&Filetype::SocketDgram,) => { + let mut debug_trait_builder = f.debug_tuple("SocketDgram"); + debug_trait_builder.finish() + } + (&Filetype::SocketStream,) => { + let mut debug_trait_builder = f.debug_tuple("SocketStream"); + debug_trait_builder.finish() + } + (&Filetype::SymbolicLink,) => { + let mut debug_trait_builder = f.debug_tuple("SymbolicLink"); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Filetype { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match (&*self,) { + _ => ::core::hash::Hash::hash( + &unsafe { ::core::intrinsics::discriminant_value(self) }, + state, + ), + } + } +} +impl ::core::marker::StructuralEq for Filetype {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Filetype { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + {} + } +} +impl ::core::marker::StructuralPartialEq for Filetype {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Filetype { + #[inline] + fn eq(&self, other: &Filetype) -> bool { + { + let __self_vi = unsafe { ::core::intrinsics::discriminant_value(&*self) } as u8; + let __arg_1_vi = unsafe { ::core::intrinsics::discriminant_value(&*other) } as u8; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + _ => true, + } + } else { + false + } + } + } +} +#[repr(C)] +pub struct Dirent { + pub d_next: Dircookie, + pub d_ino: Inode, + pub d_namlen: Dirnamlen, + pub d_type: Filetype, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Dirent {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Dirent { + #[inline] + fn clone(&self) -> Dirent { + { + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Dirent { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Dirent { + d_next: ref __self_0_0, + d_ino: ref __self_0_1, + d_namlen: ref __self_0_2, + d_type: ref __self_0_3, + } => { + let mut debug_trait_builder = f.debug_struct("Dirent"); + let _ = debug_trait_builder.field("d_next", &&(*__self_0_0)); + let _ = debug_trait_builder.field("d_ino", &&(*__self_0_1)); + let _ = debug_trait_builder.field("d_namlen", &&(*__self_0_2)); + let _ = debug_trait_builder.field("d_type", &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Dirent { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Dirent { + d_next: ref __self_0_0, + d_ino: ref __self_0_1, + d_namlen: ref __self_0_2, + d_type: ref __self_0_3, + } => { + ::core::hash::Hash::hash(&(*__self_0_0), state); + ::core::hash::Hash::hash(&(*__self_0_1), state); + ::core::hash::Hash::hash(&(*__self_0_2), state); + ::core::hash::Hash::hash(&(*__self_0_3), state) + } + } + } +} +impl ::core::marker::StructuralEq for Dirent {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Dirent { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Dirent {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Dirent { + #[inline] + fn eq(&self, other: &Dirent) -> bool { + match *other { + Dirent { + d_next: ref __self_1_0, + d_ino: ref __self_1_1, + d_namlen: ref __self_1_2, + d_type: ref __self_1_3, + } => match *self { + Dirent { + d_next: ref __self_0_0, + d_ino: ref __self_0_1, + d_namlen: ref __self_0_2, + d_type: ref __self_0_3, + } => { + (*__self_0_0) == (*__self_1_0) + && (*__self_0_1) == (*__self_1_1) + && (*__self_0_2) == (*__self_1_2) + && (*__self_0_3) == (*__self_1_3) + } + }, + } + } + #[inline] + fn ne(&self, other: &Dirent) -> bool { + match *other { + Dirent { + d_next: ref __self_1_0, + d_ino: ref __self_1_1, + d_namlen: ref __self_1_2, + d_type: ref __self_1_3, + } => match *self { + Dirent { + d_next: ref __self_0_0, + d_ino: ref __self_0_1, + d_namlen: ref __self_0_2, + d_type: ref __self_0_3, + } => { + (*__self_0_0) != (*__self_1_0) + || (*__self_0_1) != (*__self_1_1) + || (*__self_0_2) != (*__self_1_2) + || (*__self_0_3) != (*__self_1_3) + } + }, + } + } +} +#[repr(u8)] +pub enum Advice { + Normal, + Sequential, + Random, + Willneed, + Dontneed, + Noreuse, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Advice {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Advice { + #[inline] + fn clone(&self) -> Advice { + { + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Advice { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Advice::Normal,) => { + let mut debug_trait_builder = f.debug_tuple("Normal"); + debug_trait_builder.finish() + } + (&Advice::Sequential,) => { + let mut debug_trait_builder = f.debug_tuple("Sequential"); + debug_trait_builder.finish() + } + (&Advice::Random,) => { + let mut debug_trait_builder = f.debug_tuple("Random"); + debug_trait_builder.finish() + } + (&Advice::Willneed,) => { + let mut debug_trait_builder = f.debug_tuple("Willneed"); + debug_trait_builder.finish() + } + (&Advice::Dontneed,) => { + let mut debug_trait_builder = f.debug_tuple("Dontneed"); + debug_trait_builder.finish() + } + (&Advice::Noreuse,) => { + let mut debug_trait_builder = f.debug_tuple("Noreuse"); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Advice { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match (&*self,) { + _ => ::core::hash::Hash::hash( + &unsafe { ::core::intrinsics::discriminant_value(self) }, + state, + ), + } + } +} +impl ::core::marker::StructuralEq for Advice {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Advice { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + {} + } +} +impl ::core::marker::StructuralPartialEq for Advice {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Advice { + #[inline] + fn eq(&self, other: &Advice) -> bool { + { + let __self_vi = unsafe { ::core::intrinsics::discriminant_value(&*self) } as u8; + let __arg_1_vi = unsafe { ::core::intrinsics::discriminant_value(&*other) } as u8; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + _ => true, + } + } else { + false + } + } + } +} +#[repr(transparent)] +pub struct Fdflags(u16); +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Fdflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Fdflags { + #[inline] + fn clone(&self) -> Fdflags { + { + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Fdflags { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Fdflags(ref __self_0_0) => { + let mut debug_trait_builder = f.debug_tuple("Fdflags"); + let _ = debug_trait_builder.field(&&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Fdflags { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Fdflags(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state), + } + } +} +impl ::core::marker::StructuralEq for Fdflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Fdflags { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Fdflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Fdflags { + #[inline] + fn eq(&self, other: &Fdflags) -> bool { + match *other { + Fdflags(ref __self_1_0) => match *self { + Fdflags(ref __self_0_0) => (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Fdflags) -> bool { + match *other { + Fdflags(ref __self_1_0) => match *self { + Fdflags(ref __self_0_0) => (*__self_0_0) != (*__self_1_0), + }, + } + } +} +impl Fdflags { + pub const APPEND: Fdflags = Fdflags(1); + pub const DSYNC: Fdflags = Fdflags(2); + pub const NONBLOCK: Fdflags = Fdflags(4); + pub const RSYNC: Fdflags = Fdflags(8); + pub const SYNC: Fdflags = Fdflags(16); +} +#[repr(C)] +pub struct Fdstat { + pub fs_filetype: Filetype, + pub fs_flags: Fdflags, + pub fs_rights_base: Rights, + pub fs_rights_inheriting: Rights, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Fdstat {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Fdstat { + #[inline] + fn clone(&self) -> Fdstat { + { + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Fdstat { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Fdstat { + fs_filetype: ref __self_0_0, + fs_flags: ref __self_0_1, + fs_rights_base: ref __self_0_2, + fs_rights_inheriting: ref __self_0_3, + } => { + let mut debug_trait_builder = f.debug_struct("Fdstat"); + let _ = debug_trait_builder.field("fs_filetype", &&(*__self_0_0)); + let _ = debug_trait_builder.field("fs_flags", &&(*__self_0_1)); + let _ = debug_trait_builder.field("fs_rights_base", &&(*__self_0_2)); + let _ = debug_trait_builder.field("fs_rights_inheriting", &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Fdstat { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Fdstat { + fs_filetype: ref __self_0_0, + fs_flags: ref __self_0_1, + fs_rights_base: ref __self_0_2, + fs_rights_inheriting: ref __self_0_3, + } => { + ::core::hash::Hash::hash(&(*__self_0_0), state); + ::core::hash::Hash::hash(&(*__self_0_1), state); + ::core::hash::Hash::hash(&(*__self_0_2), state); + ::core::hash::Hash::hash(&(*__self_0_3), state) + } + } + } +} +impl ::core::marker::StructuralEq for Fdstat {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Fdstat { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Fdstat {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Fdstat { + #[inline] + fn eq(&self, other: &Fdstat) -> bool { + match *other { + Fdstat { + fs_filetype: ref __self_1_0, + fs_flags: ref __self_1_1, + fs_rights_base: ref __self_1_2, + fs_rights_inheriting: ref __self_1_3, + } => match *self { + Fdstat { + fs_filetype: ref __self_0_0, + fs_flags: ref __self_0_1, + fs_rights_base: ref __self_0_2, + fs_rights_inheriting: ref __self_0_3, + } => { + (*__self_0_0) == (*__self_1_0) + && (*__self_0_1) == (*__self_1_1) + && (*__self_0_2) == (*__self_1_2) + && (*__self_0_3) == (*__self_1_3) + } + }, + } + } + #[inline] + fn ne(&self, other: &Fdstat) -> bool { + match *other { + Fdstat { + fs_filetype: ref __self_1_0, + fs_flags: ref __self_1_1, + fs_rights_base: ref __self_1_2, + fs_rights_inheriting: ref __self_1_3, + } => match *self { + Fdstat { + fs_filetype: ref __self_0_0, + fs_flags: ref __self_0_1, + fs_rights_base: ref __self_0_2, + fs_rights_inheriting: ref __self_0_3, + } => { + (*__self_0_0) != (*__self_1_0) + || (*__self_0_1) != (*__self_1_1) + || (*__self_0_2) != (*__self_1_2) + || (*__self_0_3) != (*__self_1_3) + } + }, + } + } +} +pub type Device = u64; +#[repr(transparent)] +pub struct Fstflags(u16); +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Fstflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Fstflags { + #[inline] + fn clone(&self) -> Fstflags { + { + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Fstflags { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Fstflags(ref __self_0_0) => { + let mut debug_trait_builder = f.debug_tuple("Fstflags"); + let _ = debug_trait_builder.field(&&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Fstflags { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Fstflags(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state), + } + } +} +impl ::core::marker::StructuralEq for Fstflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Fstflags { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Fstflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Fstflags { + #[inline] + fn eq(&self, other: &Fstflags) -> bool { + match *other { + Fstflags(ref __self_1_0) => match *self { + Fstflags(ref __self_0_0) => (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Fstflags) -> bool { + match *other { + Fstflags(ref __self_1_0) => match *self { + Fstflags(ref __self_0_0) => (*__self_0_0) != (*__self_1_0), + }, + } + } +} +impl Fstflags { + pub const ATIM: Fstflags = Fstflags(1); + pub const ATIM_NOW: Fstflags = Fstflags(2); + pub const MTIM: Fstflags = Fstflags(4); + pub const MTIM_NOW: Fstflags = Fstflags(8); +} +#[repr(transparent)] +pub struct Lookupflags(u32); +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Lookupflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Lookupflags { + #[inline] + fn clone(&self) -> Lookupflags { + { + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Lookupflags { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Lookupflags(ref __self_0_0) => { + let mut debug_trait_builder = f.debug_tuple("Lookupflags"); + let _ = debug_trait_builder.field(&&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Lookupflags { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Lookupflags(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state), + } + } +} +impl ::core::marker::StructuralEq for Lookupflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Lookupflags { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Lookupflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Lookupflags { + #[inline] + fn eq(&self, other: &Lookupflags) -> bool { + match *other { + Lookupflags(ref __self_1_0) => match *self { + Lookupflags(ref __self_0_0) => (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Lookupflags) -> bool { + match *other { + Lookupflags(ref __self_1_0) => match *self { + Lookupflags(ref __self_0_0) => (*__self_0_0) != (*__self_1_0), + }, + } + } +} +impl Lookupflags { + pub const SYMLINK_FOLLOW: Lookupflags = Lookupflags(1); +} +#[repr(transparent)] +pub struct Oflags(u16); +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Oflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Oflags { + #[inline] + fn clone(&self) -> Oflags { + { + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Oflags { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Oflags(ref __self_0_0) => { + let mut debug_trait_builder = f.debug_tuple("Oflags"); + let _ = debug_trait_builder.field(&&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Oflags { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Oflags(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state), + } + } +} +impl ::core::marker::StructuralEq for Oflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Oflags { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Oflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Oflags { + #[inline] + fn eq(&self, other: &Oflags) -> bool { + match *other { + Oflags(ref __self_1_0) => match *self { + Oflags(ref __self_0_0) => (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Oflags) -> bool { + match *other { + Oflags(ref __self_1_0) => match *self { + Oflags(ref __self_0_0) => (*__self_0_0) != (*__self_1_0), + }, + } + } +} +impl Oflags { + pub const CREAT: Oflags = Oflags(1); + pub const DIRECTORY: Oflags = Oflags(2); + pub const EXCL: Oflags = Oflags(4); + pub const TRUNC: Oflags = Oflags(8); +} +pub type Linkcount = u64; +#[repr(C)] +pub struct Filestat { + pub dev: Device, + pub ino: Inode, + pub filetype: Filetype, + pub nlink: Linkcount, + pub size: Filesize, + pub atim: Timestamp, + pub mtim: Timestamp, + pub ctim: Timestamp, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Filestat {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Filestat { + #[inline] + fn clone(&self) -> Filestat { + { + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Filestat { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Filestat { + dev: ref __self_0_0, + ino: ref __self_0_1, + filetype: ref __self_0_2, + nlink: ref __self_0_3, + size: ref __self_0_4, + atim: ref __self_0_5, + mtim: ref __self_0_6, + ctim: ref __self_0_7, + } => { + let mut debug_trait_builder = f.debug_struct("Filestat"); + let _ = debug_trait_builder.field("dev", &&(*__self_0_0)); + let _ = debug_trait_builder.field("ino", &&(*__self_0_1)); + let _ = debug_trait_builder.field("filetype", &&(*__self_0_2)); + let _ = debug_trait_builder.field("nlink", &&(*__self_0_3)); + let _ = debug_trait_builder.field("size", &&(*__self_0_4)); + let _ = debug_trait_builder.field("atim", &&(*__self_0_5)); + let _ = debug_trait_builder.field("mtim", &&(*__self_0_6)); + let _ = debug_trait_builder.field("ctim", &&(*__self_0_7)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Filestat { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Filestat { + dev: ref __self_0_0, + ino: ref __self_0_1, + filetype: ref __self_0_2, + nlink: ref __self_0_3, + size: ref __self_0_4, + atim: ref __self_0_5, + mtim: ref __self_0_6, + ctim: ref __self_0_7, + } => { + ::core::hash::Hash::hash(&(*__self_0_0), state); + ::core::hash::Hash::hash(&(*__self_0_1), state); + ::core::hash::Hash::hash(&(*__self_0_2), state); + ::core::hash::Hash::hash(&(*__self_0_3), state); + ::core::hash::Hash::hash(&(*__self_0_4), state); + ::core::hash::Hash::hash(&(*__self_0_5), state); + ::core::hash::Hash::hash(&(*__self_0_6), state); + ::core::hash::Hash::hash(&(*__self_0_7), state) + } + } + } +} +impl ::core::marker::StructuralEq for Filestat {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Filestat { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Filestat {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Filestat { + #[inline] + fn eq(&self, other: &Filestat) -> bool { + match *other { + Filestat { + dev: ref __self_1_0, + ino: ref __self_1_1, + filetype: ref __self_1_2, + nlink: ref __self_1_3, + size: ref __self_1_4, + atim: ref __self_1_5, + mtim: ref __self_1_6, + ctim: ref __self_1_7, + } => match *self { + Filestat { + dev: ref __self_0_0, + ino: ref __self_0_1, + filetype: ref __self_0_2, + nlink: ref __self_0_3, + size: ref __self_0_4, + atim: ref __self_0_5, + mtim: ref __self_0_6, + ctim: ref __self_0_7, + } => { + (*__self_0_0) == (*__self_1_0) + && (*__self_0_1) == (*__self_1_1) + && (*__self_0_2) == (*__self_1_2) + && (*__self_0_3) == (*__self_1_3) + && (*__self_0_4) == (*__self_1_4) + && (*__self_0_5) == (*__self_1_5) + && (*__self_0_6) == (*__self_1_6) + && (*__self_0_7) == (*__self_1_7) + } + }, + } + } + #[inline] + fn ne(&self, other: &Filestat) -> bool { + match *other { + Filestat { + dev: ref __self_1_0, + ino: ref __self_1_1, + filetype: ref __self_1_2, + nlink: ref __self_1_3, + size: ref __self_1_4, + atim: ref __self_1_5, + mtim: ref __self_1_6, + ctim: ref __self_1_7, + } => match *self { + Filestat { + dev: ref __self_0_0, + ino: ref __self_0_1, + filetype: ref __self_0_2, + nlink: ref __self_0_3, + size: ref __self_0_4, + atim: ref __self_0_5, + mtim: ref __self_0_6, + ctim: ref __self_0_7, + } => { + (*__self_0_0) != (*__self_1_0) + || (*__self_0_1) != (*__self_1_1) + || (*__self_0_2) != (*__self_1_2) + || (*__self_0_3) != (*__self_1_3) + || (*__self_0_4) != (*__self_1_4) + || (*__self_0_5) != (*__self_1_5) + || (*__self_0_6) != (*__self_1_6) + || (*__self_0_7) != (*__self_1_7) + } + }, + } + } +} +pub type Userdata = u64; +#[repr(u8)] +pub enum Eventtype { + Clock, + FdRead, + FdWrite, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Eventtype {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Eventtype { + #[inline] + fn clone(&self) -> Eventtype { + { + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Eventtype { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Eventtype::Clock,) => { + let mut debug_trait_builder = f.debug_tuple("Clock"); + debug_trait_builder.finish() + } + (&Eventtype::FdRead,) => { + let mut debug_trait_builder = f.debug_tuple("FdRead"); + debug_trait_builder.finish() + } + (&Eventtype::FdWrite,) => { + let mut debug_trait_builder = f.debug_tuple("FdWrite"); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Eventtype { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match (&*self,) { + _ => ::core::hash::Hash::hash( + &unsafe { ::core::intrinsics::discriminant_value(self) }, + state, + ), + } + } +} +impl ::core::marker::StructuralEq for Eventtype {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Eventtype { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + {} + } +} +impl ::core::marker::StructuralPartialEq for Eventtype {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Eventtype { + #[inline] + fn eq(&self, other: &Eventtype) -> bool { + { + let __self_vi = unsafe { ::core::intrinsics::discriminant_value(&*self) } as u8; + let __arg_1_vi = unsafe { ::core::intrinsics::discriminant_value(&*other) } as u8; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + _ => true, + } + } else { + false + } + } + } +} +#[repr(transparent)] +pub struct Eventrwflags(u16); +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Eventrwflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Eventrwflags { + #[inline] + fn clone(&self) -> Eventrwflags { + { + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Eventrwflags { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Eventrwflags(ref __self_0_0) => { + let mut debug_trait_builder = f.debug_tuple("Eventrwflags"); + let _ = debug_trait_builder.field(&&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Eventrwflags { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Eventrwflags(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state), + } + } +} +impl ::core::marker::StructuralEq for Eventrwflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Eventrwflags { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Eventrwflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Eventrwflags { + #[inline] + fn eq(&self, other: &Eventrwflags) -> bool { + match *other { + Eventrwflags(ref __self_1_0) => match *self { + Eventrwflags(ref __self_0_0) => (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Eventrwflags) -> bool { + match *other { + Eventrwflags(ref __self_1_0) => match *self { + Eventrwflags(ref __self_0_0) => (*__self_0_0) != (*__self_1_0), + }, + } + } +} +impl Eventrwflags { + pub const FD_READWRITE_HANGUP: Eventrwflags = Eventrwflags(1); +} +#[repr(C)] +pub struct EventFdReadwrite { + pub nbytes: Filesize, + pub flags: Eventrwflags, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for EventFdReadwrite {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for EventFdReadwrite { + #[inline] + fn clone(&self) -> EventFdReadwrite { + { + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for EventFdReadwrite { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + EventFdReadwrite { + nbytes: ref __self_0_0, + flags: ref __self_0_1, + } => { + let mut debug_trait_builder = f.debug_struct("EventFdReadwrite"); + let _ = debug_trait_builder.field("nbytes", &&(*__self_0_0)); + let _ = debug_trait_builder.field("flags", &&(*__self_0_1)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for EventFdReadwrite { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + EventFdReadwrite { + nbytes: ref __self_0_0, + flags: ref __self_0_1, + } => { + ::core::hash::Hash::hash(&(*__self_0_0), state); + ::core::hash::Hash::hash(&(*__self_0_1), state) + } + } + } +} +impl ::core::marker::StructuralEq for EventFdReadwrite {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for EventFdReadwrite { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for EventFdReadwrite {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for EventFdReadwrite { + #[inline] + fn eq(&self, other: &EventFdReadwrite) -> bool { + match *other { + EventFdReadwrite { + nbytes: ref __self_1_0, + flags: ref __self_1_1, + } => match *self { + EventFdReadwrite { + nbytes: ref __self_0_0, + flags: ref __self_0_1, + } => (*__self_0_0) == (*__self_1_0) && (*__self_0_1) == (*__self_1_1), + }, + } + } + #[inline] + fn ne(&self, other: &EventFdReadwrite) -> bool { + match *other { + EventFdReadwrite { + nbytes: ref __self_1_0, + flags: ref __self_1_1, + } => match *self { + EventFdReadwrite { + nbytes: ref __self_0_0, + flags: ref __self_0_1, + } => (*__self_0_0) != (*__self_1_0) || (*__self_0_1) != (*__self_1_1), + }, + } + } +} +#[repr(C)] +#[allow(missing_debug_implementations)] +pub union EventU { + pub fd_readwrite: EventFdReadwrite, +} +#[automatically_derived] +#[allow(unused_qualifications)] +#[allow(missing_debug_implementations)] +impl ::core::marker::Copy for EventU {} +#[automatically_derived] +#[allow(unused_qualifications)] +#[allow(missing_debug_implementations)] +impl ::core::clone::Clone for EventU { + #[inline] + fn clone(&self) -> EventU { + { + let _: ::core::clone::AssertParamIsCopy; + *self + } + } +} +#[repr(C)] +#[allow(missing_debug_implementations)] +pub struct Event { + pub userdata: Userdata, + pub error: Errno, + pub r#type: Eventtype, + pub u: EventU, +} +#[automatically_derived] +#[allow(unused_qualifications)] +#[allow(missing_debug_implementations)] +impl ::core::marker::Copy for Event {} +#[automatically_derived] +#[allow(unused_qualifications)] +#[allow(missing_debug_implementations)] +impl ::core::clone::Clone for Event { + #[inline] + fn clone(&self) -> Event { + { + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[repr(transparent)] +pub struct Subclockflags(u16); +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Subclockflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Subclockflags { + #[inline] + fn clone(&self) -> Subclockflags { + { + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Subclockflags { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Subclockflags(ref __self_0_0) => { + let mut debug_trait_builder = f.debug_tuple("Subclockflags"); + let _ = debug_trait_builder.field(&&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Subclockflags { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Subclockflags(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state), + } + } +} +impl ::core::marker::StructuralEq for Subclockflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Subclockflags { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Subclockflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Subclockflags { + #[inline] + fn eq(&self, other: &Subclockflags) -> bool { + match *other { + Subclockflags(ref __self_1_0) => match *self { + Subclockflags(ref __self_0_0) => (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Subclockflags) -> bool { + match *other { + Subclockflags(ref __self_1_0) => match *self { + Subclockflags(ref __self_0_0) => (*__self_0_0) != (*__self_1_0), + }, + } + } +} +impl Subclockflags { + pub const SUBSCRIPTION_CLOCK_ABSTIME: Subclockflags = Subclockflags(1); +} +#[repr(C)] +pub struct SubscriptionClock { + pub id: Clockid, + pub timeout: Timestamp, + pub precision: Timestamp, + pub flags: Subclockflags, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for SubscriptionClock {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for SubscriptionClock { + #[inline] + fn clone(&self) -> SubscriptionClock { + { + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for SubscriptionClock { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + SubscriptionClock { + id: ref __self_0_0, + timeout: ref __self_0_1, + precision: ref __self_0_2, + flags: ref __self_0_3, + } => { + let mut debug_trait_builder = f.debug_struct("SubscriptionClock"); + let _ = debug_trait_builder.field("id", &&(*__self_0_0)); + let _ = debug_trait_builder.field("timeout", &&(*__self_0_1)); + let _ = debug_trait_builder.field("precision", &&(*__self_0_2)); + let _ = debug_trait_builder.field("flags", &&(*__self_0_3)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for SubscriptionClock { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + SubscriptionClock { + id: ref __self_0_0, + timeout: ref __self_0_1, + precision: ref __self_0_2, + flags: ref __self_0_3, + } => { + ::core::hash::Hash::hash(&(*__self_0_0), state); + ::core::hash::Hash::hash(&(*__self_0_1), state); + ::core::hash::Hash::hash(&(*__self_0_2), state); + ::core::hash::Hash::hash(&(*__self_0_3), state) + } + } + } +} +impl ::core::marker::StructuralEq for SubscriptionClock {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for SubscriptionClock { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for SubscriptionClock {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for SubscriptionClock { + #[inline] + fn eq(&self, other: &SubscriptionClock) -> bool { + match *other { + SubscriptionClock { + id: ref __self_1_0, + timeout: ref __self_1_1, + precision: ref __self_1_2, + flags: ref __self_1_3, + } => match *self { + SubscriptionClock { + id: ref __self_0_0, + timeout: ref __self_0_1, + precision: ref __self_0_2, + flags: ref __self_0_3, + } => { + (*__self_0_0) == (*__self_1_0) + && (*__self_0_1) == (*__self_1_1) + && (*__self_0_2) == (*__self_1_2) + && (*__self_0_3) == (*__self_1_3) + } + }, + } + } + #[inline] + fn ne(&self, other: &SubscriptionClock) -> bool { + match *other { + SubscriptionClock { + id: ref __self_1_0, + timeout: ref __self_1_1, + precision: ref __self_1_2, + flags: ref __self_1_3, + } => match *self { + SubscriptionClock { + id: ref __self_0_0, + timeout: ref __self_0_1, + precision: ref __self_0_2, + flags: ref __self_0_3, + } => { + (*__self_0_0) != (*__self_1_0) + || (*__self_0_1) != (*__self_1_1) + || (*__self_0_2) != (*__self_1_2) + || (*__self_0_3) != (*__self_1_3) + } + }, + } + } +} +#[repr(C)] +pub struct SubscriptionFdReadwrite { + pub file_descriptor: Fd, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for SubscriptionFdReadwrite {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for SubscriptionFdReadwrite { + #[inline] + fn clone(&self) -> SubscriptionFdReadwrite { + { + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for SubscriptionFdReadwrite { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + SubscriptionFdReadwrite { + file_descriptor: ref __self_0_0, + } => { + let mut debug_trait_builder = f.debug_struct("SubscriptionFdReadwrite"); + let _ = debug_trait_builder.field("file_descriptor", &&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for SubscriptionFdReadwrite { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + SubscriptionFdReadwrite { + file_descriptor: ref __self_0_0, + } => ::core::hash::Hash::hash(&(*__self_0_0), state), + } + } +} +impl ::core::marker::StructuralEq for SubscriptionFdReadwrite {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for SubscriptionFdReadwrite { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for SubscriptionFdReadwrite {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for SubscriptionFdReadwrite { + #[inline] + fn eq(&self, other: &SubscriptionFdReadwrite) -> bool { + match *other { + SubscriptionFdReadwrite { + file_descriptor: ref __self_1_0, + } => match *self { + SubscriptionFdReadwrite { + file_descriptor: ref __self_0_0, + } => (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &SubscriptionFdReadwrite) -> bool { + match *other { + SubscriptionFdReadwrite { + file_descriptor: ref __self_1_0, + } => match *self { + SubscriptionFdReadwrite { + file_descriptor: ref __self_0_0, + } => (*__self_0_0) != (*__self_1_0), + }, + } + } +} +#[repr(C)] +#[allow(missing_debug_implementations)] +pub union SubscriptionU { + pub clock: SubscriptionClock, + pub fd_readwrite: SubscriptionFdReadwrite, +} +#[automatically_derived] +#[allow(unused_qualifications)] +#[allow(missing_debug_implementations)] +impl ::core::marker::Copy for SubscriptionU {} +#[automatically_derived] +#[allow(unused_qualifications)] +#[allow(missing_debug_implementations)] +impl ::core::clone::Clone for SubscriptionU { + #[inline] + fn clone(&self) -> SubscriptionU { + { + let _: ::core::clone::AssertParamIsCopy; + *self + } + } +} +#[repr(C)] +#[allow(missing_debug_implementations)] +pub struct Subscription { + pub userdata: Userdata, + pub r#type: Eventtype, + pub u: SubscriptionU, +} +#[automatically_derived] +#[allow(unused_qualifications)] +#[allow(missing_debug_implementations)] +impl ::core::marker::Copy for Subscription {} +#[automatically_derived] +#[allow(unused_qualifications)] +#[allow(missing_debug_implementations)] +impl ::core::clone::Clone for Subscription { + #[inline] + fn clone(&self) -> Subscription { + { + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +pub type Exitcode = u32; +#[repr(u8)] +pub enum Signal { + None, + Hup, + Int, + Quit, + Ill, + Trap, + Abrt, + Bus, + Fpe, + Kill, + Usr1, + Segv, + Usr2, + Pipe, + Alrm, + Term, + Chld, + Cont, + Stop, + Tstp, + Ttin, + Ttou, + Urg, + Xcpu, + Xfsz, + Vtalrm, + Prof, + Winch, + Poll, + Pwr, + Sys, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Signal {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Signal { + #[inline] + fn clone(&self) -> Signal { + { + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Signal { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Signal::None,) => { + let mut debug_trait_builder = f.debug_tuple("None"); + debug_trait_builder.finish() + } + (&Signal::Hup,) => { + let mut debug_trait_builder = f.debug_tuple("Hup"); + debug_trait_builder.finish() + } + (&Signal::Int,) => { + let mut debug_trait_builder = f.debug_tuple("Int"); + debug_trait_builder.finish() + } + (&Signal::Quit,) => { + let mut debug_trait_builder = f.debug_tuple("Quit"); + debug_trait_builder.finish() + } + (&Signal::Ill,) => { + let mut debug_trait_builder = f.debug_tuple("Ill"); + debug_trait_builder.finish() + } + (&Signal::Trap,) => { + let mut debug_trait_builder = f.debug_tuple("Trap"); + debug_trait_builder.finish() + } + (&Signal::Abrt,) => { + let mut debug_trait_builder = f.debug_tuple("Abrt"); + debug_trait_builder.finish() + } + (&Signal::Bus,) => { + let mut debug_trait_builder = f.debug_tuple("Bus"); + debug_trait_builder.finish() + } + (&Signal::Fpe,) => { + let mut debug_trait_builder = f.debug_tuple("Fpe"); + debug_trait_builder.finish() + } + (&Signal::Kill,) => { + let mut debug_trait_builder = f.debug_tuple("Kill"); + debug_trait_builder.finish() + } + (&Signal::Usr1,) => { + let mut debug_trait_builder = f.debug_tuple("Usr1"); + debug_trait_builder.finish() + } + (&Signal::Segv,) => { + let mut debug_trait_builder = f.debug_tuple("Segv"); + debug_trait_builder.finish() + } + (&Signal::Usr2,) => { + let mut debug_trait_builder = f.debug_tuple("Usr2"); + debug_trait_builder.finish() + } + (&Signal::Pipe,) => { + let mut debug_trait_builder = f.debug_tuple("Pipe"); + debug_trait_builder.finish() + } + (&Signal::Alrm,) => { + let mut debug_trait_builder = f.debug_tuple("Alrm"); + debug_trait_builder.finish() + } + (&Signal::Term,) => { + let mut debug_trait_builder = f.debug_tuple("Term"); + debug_trait_builder.finish() + } + (&Signal::Chld,) => { + let mut debug_trait_builder = f.debug_tuple("Chld"); + debug_trait_builder.finish() + } + (&Signal::Cont,) => { + let mut debug_trait_builder = f.debug_tuple("Cont"); + debug_trait_builder.finish() + } + (&Signal::Stop,) => { + let mut debug_trait_builder = f.debug_tuple("Stop"); + debug_trait_builder.finish() + } + (&Signal::Tstp,) => { + let mut debug_trait_builder = f.debug_tuple("Tstp"); + debug_trait_builder.finish() + } + (&Signal::Ttin,) => { + let mut debug_trait_builder = f.debug_tuple("Ttin"); + debug_trait_builder.finish() + } + (&Signal::Ttou,) => { + let mut debug_trait_builder = f.debug_tuple("Ttou"); + debug_trait_builder.finish() + } + (&Signal::Urg,) => { + let mut debug_trait_builder = f.debug_tuple("Urg"); + debug_trait_builder.finish() + } + (&Signal::Xcpu,) => { + let mut debug_trait_builder = f.debug_tuple("Xcpu"); + debug_trait_builder.finish() + } + (&Signal::Xfsz,) => { + let mut debug_trait_builder = f.debug_tuple("Xfsz"); + debug_trait_builder.finish() + } + (&Signal::Vtalrm,) => { + let mut debug_trait_builder = f.debug_tuple("Vtalrm"); + debug_trait_builder.finish() + } + (&Signal::Prof,) => { + let mut debug_trait_builder = f.debug_tuple("Prof"); + debug_trait_builder.finish() + } + (&Signal::Winch,) => { + let mut debug_trait_builder = f.debug_tuple("Winch"); + debug_trait_builder.finish() + } + (&Signal::Poll,) => { + let mut debug_trait_builder = f.debug_tuple("Poll"); + debug_trait_builder.finish() + } + (&Signal::Pwr,) => { + let mut debug_trait_builder = f.debug_tuple("Pwr"); + debug_trait_builder.finish() + } + (&Signal::Sys,) => { + let mut debug_trait_builder = f.debug_tuple("Sys"); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Signal { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match (&*self,) { + _ => ::core::hash::Hash::hash( + &unsafe { ::core::intrinsics::discriminant_value(self) }, + state, + ), + } + } +} +impl ::core::marker::StructuralEq for Signal {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Signal { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + {} + } +} +impl ::core::marker::StructuralPartialEq for Signal {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Signal { + #[inline] + fn eq(&self, other: &Signal) -> bool { + { + let __self_vi = unsafe { ::core::intrinsics::discriminant_value(&*self) } as u8; + let __arg_1_vi = unsafe { ::core::intrinsics::discriminant_value(&*other) } as u8; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + _ => true, + } + } else { + false + } + } + } +} +#[repr(transparent)] +pub struct Riflags(u16); +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Riflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Riflags { + #[inline] + fn clone(&self) -> Riflags { + { + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Riflags { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Riflags(ref __self_0_0) => { + let mut debug_trait_builder = f.debug_tuple("Riflags"); + let _ = debug_trait_builder.field(&&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Riflags { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Riflags(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state), + } + } +} +impl ::core::marker::StructuralEq for Riflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Riflags { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Riflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Riflags { + #[inline] + fn eq(&self, other: &Riflags) -> bool { + match *other { + Riflags(ref __self_1_0) => match *self { + Riflags(ref __self_0_0) => (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Riflags) -> bool { + match *other { + Riflags(ref __self_1_0) => match *self { + Riflags(ref __self_0_0) => (*__self_0_0) != (*__self_1_0), + }, + } + } +} +impl Riflags { + pub const RECV_PEEK: Riflags = Riflags(1); + pub const RECV_WAITALL: Riflags = Riflags(2); +} +#[repr(transparent)] +pub struct Roflags(u16); +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Roflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Roflags { + #[inline] + fn clone(&self) -> Roflags { + { + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Roflags { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Roflags(ref __self_0_0) => { + let mut debug_trait_builder = f.debug_tuple("Roflags"); + let _ = debug_trait_builder.field(&&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Roflags { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Roflags(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state), + } + } +} +impl ::core::marker::StructuralEq for Roflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Roflags { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Roflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Roflags { + #[inline] + fn eq(&self, other: &Roflags) -> bool { + match *other { + Roflags(ref __self_1_0) => match *self { + Roflags(ref __self_0_0) => (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Roflags) -> bool { + match *other { + Roflags(ref __self_1_0) => match *self { + Roflags(ref __self_0_0) => (*__self_0_0) != (*__self_1_0), + }, + } + } +} +impl Roflags { + pub const RECV_DATA_TRUNCATED: Roflags = Roflags(1); +} +pub type Siflags = u16; +#[repr(transparent)] +pub struct Sdflags(u8); +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Sdflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Sdflags { + #[inline] + fn clone(&self) -> Sdflags { + { + let _: ::core::clone::AssertParamIsClone; + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Sdflags { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match *self { + Sdflags(ref __self_0_0) => { + let mut debug_trait_builder = f.debug_tuple("Sdflags"); + let _ = debug_trait_builder.field(&&(*__self_0_0)); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Sdflags { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match *self { + Sdflags(ref __self_0_0) => ::core::hash::Hash::hash(&(*__self_0_0), state), + } + } +} +impl ::core::marker::StructuralEq for Sdflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Sdflags { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + { + let _: ::core::cmp::AssertParamIsEq; + } + } +} +impl ::core::marker::StructuralPartialEq for Sdflags {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Sdflags { + #[inline] + fn eq(&self, other: &Sdflags) -> bool { + match *other { + Sdflags(ref __self_1_0) => match *self { + Sdflags(ref __self_0_0) => (*__self_0_0) == (*__self_1_0), + }, + } + } + #[inline] + fn ne(&self, other: &Sdflags) -> bool { + match *other { + Sdflags(ref __self_1_0) => match *self { + Sdflags(ref __self_0_0) => (*__self_0_0) != (*__self_1_0), + }, + } + } +} +impl Sdflags { + pub const RD: Sdflags = Sdflags(1); + pub const WR: Sdflags = Sdflags(2); +} +#[repr(u8)] +pub enum Preopentype { + Dir, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::marker::Copy for Preopentype {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::clone::Clone for Preopentype { + #[inline] + fn clone(&self) -> Preopentype { + { + *self + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug for Preopentype { + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&Preopentype::Dir,) => { + let mut debug_trait_builder = f.debug_tuple("Dir"); + debug_trait_builder.finish() + } + } + } +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::hash::Hash for Preopentype { + fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () { + match (&*self,) { + _ => {} + } + } +} +impl ::core::marker::StructuralEq for Preopentype {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::Eq for Preopentype { + #[inline] + #[doc(hidden)] + fn assert_receiver_is_total_eq(&self) -> () { + {} + } +} +impl ::core::marker::StructuralPartialEq for Preopentype {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::cmp::PartialEq for Preopentype { + #[inline] + fn eq(&self, other: &Preopentype) -> bool { + match (&*self, &*other) { + _ => true, + } + } +}