Merge remote-tracking branch 'origin/buffer_map' into koonpeng/derive_joined

Signed-off-by: Teo Koon Peng <[email protected]>

Author: koonpeng

macros/src/buffer.rs

@@ -11,54 +11,28 @@ pub(crate) fn impl_joined_value(ast: DeriveInput) -> Result<TokenStream> {
         _ => return Err("expected struct".to_string()),
     };
     let map_key: Vec<String> = field_ident.iter().map(|v| v.to_string()).collect();
-    let struct_buffer_ident = format_ident!("__{}Buffers", struct_ident);
+    let struct_buffer_ident = format_ident!("__bevy_impulse_{}_Buffers", struct_ident);
 
     let impl_buffer_map_layout =
-        buffer_map_layout(&struct_ident, &field_ident, &field_type, &map_key);
+        buffer_map_layout(&struct_buffer_ident, &field_ident, &field_type, &map_key);
+    let impl_joined = joined(&struct_buffer_ident, &struct_ident, &field_ident);
 
     let gen = quote! {
-        #impl_buffer_map_layout
-
         impl ::bevy_impulse::JoinedValue for #struct_ident {
             type Buffers = #struct_buffer_ident;
-
-            fn pull(
-                buffers: &::bevy_impulse::BufferMap,
-                session: ::bevy_ecs::prelude::Entity,
-                world: &mut ::bevy_ecs::prelude::World,
-            ) -> Result<Self, ::bevy_impulse::OperationError> {
-                use ::bevy_impulse::{ManageBuffer, OrBroken};
-
-                #(
-                    let #field_ident = world
-                        .get_entity_mut(buffers.get(#map_key).or_broken()?.id())
-                        .or_broken()?
-                        .pull_from_buffer::<#field_type>(session)?;
-                )*
-
-                Ok(Self {
-                    #(
-                        #field_ident
-                    ),*
-                })
-            }
         }
 
+        #[derive(Clone)]
+        #[allow(non_camel_case_types)]
         struct #struct_buffer_ident {
             #(
-                #field_ident: ::bevy_impulse::Buffer<#field_type>
-            ),*
+                #field_ident: ::bevy_impulse::Buffer<#field_type>,
+            )*
         }
 
-        impl From<#struct_buffer_ident> for ::bevy_impulse::BufferMap {
-            fn from(value: #struct_buffer_ident) -> Self {
-                let mut buffers = ::bevy_impulse::BufferMap::default();
-                #(
-                    buffers.insert(std::borrow::Cow::Borrowed(#map_key), value.#field_ident);
-                )*
-                buffers
-            }
-        }
+        #impl_buffer_map_layout
+
+        #impl_joined
     };
 
     Ok(gen.into())
@@ -86,103 +60,49 @@ fn buffer_map_layout(
 ) -> proc_macro2::TokenStream {
     quote! {
         impl ::bevy_impulse::BufferMapLayout for #struct_ident {
-            fn is_compatible(buffers: &BufferMap) -> Result<(), ::bevy_impulse::IncompatibleLayout> {
-                let mut compatibility = ::bevy_impulse::IncompatibleLayout::default();
-                #(
-                    compatibility.require_buffer::<#field_type>(#map_key, buffers);
-                )*
-                compatibility.into_result()
+            fn buffer_list(&self) -> ::smallvec::SmallVec<[AnyBuffer; 8]> {
+                use smallvec::smallvec;
+                smallvec![#(
+                    self.#field_ident.as_any_buffer(),
+                )*]
             }
 
-            fn buffered_count(
-                buffers: &::bevy_impulse::BufferMap,
-                session: ::bevy_ecs::prelude::Entity,
-                world: &::bevy_ecs::prelude::World,
-            ) -> Result<usize, ::bevy_impulse::OperationError> {
-                use ::bevy_impulse::{InspectBuffer, OrBroken};
-
-                #(
-                    let #field_ident = world
-                        .get_entity(buffers.get(#map_key).or_broken()?.id())
-                        .or_broken()?
-                        .buffered_count::<#field_type>(session)?;
-                )*
-
-                Ok([#( #field_ident ),*]
-                    .iter()
-                    .min()
-                    .copied()
-                    .unwrap_or(0))
-            }
-
-            fn ensure_active_session(
-                buffers: &::bevy_impulse::BufferMap,
-                session: ::bevy_ecs::prelude::Entity,
-                world: &mut ::bevy_ecs::prelude::World,
-            ) -> ::bevy_impulse::OperationResult {
-                use ::bevy_impulse::{ManageBuffer, OrBroken};
-
+            fn try_from_buffer_map(buffers: &::bevy_impulse::BufferMap) -> Result<Self, ::bevy_impulse::IncompatibleLayout> {
+                let mut compatibility = ::bevy_impulse::IncompatibleLayout::default();
                 #(
-                    world
-                        .get_entity_mut(buffers.get(#map_key).or_broken()?.id())
-                        .or_broken()?
-                        .ensure_session::<#field_type>(session)?;
+                    let #field_ident = if let Ok(buffer) = compatibility.require_message_type::<#field_type>(#map_key, buffers) {
+                        buffer
+                    } else {
+                        return Err(compatibility);
+                    };
                 )*
 
-                Ok(())
+                Ok(Self {#(
+                    #field_ident,
+                )*})
             }
         }
     }
 }
 
