Add NSThread and thread helper functions

Author: madsmtm

objc2-foundation/CHANGELOG.md

@@ -14,6 +14,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 * Implement `PartialOrd` and `Ord` for `NSString` and `NSRange`.
 * Added `NSString::has_prefix` and `NSString::has_suffix`.
 * Added `NSRange` methods `new`, `is_empty`, `contains` and `end`.
+* Added `NSThread` object.
+* Added `is_multi_threaded` and `is_main_thread` helper functions.
 
 ### Changed
 * **BREAKING**: Removed the following helper traits in favor of inherent

objc2-foundation/src/lib.rs

@@ -30,6 +30,7 @@ pub use self::enumerator::{NSEnumerator, NSFastEnumeration, NSFastEnumerator};
 pub use self::object::NSObject;
 pub use self::range::NSRange;
 pub use self::string::NSString;
+pub use self::thread::{is_main_thread, is_multi_threaded, NSThread};
 pub use self::value::NSValue;
 
 #[cfg(apple)]
@@ -52,4 +53,5 @@ mod enumerator;
 mod object;
 mod range;
 mod string;
+mod thread;
 mod value;

objc2-foundation/src/thread.rs

@@ -0,0 +1,82 @@
+use core::ptr::NonNull;
+
+use objc2::msg_send;
+use objc2::rc::{Id, Shared};
+use objc2::runtime::Bool;
+
+use crate::NSObject;
+
+object! {
+    /// A thread of execution.
+    ///
+    /// See [Apple's documentation](https://developer.apple.com/documentation/foundation/nsthread?language=objc).
+    unsafe pub struct NSThread: NSObject;
+}
+
+unsafe impl Send for NSThread {}
+unsafe impl Sync for NSThread {}
+
+impl NSThread {
+    /// Returns the [`NSThread`] object representing the current thread.
+    pub fn current() -> Id<NSThread, Shared> {
+        // currentThread is @property(strong), what does that mean?
+        let obj: *mut Self = unsafe { msg_send![Self::class(), currentThread] };
+        let obj = unsafe { NonNull::new_unchecked(obj) };
+        unsafe { Id::retain(obj) }
+    }
+
+    /// Returns the [`NSThread`] object representing the main thread.
+    pub fn main() -> Id<NSThread, Shared> {
+        // mainThread is @property(strong), what does that mean?
+        let obj: *mut Self = unsafe { msg_send![Self::class(), mainThread] };
+        let obj = unsafe { NonNull::new_unchecked(obj) };
+        unsafe { Id::retain(obj) }
+    }
+
+    /// Returns `true` if the thread is the main thread.
+    pub fn is_main(&self) -> bool {
+        let res: Bool = unsafe { msg_send![self, isMainThread] };
+        res.is_true()
+    }
+}
+
+/// Whether the application is multithreaded according to Cocoa.
+pub fn is_multi_threaded() -> bool {
+    let res: Bool = unsafe { msg_send![NSThread::class(), isMultiThreaded] };
+    res.is_true()
+}
+
+/// Whether the current thread is the main thread.
+pub fn is_main_thread() -> bool {
+    let res: Bool = unsafe { msg_send![NSThread::class(), isMainThread] };
+    res.is_true()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_main_thread() {
+        let current = NSThread::current();
+        let main = NSThread::main();
+
+        assert!(main.is_main());
+
+        if main == current {
+            assert!(current.is_main());
+            assert!(is_main_thread());
+        } else {
+            assert!(!current.is_main());
+            assert!(!is_main_thread());
+        }
+    }
+
+    #[test]
+    fn test_not_main_thread() {
+        let res = std::thread::spawn(|| (is_main_thread(), NSThread::current().is_main()))
+            .join()
+            .unwrap();
+        assert_eq!(res, (false, false));
+    }
+}