Fix serde support for Dim migration

Author: bluss

src/array_serde.rs

@@ -7,12 +7,36 @@
 // except according to those terms.
 use serde::{self, Serialize, Deserialize};
 
+use std::marker::PhantomData;
+
 use imp_prelude::*;
 
 use super::arraytraits::ARRAY_FORMAT_VERSION;
 use super::Elements;
+use Dim;
+use dimension::DimPrivate;
 
-use std::marker::PhantomData;
+/// **Requires crate feature `"serde"`**
+impl<I> Serialize for Dim<I>
+    where I: Serialize,
+{
+    fn serialize<Se>(&self, serializer: &mut Se) -> Result<(), Se::Error>
+        where Se: serde::Serializer
+    {
+        self.ix().serialize(serializer)
+    }
+}
+
+/// **Requires crate feature `"serde"`**
+impl<I> Deserialize for Dim<I>
+    where I: Deserialize,
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: serde::de::Deserializer
+    {
+        I::deserialize(deserializer).map(Dim::new)
+    }
+}
 
 /// **Requires crate feature `"serde"`**
 impl<A, D, S> Serialize for ArrayBase<S, D>

tests/serialize.rs

@@ -1,7 +1,8 @@
 #![cfg(any(feature = "rustc-serialize", feature = "serde"))]
 #[cfg(feature = "rustc-serialize")]
 extern crate rustc_serialize as serialize;
-extern crate ndarray;
+
+#[macro_use] extern crate ndarray;
 
 #[cfg(feature = "serde")]
 extern crate serde;
@@ -12,7 +13,7 @@ extern crate serde_json;
 #[cfg(feature = "rustc-serialize")]
 use serialize::json;
 
-use ndarray::{arr0, arr1, arr2, RcArray, Ix, S, Si};
+use ndarray::{arr0, arr1, arr2, RcArray, RcArray1, RcArray2};
 
 #[cfg(feature = "rustc-serialize")]
 #[test]
@@ -44,15 +45,15 @@ fn serial_many_dim()
         println!("{:?}", res);
         assert_eq!(a, res.unwrap());
         let text = r##"{"v":1,"dim":[2,3],"data":[3,1,2.2,3.1,4,7]}"##;
-        let b = json::decode::<RcArray<f32, (Ix, Ix)>>(text);
+        let b = json::decode::<RcArray2<f32>>(text);
         assert_eq!(a, b.unwrap());
     }
 
 
     {
         // Test a sliced array.
         let mut a = RcArray::linspace(0., 31., 32).reshape((2, 2, 2, 4));
-        a.islice(&[Si(0, None, -1), S, S, Si(0, Some(2), 1)]);
+        a.islice(s![..;-1, .., .., ..2]);
         let serial = json::encode(&a).unwrap();
         println!("Encode {:?} => {:?}", a, serial);
         let res = json::decode::<RcArray<f32, _>>(&serial);
@@ -67,13 +68,13 @@ fn serial_wrong_count()
 {
     // one element too few
     let text = r##"{"v":1,"dim":[2,3],"data":[3,1,2.2,3.1,4]}"##;
-    let arr = json::decode::<RcArray<f32, (Ix, Ix)>>(text);
+    let arr = json::decode::<RcArray2<f32>>(text);
     println!("{:?}", arr);
     assert!(arr.is_err());
 
     // future version
     let text = r##"{"v":200,"dim":[2,3],"data":[3,1,2.2,3.1,4,7]}"##;
-    let arr = json::decode::<RcArray<f32, (Ix, Ix)>>(text);
+    let arr = json::decode::<RcArray2<f32>>(text);
     println!("{:?}", arr);
     assert!(arr.is_err());
 }
@@ -95,7 +96,7 @@ fn serial_many_dim_serde()
         let a = arr1::<f32>(&[2.72, 1., 2.]);
         let serial = serde_json::to_string(&a).unwrap();
         println!("Serde encode {:?} => {:?}", a, serial);
-        let res = serde_json::from_str::<RcArray<f32, _>>(&serial);
+        let res = serde_json::from_str::<RcArray1<f32>>(&serial);
         println!("{:?}", res);
         assert_eq!(a, res.unwrap());
     }
@@ -104,18 +105,18 @@ fn serial_many_dim_serde()
         let a = arr2(&[[3., 1., 2.2], [3.1, 4., 7.]]);
         let serial = serde_json::to_string(&a).unwrap();
         println!("Serde encode {:?} => {:?}", a, serial);
-        let res = serde_json::from_str::<RcArray<f32, _>>(&serial);
+        let res = serde_json::from_str::<RcArray2<f32>>(&serial);
         println!("{:?}", res);
         assert_eq!(a, res.unwrap());
         let text = r##"{"v":1,"dim":[2,3],"data":[3,1,2.2,3.1,4,7]}"##;
-        let b = serde_json::from_str::<RcArray<f32, (Ix, Ix)>>(text);
+        let b = serde_json::from_str::<RcArray2<f32>>(text);
         assert_eq!(a, b.unwrap());
     }
 
     {
         // Test a sliced array.
         let mut a = RcArray::linspace(0., 31., 32).reshape((2, 2, 2, 4));
-        a.islice(&[Si(0, None, -1), S, S, Si(0, Some(2), 1)]);
+        a.islice(s![..;-1, .., .., ..2]);
         let serial = serde_json::to_string(&a).unwrap();
         println!("Encode {:?} => {:?}", a, serial);
         let res = serde_json::from_str::<RcArray<f32, _>>(&serial);
@@ -130,13 +131,13 @@ fn serial_wrong_count_serde()
 {
     // one element too few
     let text = r##"{"v":1,"dim":[2,3],"data":[3,1,2.2,3.1,4]}"##;
-    let arr = serde_json::from_str::<RcArray<f32, (Ix, Ix)>>(text);
+    let arr = serde_json::from_str::<RcArray2<f32>>(text);
     println!("{:?}", arr);
     assert!(arr.is_err());
 
     // future version
     let text = r##"{"v":200,"dim":[2,3],"data":[3,1,2.2,3.1,4,7]}"##;
-    let arr = serde_json::from_str::<RcArray<f32, (Ix, Ix)>>(text);
+    let arr = serde_json::from_str::<RcArray2<f32>>(text);
     println!("{:?}", arr);
     assert!(arr.is_err());
 }