fix: use type inference in pointer casting

Cargo.toml

@@ -2,7 +2,7 @@
 name = "eccodes"
 description = "Unofficial high-level Rust bindings of the latest ecCodes release"
 repository = "https://github.com/ScaleWeather/eccodes"
-version = "0.13.2"
+version = "0.13.3"
 readme = "README.md"
 authors = ["Jakub Lewandowski <scaleweather@gmail.com>"]
 keywords = ["eccodes", "grib", "bufr", "meteorology", "weather"]

src/codes_handle/mod.rs

@@ -8,7 +8,7 @@ use crate::{
 };
 use eccodes_sys::{codes_handle, ProductKind_PRODUCT_GRIB};
 use errno::errno;
-use libc::{c_char, c_void, size_t, FILE};
+use libc::{c_void, size_t, FILE};
 use std::{
     fmt::Debug,
     fs::{File, OpenOptions},
@@ -294,7 +294,7 @@ impl CodesHandle<CodesIndex> {
 }
 
 fn open_with_fdopen(file: &File) -> Result<*mut FILE, CodesError> {
-    let file_ptr = unsafe { libc::fdopen(file.as_raw_fd(), "r".as_ptr().cast::<c_char>()) };
+    let file_ptr = unsafe { libc::fdopen(file.as_raw_fd(), "r".as_ptr().cast::<_>()) };
 
     if file_ptr.is_null() {
         let error_val = errno();
@@ -314,7 +314,7 @@ fn open_with_fmemopen(file_data: &[u8]) -> Result<*mut FILE, CodesError> {
         file_ptr = libc::fmemopen(
             file_data_ptr,
             file_data.len() as size_t,
-            "r".as_ptr().cast::<c_char>(),
+            "r".as_ptr().cast::<_>(),
         );
     }
 

src/codes_nearest.rs

@@ -45,7 +45,7 @@ impl KeyedMessage {
     ///
     /// This function returns [`CodesInternal`](crate::errors::CodesInternal) when
     /// internal nearest handle cannot be created.
-    pub fn codes_nearest<'a>(&'a self) -> Result<CodesNearest<'a>, CodesError> {
+    pub fn codes_nearest(&self) -> Result<CodesNearest<'_>, CodesError> {
         let nearest_handle = unsafe { codes_grib_nearest_new(self.message_handle)? };
 
         Ok(CodesNearest {

src/intermediate_bindings/codes_get.rs

@@ -23,7 +23,7 @@ pub unsafe fn codes_get_native_type(
     let key = CString::new(key).unwrap();
     let mut key_type: i32 = 0;
 
-    let error_code = eccodes_sys::codes_get_native_type(handle, key.as_ptr(), &mut key_type);
+    let error_code = eccodes_sys::codes_get_native_type(handle, key.as_ptr(), &raw mut key_type);
 
     if error_code != 0 {
         let err: CodesInternal = FromPrimitive::from_i32(error_code).unwrap();
@@ -39,7 +39,7 @@ pub unsafe fn codes_get_size(handle: *const codes_handle, key: &str) -> Result<u
     let key = CString::new(key).unwrap();
     let mut key_size: usize = 0;
 
-    let error_code = eccodes_sys::codes_get_size(handle, key.as_ptr(), &mut key_size);
+    let error_code = eccodes_sys::codes_get_size(handle, key.as_ptr(), &raw mut key_size);
 
     if error_code != 0 {
         let err: CodesInternal = FromPrimitive::from_i32(error_code).unwrap();
@@ -55,7 +55,7 @@ pub unsafe fn codes_get_long(handle: *const codes_handle, key: &str) -> Result<i
     let key = CString::new(key).unwrap();
     let mut key_value: i64 = 0;
 
-    let error_code = eccodes_sys::codes_get_long(handle, key.as_ptr(), &mut key_value);
+    let error_code = eccodes_sys::codes_get_long(handle, key.as_ptr(), &raw mut key_value);
 
     if error_code != 0 {
         let err: CodesInternal = FromPrimitive::from_i32(error_code).unwrap();
@@ -71,7 +71,7 @@ pub unsafe fn codes_get_double(handle: *const codes_handle, key: &str) -> Result
     let key = CString::new(key).unwrap();
     let mut key_value: f64 = 0.0;
 
-    let error_code = eccodes_sys::codes_get_double(handle, key.as_ptr(), &mut key_value);
+    let error_code = eccodes_sys::codes_get_double(handle, key.as_ptr(), &raw mut key_value);
 
     if error_code != 0 {
         let err: CodesInternal = FromPrimitive::from_i32(error_code).unwrap();
@@ -95,8 +95,8 @@ pub unsafe fn codes_get_double_array(
     let error_code = eccodes_sys::codes_get_double_array(
         handle,
         key.as_ptr(),
-        key_values.as_mut_ptr().cast::<f64>(),
-        &mut key_size,
+        key_values.as_mut_ptr().cast::<_>(),
+        &raw mut key_size,
     );
 
     if error_code != 0 {
@@ -121,8 +121,8 @@ pub unsafe fn codes_get_long_array(
     let error_code = eccodes_sys::codes_get_long_array(
         handle,
         key.as_ptr(),
-        key_values.as_mut_ptr().cast::<i64>(),
-        &mut key_size,
+        key_values.as_mut_ptr().cast::<_>(),
+        &raw mut key_size,
     );
 
     if error_code != 0 {
@@ -142,7 +142,7 @@ pub unsafe fn codes_get_length(
     let key = CString::new(key).unwrap();
     let mut key_length: usize = 0;
 
-    let error_code = eccodes_sys::codes_get_length(handle, key.as_ptr(), &mut key_length);
+    let error_code = eccodes_sys::codes_get_length(handle, key.as_ptr(), &raw mut key_length);
 
     if error_code != 0 {
         let err: CodesInternal = FromPrimitive::from_i32(error_code).unwrap();
@@ -166,8 +166,8 @@ pub unsafe fn codes_get_string(
     let error_code = eccodes_sys::codes_get_string(
         handle,
         key.as_ptr(),
-        key_message.as_mut_ptr().cast::<i8>(),
-        &mut key_length,
+        key_message.as_mut_ptr().cast::<_>(),
+        &raw mut key_length,
     );
 
     if error_code != 0 {
@@ -204,8 +204,8 @@ pub unsafe fn codes_get_bytes(
     let error_code = eccodes_sys::codes_get_bytes(
         handle,
         key.as_ptr(),
-        buffer.as_mut_ptr().cast::<u8>(),
-        &mut key_size,
+        buffer.as_mut_ptr().cast::<_>(),
+        &raw mut key_size,
     );
 
     if error_code != 0 {
@@ -221,7 +221,7 @@ pub unsafe fn codes_get_message_size(handle: *const codes_handle) -> Result<usiz
 
     let mut size: usize = 0;
 
-    let error_code = eccodes_sys::codes_get_message_size(handle, &mut size);
+    let error_code = eccodes_sys::codes_get_message_size(handle, &raw mut size);
 
     if error_code != 0 {
         let err: CodesInternal = FromPrimitive::from_i32(error_code).unwrap();
@@ -239,11 +239,11 @@ pub unsafe fn codes_get_message(
     let buffer_size = codes_get_message_size(handle)?;
 
     let buffer: Vec<u8> = vec![0; buffer_size];
-    let mut buffer_ptr = buffer.as_ptr().cast::<libc::c_void>();
+    let mut buffer_ptr = buffer.as_ptr().cast::<_>();
 
     let mut message_size: usize = 0;
 
-    let error_code = eccodes_sys::codes_get_message(handle, &mut buffer_ptr, &mut message_size);
+    let error_code = eccodes_sys::codes_get_message(handle, &raw mut buffer_ptr, &raw mut message_size);
 
     if error_code != 0 {
         let err: CodesInternal = FromPrimitive::from_i32(error_code).unwrap();

src/intermediate_bindings/codes_handle.rs

@@ -15,12 +15,6 @@ use crate::{
     pointer_guard,
 };
 
-#[cfg(target_os = "macos")]
-type _SYS_IO_FILE = eccodes_sys::__sFILE;
-
-#[cfg(not(target_os = "macos"))]
-type _SYS_IO_FILE = eccodes_sys::_IO_FILE;
-
 pub unsafe fn codes_handle_new_from_file(
     file_pointer: *mut FILE,
     product_kind: ProductKind,
@@ -33,9 +27,9 @@ pub unsafe fn codes_handle_new_from_file(
 
     let file_handle = eccodes_sys::codes_handle_new_from_file(
         context,
-        file_pointer.cast::<_SYS_IO_FILE>(),
+        file_pointer.cast::<_>(),
         product_kind as u32,
-        &mut error_code,
+        &raw mut error_code,
     );
 
     if error_code != 0 {
@@ -73,7 +67,7 @@ pub unsafe fn codes_handle_new_from_index(
     let mut error_code: i32 = 0;
 
     let _g = CODES_LOCK.lock().unwrap();
-    let codes_handle = eccodes_sys::codes_handle_new_from_index(index, &mut error_code);
+    let codes_handle = eccodes_sys::codes_handle_new_from_index(index, &raw mut error_code);
 
     // special case! codes_handle_new_from_index returns -43 when there are no messages left in the index
     // this is also indicated by a null pointer, which is handled upstream

src/intermediate_bindings/codes_index.rs

@@ -19,7 +19,7 @@ pub unsafe fn codes_index_new(keys: &str) -> Result<*mut codes_index, CodesError
     let keys = CString::new(keys).unwrap();
 
     let _g = CODES_LOCK.lock().unwrap();
-    let codes_index = eccodes_sys::codes_index_new(context, keys.as_ptr(), &mut error_code);
+    let codes_index = eccodes_sys::codes_index_new(context, keys.as_ptr(), &raw mut error_code);
 
     if error_code != 0 {
         let err: CodesInternal = FromPrimitive::from_i32(error_code).unwrap();
@@ -34,7 +34,7 @@ pub unsafe fn codes_index_read(filename: &str) -> Result<*mut codes_index, Codes
     let mut error_code: i32 = 0;
 
     let _g = CODES_LOCK.lock().unwrap();
-    let codes_index = eccodes_sys::codes_index_read(context, filename.as_ptr(), &mut error_code);
+    let codes_index = eccodes_sys::codes_index_read(context, filename.as_ptr(), &raw mut error_code);
 
     if error_code != 0 {
         let err: CodesInternal = FromPrimitive::from_i32(error_code).unwrap();

src/intermediate_bindings/codes_set.rs

@@ -64,7 +64,7 @@ pub unsafe fn codes_set_long_array(
     let error_code = eccodes_sys::codes_set_long_array(
         handle,
         key.as_ptr(),
-        values.as_ptr().cast::<i64>(),
+        values.as_ptr().cast::<_>(),
         length,
     );
 
@@ -90,7 +90,7 @@ pub unsafe fn codes_set_double_array(
     let error_code = eccodes_sys::codes_set_double_array(
         handle,
         key.as_ptr(),
-        values.as_ptr().cast::<f64>(),
+        values.as_ptr().cast::<_>(),
         length,
     );
 
@@ -114,7 +114,7 @@ pub unsafe fn codes_set_string(
     let value = CString::new(value).unwrap();
 
     let error_code =
-        eccodes_sys::codes_set_string(handle, key.as_ptr(), value.as_ptr(), &mut length);
+        eccodes_sys::codes_set_string(handle, key.as_ptr(), value.as_ptr(), &raw mut length);
 
     if error_code != 0 {
         let err: CodesInternal = FromPrimitive::from_i32(error_code).unwrap();
@@ -138,8 +138,8 @@ pub unsafe fn codes_set_bytes(
     let error_code = eccodes_sys::codes_set_bytes(
         handle,
         key.as_ptr(),
-        values.as_ptr().cast::<u8>(),
-        &mut length,
+        values.as_ptr().cast::<_>(),
+        &raw mut length,
     );
 
     if error_code != 0 {

src/intermediate_bindings/grib_nearest.rs

@@ -19,7 +19,7 @@ pub unsafe fn codes_grib_nearest_new(
 
     let mut error_code: i32 = 0;
 
-    let nearest = eccodes_sys::codes_grib_nearest_new(handle, &mut error_code);
+    let nearest = eccodes_sys::codes_grib_nearest_new(handle, &raw mut error_code);
 
     if error_code != 0 {
         let err: CodesInternal = FromPrimitive::from_i32(error_code).unwrap();
@@ -79,7 +79,7 @@ pub unsafe fn codes_grib_nearest_find(
         addr_of_mut!(output_values[0]),
         addr_of_mut!(output_distances[0]),
         addr_of_mut!(output_indexes[0]),
-        &mut length,
+        &raw mut length,
     );
 
     if error_code != 0 {

src/keyed_message/write.rs

@@ -116,7 +116,7 @@ impl KeyedMessage {
         append: bool,
     ) -> Result<(), CodesError> {
         let msg = unsafe { codes_get_message(self.message_handle)? };
-        let buf = unsafe { slice::from_raw_parts(msg.0.cast::<u8>(), msg.1) };
+        let buf = unsafe { slice::from_raw_parts(msg.0.cast::<_>(), msg.1) };
         let mut file = OpenOptions::new()
             .write(true)
             .create(true)

src/keys_iterator.rs

@@ -160,7 +160,7 @@ impl KeyedMessage {
     ///
     /// This function returns [`CodesInternal`](crate::errors::CodesInternal) when
     /// internal ecCodes function returns non-zero code.
-    pub fn default_keys_iterator<'a>(&'a self) -> Result<KeysIterator<'a>, CodesError> {
+    pub fn default_keys_iterator(&self) -> Result<KeysIterator<'_>, CodesError> {
         let iterator_handle = unsafe { codes_keys_iterator_new(self.message_handle, 0, "")? };
         let next_item_exists = unsafe { codes_keys_iterator_next(iterator_handle)? };