feat: add jiff support

Author: l-7-l

Cargo.toml

@@ -20,6 +20,7 @@ bitcode_derive = { version = "=0.6.9", path = "./bitcode_derive", optional = tru
 bytemuck = { version = "1.14", features = [ "min_const_generics", "must_cast" ] }
 chrono = { version = ">=0.4", default-features = false, optional = true }
 glam = { version = ">=0.21", default-features = false, optional = true }
+jiff = { version = "0.2.23", optional = true }
 rust_decimal = { version = "1.36", default-features = false, optional = true }
 serde = { version = "1.0", default-features = false, features = [ "alloc" ], optional = true }
 time = { version = "0.3", default-features = false, optional = true }

src/ext/jiff/date.rs

@@ -0,0 +1,117 @@
+use jiff::civil::Date;
+
+use crate::{
+    convert::ConvertFrom,
+    error::error,
+    int::ranged_int,
+    try_convert::{impl_try_convert, TryConvertFrom},
+};
+
+impl_try_convert!(Date, DateEncode, DateDecode);
+
+// The value is guaranteed to be in the range `-9999..=9999`.
+ranged_int!(Year, i16, -9999, 9999);
+// The value is guaranteed to be in the range `1..=12`.
+ranged_int!(Month, u8, 1, 12);
+// The value is guaranteed to be in the range `0..=59`.
+ranged_int!(Day, u8, 1, 31);
+
+pub type DateEncode = (i16, u8, u8);
+pub type DateDecode = (Year, Month, Day);
+
+impl ConvertFrom<&Date> for DateEncode {
+    fn convert_from(value: &Date) -> Self {
+        (value.year(), value.month() as u8, value.day() as u8)
+    }
+}
+
+impl TryConvertFrom<DateDecode> for Date {
+    fn try_convert_from(value: DateDecode) -> Result<Self, crate::Error> {
+        Date::new(
+            value.0.into_inner(),
+            value.1.into_inner() as i8,
+            value.2.into_inner() as i8,
+        )
+        .map_err(|_| error("Failed to decode date"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use jiff::civil::Date;
+
+    #[test]
+    fn test_date() {
+        // -9999-01-01
+        let date = Date::new(-9999, 1, 1).unwrap();
+        let bytes = crate::encode(&date);
+        let decoded: Date = crate::decode(&bytes).unwrap();
+        assert_eq!(decoded, date);
+
+        // 9999-12-30
+        let date = Date::new(9999, 12, 30).unwrap();
+        let bytes = crate::encode(&date);
+        let decoded: Date = crate::decode(&bytes).unwrap();
+        assert_eq!(decoded, date);
+
+        // 2025-03-28
+        let date = Date::new(2025, 3, 28).unwrap();
+        let bytes = crate::encode(&date);
+        let decoded: Date = crate::decode(&bytes).unwrap();
+        assert_eq!(decoded, date);
+
+        let date = Date::new(2025, 1, 15).unwrap();
+        let bytes = crate::encode(&date);
+        let decoded: Date = crate::decode(&bytes).unwrap();
+        assert_eq!(decoded, date);
+
+        let date = Date::new(2025, 12, 15).unwrap();
+        let bytes = crate::encode(&date);
+        let decoded: Date = crate::decode(&bytes).unwrap();
+        assert_eq!(decoded, date);
+
+        let date = Date::new(2025, 4, 30).unwrap();
+        let bytes = crate::encode(&date);
+        let decoded: Date = crate::decode(&bytes).unwrap();
+        assert_eq!(decoded, date);
+
+        let bytes = crate::encode(&(-10000i16, 1u8, 1u8));
+        let result: Result<Date, _> = crate::decode(&bytes);
+        assert!(result.is_err());
+
+        let bytes = crate::encode(&(10000i16, 1u8, 1u8));
+        let result: Result<Date, _> = crate::decode(&bytes);
+        assert!(result.is_err());
+
+        let bytes = crate::encode(&(2025i16, 0u8, 1u8));
+        let result: Result<Date, _> = crate::decode(&bytes);
+        assert!(result.is_err());
+
+        let bytes = crate::encode(&(2025i16, 13u8, 1u8));
+        let result: Result<Date, _> = crate::decode(&bytes);
+        assert!(result.is_err());
+
+        let bytes = crate::encode(&(2025i16, 1u8, 0u8));
+        let result: Result<Date, _> = crate::decode(&bytes);
+        assert!(result.is_err());
+
+        let date = Date::new(2025, 3, 28).unwrap();
+        assert!(crate::decode::<Date>(&crate::encode(&date)).is_ok());
+    }
+
+    use alloc::vec::Vec;
+
+    fn bench_data() -> Vec<Date> {
+        crate::random_data(1000)
+            .into_iter()
+            .map(|(year, month, day): (i16, i8, i8)| {
+                let year = year.clamp(-9999, 9999);
+                let month = month.clamp(1, 12);
+                let day = day.clamp(1, 28);
+
+                Date::new(year, month, day).unwrap()
+            })
+            .collect()
+    }
+    crate::bench_encode_decode!(date_vec: Vec<_>);
+}

src/ext/jiff/mod.rs

@@ -0,0 +1,5 @@
+mod date;
+mod offset;
+mod time;
+mod timestamp;
+mod zoned;

src/ext/jiff/offset.rs

@@ -0,0 +1,89 @@
+use jiff::tz::Offset;
+
+use crate::{
+    convert::ConvertFrom,
+    error::error,
+    int::ranged_int,
+    try_convert::{impl_try_convert, TryConvertFrom},
+};
+
+impl_try_convert!(Offset, OffsetEncoder, OffsetDecoder);
+
+ranged_int!(OffsetDecoder, i32, -93599, 93599);
+
+pub(super) type OffsetEncoder = i32;
+
+impl ConvertFrom<&Offset> for OffsetEncoder {
+    fn convert_from(value: &Offset) -> Self {
+        value.seconds()
+    }
+}
+
+impl TryConvertFrom<OffsetDecoder> for Offset {
+    fn try_convert_from(value: OffsetDecoder) -> Result<Self, crate::Error> {
+        Offset::from_seconds(value.into_inner()).map_err(|_| error("Failed to decode offset"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_offset() {
+        let offset = Offset::UTC;
+        let bytes = bitcode::encode(&offset);
+        let decoded: Offset = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, offset);
+
+        let offset = Offset::from_seconds(93599).unwrap();
+        let bytes = bitcode::encode(&offset);
+        let decoded: Offset = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, offset);
+
+        let offset = Offset::from_seconds(-93599).unwrap();
+        let bytes = bitcode::encode(&offset);
+        let decoded: Offset = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, offset);
+
+        let offset = Offset::from_seconds(28800).unwrap();
+        let bytes = bitcode::encode(&offset);
+        let decoded: Offset = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, offset);
+
+        let offset = Offset::from_seconds(-21600).unwrap();
+        let bytes = bitcode::encode(&offset);
+        let decoded: Offset = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, offset);
+
+        let bytes = bitcode::encode(&93600);
+        let result: Result<Offset, _> = bitcode::decode(&bytes);
+        assert!(result.is_err());
+
+        let bytes = bitcode::encode(&-93600);
+        let result: Result<Offset, _> = bitcode::decode(&bytes);
+        assert!(result.is_err());
+
+        assert!(crate::decode::<Offset>(&crate::encode(&Offset::UTC)).is_ok());
+    }
+
+    use alloc::vec::Vec;
+    use jiff::tz::Offset;
+
+    fn offset_min() -> i32 {
+        Offset::MIN.seconds()
+    }
+    fn offset_max() -> i32 {
+        Offset::MAX.seconds()
+    }
+
+    fn bench_data() -> Vec<Offset> {
+        crate::random_data(1000)
+            .into_iter()
+            .map(|secs: i32| {
+                let secs = secs.clamp(offset_min(), offset_max());
+                Offset::from_seconds(secs).unwrap()
+            })
+            .collect()
+    }
+    crate::bench_encode_decode!(offset_vec: Vec<_>);
+}

src/ext/jiff/time.rs

@@ -0,0 +1,108 @@
+use jiff::civil::Time;
+
+use crate::{
+    convert::{impl_convert, ConvertFrom},
+    int::ranged_int,
+};
+
+impl_convert!(Time, TimeEncode, TimeDecode);
+
+// The value is guaranteed to be in the range `0..=23`.
+ranged_int!(Hour, u8, 0, 23);
+// The value is guaranteed to be in the range `0..=59`.
+ranged_int!(Minute, u8, 0, 59);
+// The value is guaranteed to be in the range `0..=59`.
+ranged_int!(Second, u8, 0, 59);
+// The value is guaranteed to be in the range `0..=999_999_999`
+ranged_int!(Nanosecond, u32, 0, 999_999_999);
+
+type TimeEncode = (u8, u8, u8, u32);
+type TimeDecode = (Hour, Minute, Second, Nanosecond);
+
+impl ConvertFrom<&Time> for TimeEncode {
+    fn convert_from(value: &Time) -> Self {
+        (
+            value.hour() as u8,
+            value.minute() as u8,
+            value.second() as u8,
+            value.subsec_nanosecond() as u32,
+        )
+    }
+}
+
+impl ConvertFrom<TimeDecode> for Time {
+    fn convert_from(value: TimeDecode) -> Self {
+        Time::constant(
+            value.0.into_inner() as i8,
+            value.1.into_inner() as i8,
+            value.2.into_inner() as i8,
+            value.3.into_inner() as i32,
+        )
+    }
+}
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_time() {
+        // 00:00:00.000000000
+        let time = Time::constant(0, 0, 0, 0);
+        let bytes = bitcode::encode(&time);
+        let decoded: Time = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, time);
+
+        // 23:59:59.999999999
+        let time = Time::constant(23, 59, 59, 999_999_999);
+        let bytes = bitcode::encode(&time);
+        let decoded: Time = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, time);
+
+        // 23:00:00
+        let time = Time::constant(23, 0, 0, 0);
+        let bytes = bitcode::encode(&time);
+        let decoded: Time = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, time);
+
+        // 00:59:00
+        let time = Time::constant(0, 59, 0, 0);
+        let bytes = bitcode::encode(&time);
+        let decoded: Time = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, time);
+
+        // 00:00:59
+        let time = Time::constant(0, 0, 59, 0);
+        let bytes = bitcode::encode(&time);
+        let decoded: Time = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, time);
+
+        // 12:30:45.123456789
+        let time = Time::constant(12, 30, 45, 123456789);
+        let bytes = bitcode::encode(&time);
+        let decoded: Time = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, time);
+
+        let time = Time::default();
+        let bytes = bitcode::encode(&time);
+        let decoded: Time = bitcode::decode(&bytes).unwrap();
+        assert_eq!(decoded, time);
+
+        assert!(crate::decode::<Time>(&crate::encode(&Time::default())).is_ok());
+    }
+
+    use alloc::vec::Vec;
+    use jiff::civil::Time;
+
+    fn bench_data() -> Vec<Time> {
+        crate::random_data(1000)
+            .into_iter()
+            .map(|(h, m, s, n): (u8, u8, u8, u32)| {
+                Time::constant(
+                    (h % 23) as i8,
+                    (m % 59) as i8,
+                    (s % 59) as i8,
+                    (n % 999_999_999) as i32,
+                )
+            })
+            .collect()
+    }
+    crate::bench_encode_decode!(time_vec: Vec<_>);
+}