Implement PartialOrd and Ord for CF types

Implement for the types that support it, namely `CFDate`, `CFNumber` and
`CFString`.

Author: madsmtm

framework-crates/objc2-core-foundation/src/base.rs

@@ -39,11 +39,13 @@
 // That means we can use `isize`/`usize`, which is more ergonomic.
 
 use core::cell::UnsafeCell;
+use core::cmp::Ordering;
 use core::convert::AsRef;
 use core::fmt;
 use core::hash;
 use core::marker::{PhantomData, PhantomPinned};
 
+use crate::CFComparisonResult;
 use crate::ConcreteType;
 use crate::{CFEqual, CFHash, Type};
 
@@ -164,3 +166,32 @@ crate::__cf_type_objc2!(CFType, crate::__cf_macro_helpers::Encoding::Void);
 
 // NOTE: impl AsRef<CFType> for AnyObject would probably not be valid, since
 // not all Objective-C objects can be used as CoreFoundation objects (?)
+
+impl Default for CFComparisonResult {
+    #[inline]
+    fn default() -> Self {
+        Self::CompareEqualTo
+    }
+}
+
+impl From<Ordering> for CFComparisonResult {
+    #[inline]
+    fn from(order: Ordering) -> Self {
+        match order {
+            Ordering::Less => Self::CompareLessThan,
+            Ordering::Equal => Self::CompareEqualTo,
+            Ordering::Greater => Self::CompareGreaterThan,
+        }
+    }
+}
+
+impl From<CFComparisonResult> for Ordering {
+    #[inline]
+    fn from(comparison_result: CFComparisonResult) -> Self {
+        match comparison_result.0 {
+            ..=-1 => Self::Less,  // ..=CFComparisonResult::CompareLessThan
+            0 => Self::Equal,     // CFComparisonResult::CompareEqualTo
+            1.. => Self::Greater, // CFComparisonResult::CompareGreaterThan..
+        }
+    }
+}

framework-crates/objc2-core-foundation/src/date.rs

@@ -0,0 +1,41 @@
+#![cfg(feature = "CFBase")]
+use core::{cmp::Ordering, ptr};
+
+use crate::{CFDate, CFDateCompare};
+
+impl PartialOrd for CFDate {
+    #[inline]
+    #[doc(alias = "CFDateCompare")]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for CFDate {
+    #[inline]
+    #[doc(alias = "CFDateCompare")]
+    fn cmp(&self, other: &Self) -> Ordering {
+        // Documented that one should pass NULL here.
+        let context = ptr::null_mut();
+        unsafe { CFDateCompare(self, Some(other), context) }.into()
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{CFAbsoluteTimeGetCurrent, CFDateCreate, CFDateGetAbsoluteTime};
+
+    use super::*;
+
+    #[test]
+    fn cmp() {
+        let now = unsafe { CFDateCreate(None, CFAbsoluteTimeGetCurrent()).unwrap() };
+        let past = unsafe { CFDateCreate(None, CFDateGetAbsoluteTime(&now) - 1.0).unwrap() };
+        assert_eq!(now.cmp(&past), Ordering::Greater);
+        assert_eq!(now.cmp(&now), Ordering::Equal);
+        assert_eq!(past.cmp(&now), Ordering::Less);
+
+        assert_eq!(now, now);
+        assert_ne!(now, past);
+    }
+}

framework-crates/objc2-core-foundation/src/lib.rs

@@ -23,13 +23,15 @@ mod base;
 #[cfg(feature = "CFBundle")]
 mod bundle;
 mod cf_type;
+#[cfg(feature = "CFDate")]
+mod date;
 mod generated;
 #[cfg(feature = "CFCGTypes")]
 mod geometry;
 #[cfg(feature = "CFNumber")]
 mod number;
 mod retained;
-#[cfg(all(feature = "CFBase", feature = "CFString"))]
+#[cfg(feature = "CFString")]
 mod string;
 mod type_traits;
 

framework-crates/objc2-core-foundation/src/number.rs

@@ -1,7 +1,10 @@
 #![cfg(feature = "CFBase")]
+use core::cmp::Ordering;
+use core::ptr;
+
 use crate::{
-    kCFBooleanFalse, kCFBooleanTrue, CFBoolean, CFBooleanGetValue, CFNumber, CFNumberCreate,
-    CFNumberGetValue, CFNumberType, CFRetained,
+    kCFBooleanFalse, kCFBooleanTrue, CFBoolean, CFBooleanGetValue, CFNumber, CFNumberCompare,
+    CFNumberCreate, CFNumberGetValue, CFNumberType, CFRetained,
 };
 
 impl CFBoolean {
@@ -104,6 +107,24 @@ impl CFNumber {
     }
 }
 
+impl PartialOrd for CFNumber {
+    #[inline]
+    #[doc(alias = "CFNumberCompare")]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for CFNumber {
+    #[inline]
+    #[doc(alias = "CFNumberCompare")]
+    fn cmp(&self, other: &Self) -> Ordering {
+        // Documented that one should pass NULL here.
+        let context = ptr::null_mut();
+        unsafe { CFNumberCompare(self, Some(other), context) }.into()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -129,4 +150,11 @@ mod tests {
         assert_eq!(n.as_f32(), Some(442.0));
         assert_eq!(n.as_f64(), Some(442.0));
     }
+
+    #[test]
+    fn cmp_number() {
+        assert!(CFNumber::new_i32(2) < CFNumber::new_i32(3));
+        assert!(CFNumber::new_i32(3) == CFNumber::new_i32(3));
+        assert!(CFNumber::new_i32(4) > CFNumber::new_i32(3));
+    }
 }

framework-crates/objc2-core-foundation/src/string.rs

@@ -1,12 +1,14 @@
+#![cfg(feature = "CFBase")]
+use core::cmp::Ordering;
 use core::ffi::{c_char, CStr};
 use core::fmt::Write;
 use core::ptr::NonNull;
 use core::{fmt, str};
 
 use crate::{
-    kCFAllocatorNull, Boolean, CFRange, CFRetained, CFString, CFStringCreateWithBytes,
-    CFStringCreateWithBytesNoCopy, CFStringEncoding, CFStringGetBytes, CFStringGetCStringPtr,
-    CFStringGetLength,
+    kCFAllocatorNull, Boolean, CFRange, CFRetained, CFString, CFStringCompare,
+    CFStringCompareFlags, CFStringCreateWithBytes, CFStringCreateWithBytesNoCopy, CFStringEncoding,
+    CFStringGetBytes, CFStringGetCStringPtr, CFStringGetLength,
 };
 
 #[track_caller]
@@ -172,6 +174,24 @@ impl fmt::Display for CFString {
     }
 }
 
+impl PartialOrd for CFString {
+    #[inline]
+    #[doc(alias = "CFStringCompare")]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for CFString {
+    #[inline]
+    #[doc(alias = "CFStringCompare")]
+    fn cmp(&self, other: &Self) -> Ordering {
+        // Request standard lexiographical ordering.
+        let flags = CFStringCompareFlags::empty();
+        unsafe { CFStringCompare(self, Some(other), flags) }.into()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use alloc::string::ToString;