4 files changed, 242 insertions, 0 deletions
diff --git a/src/collection/boxed.rs b/src/collection/boxed.rs
index a12a690..1f068ec 100644
--- a/src/collection/boxed.rs
+++ b/src/collection/boxed.rs
@@ -15,6 +15,40 @@ fn contains_duplicates(l: &[&dyn RawLock]) -> bool {
 		.any(|window| std::ptr::eq(window[0], window[1]))
 }
 
+unsafe impl<L: Lockable + Send + Sync> RawLock for BoxedLockCollection<L> {
+	unsafe fn lock(&self) {
+		for lock in self.locks() {
+			lock.lock();
+		}
+	}
+
+	unsafe fn try_lock(&self) -> bool {
+		utils::ordered_try_lock(self.locks())
+	}
+
+	unsafe fn unlock(&self) {
+		for lock in self.locks() {
+			lock.unlock();
+		}
+	}
+
+	unsafe fn read(&self) {
+		for lock in self.locks() {
+			lock.read();
+		}
+	}
+
+	unsafe fn try_read(&self) -> bool {
+		utils::ordered_try_read(self.locks())
+	}
+
+	unsafe fn unlock_read(&self) {
+		for lock in self.locks() {
+			lock.unlock_read();
+		}
+	}
+}
+
 unsafe impl<L: Lockable> Lockable for BoxedLockCollection<L> {
 	type Guard<'g> = L::Guard<'g> where Self: 'g;
 
diff --git a/src/collection/owned.rs b/src/collection/owned.rs
index d180ed2..2b6e974 100644
--- a/src/collection/owned.rs
+++ b/src/collection/owned.rs
@@ -11,6 +11,46 @@ fn get_locks<L: Lockable>(data: &L) -> Vec<&dyn RawLock> {
 	locks
 }
 
+unsafe impl<L: Lockable + Send + Sync> RawLock for OwnedLockCollection<L> {
+	unsafe fn lock(&self) {
+		let locks = get_locks(&self.data);
+		for lock in locks {
+			lock.lock();
+		}
+	}
+
+	unsafe fn try_lock(&self) -> bool {
+		let locks = get_locks(&self.data);
+		utils::ordered_try_lock(&locks)
+	}
+
+	unsafe fn unlock(&self) {
+		let locks = get_locks(&self.data);
+		for lock in locks {
+			lock.unlock();
+		}
+	}
+
+	unsafe fn read(&self) {
+		let locks = get_locks(&self.data);
+		for lock in locks {
+			lock.read();
+		}
+	}
+
+	unsafe fn try_read(&self) -> bool {
+		let locks = get_locks(&self.data);
+		utils::ordered_try_read(&locks)
+	}
+
+	unsafe fn unlock_read(&self) {
+		let locks = get_locks(&self.data);
+		for lock in locks {
+			lock.unlock_read();
+		}
+	}
+}
+
 unsafe impl<L: Lockable> Lockable for OwnedLockCollection<L> {
 	type Guard<'g> = L::Guard<'g> where Self: 'g;
 
diff --git a/src/collection/ref.rs b/src/collection/ref.rs
index 748d2d2..c3a0967 100644
--- a/src/collection/ref.rs
+++ b/src/collection/ref.rs
@@ -39,6 +39,40 @@ where
 	}
 }
 
+unsafe impl<'a, L: Lockable + Send + Sync> RawLock for RefLockCollection<'a, L> {
+	unsafe fn lock(&self) {
+		for lock in &self.locks {
+			lock.lock();
+		}
+	}
+
+	unsafe fn try_lock(&self) -> bool {
+		utils::ordered_try_lock(&self.locks)
+	}
+
+	unsafe fn unlock(&self) {
+		for lock in &self.locks {
+			lock.unlock();
+		}
+	}
+
+	unsafe fn read(&self) {
+		for lock in &self.locks {
+			lock.read();
+		}
+	}
+
+	unsafe fn try_read(&self) -> bool {
+		utils::ordered_try_read(&self.locks)
+	}
+
+	unsafe fn unlock_read(&self) {
+		for lock in &self.locks {
+			lock.unlock_read();
+		}
+	}
+}
+
 unsafe impl<'c, L: Lockable> Lockable for RefLockCollection<'c, L> {
 	type Guard<'g> = L::Guard<'g> where Self: 'g;
 
diff --git a/src/collection/retry.rs b/src/collection/retry.rs
index 2b9b0a0..b73788a 100644
--- a/src/collection/retry.rs
+++ b/src/collection/retry.rs
@@ -22,6 +22,140 @@ fn contains_duplicates<L: Lockable>(data: L) -> bool {
 	false
 }
 
+unsafe impl<L: Lockable + Send + Sync> RawLock for RetryingLockCollection<L> {
+	unsafe fn lock(&self) {
+		let mut first_index = 0;
+		let mut locks = Vec::new();
+		self.data.get_ptrs(&mut locks);
+
+		'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;
+				}
+			}
+		}
+	}
+
+	unsafe fn try_lock(&self) -> bool {
+		let mut locks = Vec::new();
+		self.data.get_ptrs(&mut locks);
+
+		if locks.is_empty() {
+			return true;
+		}
+
+		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 false;
+				}
+			}
+		}
+
+		true
+	}
+
+	unsafe fn unlock(&self) {
+		let mut locks = Vec::new();
+		self.get_ptrs(&mut locks);
+
+		for lock in locks {
+			lock.unlock();
+		}
+	}
+
+	unsafe fn read(&self) {
+		let mut first_index = 0;
+		let mut locks = Vec::new();
+		self.data.get_ptrs(&mut locks);
+
+		'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;
+				}
+			}
+		}
+	}
+
+	unsafe fn try_read(&self) -> bool {
+		let mut locks = Vec::new();
+		self.data.get_ptrs(&mut locks);
+
+		if locks.is_empty() {
+			return true;
+		}
+
+		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 false;
+				}
+			}
+		}
+
+		true
+	}
+
+	unsafe fn unlock_read(&self) {
+		let mut locks = Vec::new();
+		self.get_ptrs(&mut locks);
+
+		for lock in locks {
+			lock.unlock_read();
+		}
+	}
+}
+
 unsafe impl<L: Lockable> Lockable for RetryingLockCollection<L> {
 	type Guard<'g> = L::Guard<'g> where Self: 'g;