Adding sync block macro

oxydsp-flowgraph/src/edge.rs

@@ -1,8 +1,12 @@
+use std::any::Any;
 use std::sync::Arc;
 use std::sync::Mutex;
 
+use crate::stream;
 use crate::stream::StreamConsumer;
 use crate::stream::StreamProducer;
+use crate::stream::StreamReader;
+use crate::stream::StreamWriter;
 
 pub struct Edge
 {
@@ -22,15 +26,55 @@ pub struct BlockIOIndex
     pub port_index: usize,
 }
 
-pub struct In<T>
+// Needed for graph to be able to manipulate
+// stream endings without knowing the generic type
+pub struct AnonymousStreamProducer
 {
-    stream: Option<StreamProducer<T>>,
-
-    // Will rarely be accessed
-    edge: Arc<Mutex<Edge>>,
+    inner: Box<dyn Any>,
 }
 
-pub struct Out<T>
+pub struct AnonymousStreamConsumer
+{
+    inner: Box<dyn Any>,
+}
+
+impl<T: 'static> From<StreamProducer<T>> for AnonymousStreamProducer
+{
+    fn from(value: StreamProducer<T>) -> Self
+    {
+        AnonymousStreamProducer {
+            inner: Box::new(value),
+        }
+    }
+}
+
+impl<T: 'static> From<StreamConsumer<T>> for AnonymousStreamConsumer
+{
+    fn from(value: StreamConsumer<T>) -> Self
+    {
+        AnonymousStreamConsumer {
+            inner: Box::new(value),
+        }
+    }
+}
+
+impl AnonymousStreamProducer
+{
+    pub fn downcast<T: 'static>(self) -> StreamProducer<T>
+    {
+        *self.inner.downcast::<StreamProducer<T>>().unwrap()
+    }
+}
+
+impl AnonymousStreamConsumer
+{
+    pub fn downcast<T: 'static>(self) -> StreamConsumer<T>
+    {
+        *self.inner.downcast::<StreamConsumer<T>>().unwrap()
+    }
+}
+
+pub struct In<T>
 {
     stream: Option<StreamConsumer<T>>,
 
@@ -38,7 +82,15 @@ pub struct Out<T>
     edge: Arc<Mutex<Edge>>,
 }
 
-impl<T> In<T>
+pub struct Out<T>
+{
+    stream: Option<StreamProducer<T>>,
+
+    // Will rarely be accessed
+    edge: Arc<Mutex<Edge>>,
+}
+
+impl<T: 'static> In<T>
 {
     pub fn set_block_index(&self, index: BlockIOIndex)
     {
@@ -49,9 +101,19 @@ impl<T> In<T>
     {
         self.edge.lock().unwrap().from
     }
+
+    pub fn set_anonymous_stream(&mut self, consumer: AnonymousStreamConsumer)
+    {
+        self.stream = Some(consumer.downcast::<T>())
+    }
+
+    pub fn read<'a>(&'a mut self) -> StreamReader<'a, T>
+    {
+        self.stream.as_mut().unwrap().read()
+    }
 }
 
-impl<T> Out<T>
+impl<T: 'static> Out<T>
 {
     pub fn set_block_index(&self, index: BlockIOIndex)
     {
@@ -62,4 +124,25 @@ impl<T> Out<T>
     {
         self.edge.lock().unwrap().to
     }
+
+    pub fn set_anonymous_stream(&mut self, producer: AnonymousStreamProducer)
+    {
+        self.stream = Some(producer.downcast::<T>())
+    }
+
+    // Delegate stream creation to Out object
+    // which knows the stream type
+    pub fn create_anonymous_stream(
+        &self,
+        capacity: usize,
+    ) -> (AnonymousStreamProducer, AnonymousStreamConsumer)
+    {
+        let (tx, rx) = stream::bounded_queue::<T>(capacity);
+        (tx.into(), rx.into())
+    }
+
+    pub fn write<'a>(&'a mut self) -> StreamWriter<'a, T>
+    {
+        self.stream.as_mut().unwrap().write()
+    }
 }