-pub(crate) fn impl_buffer_key_map(ast: DeriveInput) -> Result<TokenStream> {
-    let struct_ident = ast.ident;
-    let (field_ident, field_type): (Vec<Ident>, Vec<Type>) = match ast.data {
-        syn::Data::Struct(data) => get_fields_map(data.fields)?.into_iter().unzip(),
-        _ => return Err("expected struct".to_string()),
-    };
-    let map_key: Vec<String> = field_ident.iter().map(|v| v.to_string()).collect();
-
-    let impl_buffer_map_layout =
-        buffer_map_layout(&struct_ident, &field_ident, &field_type, &map_key);
-
-    // FIXME(koonpeng): `create_key` does not allow failure and we can't guarantee that the buffer
-    // from the buffer map is valid.
-    let gen = quote! {
-        impl ::bevy_impulse::BufferKeyMap for #struct_ident {
-            fn add_accessor(buffers: &::bevy_impulse::BufferMap, accessor: ::bevy_ecs::prelude::Entity, world: &mut ::bevy_ecs::prelude::World) -> ::bevy_impulse::OperationResult {
-                use ::bevy_impulse::{Accessed, OrBroken};
+fn joined(
+    struct_ident: &Ident,
+    item_struct_ident: &Ident,
+    field_ident: &Vec<Ident>,
+) -> proc_macro2::TokenStream {
+    quote! {
+        impl ::bevy_impulse::Joined for #struct_ident {
+            type Item = #item_struct_ident;
 
+            fn pull(&self, session: ::bevy_ecs::prelude::Entity, world: &mut ::bevy_ecs::prelude::World) -> Result<Self::Item, ::bevy_impulse::OperationError> {
                 #(
-                    buffers.get(#map_key).or_broken()?.add_accessor(accessor, world)?;
+                    let #field_ident = self.#field_ident.pull(session, world)?;
                 )*
 
-                Ok(())
-            }
-
-            fn create_key(buffers: &::bevy_impulse::BufferMap, builder: &::bevy_impulse::BufferKeyBuilder) -> Self {
-                use ::bevy_impulse::{Accessed, OrBroken};
-
-                Self {#(
-                    #field_ident: buffers.get(#map_key).unwrap().create_key(builder).try_into().unwrap(),
-                )*}
-            }
-
-            fn deep_clone_key(&self) -> Self {
-                Self {#(
-                    #field_ident: self.#field_ident.deep_clone(),
-                )*}
-            }
-
-            fn is_key_in_use(&self) -> bool {
-                #(
-                    self.#field_ident.is_in_use()
-                )||*
+                Ok(Self::Item {#(
+                    #field_ident,
+                )*})
             }
         }
-
-        #impl_buffer_map_layout
-    };
-
-    Ok(gen.into())
+    }
 }

macros/src/lib.rs

@@ -16,7 +16,7 @@
 */
 
 mod buffer;
-use buffer::{impl_buffer_key_map, impl_joined_value};
+use buffer::impl_joined_value;
 
 use proc_macro::TokenStream;
 use quote::quote;
@@ -76,15 +76,3 @@ pub fn derive_joined_value(input: TokenStream) -> TokenStream {
         .into(),
     }
 }
-
-#[proc_macro_derive(BufferKeyMap)]
-pub fn derive_buffer_key_map(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-    match impl_buffer_key_map(input) {
-        Ok(tokens) => tokens,
-        Err(msg) => quote! {
-            compile_error!(#msg);
-        }
-        .into(),
-    }
-}

src/buffer.rs

@@ -113,6 +113,14 @@ impl<T> Buffer<T> {
     pub fn location(&self) -> BufferLocation {
         self.location
     }
+
+    /// Cast this into an [`AnyBuffer`].
+    pub fn as_any_buffer(&self) -> AnyBuffer
+    where
+        T: 'static + Send + Sync,
+    {
+        self.clone().into()
+    }
 }
 
 impl<T> Clone for Buffer<T> {
@@ -225,7 +233,7 @@ impl Default for RetentionPolicy {
 /// To obtain a `BufferKey`, use [`Chain::with_access`][1], or [`listen`][2].
 ///
 /// [1]: crate::Chain::with_access
-/// [2]: crate::Bufferable::listen
+/// [2]: crate::Accessible::listen
 pub struct BufferKey<T> {
     tag: BufferKeyTag,
     _ignore: std::marker::PhantomData<fn(T)>,