summaryrefslogtreecommitdiff
path: root/src/collection
diff options
context:
space:
mode:
Diffstat (limited to 'src/collection')
-rw-r--r--src/collection/boxed.rs (renamed from src/collection/boxed_collection.rs)12
-rw-r--r--src/collection/guard.rs8
-rw-r--r--src/collection/owned.rs158
-rw-r--r--src/collection/owned_collection.rs65
-rw-r--r--src/collection/ref.rs (renamed from src/collection/ref_collection.rs)31
-rw-r--r--src/collection/retry.rs271
-rw-r--r--src/collection/retry_collection.rs138
7 files changed, 466 insertions, 217 deletions
diff --git a/src/collection/boxed_collection.rs b/src/collection/boxed.rs
index 1aae1e4..8b67ee9 100644
--- a/src/collection/boxed_collection.rs
+++ b/src/collection/boxed.rs
@@ -4,7 +4,7 @@ use crate::{Lockable, OwnedLockable};
use super::{BoxedLockCollection, RefLockCollection};
-impl<'a, L> Deref for BoxedLockCollection<'a, L> {
+impl<'a, L: 'a> Deref for BoxedLockCollection<'a, L> {
type Target = RefLockCollection<'a, L>;
fn deref(&self) -> &Self::Target {
@@ -12,13 +12,13 @@ impl<'a, L> Deref for BoxedLockCollection<'a, L> {
}
}
-impl<'a, L> DerefMut for BoxedLockCollection<'a, L> {
+impl<'a, L: 'a> DerefMut for BoxedLockCollection<'a, L> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.0
}
}
-impl<'a, L> Drop for BoxedLockCollection<'a, L> {
+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()) };
@@ -26,7 +26,7 @@ impl<'a, L> Drop for BoxedLockCollection<'a, L> {
}
}
-impl<'a, L: OwnedLockable> BoxedLockCollection<'a, L> {
+impl<'a, L: OwnedLockable + 'a> BoxedLockCollection<'a, L> {
#[must_use]
pub fn new(data: L) -> Self {
let boxed = Box::leak(Box::new(data));
@@ -34,7 +34,7 @@ impl<'a, L: OwnedLockable> BoxedLockCollection<'a, L> {
}
}
-impl<'a, L: OwnedLockable> BoxedLockCollection<'a, &'a L> {
+impl<'a, L: OwnedLockable + 'a> BoxedLockCollection<'a, L> {
#[must_use]
pub fn new_ref(data: &'a L) -> Self {
let boxed = Box::leak(Box::new(data));
@@ -45,7 +45,7 @@ impl<'a, L: OwnedLockable> BoxedLockCollection<'a, &'a L> {
}
}
-impl<'a, L: Lockable> BoxedLockCollection<'a, L> {
+impl<'a, L: Lockable + 'a> BoxedLockCollection<'a, L> {
#[must_use]
pub unsafe fn new_unchecked(data: L) -> Self {
let boxed = Box::leak(Box::new(data));
diff --git a/src/collection/guard.rs b/src/collection/guard.rs
index e3ffb21..b8561eb 100644
--- a/src/collection/guard.rs
+++ b/src/collection/guard.rs
@@ -1,18 +1,18 @@
use std::ops::{Deref, DerefMut};
-use crate::{key::Keyable, Lockable};
+use crate::key::Keyable;
use super::LockGuard;
-impl<'a, 'key: 'a, L: Lockable + 'a, Key: Keyable> Deref for LockGuard<'a, 'key, L, Key> {
- type Target = L::Guard<'a>;
+impl<'key, Guard, Key: Keyable> Deref for LockGuard<'key, Guard, Key> {
+ type Target = Guard;
fn deref(&self) -> &Self::Target {
&self.guard
}
}
-impl<'a, 'key: 'a, L: Lockable + 'a, Key: Keyable> DerefMut for LockGuard<'a, 'key, L, Key> {
+impl<'key, Guard, Key: Keyable> DerefMut for LockGuard<'key, Guard, Key> {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.guard
}
diff --git a/src/collection/owned.rs b/src/collection/owned.rs
new file mode 100644
index 0000000..3415ac4
--- /dev/null
+++ b/src/collection/owned.rs
@@ -0,0 +1,158 @@
+use std::marker::PhantomData;
+
+use crate::{lockable::Lock, Keyable, Lockable, OwnedLockable, Sharable};
+
+use super::{LockGuard, OwnedLockCollection};
+
+fn get_locks<L: Lockable>(data: &L) -> Vec<&dyn Lock> {
+ let mut locks = Vec::new();
+ data.get_ptrs(&mut locks);
+ locks
+}
+
+unsafe impl<L: Lockable> Lockable for OwnedLockCollection<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 OwnedLockCollection<L> {}
+
+unsafe impl<L: OwnedLockable> OwnedLockable for OwnedLockCollection<L> {}
+
+impl<L: OwnedLockable> OwnedLockCollection<L> {
+ #[must_use]
+ pub const fn new(data: L) -> Self {
+ Self { data }
+ }
+
+ pub fn lock<'g, 'key, Key: Keyable + 'key>(
+ &'g self,
+ key: Key,
+ ) -> LockGuard<'key, L::Guard<'g>, Key> {
+ let locks = get_locks(&self.data);
+ for lock in locks {
+ // safety: we have the thread key, and these locks happen in a
+ // predetermined order
+ unsafe { lock.lock() };
+ }
+
+ // safety: we've locked all of this already
+ let guard = unsafe { self.data.guard() };
+ LockGuard {
+ 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 locks = get_locks(&self.data);
+ let guard = unsafe {
+ for (i, lock) in locks.iter().enumerate() {
+ // safety: we have the thread key
+ let success = lock.try_lock();
+
+ if !success {
+ for lock in &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,
+ })
+ }
+
+ #[allow(clippy::missing_const_for_fn)]
+ pub fn unlock<'g, 'key: 'g, Key: Keyable + 'key>(
+ guard: LockGuard<'key, L::Guard<'g>, Key>,
+ ) -> Key {
+ drop(guard.guard);
+ guard.key
+ }
+}
+
+impl<L: Sharable> OwnedLockCollection<L> {
+ pub fn read<'g, 'key, Key: Keyable + 'key>(
+ &'g self,
+ key: Key,
+ ) -> LockGuard<'key, L::ReadGuard<'g>, Key> {
+ let locks = get_locks(&self.data);
+ for lock in locks {
+ // safety: we have the thread key, and these locks happen in a
+ // predetermined order
+ unsafe { lock.read() };
+ }
+
+ // safety: we've locked all of this already
+ let guard = unsafe { self.data.read_guard() };
+ LockGuard {
+ 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 locks = get_locks(&self.data);
+ let guard = unsafe {
+ for (i, lock) in locks.iter().enumerate() {
+ // safety: we have the thread key
+ let success = lock.try_read();
+
+ if !success {
+ for lock in &locks[0..i] {
+ // safety: this lock was already acquired
+ lock.unlock();
+ }
+ return None;
+ }
+ }
+
+ // safety: we've acquired the locks
+ self.data.read_guard()
+ };
+
+ Some(LockGuard {
+ guard,
+ key,
+ _phantom: PhantomData,
+ })
+ }
+
+ #[allow(clippy::missing_const_for_fn)]
+ pub fn unlock_read<'g, 'key: 'g, Key: Keyable + 'key>(
+ guard: LockGuard<'key, L::ReadGuard<'g>, Key>,
+ ) -> Key {
+ drop(guard.guard);
+ guard.key
+ }
+}
diff --git a/src/collection/owned_collection.rs b/src/collection/owned_collection.rs
deleted file mode 100644
index ea8f2f2..0000000
--- a/src/collection/owned_collection.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use std::marker::PhantomData;
-
-use crate::{lockable::Lock, Keyable, Lockable, OwnedLockable};
-
-use super::{LockGuard, OwnedLockCollection};
-
-fn get_locks<L: Lockable>(data: &L) -> Vec<&dyn Lock> {
- let mut locks = Vec::new();
- data.get_ptrs(&mut locks);
- locks
-}
-
-impl<L: OwnedLockable> OwnedLockCollection<L> {
- #[must_use]
- pub const fn new(data: L) -> Self {
- Self { data }
- }
-
- pub fn lock<'a, 'key, Key: Keyable + 'key>(&'a self, key: Key) -> LockGuard<'a, 'key, L, Key> {
- let locks = get_locks(&self.data);
- for lock in locks {
- // safety: we have the thread key, and these locks happen in a
- // predetermined order
- unsafe { lock.lock() };
- }
-
- // safety: we've locked all of this already
- let guard = unsafe { self.data.guard() };
- LockGuard {
- guard,
- key,
- _phantom: PhantomData,
- }
- }
-
- pub fn try_lock<'a, 'key: 'a, Key: Keyable + 'key>(
- &'a self,
- key: Key,
- ) -> Option<LockGuard<'a, 'key, L, Key>> {
- let locks = get_locks(&self.data);
- let guard = unsafe {
- for (i, lock) in locks.iter().enumerate() {
- // safety: we have the thread key
- let success = lock.try_lock();
-
- if !success {
- for lock in &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,
- })
- }
-}
diff --git a/src/collection/ref_collection.rs b/src/collection/ref.rs
index 41f6b16..9fe34c9 100644
--- a/src/collection/ref_collection.rs
+++ b/src/collection/ref.rs
@@ -1,6 +1,6 @@
use std::marker::PhantomData;
-use crate::{key::Keyable, lockable::Lock, Lockable, OwnedLockable};
+use crate::{key::Keyable, lockable::Lock, Lockable, OwnedLockable, Sharable};
use super::{LockGuard, RefLockCollection};
@@ -49,6 +49,26 @@ where
}
}
+unsafe impl<'c, L: Lockable> Lockable for RefLockCollection<'c, 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>) {
+ ptrs.extend_from_slice(&self.locks);
+ }
+
+ unsafe fn guard(&self) -> Self::Guard<'_> {
+ self.data.guard()
+ }
+
+ unsafe fn read_guard(&self) -> Self::ReadGuard<'_> {
+ self.data.read_guard()
+ }
+}
+
+unsafe impl<'c, L: Sharable> Sharable for RefLockCollection<'c, L> {}
+
impl<'a, L: OwnedLockable> RefLockCollection<'a, L> {
/// Creates a new collection of owned locks.
///
@@ -143,7 +163,10 @@ impl<'a, L: Lockable> RefLockCollection<'a, L> {
/// *guard.0 += 1;
/// *guard.1 = "1";
/// ```
- pub fn lock<'key: 'a, Key: Keyable + 'key>(&'a self, key: Key) -> LockGuard<'a, 'key, L, Key> {
+ pub fn lock<'key: 'a, Key: Keyable + 'key>(
+ &'a self,
+ key: Key,
+ ) -> LockGuard<'key, L::Guard<'a>, Key> {
for lock in &self.locks {
// safety: we have the thread key
unsafe { lock.lock() };
@@ -183,7 +206,7 @@ impl<'a, L: Lockable> RefLockCollection<'a, L> {
pub fn try_lock<'key: 'a, Key: Keyable + 'key>(
&'a self,
key: Key,
- ) -> Option<LockGuard<'a, 'key, L, Key>> {
+ ) -> Option<LockGuard<'key, L::Guard<'a>, Key>> {
let guard = unsafe {
for (i, lock) in self.locks.iter().enumerate() {
// safety: we have the thread key
@@ -226,7 +249,7 @@ impl<'a, L: Lockable> RefLockCollection<'a, L> {
/// let key = LockCollection::unlock(guard);
/// ```
#[allow(clippy::missing_const_for_fn)]
- pub fn unlock<'key: 'a, Key: Keyable + 'key>(guard: LockGuard<'a, 'key, L, Key>) -> Key {
+ pub fn unlock<'key: 'a, Key: Keyable + 'key>(guard: LockGuard<'key, L::Guard<'a>, Key>) -> Key {
drop(guard.guard);
guard.key
}
diff --git a/src/collection/retry.rs b/src/collection/retry.rs
new file mode 100644
index 0000000..3000f8b
--- /dev/null
+++ b/src/collection/retry.rs
@@ -0,0 +1,271 @@
+use crate::{lockable::Lock, Keyable, Lockable, OwnedLockable, Sharable};
+use std::collections::HashSet;
+use std::marker::PhantomData;
+
+use super::{LockGuard, RetryingLockCollection};
+
+fn contains_duplicates<L: Lockable>(data: L) -> bool {
+ let mut locks = Vec::new();
+ data.get_ptrs(&mut locks);
+ let locks = locks.into_iter().map(|l| l as *const dyn Lock);
+
+ let mut locks_set = HashSet::new();
+ for lock in locks {
+ if !locks_set.insert(lock) {
+ return true;
+ }
+ }
+
+ false
+}
+
+unsafe impl<L: Lockable> Lockable for RetryingLockCollection<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 RetryingLockCollection<L> {}
+
+unsafe impl<L: OwnedLockable> OwnedLockable for RetryingLockCollection<L> {}
+
+impl<L: OwnedLockable> RetryingLockCollection<L> {
+ #[must_use]
+ pub const fn new(data: L) -> Self {
+ Self { data }
+ }
+}
+
+impl<'a, L: OwnedLockable> RetryingLockCollection<&'a L> {
+ #[must_use]
+ pub const fn new_ref(data: &'a L) -> Self {
+ Self { data }
+ }
+}
+
+impl<L: Lockable> RetryingLockCollection<L> {
+ #[must_use]
+ pub const unsafe fn new_unchecked(data: L) -> Self {
+ Self { data }
+ }
+
+ pub fn try_new(data: L) -> Option<Self> {
+ contains_duplicates(&data).then_some(Self { data })
+ }
+
+ pub fn lock<'g, 'key: 'g, Key: Keyable + 'key>(
+ &'g self,
+ key: Key,
+ ) -> LockGuard<'key, L::Guard<'g>, Key> {
+ let mut first_index = 0;
+ let mut locks = Vec::new();
+ self.data.get_ptrs(&mut locks);
+
+ if locks.is_empty() {
+ return LockGuard {
+ // safety: there's no data being returned
+ guard: unsafe { self.data.guard() },
+ key,
+ _phantom: PhantomData,
+ };
+ }
+
+ let guard = unsafe {
+ 'outer: loop {
+ // safety: we have the thread key
+ locks[first_index].lock();
+ for (i, lock) in locks.iter().enumerate() {
+ if i == first_index {
+ continue;
+ }
+
+ // safety: we have the thread key
+ if !lock.try_lock() {
+ for lock in locks.iter().take(i) {
+ // safety: we already locked all of these
+ lock.unlock();
+ }
+
+ if first_index >= i {
+ // safety: this is already locked and can't be unlocked
+ // by the previous loop
+ locks[first_index].unlock();
+ }
+
+ first_index = i;
+ continue 'outer;
+ }
+ }
+
+ // safety: we locked all the data
+ break self.data.guard();
+ }
+ };
+
+ LockGuard {
+ 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 mut locks = Vec::new();
+ self.data.get_ptrs(&mut locks);
+
+ if locks.is_empty() {
+ return Some(LockGuard {
+ // safety: there's no data being returned
+ guard: unsafe { self.data.guard() },
+ key,
+ _phantom: PhantomData,
+ });
+ }
+
+ let guard = unsafe {
+ for (i, lock) in locks.iter().enumerate() {
+ // safety: we have the thread key
+ if !lock.try_lock() {
+ for lock in locks.iter().take(i) {
+ // safety: we already locked all of these
+ lock.unlock();
+ }
+ return None;
+ }
+ }
+
+ // safety: we locked all the data
+ 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> RetryingLockCollection<L> {
+ pub fn read<'g, 'key: 'g, Key: Keyable + 'key>(
+ &'g self,
+ key: Key,
+ ) -> LockGuard<'key, L::ReadGuard<'g>, Key> {
+ let mut first_index = 0;
+ let mut locks = Vec::new();
+ self.data.get_ptrs(&mut locks);
+
+ if locks.is_empty() {
+ return LockGuard {
+ // safety: there's no data being returned
+ guard: unsafe { self.data.read_guard() },
+ key,
+ _phantom: PhantomData,
+ };
+ }
+
+ let guard = unsafe {
+ 'outer: loop {
+ // safety: we have the thread key
+ locks[first_index].read();
+ for (i, lock) in locks.iter().enumerate() {
+ if i == first_index {
+ continue;
+ }
+
+ // safety: we have the thread key
+ if !lock.try_read() {
+ for lock in locks.iter().take(i) {
+ // safety: we already locked all of these
+ lock.unlock_read();
+ }
+
+ if first_index >= i {
+ // safety: this is already locked and can't be unlocked
+ // by the previous loop
+ locks[first_index].unlock_read();
+ }
+
+ first_index = i;
+ continue 'outer;
+ }
+ }
+
+ // safety: we locked all the data
+ break self.data.read_guard();
+ }
+ };
+
+ LockGuard {
+ 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 mut locks = Vec::new();
+ self.data.get_ptrs(&mut locks);
+
+ if locks.is_empty() {
+ return Some(LockGuard {
+ // safety: there's no data being returned
+ guard: unsafe { self.data.read_guard() },
+ key,
+ _phantom: PhantomData,
+ });
+ }
+
+ let guard = unsafe {
+ for (i, lock) in locks.iter().enumerate() {
+ // safety: we have the thread key
+ if !lock.try_read() {
+ for lock in locks.iter().take(i) {
+ // safety: we already locked all of these
+ lock.unlock_read();
+ }
+ return None;
+ }
+ }
+
+ // safety: we locked all the data
+ 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
+ }
+}
diff --git a/src/collection/retry_collection.rs b/src/collection/retry_collection.rs
deleted file mode 100644
index 73f9e18..0000000
--- a/src/collection/retry_collection.rs
+++ /dev/null
@@ -1,138 +0,0 @@
-use std::marker::PhantomData;
-
-use crate::{lockable::Lock, Keyable, Lockable, OwnedLockable};
-
-use super::{LockGuard, RetryingLockCollection};
-
-fn contains_duplicates<L: Lockable>(data: L) -> bool {
- let mut locks = Vec::new();
- data.get_ptrs(&mut locks);
- let mut locks: Vec<_> = locks.into_iter().map(|l| l as *const dyn Lock).collect();
- locks.sort_unstable();
- locks.windows(2).any(|w| std::ptr::addr_eq(w[0], w[1]))
-}
-
-impl<L: OwnedLockable> RetryingLockCollection<L> {
- #[must_use]
- pub const fn new(data: L) -> Self {
- Self { data }
- }
-}
-
-impl<'a, L: OwnedLockable> RetryingLockCollection<&'a L> {
- #[must_use]
- pub const fn new_ref(data: &'a L) -> Self {
- Self { data }
- }
-}
-
-impl<L: Lockable> RetryingLockCollection<L> {
- #[must_use]
- pub const unsafe fn new_unchecked(data: L) -> Self {
- Self { data }
- }
-
- pub fn try_new(data: L) -> Option<Self> {
- contains_duplicates(&data).then_some(Self { data })
- }
-
- pub fn lock<'a, 'key: 'a, Key: Keyable + 'key>(
- &'a self,
- key: Key,
- ) -> LockGuard<'a, 'key, L, Key> {
- let mut first_index = 0;
- let mut locks = Vec::new();
- self.data.get_ptrs(&mut locks);
-
- if locks.is_empty() {
- return LockGuard {
- // safety: there's no data being returned
- guard: unsafe { self.data.guard() },
- key,
- _phantom: PhantomData,
- };
- }
-
- let guard = unsafe {
- 'outer: loop {
- // safety: we have the thread key
- locks[first_index].lock();
- for (i, lock) in locks.iter().enumerate() {
- if i == first_index {
- continue;
- }
-
- // safety: we have the thread key
- if !lock.try_lock() {
- for lock in locks.iter().take(i) {
- // safety: we already locked all of these
- lock.unlock();
- }
-
- if first_index >= i {
- // safety: this is already locked and can't be unlocked
- // by the previous loop
- locks[first_index].unlock();
- }
-
- first_index = i;
- continue 'outer;
- }
- }
-
- // safety: we locked all the data
- break self.data.guard();
- }
- };
-
- LockGuard {
- guard,
- key,
- _phantom: PhantomData,
- }
- }
-
- pub fn try_lock<'a, 'key: 'a, Key: Keyable + 'key>(
- &'a self,
- key: Key,
- ) -> Option<LockGuard<'a, 'key, L, Key>> {
- let mut locks = Vec::new();
- self.data.get_ptrs(&mut locks);
-
- if locks.is_empty() {
- return Some(LockGuard {
- // safety: there's no data being returned
- guard: unsafe { self.data.guard() },
- key,
- _phantom: PhantomData,
- });
- }
-
- let guard = unsafe {
- for (i, lock) in locks.iter().enumerate() {
- // safety: we have the thread key
- if !lock.try_lock() {
- for lock in locks.iter().take(i) {
- // safety: we already locked all of these
- lock.unlock();
- }
- return None;
- }
- }
-
- // safety: we locked all the data
- self.data.guard()
- };
-
- Some(LockGuard {
- guard,
- key,
- _phantom: PhantomData,
- })
- }
-
- pub fn unlock<'key, Key: Keyable + 'key>(guard: LockGuard<'_, 'key, L, Key>) -> Key {
- drop(guard.guard);
- guard.key
- }
-}
generated by cgit v1.2.3 (git 2.39.1) at 2026-03-04 07:53:57 +0000