Refactor Bufferable so we no longer need join_into

Signed-off-by: Michael X. Grey <[email protected]>

Author: mxgrey

src/buffer/buffer_map.rs

@@ -26,7 +26,7 @@ use bevy_ecs::prelude::{Entity, World};
 use crate::{
     add_listener_to_source, Accessed, AddOperation, AnyBuffer, AnyBufferKey, AnyMessageBox,
     Buffer, BufferKeyBuilder, Buffered, Builder, Chain, Gate, GateState, Join, Joined,
-    OperationError, OperationResult, OperationRoster, Output, UnusedTarget,
+    OperationError, OperationResult, OperationRoster, Output, UnusedTarget, Bufferable,
 };
 
 #[derive(Clone, Default)]
@@ -116,14 +116,22 @@ pub struct BufferIncompatibility {
 /// You do not normally have to implement this yourself. Instead you should
 /// `#[derive(JoinedValue)]` on a struct that you want a join operation to
 /// produce.
-pub trait BufferMapLayout: Sized + Clone {
+pub trait BufferMapLayout: Sized + Clone + 'static + Send + Sync {
     /// Produce a list of the buffers that exist in this layout.
     fn buffer_list(&self) -> SmallVec<[AnyBuffer; 8]>;
 
     /// Try to convert a generic [`BufferMap`] into this specific layout.
     fn try_from_buffer_map(buffers: &BufferMap) -> Result<Self, IncompatibleLayout>;
 }
 
+impl<T: BufferMapLayout> Bufferable for T {
+    type BufferType = Self;
+
+    fn into_buffer(self, _: &mut Builder) -> Self::BufferType {
+        self
+    }
+}
+
 impl<T: BufferMapLayout> Buffered for T {
     fn verify_scope(&self, scope: Entity) {
         for buffer in self.buffer_list() {
@@ -231,14 +239,6 @@ pub trait JoinedValue: 'static + Send + Sync + Sized {
 /// Trait to describe a layout of buffer keys
 pub trait BufferKeyMap: 'static + Send + Sync + Sized + Clone {
     type Buffers: 'static + BufferMapLayout + Accessed<Key=Self> + Send + Sync;
-
-    fn add_accessor(buffers: &BufferMap, accessor: Entity, world: &mut World) -> OperationResult;
-
-    fn create_key(buffers: &BufferMap, builder: &BufferKeyBuilder) -> Self;
-
-    fn deep_clone_key(&self) -> Self;
-
-    fn is_key_in_use(&self) -> bool;
 }
 
 impl BufferMapLayout for BufferMap {
@@ -383,7 +383,7 @@ mod tests {
     }
 
     #[test]
-    fn test_joined_value() {
+    fn test_try_join() {
         let mut context = TestingContext::minimal_plugins();
 
         let workflow = context.spawn_io_workflow(|scope, builder| {
@@ -403,7 +403,7 @@ mod tests {
             ));
 
             builder
-                .try_join_into(&buffers)
+                .try_join(&buffers)
                 .unwrap()
                 .connect(scope.terminate);
         });
@@ -421,4 +421,40 @@ mod tests {
         assert_eq!(value.string, "hello");
         assert!(context.no_unhandled_errors());
     }
+
+    #[test]
+    fn test_joined_value() {
+        let mut context = TestingContext::minimal_plugins();
+
+        let workflow = context.spawn_io_workflow(|scope, builder| {
+            let buffers = TestJoinedValueBuffers {
+                integer: builder.create_buffer(BufferSettings::default()),
+                float: builder.create_buffer(BufferSettings::default()),
+                string: builder.create_buffer(BufferSettings::default()),
+            };
+
+            scope.input.chain(builder).fork_unzip((
+                |chain: Chain<_>| chain.connect(buffers.integer.input_slot()),
+                |chain: Chain<_>| chain.connect(buffers.float.input_slot()),
+                |chain: Chain<_>| chain.connect(buffers.string.input_slot()),
+            ));
+
+            builder
+                .join(buffers)
+                .connect(scope.terminate);
+        });
+
+        let mut promise = context.command(|commands| {
+            commands
+                .request((5_i64, 3.14_f64, "hello".to_string()), workflow)
+                .take_response()
+        });
+
+        context.run_with_conditions(&mut promise, Duration::from_secs(2));
+        let value: TestJoinedValue = promise.take().available().unwrap();
+        assert_eq!(value.integer, 5);
+        assert_eq!(value.float, 3.14);
+        assert_eq!(value.string, "hello");
+        assert!(context.no_unhandled_errors());
+    }
 }

src/buffer/bufferable.rs

@@ -20,137 +20,18 @@ use smallvec::SmallVec;
 
 use crate::{
     Accessed, AddOperation, Buffer, BufferSettings, Buffered, Builder, Chain,
-    CleanupWorkflowConditions, CloneFromBuffer, Join, Joined, Listen, Output, Scope, ScopeSettings,
-    UnusedTarget,
+    CloneFromBuffer, Join, Joined, Output, UnusedTarget,
 };
 
 pub type BufferKeys<B> = <<B as Bufferable>::BufferType as Accessed>::Key;
 pub type JoinedItem<B> = <<B as Bufferable>::BufferType as Joined>::Item;
 
 pub trait Bufferable {
-    type BufferType: Joined + Accessed;
+    type BufferType: Buffered;
 
     /// Convert these bufferable workflow elements into buffers if they are not
     /// buffers already.
     fn into_buffer(self, builder: &mut Builder) -> Self::BufferType;
-
-    /// Join these bufferable workflow elements. Each time every buffer contains
-    /// at least one element, this will pull the oldest element from each buffer
-    /// and join them into a tuple that gets sent to the target.
-    ///
-    /// If you need a more general way to get access to one or more buffers,
-    /// use [`listen`](Self::listen) instead.
-    fn join<'w, 's, 'a, 'b>(
-        self,
-        builder: &'b mut Builder<'w, 's, 'a>,
-    ) -> Chain<'w, 's, 'a, 'b, JoinedItem<Self>>
-    where
-        Self: Sized,
-        Self::BufferType: 'static + Send + Sync,
-        JoinedItem<Self>: 'static + Send + Sync,
-    {
-        let scope = builder.scope();
-        let buffers = self.into_buffer(builder);
-        buffers.verify_scope(scope);
-
-        let join = builder.commands.spawn(()).id();
-        let target = builder.commands.spawn(UnusedTarget).id();
-        builder.commands.add(AddOperation::new(
-            Some(scope),
-            join,
-            Join::new(buffers, target),
-        ));
-
-        Output::new(scope, target).chain(builder)
-    }
-
-    /// Create an operation that will output buffer access keys each time any
-    /// one of the buffers is modified. This can be used to create a node in a
-    /// workflow that wakes up every time one or more buffers change, and then
-    /// operates on those buffers.
-    ///
-    /// For an operation that simply joins the contents of two or more outputs
-    /// or buffers, use [`join`](Self::join) instead.
-    fn listen<'w, 's, 'a, 'b>(
-        self,
-        builder: &'b mut Builder<'w, 's, 'a>,
-    ) -> Chain<'w, 's, 'a, 'b, BufferKeys<Self>>
-    where
-        Self: Sized,
-        Self::BufferType: 'static + Send + Sync,
-        BufferKeys<Self>: 'static + Send + Sync,
-    {
-        let scope = builder.scope();
-        let buffers = self.into_buffer(builder);
-        buffers.verify_scope(scope);
-
-        let listen = builder.commands.spawn(()).id();
-        let target = builder.commands.spawn(UnusedTarget).id();
-        builder.commands.add(AddOperation::new(
-            Some(scope),
-            listen,
-            Listen::new(buffers, target),
-        ));
-
-        Output::new(scope, target).chain(builder)
-    }
-
-    /// Alternative way to call [`Builder::on_cleanup`].
-    fn on_cleanup<Settings>(
-        self,
-        builder: &mut Builder,
-        build: impl FnOnce(Scope<BufferKeys<Self>, (), ()>, &mut Builder) -> Settings,
-    ) where
-        Self: Sized,
-        Self::BufferType: 'static + Send + Sync,
-        BufferKeys<Self>: 'static + Send + Sync,
-        Settings: Into<ScopeSettings>,
-    {
-        builder.on_cleanup(self, build)
-    }
-
-    /// Alternative way to call [`Builder::on_cancel`].
-    fn on_cancel<Settings>(
-        self,
-        builder: &mut Builder,
-        build: impl FnOnce(Scope<BufferKeys<Self>, (), ()>, &mut Builder) -> Settings,
-    ) where
-        Self: Sized,
-        Self::BufferType: 'static + Send + Sync,
-        BufferKeys<Self>: 'static + Send + Sync,
-        Settings: Into<ScopeSettings>,
-    {
-        builder.on_cancel(self, build)
-    }
-
-    /// Alternative way to call [`Builder::on_terminate`].
-    fn on_terminate<Settings>(
-        self,
-        builder: &mut Builder,
-        build: impl FnOnce(Scope<BufferKeys<Self>, (), ()>, &mut Builder) -> Settings,
-    ) where
-        Self: Sized,
-        Self::BufferType: 'static + Send + Sync,
-        BufferKeys<Self>: 'static + Send + Sync,
-        Settings: Into<ScopeSettings>,
-    {
-        builder.on_terminate(self, build)
-    }
-
-    /// Alternative way to call [`Builder::on_cleanup_if`].
-    fn on_cleanup_if<Settings>(
-        self,
-        builder: &mut Builder,
-        conditions: CleanupWorkflowConditions,
-        build: impl FnOnce(Scope<BufferKeys<Self>, (), ()>, &mut Builder) -> Settings,
-    ) where
-        Self: Sized,
-        Self::BufferType: 'static + Send + Sync,
-        BufferKeys<Self>: 'static + Send + Sync,
-        Settings: Into<ScopeSettings>,
-    {
-        builder.on_cleanup_if(conditions, self, build)
-    }
 }
 
 impl<T: 'static + Send + Sync> Bufferable for Buffer<T> {
@@ -179,6 +60,54 @@ impl<T: 'static + Send + Sync> Bufferable for Output<T> {
     }
 }
 
+pub trait Joinable: Bufferable {
+    type Item;
+
+    fn join<'w, 's, 'a, 'b>(
+        self,
+        builder: &'b mut Builder<'w, 's, 'a>,
+    ) -> Chain<'w, 's, 'a, 'b, Self::Item>;
+}
+
+impl<B> Joinable for B
+where
+    B: Bufferable,
+    B::BufferType: Joined,
+{
+    type Item = JoinedItem<B>;
+
+    fn join<'w, 's, 'a, 'b>(
+        self,
+        builder: &'b mut Builder<'w, 's, 'a>,
+    ) -> Chain<'w, 's, 'a, 'b, Self::Item> {
+        self.into_buffer(builder).join(builder)
+    }
+}
+
+pub trait Accessible: Bufferable {
+    type Keys;
+
+    fn listen<'w, 's, 'a, 'b>(
+        self,
+        builder: &'b mut Builder<'w, 's, 'a>,
+    ) -> Chain<'w, 's, 'a, 'b, Self::Keys>;
+}
+
+impl<B> Accessible for B
+where
+    B: Bufferable,
+    B::BufferType: Accessed,
+{
+    type Keys = BufferKeys<Self>;
+
+    fn listen<'w, 's, 'a, 'b>(
+        self,
+        builder: &'b mut Builder<'w, 's, 'a>,
+    ) -> Chain<'w, 's, 'a, 'b, Self::Keys> {
+        self.into_buffer(builder).listen(builder)
+    }
+}
+
 macro_rules! impl_bufferable_for_tuple {
     ($($T:ident),*) => {
         #[allow(non_snake_case)]
@@ -248,6 +177,7 @@ impl<T> IterBufferable for T
 where
     T: IntoIterator,
     T::Item: Bufferable,
+    <T::Item as Bufferable>::BufferType: Joined,
 {
     type BufferElement = <T::Item as Bufferable>::BufferType;