clippy

src/errors.rs

@@ -86,10 +86,17 @@ pub enum MessageNdarrayError {
     /// Returned when length of values array is not equal to
     /// product of Ni and Nj keys.
     #[error("The length of the values array ({0}) is different than expected ({1})")]
-    UnexpectedValuesLength(usize, i64),
+    UnexpectedValuesLength(usize, usize),
 
+    /// Returned when ndarray cannot create an array with the shape
+    /// defined by Ni and Nj keys.
     #[error("Error occured while converting to ndarray: {0}")]
     InvalidShape(#[from] ndarray::ShapeError),
+
+    /// This error can occur when casting types of shape fails
+    /// on 32-bit systems or for very large arrays.
+    #[error(transparent)]
+    IntCasting(#[from] std::num::TryFromIntError),
 }
 
 #[derive(Copy, Eq, PartialEq, Clone, Ord, PartialOrd, Hash, Error, Debug, FromPrimitive)]

src/intermediate_bindings/codes_get.rs

@@ -1,3 +1,6 @@
+#![allow(non_camel_case_types)]
+#![allow(clippy::module_name_repetitions)]
+
 use std::ffi::{CStr, CString};
 
 use eccodes_sys::codes_handle;

src/intermediate_bindings/codes_handle.rs

@@ -1,3 +1,6 @@
+#![allow(non_camel_case_types)]
+#![allow(clippy::module_name_repetitions)]
+
 use std::ptr::{self};
 
 use eccodes_sys::{codes_context, codes_handle};

src/intermediate_bindings/codes_keys.rs

@@ -1,3 +1,6 @@
+#![allow(non_camel_case_types)]
+#![allow(clippy::module_name_repetitions)]
+
 use std::ffi::{CStr, CString};
 
 use eccodes_sys::{codes_handle, codes_keys_iterator};

src/intermediate_bindings/codes_set.rs

@@ -1,3 +1,6 @@
+#![allow(non_camel_case_types)]
+#![allow(clippy::module_name_repetitions)]
+
 use std::ffi::CString;
 
 use eccodes_sys::codes_handle;

src/intermediate_bindings/grib_nearest.rs

@@ -1,3 +1,6 @@
+#![allow(non_camel_case_types)]
+#![allow(clippy::module_name_repetitions)]
+
 use std::ptr::addr_of_mut;
 
 use eccodes_sys::{codes_handle, codes_nearest, CODES_NEAREST_SAME_DATA, CODES_NEAREST_SAME_GRID};

src/keyed_message/mod.rs

@@ -51,6 +51,9 @@ pub enum KeyType {
 impl Clone for KeyedMessage {
     ///Custom function to clone the `KeyedMessage`. This function comes with memory overhead.
     ///During clone iterator flags and namespace are not copied, and the iterator is reset.
+    /// 
+    /// # Panics
+    /// This function will panic if ecCodes fails to clone the message.
     fn clone(&self) -> KeyedMessage {
         let new_handle =
             unsafe { codes_handle_clone(self.message_handle).expect("Cannot clone the message") };

src/keys_iterator.rs

@@ -12,6 +12,7 @@ use crate::{
     Key, KeyedMessage,
 };
 
+#[allow(clippy::module_name_repetitions)]
 #[derive(Debug)]
 pub struct KeysIterator<'a> {
     parent_message: &'a KeyedMessage,
@@ -21,6 +22,7 @@ pub struct KeysIterator<'a> {
 
 ///Flags to specify the subset of keys to iterate over
 ///by `FallibleIterator` in `KeyedMessage`. The flags can be used together.
+#[allow(clippy::module_name_repetitions)]
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
 pub enum KeysIteratorFlags {
     ///Iterate over all keys
@@ -89,13 +91,13 @@ impl KeyedMessage {
     ///```
     pub fn new_keys_iterator(
         &self,
-        flags: Vec<KeysIteratorFlags>,
+        flags: &[KeysIteratorFlags],
         namespace: &str,
     ) -> Result<KeysIterator, CodesError> {
         let flags = flags.iter().map(|f| *f as u32).sum();
 
         let iterator_handle =
-            unsafe { codes_keys_iterator_new(self.message_handle, flags, &namespace)? };
+            unsafe { codes_keys_iterator_new(self.message_handle, flags, namespace)? };
         let next_item_exists = unsafe { codes_keys_iterator_next(iterator_handle)? };
 
         Ok(KeysIterator {
@@ -217,7 +219,7 @@ mod tests {
 
         let namespace = "geography";
 
-        let mut kiter = current_message.new_keys_iterator(flags, namespace)?;
+        let mut kiter = current_message.new_keys_iterator(&flags, namespace)?;
 
         while let Some(key) = kiter.next()? {
             assert!(!key.name.is_empty());
@@ -240,7 +242,7 @@ mod tests {
 
         let namespace = "blabla";
 
-        let mut kiter = current_message.new_keys_iterator(flags, namespace)?;
+        let mut kiter = current_message.new_keys_iterator(&flags, namespace)?;
 
         while let Some(key) = kiter.next()? {
             assert!(!key.name.is_empty());

src/message_ndarray.rs

@@ -2,75 +2,78 @@ use ndarray::{s, Array2, Array3};
 
 use crate::{errors::MessageNdarrayError, CodesError, KeyType, KeyedMessage};
 
+#[derive(Clone, PartialEq, Debug, Default)]
+pub struct RustyCodesMessage {
+    pub longitudes: Array2<f64>,
+    pub latitudes: Array2<f64>,
+    pub values: Array2<f64>,
+}
+
 impl KeyedMessage {
     /// Returns [y, x] ([Nj, Ni], [lat, lon]) ndarray from the message,
     /// x coordinates are increasing with the i index,
     /// y coordinates are decreasing with the j index.
     pub fn to_ndarray(&self) -> Result<Array2<f64>, CodesError> {
-        let ni = if let KeyType::Int(ni) = self.read_key("Ni")?.value {
-            ni
-        } else {
+        let KeyType::Int(ni) = self.read_key("Ni")?.value else {
             return Err(MessageNdarrayError::UnexpectedKeyType("Ni".to_owned()).into());
         };
 
-        let nj = if let KeyType::Int(nj) = self.read_key("Nj")?.value {
-            nj
-        } else {
+        let KeyType::Int(nj) = self.read_key("Nj")?.value else {
             return Err(MessageNdarrayError::UnexpectedKeyType("Nj".to_owned()).into());
         };
 
-        let vals = if let KeyType::FloatArray(vals) = self.read_key("values")?.value {
-            vals
-        } else {
+        let KeyType::FloatArray(vals) = self.read_key("values")?.value else {
             return Err(MessageNdarrayError::UnexpectedKeyType("values".to_owned()).into());
         };
 
-        if vals.len() != (ni * nj) as usize {
+        let ni = usize::try_from(ni).map_err(MessageNdarrayError::from)?;
+        let nj = usize::try_from(nj).map_err(MessageNdarrayError::from)?;
+
+        if vals.len() != (ni * nj) {
             return Err(MessageNdarrayError::UnexpectedValuesLength(vals.len(), ni * nj).into());
         }
 
-        let shape = (nj as usize, ni as usize);
-        let vals = Array2::from_shape_vec(shape, vals).map_err(|e| MessageNdarrayError::from(e))?;
+        let shape = (nj, ni);
+        let vals = Array2::from_shape_vec(shape, vals).map_err(MessageNdarrayError::from)?;
 
         Ok(vals)
     }
 
-    pub fn to_lons_lats_values(
-        &self,
-    ) -> Result<(Array2<f64>, Array2<f64>, Array2<f64>), CodesError> {
-        let ni = if let KeyType::Int(ni) = self.read_key("Ni")?.value {
-            ni
-        } else {
+    pub fn to_lons_lats_values(&self) -> Result<RustyCodesMessage, CodesError> {
+        let KeyType::Int(ni) = self.read_key("Ni")?.value else {
             return Err(MessageNdarrayError::UnexpectedKeyType("Ni".to_owned()).into());
         };
 
-        let nj = if let KeyType::Int(nj) = self.read_key("Nj")?.value {
-            nj
-        } else {
+        let KeyType::Int(nj) = self.read_key("Nj")?.value else {
             return Err(MessageNdarrayError::UnexpectedKeyType("Nj".to_owned()).into());
         };
 
-        let latlonvals = if let KeyType::FloatArray(vals) = self.read_key("latLonValues")?.value {
-            vals
-        } else {
-            return Err(MessageNdarrayError::UnexpectedKeyType("values".to_owned()).into());
+        let KeyType::FloatArray(latlonvals) = self.read_key("latLonValues")?.value else {
+            return Err(MessageNdarrayError::UnexpectedKeyType("latLonValues".to_owned()).into());
         };
 
-        if latlonvals.len() != (ni * nj * 3) as usize {
+        let ni = usize::try_from(ni).map_err(MessageNdarrayError::from)?;
+        let nj = usize::try_from(nj).map_err(MessageNdarrayError::from)?;
+
+        if latlonvals.len() != (ni * nj * 3) {
             return Err(
                 MessageNdarrayError::UnexpectedValuesLength(latlonvals.len(), ni * nj * 3).into(),
             );
         }
 
-        let shape = (nj as usize, ni as usize, 3_usize);
+        let shape = (nj, ni, 3_usize);
         let mut latlonvals =
-            Array3::from_shape_vec(shape, latlonvals).map_err(|e| MessageNdarrayError::from(e))?;
+            Array3::from_shape_vec(shape, latlonvals).map_err(MessageNdarrayError::from)?;
         let (lats, lons, vals) =
             latlonvals
                 .view_mut()
                 .multi_slice_move((s![.., .., 0], s![.., .., 1], s![.., .., 2]));
 
-        Ok((lons.into_owned(), lats.into_owned(), vals.into_owned()))
+        Ok(RustyCodesMessage {
+            longitudes: lons.into_owned(),
+            latitudes: lats.into_owned(),
+            values: vals.into_owned(),
+        })
     }
 }
 
@@ -118,7 +121,11 @@ mod tests {
 
         while let Some(msg) = handle.next()? {
             if msg.read_key("shortName")?.value == KeyType::Str("2d".to_string()) {
-                let (lons, lats, vals) = msg.to_lons_lats_values()?;
+                let rmsg = msg.to_lons_lats_values()?;
+
+                let vals = rmsg.values;
+                let lons = rmsg.longitudes;
+                let lats = rmsg.latitudes;
 
                 // values from cfgrib
                 assert_approx_eq!(f64, vals[[0, 0]], 276.37793, epsilon = 0.000_1);