[object] More IntoTokens

- impl IntoTokens for &InMemDicomObject
- refactor current implementation

Author: Enet4

object/src/tokens.rs

@@ -1,7 +1,6 @@
 //! Convertion of DICOM objects into tokens.
 use crate::mem::{InMemDicomObject};
-use dicom_core::value::{PrimitiveValue};
-use dicom_core::{DataElement, Length};
+use dicom_core::{DataElement};
 use dicom_parser::dataset::{DataToken, IntoTokens};
 use std::collections::VecDeque;
 
@@ -11,8 +10,6 @@ pub struct InMemObjectTokens<E> {
     tokens_pending: VecDeque<DataToken>,
     /// the iterator of data elements in order.
     elem_iter: E,
-    /// whenever a primitive data element is yet to be processed
-    elem_pending: Option<PrimitiveValue>,
     /// whether the tokens are done
     fused: bool,
 }
@@ -28,18 +25,24 @@ where
         InMemObjectTokens {
             tokens_pending: Default::default(),
             elem_iter: obj.into_iter(),
-            elem_pending: None,
             fused: false,
         }
     }
 }
 
-impl<E> InMemObjectTokens<E>
+impl<E, I> Iterator for InMemObjectTokens<E>
 where
-    E: Iterator,
+    E: Iterator<Item = DataElement<I>>,
     E::Item: IntoTokens,
 {
-    fn next_token(&mut self) -> Option<DataToken> {
+    type Item = DataToken;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.fused {
+            return None;
+        }        
+
+        // otherwise, consume pending tokens
         if let Some(token) = self.tokens_pending.pop_front() {
             return Some(token);
         }
@@ -49,37 +52,12 @@ where
             // TODO eventually optimize this to be less eager
             self.tokens_pending = elem.into_tokens().collect();
 
-            self.next_token()
+            self.next()
         } else {
             // no more elements
             None
         }
     }
-}
-
-impl<E, I> Iterator for InMemObjectTokens<E>
-where
-    E: Iterator<Item = DataElement<I>>,
-    E::Item: IntoTokens,
-{
-    type Item = DataToken;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.fused {
-            return None;
-        }        
-        // if a data element is pending, return a value token
-        if let Some(val) = self.elem_pending.take() {
-            return Some(DataToken::PrimitiveValue(val));
-        }
-
-        // otherwise, consume pending tokens
-        if let Some(token) = self.next_token() {
-            return Some(token);
-        };
-
-        None
-    }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
         // make a slightly better estimation for the minimum
@@ -97,3 +75,15 @@ impl<D> IntoTokens for InMemDicomObject<D> {
     }
 }
 
+
+impl<'a, D> IntoTokens for &'a InMemDicomObject<D>
+where
+    D: Clone,
+{
+    type Iter =
+        InMemObjectTokens<std::iter::Cloned<<&'a InMemDicomObject<D> as IntoIterator>::IntoIter>>;
+
+    fn into_tokens(self) -> Self::Iter {
+        InMemObjectTokens::new(self.into_iter().cloned())
+    }
+}