summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/collection.rs9
-rw-r--r--src/collection/boxed.rs293
-rw-r--r--src/collection/guard.rs25
-rw-r--r--src/collection/owned.rs50
-rw-r--r--src/collection/ref.rs33
-rw-r--r--src/collection/retry.rs102
-rw-r--r--src/mutex/guard.rs57
-rw-r--r--src/mutex/mutex.rs12
-rw-r--r--src/rwlock/read_guard.rs43
-rw-r--r--src/rwlock/rwlock.rs12
-rw-r--r--src/rwlock/write_guard.rs28
11 files changed, 606 insertions, 58 deletions
diff --git a/src/collection.rs b/src/collection.rs
index 6623c8a..a84c1ce 100644
--- a/src/collection.rs
+++ b/src/collection.rs
@@ -8,6 +8,7 @@ mod owned;
mod r#ref;
mod retry;
+#[derive(Debug)]
pub struct OwnedLockCollection<L> {
data: L,
}
@@ -17,12 +18,16 @@ pub struct OwnedLockCollection<L> {
/// This could be a tuple of [`Lockable`] types, an array, or a `Vec`. But it
/// can be safely locked without causing a deadlock.
pub struct RefLockCollection<'a, L> {
- locks: Vec<&'a dyn Lock>,
data: &'a L,
+ locks: Vec<&'a dyn Lock>,
}
-pub struct BoxedLockCollection<'a, L: 'a>(RefLockCollection<'a, L>);
+pub struct BoxedLockCollection<L> {
+ data: Box<L>,
+ locks: Vec<&'static dyn Lock>,
+}
+#[derive(Debug)]
pub struct RetryingLockCollection<L> {
data: L,
}
diff --git a/src/collection/boxed.rs b/src/collection/boxed.rs
index 8b67ee9..a62a33d 100644
--- a/src/collection/boxed.rs
+++ b/src/collection/boxed.rs
@@ -1,60 +1,295 @@
-use std::ops::{Deref, DerefMut};
+use std::fmt::Debug;
+use std::marker::PhantomData;
-use crate::{Lockable, OwnedLockable};
+use crate::lockable::Lock;
+use crate::{Keyable, Lockable, OwnedLockable, Sharable};
-use super::{BoxedLockCollection, RefLockCollection};
+use super::{BoxedLockCollection, LockGuard};
-impl<'a, L: 'a> Deref for BoxedLockCollection<'a, L> {
- type Target = RefLockCollection<'a, L>;
+/// returns `true` if the sorted list contains a duplicate
+#[must_use]
+fn contains_duplicates(l: &[&dyn Lock]) -> bool {
+ l.windows(2)
+ .any(|window| std::ptr::eq(window[0], window[1]))
+}
+
+unsafe impl<L: Lockable> Lockable for BoxedLockCollection<L> {
+ type Guard<'g> = L::Guard<'g> where Self: 'g;
+
+ type ReadGuard<'g> = L::ReadGuard<'g> where Self: 'g;
+
+ fn get_ptrs<'a>(&'a self, ptrs: &mut Vec<&'a dyn Lock>) {
+ self.data.get_ptrs(ptrs)
+ }
+
+ unsafe fn guard(&self) -> Self::Guard<'_> {
+ self.data.guard()
+ }
+
+ unsafe fn read_guard(&self) -> Self::ReadGuard<'_> {
+ self.data.read_guard()
+ }
+}
+
+unsafe impl<L: Sharable> Sharable for BoxedLockCollection<L> {}
+
+unsafe impl<L: OwnedLockable> OwnedLockable for BoxedLockCollection<L> {}
+
+impl<L> IntoIterator for BoxedLockCollection<L>
+where
+ L: IntoIterator,
+{
+ type Item = <L as IntoIterator>::Item;
+ type IntoIter = <L as IntoIterator>::IntoIter;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.data.into_iter()
+ }
+}
+
+impl<'a, L> IntoIterator for &'a BoxedLockCollection<L>
+where
+ &'a L: IntoIterator,
+{
+ type Item = <&'a L as IntoIterator>::Item;
+ type IntoIter = <&'a L as IntoIterator>::IntoIter;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.data.into_iter()
+ }
+}
+
+impl<'a, L> IntoIterator for &'a mut BoxedLockCollection<L>
+where
+ &'a mut L: IntoIterator,
+{
+ type Item = <&'a mut L as IntoIterator>::Item;
+ type IntoIter = <&'a mut L as IntoIterator>::IntoIter;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.data.into_iter()
+ }
+}
+
+impl<L: OwnedLockable, I: FromIterator<L> + OwnedLockable> FromIterator<L>
+ for BoxedLockCollection<I>
+{
+ fn from_iter<T: IntoIterator<Item = L>>(iter: T) -> Self {
+ let iter: I = iter.into_iter().collect();
+ Self::new(iter)
+ }
+}
+
+impl<E: OwnedLockable + Extend<L>, L: OwnedLockable> Extend<L> for BoxedLockCollection<E> {
+ fn extend<T: IntoIterator<Item = L>>(&mut self, iter: T) {
+ self.data.extend(iter)
+ }
+}
+
+impl<L> AsRef<L> for BoxedLockCollection<L> {
+ fn as_ref(&self) -> &L {
+ &self.data
+ }
+}
+
+impl<L> AsMut<L> for BoxedLockCollection<L> {
+ fn as_mut(&mut self) -> &mut L {
+ &mut self.data
+ }
+}
- fn deref(&self) -> &Self::Target {
- &self.0
+impl<L: Debug> Debug for BoxedLockCollection<L> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.debug_struct(stringify!(BoxedLockCollection))
+ .field("data", &self.data)
+ .finish_non_exhaustive()
}
}
-impl<'a, L: 'a> DerefMut for BoxedLockCollection<'a, L> {
- fn deref_mut(&mut self) -> &mut Self::Target {
- &mut self.0
+impl<L: OwnedLockable + Default> Default for BoxedLockCollection<L> {
+ fn default() -> Self {
+ Self::new(L::default())
}
}
-impl<'a, L: 'a> Drop for BoxedLockCollection<'a, L> {
- fn drop(&mut self) {
- // this was created with Box::new
- let boxed = unsafe { Box::from_raw((self.0.data as *const L).cast_mut()) };
- drop(boxed);
+impl<L: OwnedLockable + Default> From<L> for BoxedLockCollection<L> {
+ fn from(value: L) -> Self {
+ Self::new(value)
}
}
-impl<'a, L: OwnedLockable + 'a> BoxedLockCollection<'a, L> {
+impl<L: OwnedLockable> BoxedLockCollection<L> {
#[must_use]
pub fn new(data: L) -> Self {
- let boxed = Box::leak(Box::new(data));
- Self(RefLockCollection::new(boxed))
+ // safety: owned lockable types cannot contain duplicates
+ unsafe { Self::new_unchecked(data) }
}
}
-impl<'a, L: OwnedLockable + 'a> BoxedLockCollection<'a, L> {
+impl<'a, L: OwnedLockable> BoxedLockCollection<&'a L> {
#[must_use]
pub fn new_ref(data: &'a L) -> Self {
- let boxed = Box::leak(Box::new(data));
-
- // safety: this is a reference to an OwnedLockable, which can't
- // possibly contain inner duplicates
- Self(unsafe { RefLockCollection::new_unchecked(boxed) })
+ // safety: owned lockable types cannot contain duplicates
+ unsafe { Self::new_unchecked(data) }
}
}
-impl<'a, L: Lockable + 'a> BoxedLockCollection<'a, L> {
+impl<L: Lockable> BoxedLockCollection<L> {
#[must_use]
pub unsafe fn new_unchecked(data: L) -> Self {
- let boxed = Box::leak(Box::new(data));
- Self(RefLockCollection::new_unchecked(boxed))
+ let data = Box::new(data);
+ let mut locks = Vec::new();
+ data.get_ptrs(&mut locks);
+
+ // safety: the box will be dropped after the lock references, so it's
+ // safe to just pretend they're static
+ let locks = std::mem::transmute(locks);
+ Self { data, locks }
}
#[must_use]
pub fn try_new(data: L) -> Option<Self> {
- let boxed = Box::leak(Box::new(data));
- RefLockCollection::try_new(boxed).map(Self)
+ // safety: we are checking for duplicates before returning
+ unsafe {
+ let this = Self::new_unchecked(data);
+ if contains_duplicates(&this.locks) {
+ return None;
+ }
+ Some(this)
+ }
+ }
+
+ #[must_use]
+ pub fn into_inner(self) -> Box<L> {
+ self.data
+ }
+
+ pub fn lock<'g, 'key: 'g, Key: Keyable + 'key>(
+ &'g self,
+ key: Key,
+ ) -> LockGuard<'key, L::Guard<'g>, Key> {
+ for lock in &self.locks {
+ // safety: we have the thread key
+ unsafe { lock.lock() };
+ }
+
+ LockGuard {
+ // safety: we've already acquired the lock
+ guard: unsafe { self.data.guard() },
+ key,
+ _phantom: PhantomData,
+ }
+ }
+
+ pub fn try_lock<'g, 'key: 'g, Key: Keyable + 'key>(
+ &'g self,
+ key: Key,
+ ) -> Option<LockGuard<'key, L::Guard<'g>, Key>> {
+ let guard = unsafe {
+ for (i, lock) in self.locks.iter().enumerate() {
+ // safety: we have the thread key
+ let success = lock.try_lock();
+
+ if !success {
+ for lock in &self.locks[0..i] {
+ // safety: this lock was already acquired
+ lock.unlock();
+ }
+ return None;
+ }
+ }
+
+ // safety: we've acquired the locks
+ self.data.guard()
+ };
+
+ Some(LockGuard {
+ guard,
+ key,
+ _phantom: PhantomData,
+ })
+ }
+
+ pub fn unlock<'key, Key: Keyable + 'key>(guard: LockGuard<'key, L::Guard<'_>, Key>) -> Key {
+ drop(guard.guard);
+ guard.key
+ }
+}
+
+impl<L: Sharable> BoxedLockCollection<L> {
+ pub fn read<'g, 'key: 'g, Key: Keyable + 'key>(
+ &'g self,
+ key: Key,
+ ) -> LockGuard<'key, L::ReadGuard<'g>, Key> {
+ for lock in &self.locks {
+ // safety: we have the thread key
+ unsafe { lock.read() };
+ }
+
+ LockGuard {
+ // safety: we've already acquired the lock
+ guard: unsafe { self.data.read_guard() },
+ key,
+ _phantom: PhantomData,
+ }
+ }
+
+ pub fn try_read<'g, 'key: 'g, Key: Keyable + 'key>(
+ &'g self,
+ key: Key,
+ ) -> Option<LockGuard<'key, L::ReadGuard<'g>, Key>> {
+ let guard = unsafe {
+ for (i, lock) in self.locks.iter().enumerate() {
+ // safety: we have the thread key
+ let success = lock.try_read();
+
+ if !success {
+ for lock in &self.locks[0..i] {
+ // safety: this lock was already acquired
+ lock.unlock_read();
+ }
+ return None;
+ }
+ }
+
+ // safety: we've acquired the locks
+ self.data.read_guard()
+ };
+
+ Some(LockGuard {
+ guard,
+ key,
+ _phantom: PhantomData,
+ })
+ }
+
+ pub fn unlock_read<'key, Key: Keyable + 'key>(
+ guard: LockGuard<'key, L::ReadGuard<'_>, Key>,
+ ) -> Key {
+ drop(guard.guard);
+ guard.key
+ }
+}
+
+impl<'a, L: 'a> BoxedLockCollection<L>
+where
+ &'a L: IntoIterator,
+{
+ /// Returns an iterator over references to each value in the collection.
+ #[must_use]
+ pub fn iter(&'a self) -> <&'a L as IntoIterator>::IntoIter {
+ self.into_iter()
+ }
+}
+
+impl<'a, L: 'a> BoxedLockCollection<L>
+where
+ &'a mut L: IntoIterator,
+{
+ /// Returns an iterator over mutable references to each value in the
+ /// collection.
+ #[must_use]
+ pub fn iter_mut(&'a mut self) -> <&'a mut L as IntoIterator>::IntoIter {
+ self.into_iter()
}
}
diff --git a/src/collection/guard.rs b/src/collection/guard.rs
index b8561eb..8857c5f 100644
--- a/src/collection/guard.rs
+++ b/src/collection/guard.rs
@@ -1,9 +1,22 @@
+use std::fmt::{Debug, Display};
use std::ops::{Deref, DerefMut};
use crate::key::Keyable;
use super::LockGuard;
+impl<'key, Guard: Debug, Key: Keyable> Debug for LockGuard<'key, Guard, Key> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ Debug::fmt(&**self, f)
+ }
+}
+
+impl<'key, Guard: Display, Key: Keyable> Display for LockGuard<'key, Guard, Key> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ Display::fmt(&**self, f)
+ }
+}
+
impl<'key, Guard, Key: Keyable> Deref for LockGuard<'key, Guard, Key> {
type Target = Guard;
@@ -17,3 +30,15 @@ impl<'key, Guard, Key: Keyable> DerefMut for LockGuard<'key, Guard, Key> {
&mut self.guard
}
}
+
+impl<'key, Guard, Key: Keyable> AsRef<Guard> for LockGuard<'key, Guard, Key> {
+ fn as_ref(&self) -> &Guard {
+ &self.guard
+ }
+}
+
+impl<'key, Guard, Key: Keyable> AsMut<Guard> for LockGuard<'key, Guard, Key> {
+ fn as_mut(&mut self) -> &mut Guard {
+ &mut self.guard
+ }
+}
diff --git a/src/collection/owned.rs b/src/collection/owned.rs
index 3415ac4..eb5e03a 100644
--- a/src/collection/owned.rs
+++ b/src/collection/owned.rs
@@ -32,12 +32,62 @@ unsafe impl<L: Sharable> Sharable for OwnedLockCollection<L> {}
unsafe impl<L: OwnedLockable> OwnedLockable for OwnedLockCollection<L> {}
+impl<L> IntoIterator for OwnedLockCollection<L>
+where
+ L: IntoIterator,
+{
+ type Item = <L as IntoIterator>::Item;
+ type IntoIter = <L as IntoIterator>::IntoIter;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.data.into_iter()
+ }
+}
+
+impl<L: OwnedLockable, I: FromIterator<L> + OwnedLockable> FromIterator<L>
+ for OwnedLockCollection<I>
+{
+ fn from_iter<T: IntoIterator<Item = L>>(iter: T) -> Self {
+ let iter: I = iter.into_iter().collect();
+ Self::new(iter)
+ }
+}
+
+impl<E: OwnedLockable + Extend<L>, L: OwnedLockable> Extend<L> for OwnedLockCollection<E> {
+ fn extend<T: IntoIterator<Item = L>>(&mut self, iter: T) {
+ self.data.extend(iter)
+ }
+}
+
+impl<L: OwnedLockable> AsMut<L> for OwnedLockCollection<L> {
+ fn as_mut(&mut self) -> &mut L {
+ &mut self.data
+ }
+}
+
+impl<L: OwnedLockable + Default> Default for OwnedLockCollection<L> {
+ fn default() -> Self {
+ Self::new(L::default())
+ }
+}
+
+impl<L: OwnedLockable + Default> From<L> for OwnedLockCollection<L> {
+ fn from(value: L) -> Self {
+ Self::new(value)
+ }
+}
+
impl<L: OwnedLockable> OwnedLockCollection<L> {
#[must_use]
pub const fn new(data: L) -> Self {
Self { data }
}
+ #[must_use]
+ pub fn into_inner(self) -> L {
+ self.data
+ }
+
pub fn lock<'g, 'key, Key: Keyable + 'key>(
&'g self,
key: Key,
diff --git a/src/collection/ref.rs b/src/collection/ref.rs
index da18c62..329f0ae 100644
--- a/src/collection/ref.rs
+++ b/src/collection/ref.rs
@@ -1,3 +1,4 @@
+use std::fmt::Debug;
use std::marker::PhantomData;
use crate::{key::Keyable, lockable::Lock, Lockable, OwnedLockable, Sharable};
@@ -5,7 +6,7 @@ use crate::{key::Keyable, lockable::Lock, Lockable, OwnedLockable, Sharable};
use super::{LockGuard, RefLockCollection};
#[must_use]
-fn get_locks<L: Lockable>(data: &L) -> Vec<&dyn Lock> {
+pub fn get_locks<L: Lockable>(data: &L) -> Vec<&dyn Lock> {
let mut locks = Vec::new();
data.get_ptrs(&mut locks);
locks.sort_by_key(|lock| std::ptr::from_ref(*lock));
@@ -19,24 +20,12 @@ fn contains_duplicates(l: &[&dyn Lock]) -> bool {
.any(|window| std::ptr::eq(window[0], window[1]))
}
-impl<'a, L: Lockable> AsRef<L> for RefLockCollection<'a, L> {
+impl<'a, L> AsRef<L> for RefLockCollection<'a, L> {
fn as_ref(&self) -> &L {
self.data
}
}
-impl<'a, L: Lockable> AsRef<Self> for RefLockCollection<'a, L> {
- fn as_ref(&self) -> &Self {
- self
- }
-}
-
-impl<'a, L: Lockable> AsMut<Self> for RefLockCollection<'a, L> {
- fn as_mut(&mut self) -> &mut Self {
- self
- }
-}
-
impl<'a, L> IntoIterator for &'a RefLockCollection<'a, L>
where
&'a L: IntoIterator,
@@ -69,6 +58,20 @@ unsafe impl<'c, L: Lockable> Lockable for RefLockCollection<'c, L> {
unsafe impl<'c, L: Sharable> Sharable for RefLockCollection<'c, L> {}
+impl<'a, L: Debug> Debug for RefLockCollection<'a, L> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.debug_struct(stringify!(RefLockCollection))
+ .field("data", self.data)
+ .finish_non_exhaustive()
+ }
+}
+
+impl<'a, L: OwnedLockable + Default> From<&'a L> for RefLockCollection<'a, L> {
+ fn from(value: &'a L) -> Self {
+ Self::new(value)
+ }
+}
+
impl<'a, L: OwnedLockable> RefLockCollection<'a, L> {
/// Creates a new collection of owned locks.
///
@@ -142,7 +145,7 @@ impl<'a, L: Lockable> RefLockCollection<'a, L> {
return None;
}
- Some(Self { locks, data })
+ Some(Self { data, locks })
}
/// Locks the collection
diff --git a/src/collection/retry.rs b/src/collection/retry.rs
index 3000f8b..58a0642 100644
--- a/src/collection/retry.rs
+++ b/src/collection/retry.rs
@@ -41,6 +41,81 @@ unsafe impl<L: Sharable> Sharable for RetryingLockCollection<L> {}
unsafe impl<L: OwnedLockable> OwnedLockable for RetryingLockCollection<L> {}
+impl<L> IntoIterator for RetryingLockCollection<L>
+where
+ L: IntoIterator,
+{
+ type Item = <L as IntoIterator>::Item;
+ type IntoIter = <L as IntoIterator>::IntoIter;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.data.into_iter()
+ }
+}
+
+impl<'a, L> IntoIterator for &'a RetryingLockCollection<L>
+where
+ &'a L: IntoIterator,
+{
+ type Item = <&'a L as IntoIterator>::Item;
+ type IntoIter = <&'a L as IntoIterator>::IntoIter;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.data.into_iter()
+ }
+}
+
+impl<'a, L> IntoIterator for &'a mut RetryingLockCollection<L>
+where
+ &'a mut L: IntoIterator,
+{
+ type Item = <&'a mut L as IntoIterator>::Item;
+ type IntoIter = <&'a mut L as IntoIterator>::IntoIter;
+
+ fn into_iter(self) -> Self::IntoIter {
+ self.data.into_iter()
+ }
+}
+
+impl<L: OwnedLockable, I: FromIterator<L> + OwnedLockable> FromIterator<L>
+ for RetryingLockCollection<I>
+{
+ fn from_iter<T: IntoIterator<Item = L>>(iter: T) -> Self {
+ let iter: I = iter.into_iter().collect();
+ Self::new(iter)
+ }
+}
+
+impl<E: OwnedLockable + Extend<L>, L: OwnedLockable> Extend<L> for RetryingLockCollection<E> {
+ fn extend<T: IntoIterator<Item = L>>(&mut self, iter: T) {
+ self.data.extend(iter)
+ }
+}
+
+impl<L> AsRef<L> for RetryingLockCollection<L> {
+ fn as_ref(&self) -> &L {
+ &self.data
+ }
+}
+
+impl<L> AsMut<L> for RetryingLockCollection<L> {
+ fn as_mut(&mut self) -> &mut L {
+ &mut self.data
+ }
+}
+
+impl<L: OwnedLockable + Default> Default for RetryingLockCollection<L> {
+ fn default() -> Self {
+ Self::new(L::default())
+ }
+}
+
+impl<L: OwnedLockable> From<L> for RetryingLockCollection<L> {
+ fn from(value: L) -> Self {
+ Self::new(value)
+ }
+}
+
impl<L: OwnedLockable> RetryingLockCollection<L> {
#[must_use]
pub const fn new(data: L) -> Self {
@@ -65,6 +140,10 @@ impl<L: Lockable> RetryingLockCollection<L> {
contains_duplicates(&data).then_some(Self { data })
}
+ pub fn into_inner(self) -> L {
+ self.data
+ }
+
pub fn lock<'g, 'key: 'g, Key: Keyable + 'key>(
&'g self,
key: Key,
@@ -269,3 +348,26 @@ impl<L: Sharable> RetryingLockCollection<L> {
guard.key
}
}
+
+impl<'a, L: 'a> RetryingLockCollection<L>
+where
+ &'a L: IntoIterator,
+{
+ /// Returns an iterator over references to each value in the collection.
+ #[must_use]
+ pub fn iter(&'a self) -> <&'a L as IntoIterator>::IntoIter {
+ self.into_iter()
+ }
+}
+
+impl<'a, L: 'a> RetryingLockCollection<L>
+where
+ &'a mut L: IntoIterator,
+{
+ /// Returns an iterator over mutable references to each value in the
+ /// collection.
+ #[must_use]
+ pub fn iter_mut(&'a mut self) -> <&'a mut L as IntoIterator>::IntoIter {
+ self.into_iter()
+ }
+}
diff --git a/src/mutex/guard.rs b/src/mutex/guard.rs
index 38ea125..35fe1f2 100644
--- a/src/mutex/guard.rs
+++ b/src/mutex/guard.rs
@@ -1,3 +1,4 @@
+use std::fmt::{Debug, Display};
use std::marker::PhantomData;
use std::ops::{Deref, DerefMut};
@@ -7,6 +8,18 @@ use crate::key::Keyable;
use super::{Mutex, MutexGuard, MutexRef};
+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)
+ }
+}
+
+impl<'a, T: Display + ?Sized + 'a, R: RawMutex> Display for MutexRef<'a, T, R> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ Display::fmt(&**self, f)
+ }
+}
+
impl<'a, T: ?Sized + 'a, R: RawMutex> Drop for MutexRef<'a, T, R> {
fn drop(&mut self) {
// safety: this guard is being destroyed, so the data cannot be
@@ -35,12 +48,40 @@ impl<'a, T: ?Sized + 'a, R: RawMutex> DerefMut for MutexRef<'a, T, R> {
}
}
+impl<'a, T: ?Sized + 'a, R: RawMutex> AsRef<T> for MutexRef<'a, T, R> {
+ fn as_ref(&self) -> &T {
+ self
+ }
+}
+
+impl<'a, T: ?Sized + 'a, R: RawMutex> AsMut<T> for MutexRef<'a, T, R> {
+ fn as_mut(&mut self) -> &mut T {
+ self
+ }
+}
+
impl<'a, T: ?Sized + 'a, R: RawMutex> MutexRef<'a, T, R> {
pub unsafe fn new(mutex: &'a Mutex<T, R>) -> Self {
Self(mutex, PhantomData)
}
}
+impl<'a, 'key, T: Debug + ?Sized + 'a, Key: Keyable + 'key, R: RawMutex> Debug
+ for MutexGuard<'a, 'key, T, Key, R>
+{
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ Debug::fmt(&**self, f)
+ }
+}
+
+impl<'a, 'key, T: Display + ?Sized + 'a, Key: Keyable + 'key, R: RawMutex> Display
+ for MutexGuard<'a, 'key, T, Key, R>
+{
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ Display::fmt(&**self, f)
+ }
+}
+
impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawMutex> Deref
for MutexGuard<'a, 'key, T, Key, R>
{
@@ -59,6 +100,22 @@ impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawMutex> DerefMut
}
}
+impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawMutex> AsRef<T>
+ for MutexGuard<'a, 'key, T, Key, R>
+{
+ fn as_ref(&self) -> &T {
+ self
+ }
+}
+
+impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawMutex> AsMut<T>
+ for MutexGuard<'a, 'key, T, Key, R>
+{
+ fn as_mut(&mut self) -> &mut T {
+ self
+ }
+}
+
impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawMutex> MutexGuard<'a, 'key, T, Key, R> {
/// Create a guard to the given mutex. Undefined if multiple guards to the
/// same mutex exist at once.
diff --git a/src/mutex/mutex.rs b/src/mutex/mutex.rs
index 3b8c221..52b6081 100644
--- a/src/mutex/mutex.rs
+++ b/src/mutex/mutex.rs
@@ -43,12 +43,6 @@ impl<T, R: RawMutex> Mutex<T, R> {
}
}
-impl<T: ?Sized + Default, R: RawMutex> Default for Mutex<T, R> {
- fn default() -> Self {
- Self::new(T::default())
- }
-}
-
impl<T: ?Sized + Debug, R: RawMutex> Debug for Mutex<T, R> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
// safety: this is just a try lock, and the value is dropped
@@ -71,6 +65,12 @@ impl<T: ?Sized + Debug, R: RawMutex> Debug for Mutex<T, R> {
}
}
+impl<T: ?Sized + Default, R: RawMutex> Default for Mutex<T, R> {
+ fn default() -> Self {
+ Self::new(T::default())
+ }
+}
+
impl<T, R: RawMutex> From<T> for Mutex<T, R> {
fn from(value: T) -> Self {
Self::new(value)
diff --git a/src/rwlock/read_guard.rs b/src/rwlock/read_guard.rs
index 8428987..da3d101 100644
--- a/src/rwlock/read_guard.rs
+++ b/src/rwlock/read_guard.rs
@@ -1,3 +1,4 @@
+use std::fmt::{Debug, Display};
use std::marker::PhantomData;
use std::ops::Deref;
@@ -7,6 +8,18 @@ use crate::key::Keyable;
use super::{RwLock, RwLockReadGuard, RwLockReadRef};
+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)
+ }
+}
+
+impl<'a, T: Display + ?Sized + 'a, R: RawRwLock> Display for RwLockReadRef<'a, T, R> {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ Display::fmt(&**self, f)
+ }
+}
+
impl<'a, T: ?Sized + 'a, R: RawRwLock> Deref for RwLockReadRef<'a, T, R> {
type Target = T;
@@ -18,6 +31,12 @@ impl<'a, T: ?Sized + 'a, R: RawRwLock> Deref for RwLockReadRef<'a, T, R> {
}
}
+impl<'a, T: ?Sized + 'a, R: RawRwLock> AsRef<T> for RwLockReadRef<'a, T, R> {
+ fn as_ref(&self) -> &T {
+ self
+ }
+}
+
impl<'a, T: ?Sized + 'a, R: RawRwLock> Drop for RwLockReadRef<'a, T, R> {
fn drop(&mut self) {
// safety: this guard is being destroyed, so the data cannot be
@@ -32,6 +51,22 @@ impl<'a, T: ?Sized + 'a, R: RawRwLock> RwLockReadRef<'a, T, R> {
}
}
+impl<'a, 'key, T: Debug + ?Sized + 'a, Key: Keyable + 'key, R: RawRwLock> Debug
+ for RwLockReadGuard<'a, 'key, T, Key, R>
+{
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ Debug::fmt(&**self, f)
+ }
+}
+
+impl<'a, 'key, T: Display + ?Sized + 'a, Key: Keyable + 'key, R: RawRwLock> Display
+ for RwLockReadGuard<'a, 'key, T, Key, R>
+{
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ Display::fmt(&**self, f)
+ }
+}
+
impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawRwLock> Deref
for RwLockReadGuard<'a, 'key, T, Key, R>
{
@@ -42,6 +77,14 @@ impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawRwLock> Deref
}
}
+impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawRwLock> AsRef<T>
+ for RwLockReadGuard<'a, 'key, T, Key, R>
+{
+ fn as_ref(&self) -> &T {
+ self
+ }
+}
+
impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawRwLock>
RwLockReadGuard<'a, 'key, T, Key, R>
{
diff --git a/src/rwlock/rwlock.rs b/src/rwlock/rwlock.rs
index 7070b0e..9a7590a 100644
--- a/src/rwlock/rwlock.rs
+++ b/src/rwlock/rwlock.rs
@@ -40,12 +40,6 @@ impl<T, R: RawRwLock> RwLock<T, R> {
}
}
-impl<T: ?Sized + Default, R: RawRwLock> Default for RwLock<T, R> {
- fn default() -> Self {
- Self::new(T::default())
- }
-}
-
impl<T: ?Sized + Debug, R: RawRwLock> Debug for RwLock<T, R> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
// safety: this is just a try lock, and the value is dropped
@@ -68,6 +62,12 @@ impl<T: ?Sized + Debug, R: RawRwLock> Debug for RwLock<T, R> {
}
}
+impl<T: ?Sized + Default, R: RawRwLock> Default for RwLock<T, R> {
+ fn default() -> Self {
+ Self::new(T::default())
+ }
+}
+
impl<T, R: RawRwLock> From<T> for RwLock<T, R> {
fn from(value: T) -> Self {
Self::new(value)
diff --git a/src/rwlock/write_guard.rs b/src/rwlock/write_guard.rs
index 16b474e..c8dd58b 100644
--- a/src/rwlock/write_guard.rs
+++ b/src/rwlock/write_guard.rs
@@ -27,6 +27,18 @@ impl<'a, T: ?Sized + 'a, R: RawRwLock> DerefMut for RwLockWriteRef<'a, T, R> {
}
}
+impl<'a, T: ?Sized + 'a, R: RawRwLock> AsRef<T> for RwLockWriteRef<'a, T, R> {
+ fn as_ref(&self) -> &T {
+ self
+ }
+}
+
+impl<'a, T: ?Sized + 'a, R: RawRwLock> AsMut<T> for RwLockWriteRef<'a, T, R> {
+ fn as_mut(&mut self) -> &mut T {
+ self
+ }
+}
+
impl<'a, T: ?Sized + 'a, R: RawRwLock> Drop for RwLockWriteRef<'a, T, R> {
fn drop(&mut self) {
// safety: this guard is being destroyed, so the data cannot be
@@ -59,6 +71,22 @@ impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawRwLock> DerefMut
}
}
+impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawRwLock> AsRef<T>
+ for RwLockWriteGuard<'a, 'key, T, Key, R>
+{
+ fn as_ref(&self) -> &T {
+ self
+ }
+}
+
+impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawRwLock> AsMut<T>
+ for RwLockWriteGuard<'a, 'key, T, Key, R>
+{
+ fn as_mut(&mut self) -> &mut T {
+ self
+ }
+}
+
impl<'a, 'key: 'a, T: ?Sized + 'a, Key: Keyable, R: RawRwLock>
RwLockWriteGuard<'a, 'key, T, Key, R>
{
generated by cgit v1.2.3 (git 2.39.1) at 2026-03-04 06:07:04 +0000