Support for joining Vec and json values

Signed-off-by: Michael X. Grey <greyxmike@gmail.com>

Author: mxgrey

macros/src/buffer.rs

@@ -208,19 +208,17 @@ fn impl_buffer_map_layout(
 
     Ok(quote! {
         impl #impl_generics ::bevy_impulse::BufferMapLayout for #struct_ident #ty_generics #where_clause {
-            fn buffer_list(&self) -> ::smallvec::SmallVec<[AnyBuffer; 8]> {
-                use smallvec::smallvec;
-                smallvec![#(
-                    ::bevy_impulse::AsAnyBuffer::as_any_buffer(&self.#field_ident),
-                )*]
-            }
-
             fn try_from_buffer_map(buffers: &::bevy_impulse::BufferMap) -> Result<Self, ::bevy_impulse::IncompatibleLayout> {
                 let mut compatibility = ::bevy_impulse::IncompatibleLayout::default();
                 #(
-                    let #field_ident = if let Ok(buffer) = compatibility.require_buffer_by_literal::<#buffer>(#map_key, buffers) {
-                        buffer
-                    } else {
+                    let #field_ident = compatibility.require_buffer_by_literal::<#buffer>(#map_key, buffers);
+                )*
+
+                // Unwrap the Ok after inspecting every field so that the
+                // IncompatibleLayout error can include all information about
+                // which fields were incompatible.
+                #(
+                    let Ok(#field_ident) = #field_ident else {
                         return Err(compatibility);
                     };
                 )*
@@ -232,6 +230,15 @@ fn impl_buffer_map_layout(
                 })
             }
         }
+
+        impl #impl_generics ::bevy_impulse::BufferMapStruct for #struct_ident #ty_generics #where_clause {
+            fn buffer_list(&self) -> ::smallvec::SmallVec<[AnyBuffer; 8]> {
+                use smallvec::smallvec;
+                smallvec![#(
+                    ::bevy_impulse::AsAnyBuffer::as_any_buffer(&self.#field_ident),
+                )*]
+            }
+        }
     }
     .into())
 }

src/buffer/buffer_map.rs

@@ -24,9 +24,9 @@ use smallvec::SmallVec;
 use bevy_ecs::prelude::{Entity, World};
 
 use crate::{
-    add_listener_to_source, Accessed, AddOperation, AnyBuffer, AnyBufferKey, AnyMessageBox, AsAnyBuffer,
-    BufferKeyBuilder, Bufferable, Buffered, Builder, Chain, Gate, GateState, Join, Joined,
-    OperationError, OperationResult, OperationRoster, Output, UnusedTarget,
+    add_listener_to_source, Accessed, AddOperation, AnyBuffer, AnyBufferKey, AnyMessageBox,
+    AsAnyBuffer, Buffer, BufferKeyBuilder, Bufferable, Buffered, Builder, Chain, Gate, GateState,
+    Join, Joined, OperationError, OperationResult, OperationRoster, Output, UnusedTarget,
 };
 
 pub use bevy_impulse_derive::JoinedValue;
@@ -92,15 +92,32 @@ impl AddBufferToMap for BufferMap {
 #[derive(ThisError, Debug, Clone, Default)]
 #[error("the incoming buffer map is incompatible with the layout")]
 pub struct IncompatibleLayout {
-    /// Names of buffers that were missing from the incoming buffer map.
+    /// Identities of buffers that were missing from the incoming buffer map.
     pub missing_buffers: Vec<BufferIdentifier<'static>>,
+    /// Identities of buffers in the incoming buffer map which cannot exist in
+    /// the target layout.
+    pub forbidden_buffers: Vec<BufferIdentifier<'static>>,
     /// Buffers whose expected type did not match the received type.
     pub incompatible_buffers: Vec<BufferIncompatibility>,
 }
 
 impl IncompatibleLayout {
-    /// Check whether a named buffer is compatible with a specialized buffer type,
-    /// such as `JsonBuffer`.
+    /// Convert this into an error if it has any contents inside.
+    pub fn as_result(self) -> Result<(), Self> {
+        if !self.missing_buffers.is_empty() {
+            return Err(self);
+        }
+
+        if !self.incompatible_buffers.is_empty() {
+            return Err(self);
+        }
+
+        Ok(())
+    }
+
+    /// Same as [`Self::require_buffer_by_literal`], but can be used with
+    /// temporary borrows of a string slice. The string slice will be cloned if
+    /// an error message needs to be produced.
     pub fn require_buffer_by_name<BufferType: 'static>(
         &mut self,
         expected_name: &str,
@@ -118,20 +135,38 @@ impl IncompatibleLayout {
                 });
             }
         } else {
-            self.missing_buffers.push(BufferIdentifier::Name(Cow::Owned(expected_name.to_owned())));
+            self.missing_buffers
+                .push(BufferIdentifier::Name(Cow::Owned(expected_name.to_owned())));
         }
 
         Err(())
     }
 
