Switching things to tagged type

oxydsp-flowgraph/src/io.rs

@@ -13,6 +13,7 @@ use crate::stream::StreamReader;
 use crate::stream::StreamWriter;
 use crate::stream::{self};
 use crate::tag::Tag;
+use crate::tag::Tagged;
 
 pub struct In<T>
 {
@@ -173,7 +174,7 @@ impl<T> InReader<'_, T>
         self.data_reader.len()
     }
 
-    pub fn pop_tagged(&self) -> Option<(T, Option<Tag>)>
+    pub fn pop(&self) -> Option<Tagged<T>>
     {
         let data = self.data_reader.pop_with_index();
         if let Some((data, index)) = data
@@ -186,7 +187,7 @@ impl<T> InReader<'_, T>
             {
                 tag = self.tag_reader.pop();
             }
-            Some((data, tag))
+            Some((data, tag).into())
         }
         else
         {
@@ -194,9 +195,9 @@ impl<T> InReader<'_, T>
         }
     }
 
-    pub fn pop_drop_tag(&self) -> Option<T>
+    pub fn pop_untag(&self) -> Option<T>
     {
-        self.pop_tagged().map(|(data, _)| data)
+        self.pop().map(|data| data.into_inner())
     }
 }
 
@@ -207,8 +208,9 @@ impl<T> OutWriter<'_, T>
         self.data_writer.len().min(self.tag_writer.len())
     }
 
-    pub fn push(&self, (data, tag): (T, Option<Tag>)) -> Result<(), (T, Option<Tag>)>
+    pub fn push(&self, data: Tagged<T>) -> Result<(), (T, Option<Tag>)>
     {
+        let (data, tag) = data.into();
         match self.data_writer.push(data)
         {
             Ok(_) if tag.is_some() =>
@@ -221,23 +223,9 @@ impl<T> OutWriter<'_, T>
         }
     }
 
-    pub fn push_tagged(&self, data: T, tag: Tag) -> Result<(), (T, Tag)>
-    {
-        let res = self.data_writer.push(data);
-        match res
-        {
-            Ok(_) =>
-            {
-                let _ = self.tag_writer.push(tag);
-                Ok(())
-            }
-            Err(t) => Err((t, tag)),
-        }
-    }
-
     pub fn push_no_tag(&self, data: T) -> Result<(), T>
     {
-        self.data_writer.push(data)
+        self.data_writer.push(data.into())
     }
 }
 
@@ -268,6 +256,7 @@ impl<'a, T: 'static> PopIterable<'a> for In<T>
     }
 }
 
+generate_pop_iterable_tuple_impl! {1}
 generate_pop_iterable_tuple_impl! {2}
 generate_pop_iterable_tuple_impl! {3}
 generate_pop_iterable_tuple_impl! {4}
@@ -279,25 +268,18 @@ generate_pop_iterable_tuple_impl! {9}
 generate_pop_iterable_tuple_impl! {10}
 generate_pop_iterable_tuple_impl! {11}
 generate_pop_iterable_tuple_impl! {12}
-generate_pop_iterable_tuple_impl! {13}
-generate_pop_iterable_tuple_impl! {14}
-generate_pop_iterable_tuple_impl! {15}
-generate_pop_iterable_tuple_impl! {16}
-generate_pop_iterable_tuple_impl! {17}
-generate_pop_iterable_tuple_impl! {18}
-generate_pop_iterable_tuple_impl! {19}
-generate_pop_iterable_tuple_impl! {20}
 
 impl<'a, T> Iterator for PopIter<InReader<'a, T>>
 {
-    type Item = (T, Option<Tag>);
+    type Item = Tagged<T>;
 
     fn next(&mut self) -> Option<Self::Item>
     {
-        self.reader.pop_tagged()
+        self.reader.pop()
     }
 }
 
+impl_iterator_for_pop_iter_tuple! {1}
 impl_iterator_for_pop_iter_tuple! {2}
 impl_iterator_for_pop_iter_tuple! {3}
 impl_iterator_for_pop_iter_tuple! {4}
