Implement Hash for all types

Author: Susurrus

README.md

@@ -45,8 +45,9 @@ libc = { version = "0.2", features = ["align"] }
 ```
 
 All structs implemented by the libc crate have the `Copy` and `Clone` traits
-implemented for them. The additional traits of `Debug, `Eq`, and `PartialEq`
-can be enabled with the *extra_traits* feature (requires Rust 1.25 or newer):
+implemented for them. The additional traits of `Debug, `Eq`, `Hash`, and
+`PartialEq` can be enabled with the *extra_traits* feature (requires Rust 1.25
+or newer):
 
 ```toml
 [dependencies]

src/macros.rs

@@ -39,7 +39,7 @@ macro_rules! s {
         __item! {
             #[repr(C)]
             $(#[$attr])*
-            #[cfg_attr(feature = "extra_traits", derive(Debug, Eq, PartialEq))]
+            #[cfg_attr(feature = "extra_traits", derive(Debug, Eq, Hash, PartialEq))]
             pub $t $i { $($field)* }
         }
         impl ::dox::Copy for $i {}

src/unix/bsd/apple/b32.rs

@@ -73,6 +73,13 @@ impl std::fmt::Debug for pthread_attr_t {
             .finish()
     }
 }
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for pthread_attr_t {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.__sig.hash(state);
+        self.__opaque.hash(state);
+    }
+}
 
 pub const __PTHREAD_MUTEX_SIZE__: usize = 40;
 pub const __PTHREAD_COND_SIZE__: usize = 24;

src/unix/bsd/apple/b64.rs

@@ -78,6 +78,13 @@ impl std::fmt::Debug for pthread_attr_t {
             .finish()
     }
 }
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for pthread_attr_t {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.__sig.hash(state);
+        self.__opaque.hash(state);
+    }
+}
 
 pub const __PTHREAD_MUTEX_SIZE__: usize = 56;
 pub const __PTHREAD_COND_SIZE__: usize = 40;

src/unix/bsd/apple/mod.rs

