Add support for std::sync::atomic

Author: Rebekah Kim

src/derive/atomic.rs

@@ -0,0 +1,160 @@
+use super::convert::ConvertFrom;
+use std::sync::atomic;
+
+macro_rules! atomic_impl {
+    ($atomic: path, $repr: ident) => {
+        impl ConvertFrom<&$atomic> for $repr {
+            fn convert_from(atomic: &$atomic) -> Self {
+                atomic.load(std::sync::atomic::Ordering::Relaxed)
+            }
+        }
+
+        impl ConvertFrom<$repr> for $atomic {
+            fn convert_from(bits: $repr) -> Self {
+                Self::from(bits)
+            }
+        }
+    };
+}
+
+atomic_impl!(atomic::AtomicBool, bool);
+atomic_impl!(atomic::AtomicI8, i8);
+atomic_impl!(atomic::AtomicI16, i16);
+atomic_impl!(atomic::AtomicI32, i32);
+atomic_impl!(atomic::AtomicI64, i64);
+atomic_impl!(atomic::AtomicIsize, isize);
+atomic_impl!(atomic::AtomicU8, u8);
+atomic_impl!(atomic::AtomicU16, u16);
+atomic_impl!(atomic::AtomicU32, u32);
+atomic_impl!(atomic::AtomicU64, u64);
+atomic_impl!(atomic::AtomicUsize, usize);
+
+#[cfg(test)]
+mod tests {
+    use crate::{decode, encode, Decode, Encode};
+    use std::sync::atomic::*;
+
+    #[allow(unused)]
+    #[test]
+    fn test_atomic() {
+        macro_rules! atomic_test {
+            ($atomic: ident, $inner: expr) => {
+                assert!(decode::<$atomic>(&encode(&$atomic::new($inner)))
+                    .is_ok_and(|x| x.load(Ordering::Relaxed) == $inner));
+            };
+        }
+        atomic_test!(AtomicBool, true);
+        atomic_test!(AtomicI8, -128i8);
+        atomic_test!(AtomicI16, -5897i16);
+        atomic_test!(AtomicI32, -487952i32);
+        atomic_test!(AtomicI64, -783414i64);
+        atomic_test!(AtomicIsize, isize::MIN);
+        atomic_test!(AtomicU8, 255u8);
+        atomic_test!(AtomicU16, 8932u16);
+        atomic_test!(AtomicU32, 58902u32);
+        atomic_test!(AtomicU64, 90887783u64);
+        atomic_test!(AtomicUsize, usize::MAX);
+    }
+
+    #[derive(Default, Encode, Decode)]
+    struct AtomicStruct {
+        a: AtomicBool,
+        b: AtomicI8,
+        c: AtomicI16,
+        d: AtomicI32,
+        e: AtomicI64,
+        f: AtomicIsize,
+        g: AtomicU8,
+        h: AtomicU16,
+        i: AtomicU32,
+        j: AtomicU64,
+        k: AtomicUsize,
+    }
+    impl AtomicStruct {
+        fn new(value: i32) -> Self {
+            Self {
+                d: AtomicI32::new(value),
+                ..Default::default()
+            }
+        }
+        fn load(&self, ordering: Ordering) -> i32 {
+            self.d.load(ordering)
+        }
+    }
+
+    #[allow(unused)]
+    #[test]
+    fn test_struct_atomic() {
+        macro_rules! atomic_struct_test {
+            ($field: ident, $atomic: ident, $inner: expr) => {
+                let original = AtomicStruct::default();
+                let encoded = encode(&original);
+                let decoded = decode::<AtomicStruct>(&encoded).unwrap();
+                assert_eq!(
+                    original.$field.load(Ordering::Relaxed),
+                    decoded.$field.load(Ordering::Relaxed)
+                );
+            };
+        }
+
+        atomic_struct_test!(a, AtomicBool, true);
+        atomic_struct_test!(b, AtomicI8, -128i8);
+        atomic_struct_test!(c, AtomicI16, -5897i16);
+        atomic_struct_test!(d, AtomicI32, -487952i32);
+        atomic_struct_test!(e, AtomicI64, -783414i64);
+        atomic_struct_test!(f, AtomicIsize, isize::MIN);
+        atomic_struct_test!(g, AtomicU8, 255u8);
+        atomic_struct_test!(h, AtomicU16, 8932u16);
+        atomic_struct_test!(i, AtomicU32, 58902u32);
+        atomic_struct_test!(j, AtomicU64, 90887783u64);
+        atomic_struct_test!(k, AtomicUsize, usize::MAX);
+    }
+
+    #[allow(unused)]
+    #[test]
+    fn test_enum_atomic() {
+        macro_rules! atomic_enum_test {
+            ($variant: ident, $atomic: ident, $inner: expr) => {
+                let original = AtomicEnum::$variant($atomic::new($inner));
+                let encoded = encode(&original);
+                let decoded = decode::<AtomicEnum>(&encoded).unwrap();
+                match (original, decoded) {
+                    (AtomicEnum::$variant(a), AtomicEnum::$variant(b)) => {
+                        assert_eq!(a.load(Ordering::Relaxed), b.load(Ordering::Relaxed))
+                    }
+                    _ => panic!("Enum variant mismatch"),
+                }
+            };
+        }
+
+        #[derive(Encode, Decode)]
+        enum AtomicEnum {
+            A(AtomicBool),
+            B(AtomicI8),
+            C(AtomicI16),
+            D(AtomicI32),
+            E(AtomicI64),
+            F(AtomicIsize),
+            G(AtomicU8),
+            H(AtomicU16),
+            I(AtomicU32),
+            J(AtomicU64),
+            K(AtomicUsize),
+            L(NestedAtomic),
+        }
+        type NestedAtomic = AtomicStruct;
+
+        atomic_enum_test!(A, AtomicBool, true);
+        atomic_enum_test!(B, AtomicI8, -128i8);
+        atomic_enum_test!(C, AtomicI16, -5897i16);
+        atomic_enum_test!(D, AtomicI32, -487952i32);
+        atomic_enum_test!(E, AtomicI64, -783414i64);
+        atomic_enum_test!(F, AtomicIsize, isize::MIN);
+        atomic_enum_test!(G, AtomicU8, 255u8);
+        atomic_enum_test!(H, AtomicU16, 8932u16);
+        atomic_enum_test!(I, AtomicU32, 58902u32);
+        atomic_enum_test!(J, AtomicU64, 90887783u64);
+        atomic_enum_test!(K, AtomicUsize, usize::MAX);
+        atomic_enum_test!(L, NestedAtomic, 37982i32);
+    }
+}