@@ -309,14 +291,6 @@ impl_iterator_for_pop_iter_tuple! {9}
 impl_iterator_for_pop_iter_tuple! {10}
 impl_iterator_for_pop_iter_tuple! {11}
 impl_iterator_for_pop_iter_tuple! {12}
-impl_iterator_for_pop_iter_tuple! {13}
-impl_iterator_for_pop_iter_tuple! {14}
-impl_iterator_for_pop_iter_tuple! {15}
-impl_iterator_for_pop_iter_tuple! {16}
-impl_iterator_for_pop_iter_tuple! {17}
-impl_iterator_for_pop_iter_tuple! {18}
-impl_iterator_for_pop_iter_tuple! {19}
-impl_iterator_for_pop_iter_tuple! {20}
 
 // Needed for graph to be able to manipulate
 // stream endings without knowing the generic type
@@ -375,3 +349,10 @@ impl AnonymousStreamConsumer
         )
     }
 }
+
+// pub trait PushIterable<'a, T, I>
+// where
+//     I: Iterator<Item = T>,
+// {
+//     fn push_iter(&'a mut self, iter: I) -> bool;
+// }

oxydsp-flowgraph/src/tag.rs

@@ -77,35 +77,44 @@ impl TagMergable<Option<Tag>> for Option<Tag>
     }
 }
 
+impl<T: Clone> TagMergable<Option<Tag>> for Tagged<T>
+{
+    fn merge(&self, other: &Option<Tag>) -> Self
+    {
+        Tagged::new(self.0.clone(), self.1.merge(other))
+    }
+}
+
 /// Represents a data, with a potential tag attached to it.
 #[derive(Clone)]
-pub struct Tagged<T>
-{
-    inner: T,
-    tag: Option<Tag>,
-}
+pub struct Tagged<T>(pub T, pub Option<Tag>);
 
 impl<T> Tagged<T>
 {
     pub fn new(inner: T, tag: Option<Tag>) -> Self
     {
-        Self { inner, tag }
+        Self(inner, tag)
     }
 
     pub fn has_tag(&self) -> bool
     {
-        self.tag.is_some()
+        self.1.is_some()
     }
 
     pub fn strip(&mut self)
     {
-        self.tag = None;
+        self.1 = None;
+    }
+
+    pub fn into_inner(self) -> T
+    {
+        self.0
     }
 
     pub fn tag(&mut self, tag: Tag) -> Option<Tag>
     {
-        let t = self.tag.take();
-        self.tag = Some(tag);
+        let t = self.1.take();
+        self.1 = Some(tag);
         t
     }
 }
@@ -114,12 +123,12 @@ impl<T: Clone> Tagged<T>
 {
     pub fn stripped(&self) -> Self
     {
-        self.inner.clone().into()
+        self.0.clone().into()
     }
 
     pub fn tagged(&self, tag: Tag) -> Self
     {
-        (self.inner.clone(), tag).into()
+        (self.0.clone(), tag).into()
     }
 }
 
@@ -139,11 +148,27 @@ impl<T> From<(T, Tag)> for Tagged<T>
     }
 }
 
+impl<T> From<(T, Option<Tag>)> for Tagged<T>
+{
+    fn from((value, tag): (T, Option<Tag>)) -> Self
+    {
+        Self::new(value, tag)
+    }
+}
+
+impl<T> Into<(T, Option<Tag>)> for Tagged<T>
+{
+    fn into(self) -> (T, Option<Tag>)
+    {
+        (self.0, self.1)
+    }
+}
+
 impl<T> DerefMut for Tagged<T>
 {
     fn deref_mut(&mut self) -> &mut Self::Target
     {
-        &mut self.inner
+        &mut self.0
     }
 }
 
@@ -153,6 +178,6 @@ impl<T> Deref for Tagged<T>
 
     fn deref(&self) -> &Self::Target
     {
-        &self.inner
+        &self.0
     }
 }