WIP: Use derived traits in more places

Author: tgross35

src/unix/bsd/apple/mod.rs

@@ -1250,14 +1250,6 @@ s! {
         pub proc_fd: i32,
         pub proc_fdtype: u32,
     }
-}
-
-s_no_extra_traits! {
-    #[repr(packed(4))]
-    pub struct ifconf {
-        pub ifc_len: c_int,
-        pub ifc_ifcu: __c_anonymous_ifc_ifcu,
-    }
 
     #[repr(packed(4))]
     pub struct kevent {
@@ -1380,6 +1372,14 @@ s_no_extra_traits! {
         __unused1: *mut c_void, //actually a function pointer
         pub sigev_notify_attributes: *mut crate::pthread_attr_t,
     }
+}
+
+s_no_extra_traits! {
+    #[repr(packed(4))]
+    pub struct ifconf {
+        pub ifc_len: c_int,
+        pub ifc_ifcu: __c_anonymous_ifc_ifcu,
+    }
 
     pub struct processor_cpu_load_info {
         pub cpu_ticks: [c_uint; CPU_STATE_MAX as usize],
@@ -1674,367 +1674,6 @@ cfg_if! {
 
 cfg_if! {
     if #[cfg(feature = "extra_traits")] {
-        impl PartialEq for kevent {
-            fn eq(&self, other: &kevent) -> bool {
-                self.ident == other.ident
-                    && self.filter == other.filter
-                    && self.flags == other.flags
-                    && self.fflags == other.fflags
-                    && self.data == other.data
-                    && self.udata == other.udata
-            }
-        }
-        impl Eq for kevent {}
-        impl hash::Hash for kevent {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                let ident = self.ident;
-                let filter = self.filter;
-                let flags = self.flags;
-                let fflags = self.fflags;
-                let data = self.data;
-                let udata = self.udata;
-                ident.hash(state);
-                filter.hash(state);
-                flags.hash(state);
-                fflags.hash(state);
-                data.hash(state);
-                udata.hash(state);
-            }
-        }
-
-        impl PartialEq for semid_ds {
-            fn eq(&self, other: &semid_ds) -> bool {
-                let sem_perm = self.sem_perm;
-                let sem_pad3 = self.sem_pad3;
-                let other_sem_perm = other.sem_perm;
-                let other_sem_pad3 = other.sem_pad3;
-                sem_perm == other_sem_perm
-                    && self.sem_base == other.sem_base
-                    && self.sem_nsems == other.sem_nsems
-                    && self.sem_otime == other.sem_otime
-                    && self.sem_pad1 == other.sem_pad1
-                    && self.sem_ctime == other.sem_ctime
-                    && self.sem_pad2 == other.sem_pad2
-                    && sem_pad3 == other_sem_pad3
-            }
-        }
-        impl Eq for semid_ds {}
-        impl hash::Hash for semid_ds {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                let sem_perm = self.sem_perm;
-                let sem_base = self.sem_base;
-                let sem_nsems = self.sem_nsems;
-                let sem_otime = self.sem_otime;
-                let sem_pad1 = self.sem_pad1;
-                let sem_ctime = self.sem_ctime;
-                let sem_pad2 = self.sem_pad2;
-                let sem_pad3 = self.sem_pad3;
-                sem_perm.hash(state);
-                sem_base.hash(state);
-                sem_nsems.hash(state);
-                sem_otime.hash(state);
-                sem_pad1.hash(state);
-                sem_ctime.hash(state);
-                sem_pad2.hash(state);
-                sem_pad3.hash(state);
-            }
-        }
-
-        impl PartialEq for shmid_ds {
-            fn eq(&self, other: &shmid_ds) -> bool {
-                let shm_perm = self.shm_perm;
-                let other_shm_perm = other.shm_perm;
-                shm_perm == other_shm_perm
-                    && self.shm_segsz == other.shm_segsz
-                    && self.shm_lpid == other.shm_lpid
-                    && self.shm_cpid == other.shm_cpid
-                    && self.shm_nattch == other.shm_nattch
-                    && self.shm_atime == other.shm_atime
-                    && self.shm_dtime == other.shm_dtime
-                    && self.shm_ctime == other.shm_ctime
-                    && self.shm_internal == other.shm_internal
-            }
-        }
-        impl Eq for shmid_ds {}
-        impl hash::Hash for shmid_ds {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                let shm_perm = self.shm_perm;
-                let shm_segsz = self.shm_segsz;
-                let shm_lpid = self.shm_lpid;
-                let shm_cpid = self.shm_cpid;
-                let shm_nattch = self.shm_nattch;
-                let shm_atime = self.shm_atime;
-                let shm_dtime = self.shm_dtime;
-                let shm_ctime = self.shm_ctime;
-                let shm_internal = self.shm_internal;
-                shm_perm.hash(state);
-                shm_segsz.hash(state);
-                shm_lpid.hash(state);
-                shm_cpid.hash(state);
-                shm_nattch.hash(state);
-                shm_atime.hash(state);
-                shm_dtime.hash(state);
-                shm_ctime.hash(state);
-                shm_internal.hash(state);
-            }
-        }
-
-        impl PartialEq for proc_threadinfo {
-            fn eq(&self, other: &proc_threadinfo) -> bool {
-                self.pth_user_time == other.pth_user_time
-                    && self.pth_system_time == other.pth_system_time
-                    && self.pth_cpu_usage == other.pth_cpu_usage
-                    && self.pth_policy == other.pth_policy
-                    && self.pth_run_state == other.pth_run_state
-                    && self.pth_flags == other.pth_flags
-                    && self.pth_sleep_time == other.pth_sleep_time
-                    && self.pth_curpri == other.pth_curpri
-                    && self.pth_priority == other.pth_priority
-                    && self.pth_maxpriority == other.pth_maxpriority
-                    && self
-                        .pth_name
-                        .iter()
-                        .zip(other.pth_name.iter())
-                        .all(|(a, b)| a == b)
-            }
-        }
-        impl Eq for proc_threadinfo {}
-        impl hash::Hash for proc_threadinfo {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                self.pth_user_time.hash(state);
-                self.pth_system_time.hash(state);
-                self.pth_cpu_usage.hash(state);
-                self.pth_policy.hash(state);
-                self.pth_run_state.hash(state);
-                self.pth_flags.hash(state);
-                self.pth_sleep_time.hash(state);
-                self.pth_curpri.hash(state);
-                self.pth_priority.hash(state);
-                self.pth_maxpriority.hash(state);
-                self.pth_name.hash(state);
-            }
-        }
-
-        impl PartialEq for statfs {
-            fn eq(&self, other: &statfs) -> bool {
-                self.f_bsize == other.f_bsize
-                    && self.f_iosize == other.f_iosize
-                    && self.f_blocks == other.f_blocks
-                    && self.f_bfree == other.f_bfree
-                    && self.f_bavail == other.f_bavail
-                    && self.f_files == other.f_files
-                    && self.f_ffree == other.f_ffree
-                    && self.f_fsid == other.f_fsid
-                    && self.f_owner == other.f_owner
-                    && self.f_flags == other.f_flags
-                    && self.f_fssubtype == other.f_fssubtype
-                    && self.f_fstypename == other.f_fstypename
-                    && self.f_type == other.f_type
-                    && self
-                        .f_mntonname
-                        .iter()
-                        .zip(other.f_mntonname.iter())
-                        .all(|(a, b)| a == b)
-                    && self
-                        .f_mntfromname
-                        .iter()
-                        .zip(other.f_mntfromname.iter())
-                        .all(|(a, b)| a == b)
-                    && self.f_reserved == other.f_reserved
-            }
-        }
-
-        impl Eq for statfs {}
-
-        impl hash::Hash for statfs {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                self.f_bsize.hash(state);
-                self.f_iosize.hash(state);
-                self.f_blocks.hash(state);
-                self.f_bfree.hash(state);
-                self.f_bavail.hash(state);
-                self.f_files.hash(state);
-                self.f_ffree.hash(state);
-                self.f_fsid.hash(state);
-                self.f_owner.hash(state);
-                self.f_flags.hash(state);
-                self.f_fssubtype.hash(state);
-                self.f_fstypename.hash(state);
-                self.f_type.hash(state);
-                self.f_mntonname.hash(state);
-                self.f_mntfromname.hash(state);
-                self.f_reserved.hash(state);
-            }
-        }
-
-        impl PartialEq for dirent {
-            fn eq(&self, other: &dirent) -> bool {
-                self.d_ino == other.d_ino
-                    && self.d_seekoff == other.d_seekoff
-                    && self.d_reclen == other.d_reclen
-                    && self.d_namlen == other.d_namlen
-                    && self.d_type == other.d_type
-                    && self
-                        .d_name
-                        .iter()
-                        .zip(other.d_name.iter())
-                        .all(|(a, b)| a == b)
-            }
-        }
-        impl Eq for dirent {}
-        impl hash::Hash for dirent {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                self.d_ino.hash(state);
-                self.d_seekoff.hash(state);
-                self.d_reclen.hash(state);
-                self.d_namlen.hash(state);
-                self.d_type.hash(state);
-                self.d_name.hash(state);
-            }
-        }
-        impl PartialEq for pthread_rwlock_t {
-            fn eq(&self, other: &pthread_rwlock_t) -> bool {
-                self.__sig == other.__sig
-                    && self
-                        .__opaque
-                        .iter()
-                        .zip(other.__opaque.iter())
-                        .all(|(a, b)| a == b)
-            }
-        }
-        impl Eq for pthread_rwlock_t {}
-        impl hash::Hash for pthread_rwlock_t {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                self.__sig.hash(state);
-                self.__opaque.hash(state);
-            }
-        }
-
-        impl PartialEq for pthread_mutex_t {
-            fn eq(&self, other: &pthread_mutex_t) -> bool {
-                self.__sig == other.__sig
-                    && self
-                        .__opaque
-                        .iter()
-                        .zip(other.__opaque.iter())
-                        .all(|(a, b)| a == b)
-            }
-        }
-
-        impl Eq for pthread_mutex_t {}
-
-        impl hash::Hash for pthread_mutex_t {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                self.__sig.hash(state);
-                self.__opaque.hash(state);
-            }
-        }
-
-        impl PartialEq for pthread_cond_t {
-            fn eq(&self, other: &pthread_cond_t) -> bool {
-                self.__sig == other.__sig
-                    && self
-                        .__opaque
-                        .iter()
-                        .zip(other.__opaque.iter())
-                        .all(|(a, b)| a == b)
-            }
-        }
-
-        impl Eq for pthread_cond_t {}
-
-        impl hash::Hash for pthread_cond_t {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                self.__sig.hash(state);
-                self.__opaque.hash(state);
-            }
-        }
-
-        impl PartialEq for sockaddr_storage {
-            fn eq(&self, other: &sockaddr_storage) -> bool {
-                self.ss_len == other.ss_len
-                    && self.ss_family == other.ss_family
-                    && self
-                        .__ss_pad1
-                        .iter()
-                        .zip(other.__ss_pad1.iter())
-                        .all(|(a, b)| a == b)
-                    && self.__ss_align == other.__ss_align
-                    && self
-                        .__ss_pad2
-                        .iter()
-                        .zip(other.__ss_pad2.iter())
-                        .all(|(a, b)| a == b)
-            }
-        }
-
-        impl Eq for sockaddr_storage {}
-
-        impl hash::Hash for sockaddr_storage {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                self.ss_len.hash(state);
-                self.ss_family.hash(state);
-                self.__ss_pad1.hash(state);
-                self.__ss_align.hash(state);
-                self.__ss_pad2.hash(state);
-            }
-        }
-
-        impl PartialEq for utmpx {
-            fn eq(&self, other: &utmpx) -> bool {
-                self.ut_user
-                    .iter()
-                    .zip(other.ut_user.iter())
-                    .all(|(a, b)| a == b)
-                    && self.ut_id == other.ut_id
-                    && self.ut_line == other.ut_line
-                    && self.ut_pid == other.ut_pid
-                    && self.ut_type == other.ut_type
-                    && self.ut_tv == other.ut_tv
-                    && self
-                        .ut_host
-                        .iter()
-                        .zip(other.ut_host.iter())
-                        .all(|(a, b)| a == b)
-                    && self.ut_pad == other.ut_pad
-            }
-        }
-
-        impl Eq for utmpx {}
-
-        impl hash::Hash for utmpx {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                self.ut_user.hash(state);
-                self.ut_id.hash(state);
-                self.ut_line.hash(state);
-                self.ut_pid.hash(state);
-                self.ut_type.hash(state);
-                self.ut_tv.hash(state);
-                self.ut_host.hash(state);
-                self.ut_pad.hash(state);
-            }
-        }
-
-        impl PartialEq for sigevent {
-            fn eq(&self, other: &sigevent) -> bool {
-                self.sigev_notify == other.sigev_notify
-                    && self.sigev_signo == other.sigev_signo
-                    && self.sigev_value == other.sigev_value
-                    && self.sigev_notify_attributes == other.sigev_notify_attributes
-            }
-        }
-
-        impl Eq for sigevent {}
-
-        impl hash::Hash for sigevent {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
-                self.sigev_notify.hash(state);
-                self.sigev_signo.hash(state);
-                self.sigev_value.hash(state);
-                self.sigev_notify_attributes.hash(state);
-            }
-        }
-
         impl PartialEq for processor_cpu_load_info {
             fn eq(&self, other: &processor_cpu_load_info) -> bool {
                 self.cpu_ticks == other.cpu_ticks