@@ -608,6 +608,12 @@ impl std::fmt::Debug for semun {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for semun {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        unsafe { self.val.hash(state) };
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for proc_threadinfo {
     fn eq(&self, other: &proc_threadinfo) -> bool {
         self.pth_user_time == other.pth_user_time
@@ -648,6 +654,22 @@ impl std::fmt::Debug for proc_threadinfo {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for proc_threadinfo {
+    fn hash<H: std::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);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for statfs {
     fn eq(&self, other: &statfs) -> bool {
         self.f_bsize == other.f_bsize
@@ -702,6 +724,27 @@ impl std::fmt::Debug for statfs {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for statfs {
+    fn hash<H: std::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);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for dirent {
     fn eq(&self, other: &dirent) -> bool {
         self.d_ino == other.d_ino
@@ -732,6 +775,17 @@ impl std::fmt::Debug for dirent {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for dirent {
+    fn hash<H: std::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);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for pthread_rwlock_t {
     fn eq(&self, other: &pthread_rwlock_t) -> bool {
         self.__sig == other.__sig
@@ -754,6 +808,13 @@ impl std::fmt::Debug for pthread_rwlock_t {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for pthread_rwlock_t {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.__sig.hash(state);
+        self.__opaque.hash(state);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for pthread_mutex_t {
     fn eq(&self, other: &pthread_mutex_t) -> bool {
         self.__sig == other.__sig
@@ -776,6 +837,13 @@ impl std::fmt::Debug for pthread_mutex_t {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for pthread_mutex_t {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.__sig.hash(state);
+        self.__opaque.hash(state);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for pthread_cond_t {
     fn eq(&self, other: &pthread_cond_t) -> bool {
         self.__sig == other.__sig
@@ -798,6 +866,13 @@ impl std::fmt::Debug for pthread_cond_t {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for pthread_cond_t {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.__sig.hash(state);
+        self.__opaque.hash(state);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for sockaddr_storage {
     fn eq(&self, other: &sockaddr_storage) -> bool {
         self.ss_len == other.ss_len
@@ -830,6 +905,16 @@ impl std::fmt::Debug for sockaddr_storage {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for sockaddr_storage {
+    fn hash<H: std::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);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for utmpx {
     fn eq(&self, other: &utmpx) -> bool {
         self.ut_user
@@ -866,6 +951,19 @@ impl std::fmt::Debug for utmpx {
             .finish()
     }
 }
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for utmpx {
+    fn hash<H: std::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);
+    }
+}
 
 pub const _UTX_USERSIZE: usize = 256;
 pub const _UTX_LINESIZE: usize = 32;

src/unix/bsd/mod.rs

@@ -162,6 +162,14 @@ impl std::fmt::Debug for sockaddr_un {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for sockaddr_un {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.sun_len.hash(state);
+        self.sun_family.hash(state);
+        self.sun_path.hash(state);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for utsname {
     fn eq(&self, other: &utsname) -> bool {
         self.sysname
@@ -204,6 +212,16 @@ impl std::fmt::Debug for utsname {
             .finish()
     }
 }
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for utsname {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.sysname.hash(state);
+        self.nodename.hash(state);
+        self.release.hash(state);
+        self.version.hash(state);
+        self.machine.hash(state);
+    }
+}
 
 pub const LC_ALL: ::c_int = 0;
 pub const LC_COLLATE: ::c_int = 1;

src/unix/notbsd/android/b64/mod.rs

@@ -150,6 +150,13 @@ impl std::fmt::Debug for pthread_mutex_t {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for pthread_mutex_t {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.value.hash(state);
+        self.__reserved.hash(state);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for pthread_cond_t {
     fn eq(&self, other: &pthread_cond_t) -> bool {
         self.value == other.value
@@ -172,6 +179,13 @@ impl std::fmt::Debug for pthread_cond_t {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for pthread_cond_t {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.value.hash(state);
+        self.__reserved.hash(state);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for pthread_rwlock_t {
     fn eq(&self, other: &pthread_rwlock_t) -> bool {
         self.numLocks == other.numLocks
@@ -201,6 +215,17 @@ impl std::fmt::Debug for pthread_rwlock_t {
             .finish()
     }
 }
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for pthread_rwlock_t {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.numLocks.hash(state);
+        self.writerThreadId.hash(state);
+        self.pendingReaders.hash(state);
+        self.pendingWriters.hash(state);
+        self.attr.hash(state);
+        self.__reserved.hash(state);
+    }
+}
 
 pub const RTLD_GLOBAL: ::c_int = 0x00100;
 pub const RTLD_NOW: ::c_int = 2;

src/unix/notbsd/android/mod.rs

@@ -269,6 +269,16 @@ impl std::fmt::Debug for dirent {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for dirent {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.d_ino.hash(state);
+        self.d_off.hash(state);
+        self.d_reclen.hash(state);
+        self.d_type.hash(state);
+        self.d_name.hash(state);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for dirent64 {
     fn eq(&self, other: &dirent64) -> bool {
         self.d_ino == other.d_ino
@@ -297,6 +307,16 @@ impl std::fmt::Debug for dirent64 {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for dirent64 {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.d_ino.hash(state);
+        self.d_off.hash(state);
+        self.d_reclen.hash(state);
+        self.d_type.hash(state);
+        self.d_name.hash(state);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for siginfo_t {
     fn eq(&self, other: &siginfo_t) -> bool {
         self.si_signo == other.si_signo
@@ -321,6 +341,16 @@ impl std::fmt::Debug for siginfo_t {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for siginfo_t {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.si_signo.hash(state);
+        self.si_errno.hash(state);
+        self.si_code.hash(state);
+            // Ignore _pad
+            // Ignore _align
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for lastlog {
     fn eq(&self, other: &lastlog) -> bool {
         self.ll_time == other.ll_time
@@ -349,6 +379,14 @@ impl std::fmt::Debug for lastlog {
     }
 }
 #[cfg(feature = "extra_traits")]
+impl std::hash::Hash for lastlog {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.ll_time.hash(state);
+        self.ll_line.hash(state);
+        self.ll_host.hash(state);
+    }
+}
+#[cfg(feature = "extra_traits")]
 impl PartialEq for utmp {
     fn eq(&self, other: &utmp) -> bool {
         self.ut_type == other.ut_type
@@ -396,6 +434,22 @@ impl std::fmt::Debug for utmp {
             .finish()
     }
 }
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for utmp {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.ut_type.hash(state);
+        self.ut_pid.hash(state);
+        self.ut_line.hash(state);
+        self.ut_id.hash(state);
+        self.ut_user.hash(state);
+        self.ut_host.hash(state);
+        self.ut_exit.hash(state);
+        self.ut_session.hash(state);
+        self.ut_tv.hash(state);
+        self.ut_addr_v6.hash(state);
+        self.unused.hash(state);
+    }
+}
 
 pub const O_TRUNC: ::c_int = 512;
 pub const O_CLOEXEC: ::c_int = 0x80000;