Support for chrono (#39) and jiff

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 [package]
 name = "bitcode"
 authors = [ "Cai Bear", "Finn Bear" ]
-version = "0.6.9"
+version = "0.7.0"
 edition = "2021"
 rust-version = "1.70"
 license = "MIT OR Apache-2.0"
@@ -18,7 +18,9 @@ exclude = ["fuzz/"]
 arrayvec = { version = "0.7", default-features = false, optional = true }
 bitcode_derive = { version = "=0.6.9", path = "./bitcode_derive", optional = true }
 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.0", 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 }
@@ -29,7 +31,7 @@ arrayvec = { version = "0.7", features = [ "serde" ] }
 bincode = "1.3.3"
 flate2 = "1.0.28"
 glam = { version = "0.22", default-features = false, features = [ "rand" ] }
-lz4_flex = { version = "=0.11.2", default-features = false }
+lz4_flex = { version = "=0.13.0", default-features = false }
 paste = "1.0.14"
 rand = "0.8.5"
 rand_chacha = "0.3.1"

fuzz/Cargo.toml

@@ -10,11 +10,14 @@ cargo-fuzz = true
 
 [dependencies]
 arrayvec = { version = "0.7", features = ["serde"] }
-bitcode = { path = "..", features = [ "arrayvec", "rust_decimal", "serde", "time" ] }
+bitcode = { path = "..", features = [ "arrayvec", "rust_decimal", "serde", "time", "chrono", "jiff" ] }
 libfuzzer-sys = "0.4"
 rust_decimal = "1.36.0"
 serde = { version ="1.0", features = [ "derive" ] }
 time = { version = "0.3", features = ["serde"]}
+chrono = { version = "0.4.42", features = ["serde"] }
+jiff = {version = "0.2.23", features = ["serde"]}
+
 
 # Prevent this from interfering with workspaces
 [workspace]
@@ -24,4 +27,4 @@ members = ["."]
 name = "fuzz"
 path = "fuzz_targets/fuzz.rs"
 test = false
-doc = false
+doc = false

fuzz/fuzz_targets/fuzz.rs

@@ -3,14 +3,14 @@ use libfuzzer_sys::fuzz_target;
 extern crate bitcode;
 use arrayvec::{ArrayString, ArrayVec};
 use bitcode::{Decode, DecodeOwned, Encode};
+use rust_decimal::Decimal;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, HashMap};
 use std::fmt::Debug;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 use std::num::NonZeroU32;
 use std::time::Duration;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
