Remove unnecessary files and code leftover from indexing feature

Author: Quba1

data/iceland-levels-bad-path.grib.idx

@@ -1,75 +1,68 @@
 use fallible_iterator::FallibleIterator;
 
-use crate::{
-    ArcMessage, CodesFile, RefMessage,
-    codes_handle::{HandleGenerator, ThreadSafeHandle},
-    errors::CodesError,
-};
+use crate::{ArcMessage, CodesFile, RefMessage, errors::CodesError};
+use std::fmt::Debug;
 use std::sync::{Arc, Mutex};
 
 #[derive(Debug)]
-pub struct RefMessageIter<'a, S: HandleGenerator> {
-    codes_handle: &'a mut CodesFile<S>,
+pub struct RefMessageIter<'a, D: Debug> {
+    codes_file: &'a mut CodesFile<D>,
 }
 
-impl<S: HandleGenerator> CodesFile<S> {
-    pub fn ref_message_iter<'a>(&'a mut self) -> RefMessageIter<'a, S> {
-        RefMessageIter { codes_handle: self }
+impl<D: Debug> CodesFile<D> {
+    pub fn ref_message_iter<'a>(&'a mut self) -> RefMessageIter<'a, D> {
+        RefMessageIter { codes_file: self }
     }
 }
 
 /// # Errors
 ///
 /// The `next()` will return [`CodesInternal`](crate::errors::CodesInternal)
 /// when internal ecCodes function returns non-zero code.
