Add optional serde serialization support

- Update ci to run serde tests
- Add serialization support for Enums except the enum `arrayfire::Scalar`
- Structs with serde support added
    - [x] Array
    - [x] Dim4
    - [x] Seq
    - [x] RandomEngine
- Structs without serde support
    - Features - currently not possible as `af_features` can't be recreated
      from individual `af_arrays` with current upstream API
    - Indexer - not possible with current API. Also, any subarray when fetched
      to host for serialization results in separate owned copy this making serde
      support for this unnecessary.
    - Callback
    - Event
    - Window

Author: 9prady9

.github/workflows/ci.yml

@@ -48,8 +48,8 @@ jobs:
                   export AF_PATH=${GITHUB_WORKSPACE}/afbin
                   export LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:${AF_PATH}/lib64
                   echo "Using cargo version: $(cargo --version)"
-                  cargo build --all
-                  cargo test --no-fail-fast
+                  cargo build --all --features="afserde"
+                  cargo test --no-fail-fast --features="afserde"
 
     format:
         name: Format Check

Cargo.toml

@@ -46,15 +46,19 @@ statistics = []
 vision = []
 default = ["algorithm", "arithmetic", "blas", "data", "indexing", "graphics", "image", "lapack",
 "ml", "macros", "random", "signal", "sparse", "statistics", "vision"]
+afserde = ["serde"]
 
 [dependencies]
 libc = "0.2"
 num  = "0.2"
 lazy_static = "1.0"
 half = "1.5.0"
+serde = { version = "1.0", features = ["derive"], optional = true }
 
 [dev-dependencies]
 half = "1.5.0"
+serde_json = "1.0"
+bincode = "1.3"
 
 [build-dependencies]
 serde_json = "1.0"

README.md

@@ -16,7 +16,7 @@ Only, Major(M) & Minor(m) version numbers need to match. *p1* and *p2* are patch
 
 ## Supported platforms
 
-Linux, Windows and OSX. Rust 1.15.1 or higher is required.
+Linux, Windows and OSX. Rust 1.31 or newer is required.
 
 ## Use from Crates.io [![][6]][7] [![][8]][9]
 

src/core/array.rs

@@ -4,7 +4,16 @@ use super::error::HANDLE_ERROR;
 use super::util::{af_array, dim_t, void_ptr, HasAfEnum};
 
 use libc::{c_char, c_int, c_longlong, c_uint, c_void};
+#[cfg(feature = "afserde")]
+use serde::de::{Deserializer, Error, Unexpected};
+#[cfg(feature = "afserde")]
+use serde::ser::Serializer;
+#[cfg(feature = "afserde")]
+use serde::{Deserialize, Serialize};
+use std::clone::Clone;
+use std::default::Default;
 use std::ffi::CString;
+use std::fmt::Debug;
 use std::marker::PhantomData;
 
 // Some unused functions from array.h in C-API of ArrayFire
@@ -851,12 +860,73 @@ pub fn is_eval_manual() -> bool {
     }
 }
 
+#[cfg(feature = "afserde")]
+#[derive(Debug, Serialize, Deserialize)]
+struct ArrayOnHost<T: HasAfEnum + Debug> {
+    dtype: DType,
+    shape: Dim4,
+    data: Vec<T>,
+}
+
+/// Serialize Implementation of Array
+#[cfg(feature = "afserde")]
+impl<T> Serialize for Array<T>
+where
+    T: Default + Clone + Serialize + HasAfEnum + Debug,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut vec = vec![T::default(); self.elements()];
+        self.host(&mut vec);
+        let arr_on_host = ArrayOnHost {
+            dtype: self.get_type(),
+            shape: self.dims().clone(),
+            data: vec,
+        };
+        arr_on_host.serialize(serializer)
+    }
+}
+
+/// Deserialize Implementation of Array
+#[cfg(feature = "afserde")]
+impl<'de, T> Deserialize<'de> for Array<T>
+where
+    T: Deserialize<'de> + HasAfEnum + Debug,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        match ArrayOnHost::<T>::deserialize(deserializer) {
+            Ok(arr_on_host) => {
+                let read_dtype = arr_on_host.dtype;
+                let expected_dtype = T::get_af_dtype();
+                if expected_dtype != read_dtype {
+                    let error_msg = format!(
+                        "data type is {:?}, deserialized type is {:?}",
+                        expected_dtype, read_dtype
+                    );
+                    return Err(Error::invalid_value(Unexpected::Enum, &error_msg.as_str()));
+                }
+                Ok(Array::<T>::new(
+                    &arr_on_host.data,
+                    arr_on_host.shape.clone(),
+                ))
+            }
+            Err(err) => Err(err),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
+    use super::super::super::algorithm::sum_all;
     use super::super::array::print;
     use super::super::data::constant;
     use super::super::device::{info, set_device, sync};
-    use crate::dim4;
+    use crate::{dim4, randu};
     use std::sync::{mpsc, Arc, RwLock};
     use std::thread;
 
@@ -1082,4 +1152,36 @@ mod tests {
         //    8.0000     8.0000     8.0000
         // ANCHOR_END: accum_using_channel
     }
+
+    #[test]
+    #[cfg(feature = "afserde")]
+    fn array_serde_json() {
+        use super::Array;
+
+        let input = randu!(u8; 2, 2);
+        let serd = match serde_json::to_string(&input) {
+            Ok(serialized_str) => serialized_str,
+            Err(e) => e.to_string(),
+        };
+
+        let deserd: Array<u8> = serde_json::from_str(&serd).unwrap();
+
+        assert_eq!(sum_all(&(input - deserd)), (0u32, 0u32));
+    }
+
+    #[test]
+    #[cfg(feature = "afserde")]
+    fn array_serde_bincode() {
+        use super::Array;
+
+        let input = randu!(u8; 2, 2);
+        let encoded = match bincode::serialize(&input) {
+            Ok(encoded) => encoded,
+            Err(_) => vec![],
+        };
+
+        let decoded: Array<u8> = bincode::deserialize(&encoded).unwrap();
+
+        assert_eq!(sum_all(&(input - decoded)), (0u32, 0u32));
+    }
 }