- frame caching

src/readers.rs

@@ -143,8 +143,8 @@ pub trait Reader: Clone + Sized + Debug + Send + Hash + Into<DynReader> {
     where
         P: AsRef<Path>;
 
-    fn reader_name(&self) -> String {
-        type_name::<Self>().to_string()
+    fn reader_name(&self) -> &'static str {
+        type_name::<Self>()
     }
 
     // TODO: read from file if present
@@ -257,83 +257,77 @@ impl_frame_cast! {
     isize: INT32
 }
 
-impl<D, T> TryInto<Array<T, D>> for ArrayT<D>
-where
-    D: Dimension,
-    T: FromPrimitive + Zero + 'static,
-{
-    type Error = Error;
-
-    fn try_into(self) -> Result<Array<T, D>, Self::Error> {
+macro_rules! try_into_array_body {
+    ($self:expr, $map:ident) => {{
         let mut err = Ok(());
-        let arr = match self {
-            ArrayT::I8(v) => v.mapv_into_any(|x| {
+        let arr = match $self {
+            ArrayT::I8(v) => v.$map(|x| {
                 T::from_i8(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
                 })
             }),
-            ArrayT::U8(v) => v.mapv_into_any(|x| {
+            ArrayT::U8(v) => v.$map(|x| {
                 T::from_u8(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
                 })
             }),
-            ArrayT::I16(v) => v.mapv_into_any(|x| {
+            ArrayT::I16(v) => v.$map(|x| {
                 T::from_i16(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
                 })
             }),
-            ArrayT::U16(v) => v.mapv_into_any(|x| {
+            ArrayT::U16(v) => v.$map(|x| {
                 T::from_u16(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
                 })
             }),
-            ArrayT::I32(v) => v.mapv_into_any(|x| {
+            ArrayT::I32(v) => v.$map(|x| {
                 T::from_i32(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
                 })
             }),
-            ArrayT::U32(v) => v.mapv_into_any(|x| {
+            ArrayT::U32(v) => v.$map(|x| {
                 T::from_u32(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
                 })
             }),
-            ArrayT::F32(v) => v.mapv_into_any(|x| {
+            ArrayT::F32(v) => v.$map(|x| {
                 T::from_f32(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
                 })
             }),
-            ArrayT::F64(v) | ArrayT::F128(v) => v.mapv_into_any(|x| {
+            ArrayT::F64(v) | ArrayT::F128(v) => v.$map(|x| {
                 T::from_f64(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
                 })
             }),
-            ArrayT::I64(v) => v.mapv_into_any(|x| {
+            ArrayT::I64(v) => v.$map(|x| {
                 T::from_i64(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
                 })
             }),
-            ArrayT::U64(v) => v.mapv_into_any(|x| {
+            ArrayT::U64(v) => v.$map(|x| {
                 T::from_u64(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
                 })
             }),
-            ArrayT::I128(v) => v.mapv_into_any(|x| {
+            ArrayT::I128(v) => v.$map(|x| {
                 T::from_i128(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
                 })
             }),
-            ArrayT::U128(v) => v.mapv_into_any(|x| {
+            ArrayT::U128(v) => v.$map(|x| {
                 T::from_u128(x).unwrap_or_else(|| {
                     err = Err(Error::Cast(x.to_string(), type_name::<T>().to_string()));
                     T::zero()
@@ -344,6 +338,30 @@ where
             Err(err) => Err(err),
             Ok(()) => Ok(arr),
         }
+    }};
+}
+
+impl<D, T> TryInto<Array<T, D>> for ArrayT<D>
+where
+    D: Dimension,
+    T: FromPrimitive + Zero + 'static,
+{
+    type Error = Error;
+
+    fn try_into(self) -> Result<Array<T, D>, Self::Error> {
+        try_into_array_body!(self, mapv_into_any)
+    }
+}
+
+impl<D, T> TryInto<Array<T, D>> for &ArrayT<D>
+where
+    D: Dimension,
+    T: Clone + FromPrimitive + Zero + 'static,
+{
+    type Error = Error;
+
+    fn try_into(self) -> Result<Array<T, D>, Self::Error> {
+        try_into_array_body!(self, mapv)
     }
 }
 
@@ -398,8 +416,8 @@ impl Reader for DynReader {
         ))
     }
 
-    fn reader_name(&self) -> String {
-        let name = match self {
+    fn reader_name(&self) -> &'static str {
+        match self {
             #[cfg(feature = "tiff")]
             DynReader::Tiff(r) => r.reader_name(),
             #[cfg(feature = "tiffseq")]
@@ -412,8 +430,7 @@ impl Reader for DynReader {
             DynReader::BioFormatsJava(r) => r.reader_name(),
             #[allow(unreachable_patterns)]
             _ => unreachable!(),
-        };
-        format!("DynReader<{}>", name)
+        }
     }
 
     fn metadata(&self) -> Result<Ome, Error> {