From 129c13c21254ca104bddf020170edaca1fb7107d Mon Sep 17 00:00:00 2001 From: Mica White Date: Wed, 25 Dec 2024 22:49:42 -0500 Subject: Implement common traits --- Cargo.toml | 3 ++- src/collection/boxed.rs | 1 - src/collection/guard.rs | 27 ++++++++++++++++++++++ src/collection/retry.rs | 8 +++---- src/mutex/guard.rs | 58 +++++++++++++++++++++++++++++++++++++++++++++-- src/poisonable.rs | 2 ++ src/poisonable/guard.rs | 53 +++++++++++++++++++++++++++++++++++++++++++ src/rwlock/read_guard.rs | 57 ++++++++++++++++++++++++++++++++++++++++++++++ src/rwlock/write_guard.rs | 57 ++++++++++++++++++++++++++++++++++++++++++++++ 9 files changed, 258 insertions(+), 8 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index b7d06ba..5fb9dbf 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,7 +3,7 @@ name = "happylock" version = "0.3.0" authors = ["Mica White "] edition = "2021" -rust-version = "1.80" +rust-version = "1.82" description = "Free deadlock prevention" documentation = "https://docs.rs/happylock" readme = "README.md" @@ -11,6 +11,7 @@ repository = "https://github.com/botahamec/happylock/" license = "CC0-1.0" keywords = ["deadlock", "mutex", "rwlock"] categories = ["concurrency"] +include = ["src/**/*", "LICENSE", "README.md"] [dependencies] lock_api = "0.4" diff --git a/src/collection/boxed.rs b/src/collection/boxed.rs index fca1db2..2397bd3 100644 --- a/src/collection/boxed.rs +++ b/src/collection/boxed.rs @@ -1,4 +1,3 @@ -use std::alloc::Layout; use std::cell::UnsafeCell; use std::fmt::Debug; use std::marker::PhantomData; diff --git a/src/collection/guard.rs b/src/collection/guard.rs index d604680..fc8df30 100644 --- a/src/collection/guard.rs +++ b/src/collection/guard.rs @@ -1,10 +1,37 @@ use std::fmt::{Debug, Display}; +use std::hash::Hash; use std::ops::{Deref, DerefMut}; use crate::key::Keyable; use super::LockGuard; +impl PartialEq for LockGuard<'_, Guard, Key> { + fn eq(&self, other: &Self) -> bool { + self.guard.eq(&other.guard) + } +} + +impl PartialOrd for LockGuard<'_, Guard, Key> { + fn partial_cmp(&self, other: &Self) -> Option { + self.guard.partial_cmp(&other.guard) + } +} + +impl Eq for LockGuard<'_, Guard, Key> {} + +impl Ord for LockGuard<'_, Guard, Key> { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.guard.cmp(&other.guard) + } +} + +impl Hash for LockGuard<'_, Guard, Key> { + fn hash(&self, state: &mut H) { + self.guard.hash(state) + } +} + impl Debug for LockGuard<'_, Guard, Key> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { Debug::fmt(&**self, f) diff --git a/src/collection/retry.rs b/src/collection/retry.rs index 3f5d471..687c5ec 100644 --- a/src/collection/retry.rs +++ b/src/collection/retry.rs @@ -1,3 +1,7 @@ +use std::cell::RefCell; +use std::collections::HashSet; +use std::marker::PhantomData; + use crate::collection::utils; use crate::handle_unwind::handle_unwind; use crate::lockable::{ @@ -5,10 +9,6 @@ use crate::lockable::{ }; use crate::Keyable; -use std::cell::RefCell; -use std::collections::HashSet; -use std::marker::PhantomData; - use super::{LockGuard, RetryingLockCollection}; /// Get all raw locks in the collection diff --git a/src/mutex/guard.rs b/src/mutex/guard.rs index c255996..b79d90b 100644 --- a/src/mutex/guard.rs +++ b/src/mutex/guard.rs @@ -1,4 +1,5 @@ use std::fmt::{Debug, Display}; +use std::hash::Hash; use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; @@ -9,9 +10,34 @@ use crate::lockable::RawLock; use super::{Mutex, MutexGuard, MutexRef}; +impl PartialEq for MutexRef<'_, T, R> { + fn eq(&self, other: &Self) -> bool { + self.deref().eq(&**other) + } +} + +impl Eq for MutexRef<'_, T, R> {} + +impl PartialOrd for MutexRef<'_, T, R> { + fn partial_cmp(&self, other: &Self) -> Option { + self.deref().partial_cmp(&**other) + } +} + +impl Ord for MutexRef<'_, T, R> { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.deref().cmp(&**other) + } +} + +impl Hash for MutexRef<'_, T, R> { + fn hash(&self, state: &mut H) { + self.deref().hash(state) + } +} + // This makes things slightly easier because now you can use -// `println!("{guard}")` instead of `println!("{}", *guard)`. I wonder if I -// should implement some other standard library traits like this too? +// `println!("{guard}")` instead of `println!("{}", *guard)` impl<'a, T: Debug + ?Sized + 'a, R: RawMutex> Debug for MutexRef<'a, T, R> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { Debug::fmt(&**self, f) @@ -76,6 +102,34 @@ impl<'a, T: ?Sized + 'a, R: RawMutex> MutexRef<'a, T, R> { // it's kinda annoying to re-implement some of this stuff on guards // there's nothing i can do about that +impl PartialEq for MutexGuard<'_, '_, T, Key, R> { + fn eq(&self, other: &Self) -> bool { + self.deref().eq(&**other) + } +} + +impl Eq for MutexGuard<'_, '_, T, Key, R> {} + +impl PartialOrd + for MutexGuard<'_, '_, T, Key, R> +{ + fn partial_cmp(&self, other: &Self) -> Option { + self.deref().partial_cmp(&**other) + } +} + +impl Ord for MutexGuard<'_, '_, T, Key, R> { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.deref().cmp(&**other) + } +} + +impl Hash for MutexGuard<'_, '_, T, Key, R> { + fn hash(&self, state: &mut H) { + self.deref().hash(state) + } +} + impl<'a, 'key, T: Debug + ?Sized + 'a, Key: Keyable + 'key, R: RawMutex> Debug for MutexGuard<'a, 'key, T, Key, R> { diff --git a/src/poisonable.rs b/src/poisonable.rs index f9152d1..6af9f9a 100644 --- a/src/poisonable.rs +++ b/src/poisonable.rs @@ -1,6 +1,8 @@ use std::marker::PhantomData; use std::sync::atomic::AtomicBool; +use crate::Keyable; + mod error; mod flag; mod guard; diff --git a/src/poisonable/guard.rs b/src/poisonable/guard.rs index 6438c2d..97d1c60 100644 --- a/src/poisonable/guard.rs +++ b/src/poisonable/guard.rs @@ -1,4 +1,5 @@ use std::fmt::{Debug, Display}; +use std::hash::Hash; use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; @@ -27,6 +28,32 @@ impl Drop for PoisonRef<'_, Guard> { } } +impl PartialEq for PoisonRef<'_, Guard> { + fn eq(&self, other: &Self) -> bool { + self.guard.eq(&other.guard) + } +} + +impl PartialOrd for PoisonRef<'_, Guard> { + fn partial_cmp(&self, other: &Self) -> Option { + self.guard.partial_cmp(&other.guard) + } +} + +impl Eq for PoisonRef<'_, Guard> {} + +impl Ord for PoisonRef<'_, Guard> { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.guard.cmp(&other.guard) + } +} + +impl Hash for PoisonRef<'_, Guard> { + fn hash(&self, state: &mut H) { + self.guard.hash(state) + } +} + impl Debug for PoisonRef<'_, Guard> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { Debug::fmt(&**self, f) @@ -65,6 +92,32 @@ impl AsMut for PoisonRef<'_, Guard> { } } +impl PartialEq for PoisonGuard<'_, '_, Guard, Key> { + fn eq(&self, other: &Self) -> bool { + self.guard.eq(&other.guard) + } +} + +impl PartialOrd for PoisonGuard<'_, '_, Guard, Key> { + fn partial_cmp(&self, other: &Self) -> Option { + self.guard.partial_cmp(&other.guard) + } +} + +impl Eq for PoisonGuard<'_, '_, Guard, Key> {} + +impl Ord for PoisonGuard<'_, '_, Guard, Key> { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.guard.cmp(&other.guard) + } +} + +impl Hash for PoisonGuard<'_, '_, Guard, Key> { + fn hash(&self, state: &mut H) { + self.guard.hash(state) + } +} + impl Debug for PoisonGuard<'_, '_, Guard, Key> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { Debug::fmt(&self.guard, f) diff --git a/src/rwlock/read_guard.rs b/src/rwlock/read_guard.rs index 0668dca..45d0bd9 100644 --- a/src/rwlock/read_guard.rs +++ b/src/rwlock/read_guard.rs @@ -1,4 +1,5 @@ use std::fmt::{Debug, Display}; +use std::hash::Hash; use std::marker::PhantomData; use std::ops::Deref; @@ -9,6 +10,32 @@ use crate::lockable::RawLock; use super::{RwLock, RwLockReadGuard, RwLockReadRef}; +impl PartialEq for RwLockReadRef<'_, T, R> { + fn eq(&self, other: &Self) -> bool { + self.deref().eq(&**other) + } +} + +impl Eq for RwLockReadRef<'_, T, R> {} + +impl PartialOrd for RwLockReadRef<'_, T, R> { + fn partial_cmp(&self, other: &Self) -> Option { + self.deref().partial_cmp(&**other) + } +} + +impl Ord for RwLockReadRef<'_, T, R> { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.deref().cmp(&**other) + } +} + +impl Hash for RwLockReadRef<'_, T, R> { + fn hash(&self, state: &mut H) { + self.deref().hash(state) + } +} + impl<'a, T: Debug + ?Sized + 'a, R: RawRwLock> Debug for RwLockReadRef<'a, T, R> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { Debug::fmt(&**self, f) @@ -55,6 +82,36 @@ impl<'a, T: ?Sized + 'a, R: RawRwLock> RwLockReadRef<'a, T, R> { } } +impl PartialEq + for RwLockReadGuard<'_, '_, T, Key, R> +{ + fn eq(&self, other: &Self) -> bool { + self.deref().eq(&**other) + } +} + +impl Eq for RwLockReadGuard<'_, '_, T, Key, R> {} + +impl PartialOrd + for RwLockReadGuard<'_, '_, T, Key, R> +{ + fn partial_cmp(&self, other: &Self) -> Option { + self.deref().partial_cmp(&**other) + } +} + +impl Ord for RwLockReadGuard<'_, '_, T, Key, R> { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.deref().cmp(&**other) + } +} + +impl Hash for RwLockReadGuard<'_, '_, T, Key, R> { + fn hash(&self, state: &mut H) { + self.deref().hash(state) + } +} + impl<'a, 'key, T: Debug + ?Sized + 'a, Key: Keyable + 'key, R: RawRwLock> Debug for RwLockReadGuard<'a, 'key, T, Key, R> { diff --git a/src/rwlock/write_guard.rs b/src/rwlock/write_guard.rs index 31ed14a..62f7762 100644 --- a/src/rwlock/write_guard.rs +++ b/src/rwlock/write_guard.rs @@ -1,4 +1,5 @@ use std::fmt::{Debug, Display}; +use std::hash::Hash; use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; @@ -9,6 +10,32 @@ use crate::lockable::RawLock; use super::{RwLock, RwLockWriteGuard, RwLockWriteRef}; +impl PartialEq for RwLockWriteRef<'_, T, R> { + fn eq(&self, other: &Self) -> bool { + self.deref().eq(&**other) + } +} + +impl Eq for RwLockWriteRef<'_, T, R> {} + +impl PartialOrd for RwLockWriteRef<'_, T, R> { + fn partial_cmp(&self, other: &Self) -> Option { + self.deref().partial_cmp(&**other) + } +} + +impl Ord for RwLockWriteRef<'_, T, R> { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.deref().cmp(&**other) + } +} + +impl Hash for RwLockWriteRef<'_, T, R> { + fn hash(&self, state: &mut H) { + self.deref().hash(state) + } +} + impl<'a, T: Debug + ?Sized + 'a, R: RawRwLock> Debug for RwLockWriteRef<'a, T, R> { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { Debug::fmt(&**self, f) @@ -70,6 +97,36 @@ impl<'a, T: ?Sized + 'a, R: RawRwLock> RwLockWriteRef<'a, T, R> { } } +impl PartialEq + for RwLockWriteGuard<'_, '_, T, Key, R> +{ + fn eq(&self, other: &Self) -> bool { + self.deref().eq(&**other) + } +} + +impl Eq for RwLockWriteGuard<'_, '_, T, Key, R> {} + +impl PartialOrd + for RwLockWriteGuard<'_, '_, T, Key, R> +{ + fn partial_cmp(&self, other: &Self) -> Option { + self.deref().partial_cmp(&**other) + } +} + +impl Ord for RwLockWriteGuard<'_, '_, T, Key, R> { + fn cmp(&self, other: &Self) -> std::cmp::Ordering { + self.deref().cmp(&**other) + } +} + +impl Hash for RwLockWriteGuard<'_, '_, T, Key, R> { + fn hash(&self, state: &mut H) { + self.deref().hash(state) + } +} + impl<'a, 'key, T: Debug + ?Sized + 'a, Key: Keyable + 'key, R: RawRwLock> Debug for RwLockWriteGuard<'a, 'key, T, Key, R> { -- cgit v1.2.3