From 16d6bd7ece4c4b9b72f6bd51c9b034270b745525 Mon Sep 17 00:00:00 2001
From: Mica White <botahamec@outlook.com>
Date: Sun, 13 Sep 2026 15:12:08 -0400
Subject: Support no_std

---
 src/collection/ref.rs | 35 +++++++++++++++++++++++++++--------
 1 file changed, 27 insertions(+), 8 deletions(-)

(limited to 'src/collection/ref.rs')

diff --git a/src/collection/ref.rs b/src/collection/ref.rs
index a422bb2..8ab7120 100755
--- a/src/collection/ref.rs
+++ b/src/collection/ref.rs
@@ -1,4 +1,6 @@
-use std::fmt::Debug;
+use core::fmt::Debug;
+
+use alloc::vec::Vec;
 
 use crate::lockable::{Lockable, OwnedLockable, RawLock, Sharable};
 use crate::{Keyable, ThreadKey};
@@ -114,7 +116,7 @@ impl<T: ?Sized, L: AsRef<T>> AsRef<T> for RefLockCollection<'_, L> {
 #[mutants::skip]
 #[cfg(not(tarpaulin_include))]
 impl<L: Debug> Debug for RefLockCollection<'_, L> {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
 		f.debug_struct(stringify!(RefLockCollection))
 			.field("data", self.child)
 			// there's not much reason to show the sorting order
@@ -640,7 +642,9 @@ where
 #[cfg(test)]
 mod tests {
 	use super::*;
-	use crate::{Mutex, RwLock, ThreadKey};
+	use crate::Mutex;
+	#[cfg(feature = "std")]
+	use crate::{RwLock, ThreadKey};
 
 	#[test]
 	fn non_duplicates_allowed() {
@@ -656,6 +660,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn from() {
 		let key = ThreadKey::get().unwrap();
 		let mutexes = [Mutex::new("foo"), Mutex::new("bar"), Mutex::new("baz")];
@@ -667,6 +672,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn scoped_lock_changes_collection() {
 		let mut key = ThreadKey::get().unwrap();
 		let mutexes = [Mutex::new(24), Mutex::new(42)];
@@ -684,6 +690,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn scoped_read_sees_changes() {
 		let mut key = ThreadKey::get().unwrap();
 		let mutexes = [RwLock::new(24), RwLock::new(42)];
@@ -702,6 +709,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn scoped_try_lock_can_fail() {
 		let key = ThreadKey::get().unwrap();
 		let locks = [Mutex::new(1), Mutex::new(2)];
@@ -720,6 +728,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn scoped_try_read_can_fail() {
 		let key = ThreadKey::get().unwrap();
 		let locks = [RwLock::new(1), RwLock::new(2)];
@@ -738,6 +747,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn try_lock_succeeds_for_unlocked_collection() {
 		let key = ThreadKey::get().unwrap();
 		let mutexes = [Mutex::new(24), Mutex::new(42)];
@@ -748,6 +758,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn try_lock_fails_for_locked_collection() {
 		let key = ThreadKey::get().unwrap();
 		let mutexes = [Mutex::new(24), Mutex::new(42)];
@@ -758,7 +769,7 @@ mod tests {
 				let key = ThreadKey::get().unwrap();
 				let guard = mutexes[1].lock(key);
 				assert_eq!(*guard, 42);
-				std::mem::forget(guard);
+				core::mem::forget(guard);
 			});
 		});
 
@@ -767,6 +778,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn try_read_succeeds_for_unlocked_collection() {
 		let key = ThreadKey::get().unwrap();
 		let mutexes = [RwLock::new(24), RwLock::new(42)];
@@ -777,6 +789,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn try_read_fails_for_locked_collection() {
 		let key = ThreadKey::get().unwrap();
 		let mutexes = [RwLock::new(24), RwLock::new(42)];
@@ -787,7 +800,7 @@ mod tests {
 				let key = ThreadKey::get().unwrap();
 				let guard = mutexes[1].write(key);
 				assert_eq!(*guard, 42);
-				std::mem::forget(guard);
+				core::mem::forget(guard);
 			});
 		});
 
@@ -796,6 +809,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn can_read_twice_on_different_threads() {
 		let key = ThreadKey::get().unwrap();
 		let mutexes = [RwLock::new(24), RwLock::new(42)];
@@ -807,7 +821,7 @@ mod tests {
 				let guard = collection.read(key);
 				assert_eq!(*guard[0], 24);
 				assert_eq!(*guard[1], 42);
-				std::mem::forget(guard);
+				core::mem::forget(guard);
 			});
 		});
 
@@ -817,6 +831,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn into_ref_iterator() {
 		let mut key = ThreadKey::get().unwrap();
 		let mutexes = [Mutex::new(0), Mutex::new(1), Mutex::new(2)];
@@ -827,6 +842,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn ref_iterator() {
 		let mut key = ThreadKey::get().unwrap();
 		let mutexes = [Mutex::new(0), Mutex::new(1), Mutex::new(2)];
@@ -837,6 +853,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn works_in_collection() {
 		let key = ThreadKey::get().unwrap();
 		let mutex1 = RwLock::new(0);
@@ -862,6 +879,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn unlock_collection_works() {
 		let key = ThreadKey::get().unwrap();
 		let mutexes = (Mutex::new("foo"), Mutex::new("bar"));
@@ -873,6 +891,7 @@ mod tests {
 	}
 
 	#[test]
+	#[cfg(feature = "std")]
 	fn read_unlock_collection_works() {
 		let key = ThreadKey::get().unwrap();
 		let locks = (RwLock::new("foo"), RwLock::new("bar"));
@@ -888,7 +907,7 @@ mod tests {
 		let mutexes = [Mutex::new(0), Mutex::new(1)];
 		let collection = RefLockCollection::new(&mutexes);
 
-		assert!(std::ptr::addr_eq(&raw const mutexes, collection.as_ref()))
+		assert!(core::ptr::addr_eq(&raw const mutexes, collection.as_ref()))
 	}
 
 	#[test]
@@ -896,6 +915,6 @@ mod tests {
 		let mutexes = [Mutex::new(0), Mutex::new(1)];
 		let collection = RefLockCollection::new(&mutexes);
 
-		assert!(std::ptr::addr_eq(&raw const mutexes, collection.child()))
+		assert!(core::ptr::addr_eq(&raw const mutexes, collection.child()))
 	}
 }
-- 
cgit v1.3.1