-    /// Same as [`Self::require_buffer_by_name`] but more efficient for names
-    /// given by string literal values.
+    /// Check whether a named buffer is compatible with the required buffer type.
     pub fn require_buffer_by_literal<BufferType: 'static>(
         &mut self,
         expected_name: &'static str,
         buffers: &BufferMap,
     ) -> Result<BufferType, ()> {
-        let identifier = BufferIdentifier::Name(Cow::Borrowed(expected_name));
+        self.require_buffer::<BufferType>(BufferIdentifier::literal_name(expected_name), buffers)
+    }
+
+    /// Check whether an indexed buffer is compatible with the required buffer type.
+    pub fn require_buffer_by_index<BufferType: 'static>(
+        &mut self,
+        expected_index: usize,
+        buffers: &BufferMap,
+    ) -> Result<BufferType, ()> {
+        self.require_buffer::<BufferType>(BufferIdentifier::Index(expected_index), buffers)
+    }
+
+    /// Check whether the buffer associated with the identifier is compatible with
+    /// the required buffer type.
+    pub fn require_buffer<BufferType: 'static>(
+        &mut self,
+        identifier: BufferIdentifier<'static>,
+        buffers: &BufferMap,
+    ) -> Result<BufferType, ()> {
         if let Some(buffer) = buffers.get(&identifier) {
             if let Some(buffer) = buffer.downcast_buffer::<BufferType>() {
                 return Ok(buffer);
@@ -167,22 +202,26 @@ pub struct BufferIncompatibility {
 /// `#[derive(JoinedValue)]` on a struct that you want a join operation to
 /// produce.
 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 {
+/// This trait helps auto-generated buffer map structs to implement the Buffered
+/// trait.
+pub trait BufferMapStruct: Sized + Clone + 'static + Send + Sync {
+    /// Produce a list of the buffers that exist in this layout.
+    fn buffer_list(&self) -> SmallVec<[AnyBuffer; 8]>;
+}
+
+impl<T: BufferMapStruct> Bufferable for T {
     type BufferType = Self;
 
     fn into_buffer(self, _: &mut Builder) -> Self::BufferType {
         self
     }
 }
 
-impl<T: BufferMapLayout> Buffered for T {
+impl<T: BufferMapStruct> Buffered for T {
     fn verify_scope(&self, scope: Entity) {
         for buffer in self.buffer_list() {
             assert_eq!(buffer.scope(), scope);
@@ -285,14 +324,17 @@ pub trait BufferKeyMap: 'static + Send + Sync + Sized + Clone {
 }
 
 impl BufferMapLayout for BufferMap {
-    fn buffer_list(&self) -> SmallVec<[AnyBuffer; 8]> {
-        self.values().cloned().collect()
-    }
     fn try_from_buffer_map(buffers: &BufferMap) -> Result<Self, IncompatibleLayout> {
         Ok(buffers.clone())
     }
 }
 
+impl BufferMapStruct for BufferMap {
+    fn buffer_list(&self) -> SmallVec<[AnyBuffer; 8]> {
+        self.values().cloned().collect()
+    }
+}
+
 impl Joined for BufferMap {
     type Item = HashMap<BufferIdentifier<'static>, AnyMessageBox>;
 
@@ -351,9 +393,49 @@ impl Accessed for BufferMap {
     }
 }
 
+impl<T: 'static + Send + Sync> JoinedValue for Vec<T> {
+    type Buffers = Vec<Buffer<T>>;
+}
+
+impl<B: 'static + Send + Sync + AsAnyBuffer + Clone> BufferMapLayout for Vec<B> {
+    fn try_from_buffer_map(buffers: &BufferMap) -> Result<Self, IncompatibleLayout> {
+        let mut downcast_buffers = Vec::new();
+        let mut compatibility = IncompatibleLayout::default();
+        for i in 0..buffers.len() {
+            if let Ok(downcast) = compatibility.require_buffer_by_index::<B>(i, buffers) {
+                downcast_buffers.push(downcast);
+            }
+        }
+
+        compatibility.as_result()?;
+        Ok(downcast_buffers)
+    }
+}
+
+impl<T: 'static + Send + Sync, const N: usize> JoinedValue for SmallVec<[T; N]> {
+    type Buffers = SmallVec<[Buffer<T>; N]>;
+}
+
+impl<B: 'static + Send + Sync + AsAnyBuffer + Clone, const N: usize> BufferMapLayout
+    for SmallVec<[B; N]>
+{
+    fn try_from_buffer_map(buffers: &BufferMap) -> Result<Self, IncompatibleLayout> {
+        let mut downcast_buffers = SmallVec::new();
+        let mut compatibility = IncompatibleLayout::default();
+        for i in 0..buffers.len() {
+            if let Ok(downcast) = compatibility.require_buffer_by_index::<B>(i, buffers) {
+                downcast_buffers.push(downcast);
+            }
+        }
+
+        compatibility.as_result()?;
+        Ok(downcast_buffers)
+    }
+}
+
 #[cfg(test)]
 mod tests {
-    use crate::{prelude::*, testing::*, BufferMap, AddBufferToMap};
+    use crate::{prelude::*, testing::*, AddBufferToMap, BufferMap};
 
     #[derive(JoinedValue)]
     struct TestJoinedValue<T: Send + Sync + 'static + Clone> {

src/buffer/bufferable.rs

@@ -152,6 +152,13 @@ impl<T: Bufferable, const N: usize> Bufferable for [T; N] {
     }
 }
 
+impl<T: Bufferable> Bufferable for Vec<T> {
+    type BufferType = Vec<T::BufferType>;
+    fn into_buffer(self, builder: &mut Builder) -> Self::BufferType {
+        self.into_iter().map(|b| b.into_buffer(builder)).collect()
+    }
+}
+
 pub trait IterBufferable {
     type BufferElement: Buffered + Joined;
 

src/buffer/buffered.rs

@@ -662,6 +662,103 @@ impl<T: Accessed, const N: usize> Accessed for SmallVec<[T; N]> {
     }
 }
 
+impl<B: Buffered> Buffered for Vec<B> {
+    fn verify_scope(&self, scope: Entity) {
+        for buffer in self {
+            buffer.verify_scope(scope);
+        }
+    }
+
+    fn buffered_count(&self, session: Entity, world: &World) -> Result<usize, OperationError> {
+        let mut min_count = None;
+        for buffer in self {
+            let count = buffer.buffered_count(session, world)?;
+            if !min_count.is_some_and(|min| min < count) {
+                min_count = Some(count);
+            }
+        }
+
+        Ok(min_count.unwrap_or(0))
+    }
+
+    fn add_listener(&self, listener: Entity, world: &mut World) -> OperationResult {
+        for buffer in self {
+            buffer.add_listener(listener, world)?;
+        }
+        Ok(())
+    }
+
+    fn gate_action(
+        &self,
+        session: Entity,
+        action: Gate,
+        world: &mut World,
+        roster: &mut OperationRoster,
+    ) -> OperationResult {
+        for buffer in self {
+            buffer.gate_action(session, action, world, roster)?;
+        }
+        Ok(())
+    }
+
+    fn as_input(&self) -> SmallVec<[Entity; 8]> {
+        self.iter().flat_map(|buffer| buffer.as_input()).collect()
+    }
+
+    fn ensure_active_session(&self, session: Entity, world: &mut World) -> OperationResult {
+        for buffer in self {
+            buffer.ensure_active_session(session, world)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl<B: Joined> Joined for Vec<B> {
+    type Item = Vec<B::Item>;
+    fn pull(&self, session: Entity, world: &mut World) -> Result<Self::Item, OperationError> {
+        self.iter()
+            .map(|buffer| buffer.pull(session, world))
+            .collect()
+    }
+}
+
+impl<B: Accessed> Accessed for Vec<B> {
+    type Key = Vec<B::Key>;
+    fn add_accessor(&self, accessor: Entity, world: &mut World) -> OperationResult {
+        for buffer in self {
+            buffer.add_accessor(accessor, world)?;
+        }
+        Ok(())
+    }
+
+    fn create_key(&self, builder: &BufferKeyBuilder) -> Self::Key {
+        let mut keys = Vec::new();
+        for buffer in self {
+            keys.push(buffer.create_key(builder));
+        }
+        keys
+    }
+
+    fn deep_clone_key(key: &Self::Key) -> Self::Key {
+        let mut keys = Vec::new();
+        for k in key {
+            keys.push(B::deep_clone_key(k));
+        }
+        keys
+    }
+
+    fn is_key_in_use(key: &Self::Key) -> bool {
+        for k in key {
+            if B::is_key_in_use(k) {
+                return true;
+            }
+        }
+
+        false
+    }
+}
+
 pub(crate) fn add_listener_to_source(
     source: Entity,
     listener: Entity,