-impl<'ch, S: HandleGenerator> FallibleIterator for RefMessageIter<'ch, S> {
+impl<'ch, D: Debug> FallibleIterator for RefMessageIter<'ch, D> {
     type Item = RefMessage<'ch>;
     type Error = CodesError;
 
     fn next(&mut self) -> Result<Option<Self::Item>, Self::Error> {
-        let new_eccodes_handle = self.codes_handle.source.gen_codes_handle()?;
+        let eccodes_handle = self.codes_file.generate_codes_handle()?;
 
-        if new_eccodes_handle.is_null() {
+        if eccodes_handle.is_null() {
             Ok(None)
         } else {
-            Ok(Some(RefMessage::new(new_eccodes_handle)))
+            Ok(Some(RefMessage::new(eccodes_handle)))
         }
     }
 }
 
 #[derive(Debug)]
-pub struct ArcMessageIter<S: ThreadSafeHandle> {
-    codes_handle: Arc<Mutex<CodesFile<S>>>,
+pub struct ArcMessageIter<D: Debug> {
+    codes_file: Arc<Mutex<CodesFile<D>>>,
 }
-impl<S: ThreadSafeHandle> CodesFile<S> {
-    pub fn arc_message_iter(self) -> ArcMessageIter<S> {
+impl<D: Debug> CodesFile<D> {
+    pub fn arc_message_iter(self) -> ArcMessageIter<D> {
         ArcMessageIter {
-            codes_handle: Arc::new(Mutex::new(self)),
+            codes_file: Arc::new(Mutex::new(self)),
         }
     }
 }
 
-impl<S: ThreadSafeHandle> FallibleIterator for ArcMessageIter<S> {
-    type Item = ArcMessage<S>;
+impl<D: Debug> FallibleIterator for ArcMessageIter<D> {
+    type Item = ArcMessage<D>;
 
     type Error = CodesError;
 
     fn next(&mut self) -> Result<Option<Self::Item>, Self::Error> {
-        let new_eccodes_handle = self
-            .codes_handle
+        let eccodes_handle = self
+            .codes_file
             .lock()
             // This mutex can be poisoned only when thread that holds ArcMessageIter panics, which would make using the mutex impossible")
             .unwrap()
-            .source
-            .gen_codes_handle()?;
+            .generate_codes_handle()?;
 
-        if new_eccodes_handle.is_null() {
+        if eccodes_handle.is_null() {
             Ok(None)
         } else {
-            Ok(Some(ArcMessage::new(
-                new_eccodes_handle,
-                &self.codes_handle,
-            )))
+            Ok(Some(ArcMessage::new(eccodes_handle, &self.codes_file)))
         }
     }
 }

data/iceland-surface.grib.idx

@@ -17,37 +17,6 @@ pub use iterator::{ArcMessageIter, RefMessageIter};
 
 mod iterator;
 
-/// This is an internal structure used to access provided file by `CodesHandle`.
-/// It also allows to differentiate between `CodesFile` created from file and from index.
-/// It is not intended to be used directly by the user.
-#[doc(hidden)]
-#[derive(Debug)]
-pub struct CodesFileSource<D: Debug> {
-    // fields dropped from top
-    pointer: *mut FILE,
-    product_kind: ProductKind,
-    _data: D,
-}
-
-/// Marker trait to differentiate between `CodesHandle` created from index and file/buffer.
-#[doc(hidden)]
-pub trait ThreadSafeHandle: HandleGenerator {}
-
-impl ThreadSafeHandle for CodesFileSource<Vec<u8>> {}
-impl ThreadSafeHandle for CodesFileSource<File> {}
-
-/// Internal trait implemented for types that can be called to generate `*mut codes_handle`.
-#[doc(hidden)]
-pub trait HandleGenerator: Debug {
-    fn gen_codes_handle(&mut self) -> Result<*mut codes_handle, CodesError>;
-}
-
-impl<D: Debug> HandleGenerator for CodesFileSource<D> {
-    fn gen_codes_handle(&mut self) -> Result<*mut codes_handle, CodesError> {
-        unsafe { codes_handle_new_from_file(self.pointer, self.product_kind) }
-    }
-}
-
 /// Structure providing access to the GRIB file which takes a full ownership of the accessed file.
 ///  
 /// It can be constructed from:
@@ -117,8 +86,11 @@ impl<D: Debug> HandleGenerator for CodesFileSource<D> {
 ///
 /// All available methods for `CodesHandle` iterator can be found in [`FallibleStreamingIterator`](crate::FallibleStreamingIterator) trait.
 #[derive(Debug)]
-pub struct CodesFile<S: HandleGenerator> {
-    source: S,
+pub struct CodesFile<D: Debug> {
+    // fields are dropped from top
+    pointer: *mut FILE,
+    product_kind: ProductKind,
+    _data: D,
 }
 
 // 2024-07-26
@@ -135,6 +107,12 @@ pub struct CodesFile<S: HandleGenerator> {
 // Clearing the memory is handled on ecCodes side by KeyedMessage/CodesIndex destructors
 // and on rust side by destructors of data_container we own.
 
+impl<D: Debug> CodesFile<D> {
+    fn generate_codes_handle(&mut self) -> Result<*mut codes_handle, CodesError> {
+        unsafe { codes_handle_new_from_file(self.pointer, self.product_kind) }
+    }
+}
+
 /// Enum representing the kind of product (file type) inside handled file.
 /// Used to indicate to ecCodes how it should decode/encode messages.
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
@@ -143,7 +121,7 @@ pub enum ProductKind {
     GRIB = ProductKind_PRODUCT_GRIB as isize,
 }
 
-impl CodesFile<CodesFileSource<File>> {
+impl CodesFile<File> {
     ///Opens file at given [`Path`] as selected [`ProductKind`] and contructs `CodesHandle`.
     ///
     ///## Example
@@ -188,15 +166,13 @@ impl CodesFile<CodesFileSource<File>> {
         let file_pointer = open_with_fdopen(&file)?;
 
         Ok(Self {
-            source: CodesFileSource {
-                _data: file,
-                pointer: file_pointer,
-                product_kind,
-            },
+            _data: file,
+            pointer: file_pointer,
+            product_kind,
         })
     }
 }
-impl CodesFile<CodesFileSource<Vec<u8>>> {
+impl CodesFile<Vec<u8>> {
     ///Opens data in provided buffer as selected [`ProductKind`] and contructs `CodesHandle`.
     ///
     ///## Example
@@ -239,11 +215,9 @@ impl CodesFile<CodesFileSource<Vec<u8>>> {
         let file_pointer = open_with_fmemopen(&file_data)?;
 
         Ok(Self {
-            source: CodesFileSource {
-                _data: file_data,
-                product_kind,
-                pointer: file_pointer,
-            },
+            _data: file_data,
+            product_kind,
+            pointer: file_pointer,
         })
     }
 }
@@ -297,14 +271,14 @@ mod tests {
         let file_path = Path::new("./data/iceland.grib");
         let product_kind = ProductKind::GRIB;
 
-        let handle = CodesFile::new_from_file(file_path, product_kind)?;
+        let codes_file = CodesFile::new_from_file(file_path, product_kind)?;
 
-        assert!(!handle.source.pointer.is_null());
-        assert_eq!(handle.source.product_kind as u32, {
+        assert!(!codes_file.pointer.is_null());
+        assert_eq!(codes_file.product_kind as u32, {
             ProductKind_PRODUCT_GRIB
         });
 
-        handle.source._data.metadata()?;
+        codes_file._data.metadata()?;
 
         Ok(())
     }
@@ -317,13 +291,13 @@ mod tests {
         let mut buf = Vec::new();
         f.read_to_end(&mut buf)?;
 
-        let handle = CodesFile::new_from_memory(buf, product_kind)?;
-        assert!(!handle.source.pointer.is_null());
-        assert_eq!(handle.source.product_kind as u32, {
+        let codes_file = CodesFile::new_from_memory(buf, product_kind)?;
+        assert!(!codes_file.pointer.is_null());
+        assert_eq!(codes_file.product_kind as u32, {
             ProductKind_PRODUCT_GRIB
         });
 
-        assert!(!handle.source._data.is_empty());
+        assert!(!codes_file._data.is_empty());
 
         Ok(())
     }

src/codes_handle/iterator.rs

@@ -11,12 +11,16 @@ pub use read::{DynamicKeyType, KeyPropertiesRead, KeyRead};
 pub use write::KeyWrite;
 
 use eccodes_sys::codes_handle;
-use std::{fmt::Debug, hash::Hash, marker::PhantomData, ptr::null_mut, sync::{Arc, Mutex}};
+use std::{
+    fmt::Debug,
+    hash::Hash,
+    marker::PhantomData,
+    ptr::null_mut,
+    sync::{Arc, Mutex},
+};
 use tracing::{Level, event, instrument};
 
-use crate::{
-    CodesFile, codes_handle::ThreadSafeHandle, intermediate_bindings::codes_handle_delete,
-};
+use crate::{CodesFile, intermediate_bindings::codes_handle_delete};
 
 /// Structure that provides access to the data contained in the GRIB file, which directly corresponds to the message in the GRIB file
 ///
@@ -54,10 +58,10 @@ pub type RefMessage<'ch> = CodesMessage<RefParent<'ch>>;
 /// requiring `&mut self`. As `AtomicMessage` implements `Send + Sync` this exclusive method access is not
 /// guaranteed with just `&self`. `AtomicMessage` also implements a minimal subset of functionalities
 /// to limit the risk of some internal ecCodes functions not being thread-safe.
-pub type ArcMessage<S> = CodesMessage<ArcParent<S>>;
+pub type ArcMessage<D> = CodesMessage<ArcParent<D>>;
 
-unsafe impl<S: ThreadSafeHandle> Send for ArcMessage<S> {}
-unsafe impl<S: ThreadSafeHandle> Sync for ArcMessage<S> {}
+unsafe impl<D: Debug> Send for ArcMessage<D> {}
+unsafe impl<D: Debug> Sync for ArcMessage<D> {}
 
 pub type BufMessage = CodesMessage<BufParent>;
 
@@ -85,8 +89,8 @@ pub struct BufParent();
 
 #[derive(Debug)]
 #[doc(hidden)]
-pub struct ArcParent<S: ThreadSafeHandle> {
-    _arc_handle: Arc<Mutex<CodesFile<S>>>,
+pub struct ArcParent<D: Debug> {
+    _arc_handle: Arc<Mutex<CodesFile<D>>>,
 }
 
 impl RefMessage<'_> {
@@ -98,8 +102,8 @@ impl RefMessage<'_> {
     }
 }
 
-impl<S: ThreadSafeHandle> ArcMessage<S> {
-    pub(crate) fn new(handle: *mut codes_handle, parent: &Arc<Mutex<CodesFile<S>>>) -> Self {
+impl<D: Debug> ArcMessage<D> {
+    pub(crate) fn new(handle: *mut codes_handle, parent: &Arc<Mutex<CodesFile<D>>>) -> Self {
         ArcMessage {
             _parent: ArcParent {
                 _arc_handle: parent.clone(),