T0b1/wasmtime
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
4c7b3e8685887dce827ca16dacb2a7d68dd1b5bb
wasmtime/lib_generated.rs
Jakub Konka 8882cb8ea6 Add auto-generated file
2020-01-17 19:39:44 +01:00

2822 lines
89 KiB
Rust
Raw Blame History

#![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<u64>;
*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<u64>;
}
}
}
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<Dircookie>;
let _: ::core::clone::AssertParamIsClone<Inode>;
let _: ::core::clone::AssertParamIsClone<Dirnamlen>;
let _: ::core::clone::AssertParamIsClone<Filetype>;
*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<Dircookie>;
let _: ::core::cmp::AssertParamIsEq<Inode>;
let _: ::core::cmp::AssertParamIsEq<Dirnamlen>;
let _: ::core::cmp::AssertParamIsEq<Filetype>;
}
}
}
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<u16>;
*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<u16>;
}
}
}
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<Filetype>;
let _: ::core::clone::AssertParamIsClone<Fdflags>;
let _: ::core::clone::AssertParamIsClone<Rights>;
let _: ::core::clone::AssertParamIsClone<Rights>;
*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<Filetype>;
let _: ::core::cmp::AssertParamIsEq<Fdflags>;
let _: ::core::cmp::AssertParamIsEq<Rights>;
let _: ::core::cmp::AssertParamIsEq<Rights>;
}
}
}
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<u16>;
*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<u16>;
}
}
}
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<u32>;
*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<u32>;
}
}
}
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<u16>;
*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<u16>;
}
}
}
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<Device>;
let _: ::core::clone::AssertParamIsClone<Inode>;
let _: ::core::clone::AssertParamIsClone<Filetype>;
let _: ::core::clone::AssertParamIsClone<Linkcount>;
let _: ::core::clone::AssertParamIsClone<Filesize>;
let _: ::core::clone::AssertParamIsClone<Timestamp>;
let _: ::core::clone::AssertParamIsClone<Timestamp>;
let _: ::core::clone::AssertParamIsClone<Timestamp>;
*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<Device>;
let _: ::core::cmp::AssertParamIsEq<Inode>;
let _: ::core::cmp::AssertParamIsEq<Filetype>;
let _: ::core::cmp::AssertParamIsEq<Linkcount>;
let _: ::core::cmp::AssertParamIsEq<Filesize>;
let _: ::core::cmp::AssertParamIsEq<Timestamp>;
let _: ::core::cmp::AssertParamIsEq<Timestamp>;
let _: ::core::cmp::AssertParamIsEq<Timestamp>;
}
}
}
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<u16>;
*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<u16>;
}
}
}
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<Filesize>;
let _: ::core::clone::AssertParamIsClone<Eventrwflags>;
*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<Filesize>;
let _: ::core::cmp::AssertParamIsEq<Eventrwflags>;
}
}
}
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>;
*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<Userdata>;
let _: ::core::clone::AssertParamIsClone<Errno>;
let _: ::core::clone::AssertParamIsClone<Eventtype>;
let _: ::core::clone::AssertParamIsClone<EventU>;
*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<u16>;
*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<u16>;
}
}
}
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<Clockid>;
let _: ::core::clone::AssertParamIsClone<Timestamp>;
let _: ::core::clone::AssertParamIsClone<Timestamp>;
let _: ::core::clone::AssertParamIsClone<Subclockflags>;
*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<Clockid>;
let _: ::core::cmp::AssertParamIsEq<Timestamp>;
let _: ::core::cmp::AssertParamIsEq<Timestamp>;
let _: ::core::cmp::AssertParamIsEq<Subclockflags>;
}
}
}
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<Fd>;
*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<Fd>;
}
}
}
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>;
*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<Userdata>;
let _: ::core::clone::AssertParamIsClone<Eventtype>;
let _: ::core::clone::AssertParamIsClone<SubscriptionU>;
*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<u16>;
*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<u16>;
}
}
}
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<u16>;
*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<u16>;
}
}
}
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<u8>;
*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<u8>;
}
}
}
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,
}
}
}
Reference in New Issue View Git Blame Copy Permalink