-use rust_decimal::Decimal;
 
 #[inline(never)]
 fn test_derive<T: Debug + PartialEq + Encode + DecodeOwned>(data: &[u8]) {
@@ -148,10 +148,20 @@ fuzz_target!(|data: &[u8]| {
         A,
         B,
         C(u16),
-        D { a: u8, b: u8, #[serde(skip)] #[bitcode(skip)] c: u8 },
+        D {
+            a: u8,
+            b: u8,
+            #[serde(skip)]
+            #[bitcode(skip)]
+            c: u8,
+        },
         E(String),
         F,
-        G(#[bitcode(skip)] #[serde(skip)] i16),
+        G(
+            #[bitcode(skip)]
+            #[serde(skip)]
+            i16,
+        ),
         P(BTreeMap<u16, u8>),
     }
 
@@ -233,5 +243,13 @@ fuzz_target!(|data: &[u8]| {
         SocketAddrV6,
         SocketAddr,
         time::Time,
+        chrono::NaiveTime,
+        chrono::NaiveDate,
+        chrono::NaiveDateTime,
+        chrono::DateTime<chrono::Utc>,
+        jiff::civil::Date,
+        jiff::civil::Time,
+        jiff::Timestamp,
+        jiff::Zoned,
     );
 });

src/derive/mod.rs

@@ -10,6 +10,8 @@ pub(crate) mod convert;
 mod duration;
 mod empty;
 mod impls;
+#[cfg(any(feature = "chrono", feature = "jiff"))]
+pub(crate) mod try_convert;
 // TODO: When ip_in_core has been stable (https://github.com/rust-lang/rust/issues/108443)
 // for long enough, remove feature check.
 #[cfg(feature = "std")]

src/derive/try_convert.rs

@@ -0,0 +1,81 @@
+use crate::{
+    coder::{Decoder, View},
+    derive::Decode,
+    fast::{CowSlice, PushUnchecked, SliceImpl, Unaligned},
+};
+
+#[allow(unused)]
+macro_rules! impl_try_convert {
+    ($want: path, $have: ty) => {
+        impl_try_convert!($want, $have, $have);
+    };
+    ($want: path, $have_encode: ty, $have_decode: ty) => {
+        impl crate::derive::Encode for $want {
+            type Encoder = crate::derive::convert::ConvertIntoEncoder<$have_encode>;
+        }
+        impl<'a> crate::derive::Decode<'a> for $want {
+            type Decoder =
+                crate::derive::try_convert::TryConvertFromDecoder<'a, $have_decode, $want>;
+        }
+    };
+}
+
+#[allow(unused)]
+pub(crate) use impl_try_convert;
+
+// Like [`TryFrom`] but we can implement it ourselves.
+pub trait TryConvertFrom<T>: Sized {
+    fn try_convert_from(value: T) -> Result<Self, crate::Error>;
+}
+/// Decodes a `T` and then converts it with [`TryConvertFrom`].
+pub struct TryConvertFromDecoder<'a, T: Decode<'a>, F: TryConvertFrom<T>> {
+    data: CowSlice<'a, F>,
+    decoder: T::Decoder,
+}
+
+// Can't derive since it would bound T: Default.
+impl<'a, T: Decode<'a>, F: TryConvertFrom<T>> Default for TryConvertFromDecoder<'a, T, F> {
+    fn default() -> Self {
+        Self {
+            data: CowSlice::with_allocation(Vec::new()),
+            decoder: Default::default(),
+        }
+    }
+}
+
+impl<'a, T: Decode<'a>, F: TryConvertFrom<T>> View<'a> for TryConvertFromDecoder<'a, T, F> {
+    fn populate(&mut self, input: &mut &'a [u8], length: usize) -> Result<(), crate::Error> {
+        self.decoder.populate(input, length)?;
+
+        let out: &mut Vec<F> = &mut self.data.set_owned();
+        out.reserve(length);
+
+        for _ in 0..length {
+            let value = F::try_convert_from(self.decoder.decode())?;
+            unsafe { out.push_unchecked(value) };
+        }
+
+        Ok(())
+    }
+}
+
+impl<'a, T: Decode<'a>, F: TryConvertFrom<T> + Send + Sync> Decoder<'a, F>
+    for TryConvertFromDecoder<'a, T, F>
+{
+    #[inline(always)]
+    fn as_primitive(&mut self) -> Option<&mut SliceImpl<'_, Unaligned<F>>> {
+        None
+    }
+
+    #[inline(always)]
+    fn decode(&mut self) -> F {
+        let slice = self.data.mut_slice();
+        let ptr = slice.as_ptr();
+        unsafe {
+            let val = ptr.read();
+            slice.advance(1);
+
+            val
+        }
+    }
+}

src/ext/chrono.rs

@@ -0,0 +1,20 @@
+mod date_time_utc;
+mod naive_date;
+mod naive_date_time;
+mod naive_time;
+
+use crate::int::ranged_int;
+
+ranged_int!(Hour, u8, 0, 23);
+ranged_int!(Minute, u8, 0, 59);
+ranged_int!(Second, u8, 0, 59);
+ranged_int!(Nanosecond, u32, 0, 1_999_999_999);
+
+type TimeEncode = (u8, u8, u8, u32);
+type TimeDecode = (Hour, Minute, Second, Nanosecond);
+
+type DateEncode = i32;
+type DateDecode = i32;
+
+type DateTimeEncode = (DateEncode, TimeEncode);
+type DateTimeDecode = (DateEncode, TimeDecode);

src/ext/chrono/date_time_utc.rs

@@ -0,0 +1,70 @@
+use chrono::{DateTime, NaiveDateTime, Utc};
+
+use crate::{
+    convert::ConvertFrom,
+    ext::chrono::{DateTimeDecode, DateTimeEncode},
+    try_convert::{impl_try_convert, TryConvertFrom},
+};
+
+impl_try_convert!(DateTime<Utc>, DateTimeEncode, DateTimeDecode);
+
+impl ConvertFrom<&DateTime<Utc>> for DateTimeEncode {
+    fn convert_from(x: &DateTime<Utc>) -> Self {
+        DateTimeEncode::convert_from(&x.naive_utc())
+    }
+}
+
+impl TryConvertFrom<DateTimeDecode> for DateTime<Utc> {
+    fn try_convert_from(enc: DateTimeDecode) -> Result<Self, crate::Error> {
+        NaiveDateTime::try_convert_from(enc)
+            .map(|naive| DateTime::from_naive_utc_and_offset(naive, Utc))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::vec::Vec;
+    use chrono::{DateTime, NaiveDate, Utc};
+
+    #[test]
+    fn test_chrono_datetime_utc() {
+        let ymds = [
+            (1970, 1, 1), // epoch
+            (2025, 10, 6),
+            (1, 1, 1),
+            (-44, 3, 15), // BCE
+            (9999, 12, 31),
+        ];
+
+        for &(y, m, d) in ymds.iter() {
+            let naive = NaiveDate::from_ymd_opt(y, m, d)
+                .unwrap()
+                .and_hms_opt(12, 34, 56)
+                .unwrap();
+            let dt_utc = DateTime::<Utc>::from_naive_utc_and_offset(naive, Utc);
+
+            let enc = crate::encode(&dt_utc);
+            let decoded: DateTime<Utc> = crate::decode(&enc).unwrap();
+
+            assert_eq!(dt_utc, decoded, "failed for datetime {:?}", dt_utc);
+        }
+    }
+
+    fn bench_data() -> Vec<DateTime<Utc>> {
+        crate::random_data(1000)
+            .into_iter()
+            .map(
+                |(y, m, d, h, mi, s, n, _offset_sec): (i32, u32, u32, u32, u32, u32, u32, i32)| {
+                    let naive =
+                        NaiveDate::from_ymd_opt((y % 9999).max(1), (m % 12).max(1), (d % 28) + 1)
+                            .unwrap()
+                            .and_hms_nano_opt(h % 24, mi % 60, s % 60, n % 1_000_000_000)
+                            .unwrap();
+                    DateTime::<Utc>::from_naive_utc_and_offset(naive, Utc)
+                },
+            )
+            .collect()
+    }
+
+    crate::bench_encode_decode!(utc_vec: Vec<DateTime<Utc>>);
+}

src/ext/chrono/naive_date.rs

@@ -0,0 +1,60 @@
+use chrono::{Datelike, NaiveDate};
+
+use crate::{
+    convert::ConvertFrom,
+    ext::chrono::{DateDecode, DateEncode},
+    try_convert::{impl_try_convert, TryConvertFrom},
+};
+
+impl_try_convert!(NaiveDate, DateEncode, DateDecode);
+
+impl ConvertFrom<&NaiveDate> for DateEncode {
+    fn convert_from(days: &NaiveDate) -> Self {
+        days.num_days_from_ce()
+    }
+}
+
+impl TryConvertFrom<DateDecode> for NaiveDate {
+    fn try_convert_from(days: DateDecode) -> Result<Self, crate::Error> {
+        NaiveDate::from_num_days_from_ce_opt(days)
+            .ok_or_else(|| crate::error::error("Failed to convert DateDecode to chrono::NaiveDate"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_chrono_naive_date() {
+        let dates = [
+            NaiveDate::from_ymd_opt(1970, 1, 1).unwrap(), // epoch
+            NaiveDate::from_ymd_opt(2025, 10, 6).unwrap(),
+            NaiveDate::from_ymd_opt(1, 1, 1).unwrap(),
+            NaiveDate::from_ymd_opt(-44, 3, 15).unwrap(), // BCE
+            NaiveDate::from_ymd_opt(-44, 3, 15).unwrap(), // BCE
+            NaiveDate::from_ymd_opt(9999, 12, 31).unwrap(),
+        ];
+
+        for x in dates {
+            let enc = crate::encode(&x);
+            let date: NaiveDate = crate::decode(&enc).unwrap();
+
+            assert_eq!(x, date, "failed for date {:?}", x);
+        }
+    }
+
+    use alloc::vec::Vec;
+    use chrono::NaiveDate;
+
+    fn bench_data() -> Vec<NaiveDate> {
+        crate::random_data(1000)
+            .into_iter()
+            .map(|(y, m, d): (i32, u32, u32)| {
+                let year = (y % 9999).max(1); // 1 ~ 9998
+                let month = (m % 12).max(1); // 1 ~ 12
+                let day = (d % 28) + 1; // 1 ~ 28
+                NaiveDate::from_ymd_opt(year, month, day).unwrap()
+            })
+            .collect()
+    }
+    crate::bench_encode_decode!(data: Vec<_>);
+}