summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/collection/boxed.rs1
-rw-r--r--src/collection/guard.rs27
-rw-r--r--src/collection/retry.rs8
-rw-r--r--src/mutex/guard.rs58
-rw-r--r--src/poisonable.rs2
-rw-r--r--src/poisonable/guard.rs53
-rw-r--r--src/rwlock/read_guard.rs57
-rw-r--r--src/rwlock/write_guard.rs57
8 files changed, 256 insertions, 7 deletions
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<Guard: PartialEq, Key: Keyable> PartialEq for LockGuard<'_, Guard, Key> {
+ fn eq(&self, other: &Self) -> bool {
+ self.guard.eq(&other.guard)
+ }
+}
+
+impl<Guard: PartialOrd, Key: Keyable> PartialOrd for LockGuard<'_, Guard, Key> {
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ self.guard.partial_cmp(&other.guard)
+ }
+}
+
+impl<Guard: Eq, Key: Keyable> Eq for LockGuard<'_, Guard, Key> {}
+
+impl<Guard: Ord, Key: Keyable> Ord for LockGuard<'_, Guard, Key> {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.guard.cmp(&other.guard)
+ }
+}
+
+impl<Guard: Hash, Key: Keyable> Hash for LockGuard<'_, Guard, Key> {
+ fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+ self.guard.hash(state)
+ }
+}
+
impl<Guard: Debug, Key: Keyable> 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<T: PartialEq + ?Sized, R: RawMutex> PartialEq for MutexRef<'_, T, R> {
+ fn eq(&self, other: &Self) -> bool {
+ self.deref().eq(&**other)
+ }
+}
+
+impl<T: Eq + ?Sized, R: RawMutex> Eq for MutexRef<'_, T, R> {}
+
+impl<T: PartialOrd + ?Sized, R: RawMutex> PartialOrd for MutexRef<'_, T, R> {
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ self.deref().partial_cmp(&**other)
+ }
+}
+
+impl<T: Ord + ?Sized, R: RawMutex> Ord for MutexRef<'_, T, R> {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.deref().cmp(&**other)
+ }
+}
+
+impl<T: Hash + ?Sized, R: RawMutex> Hash for MutexRef<'_, T, R> {
+ fn hash<H: std::hash::Hasher>(&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<T: PartialEq + ?Sized, R: RawMutex, Key: Keyable> PartialEq for MutexGuard<'_, '_, T, Key, R> {
+ fn eq(&self, other: &Self) -> bool {
+ self.deref().eq(&**other)
+ }
+}
+
+impl<T: Eq + ?Sized, R: RawMutex, Key: Keyable> Eq for MutexGuard<'_, '_, T, Key, R> {}
+
+impl<T: PartialOrd + ?Sized, R: RawMutex, Key: Keyable> PartialOrd
+ for MutexGuard<'_, '_, T, Key, R>
+{
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ self.deref().partial_cmp(&**other)
+ }
+}
+
+impl<T: Ord + ?Sized, R: RawMutex, Key: Keyable> Ord for MutexGuard<'_, '_, T, Key, R> {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.deref().cmp(&**other)
+ }
+}
+
+impl<T: Hash + ?Sized, R: RawMutex, Key: Keyable> Hash for MutexGuard<'_, '_, T, Key, R> {
+ fn hash<H: std::hash::Hasher>(&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<Guard> Drop for PoisonRef<'_, Guard> {
}
}
+impl<Guard: PartialEq> PartialEq for PoisonRef<'_, Guard> {
+ fn eq(&self, other: &Self) -> bool {
+ self.guard.eq(&other.guard)
+ }
+}
+
+impl<Guard: PartialOrd> PartialOrd for PoisonRef<'_, Guard> {
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ self.guard.partial_cmp(&other.guard)
+ }
+}
+
+impl<Guard: Eq> Eq for PoisonRef<'_, Guard> {}
+
+impl<Guard: Ord> Ord for PoisonRef<'_, Guard> {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.guard.cmp(&other.guard)
+ }
+}
+
+impl<Guard: Hash> Hash for PoisonRef<'_, Guard> {
+ fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+ self.guard.hash(state)
+ }
+}
+
impl<Guard: Debug> Debug for PoisonRef<'_, Guard> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
Debug::fmt(&**self, f)
@@ -65,6 +92,32 @@ impl<Guard> AsMut<Guard> for PoisonRef<'_, Guard> {
}
}
+impl<Guard: PartialEq, Key: Keyable> PartialEq for PoisonGuard<'_, '_, Guard, Key> {
+ fn eq(&self, other: &Self) -> bool {
+ self.guard.eq(&other.guard)
+ }
+}
+
+impl<Guard: PartialOrd, Key: Keyable> PartialOrd for PoisonGuard<'_, '_, Guard, Key> {
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ self.guard.partial_cmp(&other.guard)
+ }
+}
+
+impl<Guard: Eq, Key: Keyable> Eq for PoisonGuard<'_, '_, Guard, Key> {}
+
+impl<Guard: Ord, Key: Keyable> Ord for PoisonGuard<'_, '_, Guard, Key> {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.guard.cmp(&other.guard)
+ }
+}
+
+impl<Guard: Hash, Key: Keyable> Hash for PoisonGuard<'_, '_, Guard, Key> {
+ fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+ self.guard.hash(state)
+ }
+}
+
impl<Guard: Debug, Key: Keyable> 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<T: PartialEq + ?Sized, R: RawRwLock> PartialEq for RwLockReadRef<'_, T, R> {
+ fn eq(&self, other: &Self) -> bool {
+ self.deref().eq(&**other)
+ }
+}
+
+impl<T: Eq + ?Sized, R: RawRwLock> Eq for RwLockReadRef<'_, T, R> {}
+
+impl<T: PartialOrd + ?Sized, R: RawRwLock> PartialOrd for RwLockReadRef<'_, T, R> {
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ self.deref().partial_cmp(&**other)
+ }
+}
+
+impl<T: Ord + ?Sized, R: RawRwLock> Ord for RwLockReadRef<'_, T, R> {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.deref().cmp(&**other)
+ }
+}
+
+impl<T: Hash + ?Sized, R: RawRwLock> Hash for RwLockReadRef<'_, T, R> {
+ fn hash<H: std::hash::Hasher>(&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<T: PartialEq + ?Sized, R: RawRwLock, Key: Keyable> PartialEq
+ for RwLockReadGuard<'_, '_, T, Key, R>
+{
+ fn eq(&self, other: &Self) -> bool {
+ self.deref().eq(&**other)
+ }
+}
+
+impl<T: Eq + ?Sized, R: RawRwLock, Key: Keyable> Eq for RwLockReadGuard<'_, '_, T, Key, R> {}
+
+impl<T: PartialOrd + ?Sized, R: RawRwLock, Key: Keyable> PartialOrd
+ for RwLockReadGuard<'_, '_, T, Key, R>
+{
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ self.deref().partial_cmp(&**other)
+ }
+}
+
+impl<T: Ord + ?Sized, R: RawRwLock, Key: Keyable> Ord for RwLockReadGuard<'_, '_, T, Key, R> {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.deref().cmp(&**other)
+ }
+}
+
+impl<T: Hash + ?Sized, R: RawRwLock, Key: Keyable> Hash for RwLockReadGuard<'_, '_, T, Key, R> {
+ fn hash<H: std::hash::Hasher>(&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<T: PartialEq + ?Sized, R: RawRwLock> PartialEq for RwLockWriteRef<'_, T, R> {
+ fn eq(&self, other: &Self) -> bool {
+ self.deref().eq(&**other)
+ }
+}
+
+impl<T: Eq + ?Sized, R: RawRwLock> Eq for RwLockWriteRef<'_, T, R> {}
+
+impl<T: PartialOrd + ?Sized, R: RawRwLock> PartialOrd for RwLockWriteRef<'_, T, R> {
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ self.deref().partial_cmp(&**other)
+ }
+}
+
+impl<T: Ord + ?Sized, R: RawRwLock> Ord for RwLockWriteRef<'_, T, R> {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.deref().cmp(&**other)
+ }
+}
+
+impl<T: Hash + ?Sized, R: RawRwLock> Hash for RwLockWriteRef<'_, T, R> {
+ fn hash<H: std::hash::Hasher>(&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<T: PartialEq + ?Sized, R: RawRwLock, Key: Keyable> PartialEq
+ for RwLockWriteGuard<'_, '_, T, Key, R>
+{
+ fn eq(&self, other: &Self) -> bool {
+ self.deref().eq(&**other)
+ }
+}
+
+impl<T: Eq + ?Sized, R: RawRwLock, Key: Keyable> Eq for RwLockWriteGuard<'_, '_, T, Key, R> {}
+
+impl<T: PartialOrd + ?Sized, R: RawRwLock, Key: Keyable> PartialOrd
+ for RwLockWriteGuard<'_, '_, T, Key, R>
+{
+ fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+ self.deref().partial_cmp(&**other)
+ }
+}
+
+impl<T: Ord + ?Sized, R: RawRwLock, Key: Keyable> Ord for RwLockWriteGuard<'_, '_, T, Key, R> {
+ fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+ self.deref().cmp(&**other)
+ }
+}
+
+impl<T: Hash + ?Sized, R: RawRwLock, Key: Keyable> Hash for RwLockWriteGuard<'_, '_, T, Key, R> {
+ fn hash<H: std::hash::Hasher>(&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>
{
generated by cgit v1.2.3 (git 2.39.1) at 2026-03-04 07:40:54 +0000