src/derive/impls.rs

@@ -167,6 +167,7 @@ mod with_std {
     use crate::derive::convert::impl_convert;
     use core::hash::{BuildHasher, Hash};
     use std::collections::{HashMap, HashSet};
+    use std::sync::atomic;
 
     impl<T: Encode, S> Encode for HashSet<T, S> {
         type Encoder = VecEncoder<T>;
@@ -183,6 +184,18 @@ mod with_std {
         type Decoder = MapDecoder<'a, K, V>;
     }
 
+    impl_convert!(atomic::AtomicBool, bool);
+    impl_convert!(atomic::AtomicI8, i8);
+    impl_convert!(atomic::AtomicI16, i16);
+    impl_convert!(atomic::AtomicI32, i32);
+    impl_convert!(atomic::AtomicI64, i64);
+    impl_convert!(atomic::AtomicIsize, isize);
+    impl_convert!(atomic::AtomicU8, u8);
+    impl_convert!(atomic::AtomicU16, u16);
+    impl_convert!(atomic::AtomicU32, u32);
+    impl_convert!(atomic::AtomicU64, u64);
+    impl_convert!(atomic::AtomicUsize, usize);
+
     macro_rules! impl_ipvx_addr {
         ($addr: ident, $repr: ident) => {
             impl_convert!(std::net::$addr, $repr);

src/derive/mod.rs

@@ -5,6 +5,8 @@ use alloc::vec::Vec;
 use core::num::NonZeroUsize;
 
 mod array;
+#[cfg(feature = "std")]
+mod atomic;
 pub(crate) mod convert;
 mod duration;
 mod empty;