Expose equals and compare over FFI

temporal_capi/src/plain_date.rs

@@ -15,6 +15,7 @@ pub mod ffi {
     use crate::plain_time::ffi::PlainTime;
     use crate::plain_year_month::ffi::PlainYearMonth;
     use diplomat_runtime::{DiplomatOption, DiplomatStrSlice, DiplomatWrite};
+    use std::cmp::Ordering;
     use std::fmt::Write;
 
     #[diplomat::opaque]
@@ -158,7 +159,36 @@ pub mod ffi {
         pub fn equals(&self, other: &Self) -> bool {
             self.0 == other.0
         }
-
+
+        pub fn compare(one: &Self, two: &Self) -> i32 {
+            Self::compare_iso_date(
+                one.iso_year(),
+                one.iso_month(),
+                one.iso_day(),
+                two.iso_year(),
+                two.iso_month(),
+                two.iso_day(),
+            )
+        }
+
+        pub fn compare_iso_date(
+            year1: i32,
+            month1: u8,
+            day1: u8,
+            year2: i32,
+            month2: u8,
+            day2: u8,
+        ) -> i32 {
+            match (year1.cmp(&year2), month1.cmp(&month2), day1.cmp(&day2)) {
+                (Ordering::Greater, _, _) => 1,
+                (Ordering::Less, _, _) => -1,
+                (_, Ordering::Greater, _) => 1,
+                (_, Ordering::Less, _) => -1,
+                (_, _, Ordering::Greater) => 1,
+                (_, _, Ordering::Less) => -1,
+                _ => 0,
+            }
+        }
         pub fn year(&self) -> i32 {
             self.0.year()
         }

temporal_capi/src/plain_date_time.rs

@@ -245,7 +245,71 @@ pub mod ffi {
         pub fn equals(&self, other: &Self) -> bool {
             self.0 == other.0
         }
-
+
+        pub fn compare(one: &Self, two: &Self) -> i32 {
+            Self::compare_iso_plain_date_time(
+                one.iso_year(),
+                one.iso_month(),
+                one.iso_day(),
+                one.hour(),
+                one.minute(),
+                one.second(),
+                one.millisecond(),
+                one.microsecond(),
+                one.nanosecond(),
+                two.iso_year(),
+                two.iso_month(),
+                two.iso_day(),
+                two.hour(),
+                two.minute(),
+                two.second(),
+                two.millisecond(),
+                two.microsecond(),
+                two.nanosecond(),
+            )
+        }
+
+        pub fn compare_iso_plain_date_time(
+            year1: i32,
+            month1: u8,
+            day1: u8,
+            hour1: u8,
+            minute1: u8,
+            second1: u8,
+            millisecond1: u16,
+            microsecond1: u16,
+            nanosecond1: u16,
+            year2: i32,
+            month2: u8,
+            day2: u8,
+            hour2: u8,
+            minute2: u8,
+            second2: u8,
+            millisecond2: u16,
+            microsecond2: u16,
+            nanosecond2: u16,
+        ) -> i32 {
+            let comparisons = [
+                year1.cmp(&year2),
+                month1.cmp(&month2),
+                day1.cmp(&day2),
+                hour1.cmp(&hour2),
+                minute1.cmp(&minute2),
+                second1.cmp(&second2),
+                millisecond1.cmp(&millisecond2),
+                microsecond1.cmp(&microsecond2),
+                nanosecond1.cmp(&nanosecond2),
+            ];
+            comparisons
+                .iter()
+                .find(|&&ord| ord != std::cmp::Ordering::Equal)
+                .map_or(0, |ord| match ord {
+                    std::cmp::Ordering::Greater => 1,
+                    std::cmp::Ordering::Less => -1,
+                    std::cmp::Ordering::Equal => 0,
+                })
+        }
+
         pub fn round(&self, options: RoundingOptions) -> Result<Box<Self>, TemporalError> {
             self.0
                 .round(options.try_into()?)

temporal_capi/src/plain_month_day.rs

@@ -9,6 +9,7 @@ pub mod ffi {
     use crate::plain_date::ffi::{PartialDate, PlainDate};
 
     use diplomat_runtime::DiplomatWrite;
+    use std::cmp::Ordering;
     use std::fmt::Write;
 
     #[diplomat::opaque]
@@ -47,7 +48,30 @@ pub mod ffi {
         pub fn equals(&self, other: &Self) -> bool {
             self.0 == other.0
         }
-
+
+        pub fn compare(one: &Self, two: &Self) -> i32 {
+            Self::compare_iso_month_day(
+                one.iso_month(),
+                one.iso_day(),
+                two.iso_month(),
+                two.iso_day(),
+            )
+        }
+
+        /// Compares two ISO month-day pairs and returns -1, 0, or 1.
+        pub fn compare_iso_month_day(month1: u8, day1: u8, month2: u8, day2: u8) -> i32 {
+            if month1 > month2 {
+                1
+            } else if month1 < month2 {
+                -1
+            } else if day1 > day2 {
+                1
+            } else if day1 < day2 {
+                -1
+            } else {
+                0
+            }
+        }
         pub fn iso_year(&self) -> i32 {
             self.0.iso_year()
         }

temporal_capi/src/plain_time.rs

@@ -147,6 +147,54 @@ pub mod ffi {
         pub fn equals(&self, other: &Self) -> bool {
             self.0 == other.0
         }
+        pub fn compare(one: &Self, two: &Self) -> i32 {
+            Self::compare_iso_time(
+                one.hour(),
+                one.minute(),
+                one.second(),
+                one.millisecond(),
+                one.microsecond(),
+                one.nanosecond(),
+                two.hour(),
+                two.minute(),
+                two.second(),
+                two.millisecond(),
+                two.microsecond(),
+                two.nanosecond(),
+            )
+        }
+
+        pub fn compare_iso_time(
+            hour1: u8,
+            minute1: u8,
+            second1: u8,
+            millisecond1: u16,
+            microsecond1: u16,
+            nanosecond1: u16,
+            hour2: u8,
+            minute2: u8,
+            second2: u8,
+            millisecond2: u16,
+            microsecond2: u16,
+            nanosecond2: u16,
+        ) -> i32 {
+            let comparisons = [
+                hour1.cmp(&hour2),
+                minute1.cmp(&minute2),
+                second1.cmp(&second2),
+                millisecond1.cmp(&millisecond2),
+                microsecond1.cmp(&microsecond2),
+                nanosecond1.cmp(&nanosecond2),
+            ];
+            comparisons
+                .iter()
+                .find(|&&ord| ord != std::cmp::Ordering::Equal)
+                .map_or(0, |ord| match ord {
+                    std::cmp::Ordering::Greater => 1,
+                    std::cmp::Ordering::Less => -1,
+                    std::cmp::Ordering::Equal => 0,
+                })
+        }
         pub fn round(
             &self,
             smallest_unit: Unit,

temporal_capi/src/plain_year_month.rs

@@ -142,6 +142,28 @@ pub mod ffi {
         pub fn equals(&self, other: &Self) -> bool {
             self.0 == other.0
         }
+        pub fn compare(one: &Self, two: &Self) -> i32 {
+            Self::compare_iso_year_month(
+                one.iso_year(),
+                one.iso_month(),
+                two.iso_year(),
+                two.iso_month(),
+            )
+        }
+
+        pub fn compare_iso_year_month(year1: i32, month1: u8, year2: i32, month2: u8) -> i32 {
+            if year1 > year2 {
+                1
+            } else if year1 < year2 {
+                -1
+            } else if month1 > month2 {
+                1
+            } else if month1 < month2 {
+                -1
+            } else {
+                0
+            }
+        }
         pub fn to_plain_date(&self) -> Result<Box<PlainDate>, TemporalError> {
             self.0
                 .to_plain_date()