derive joined

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

Author: koonpeng

macros/src/buffers.rs

@@ -0,0 +1,118 @@
+use proc_macro::TokenStream;
+use quote::{format_ident, quote};
+use syn::{DeriveInput, Ident, Type};
+
+use crate::Result;
+
+pub(crate) fn impl_buffer_map_layout(ast: DeriveInput) -> Result<TokenStream> {
+    let struct_ident = ast.ident;
+    let (field_ident, field_type) = match ast.data {
+        syn::Data::Struct(data) => get_fields_map(data.fields)?,
+        _ => 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 gen = quote! {
+        impl BufferMapLayout for #struct_ident {
+            fn is_compatible(buffers: &BufferMap) -> Result<(), IncompatibleLayout> {
+                let mut compatibility = IncompatibleLayout::default();
+                #(
+                    compatibility.require_buffer::<#field_type>(#map_key, buffers);
+                )*
+                compatibility.into_result()
+            }
+
+            fn buffered_count(
+                buffers: &BufferMap,
+                session: Entity,
+                world: &World,
+            ) -> Result<usize, OperationError> {
+                #(
+                    let #field_ident = world
+                        .get_entity(buffers.get(#map_key).unwrap().id())
+                        .or_broken()?
+                        .buffered_count::<#field_type>(session)?;
+                )*
+
+                Ok([#( #field_ident ),*]
+                    .iter()
+                    .min()
+                    .copied()
+                    .unwrap_or(0))
+            }
+
+            fn ensure_active_session(
+                buffers: &BufferMap,
+                session: Entity,
+                world: &mut World,
+            ) -> OperationResult {
+                #(
+                    world
+                        .get_entity_mut(buffers.get(#map_key).unwrap().id())
+                        .or_broken()?
+                        .ensure_session::<#field_type>(session)?;
+                )*
+
+                Ok(())
+            }
+        }
+
+        impl JoinedValue for #struct_ident {
+            type Buffers = #struct_buffer_ident;
+
+            fn pull(
+                buffers: &BufferMap,
+                session: Entity,
+                world: &mut World,
+            ) -> Result<Self, OperationError> {
+                #(
+                    let #field_ident = world
+                        .get_entity_mut(buffers.get(#map_key).unwrap().id())
+                        .or_broken()?
+                        .pull_from_buffer::<#field_type>(session)?;
+                )*
+
+                Ok(Self {
+                    #(
+                        #field_ident
+                    ),*
+                })
+            }
+        }
+
+        struct #struct_buffer_ident {
+            #(
+                #field_ident: Buffer<#field_type>
+            ),*
+        }
+
+        impl From<#struct_buffer_ident> for BufferMap {
+            fn from(value: #struct_buffer_ident) -> Self {
+                let mut buffers = BufferMap::default();
+                #(
+                    buffers.insert(Cow::Borrowed(#map_key), value.#field_ident);
+                )*
+                buffers
+            }
+        }
+    };
+
+    Ok(gen.into())
+}
+
+fn get_fields_map(fields: syn::Fields) -> Result<(Vec<Ident>, Vec<Type>)> {
+    match fields {
+        syn::Fields::Named(data) => {
+            let mut idents = Vec::with_capacity(data.named.len());
+            let mut types = Vec::with_capacity(data.named.len());
+            for field in data.named {
+                let ident = field.ident.ok_or("expected named fields".to_string())?;
+                idents.push(ident);
+                types.push(field.ty);
+            }
+            Ok((idents, types))
+        }
+        _ => return Err("expected named fields".to_string()),
+    }
+}

macros/src/lib.rs

@@ -15,9 +15,12 @@
  *
 */
 
+mod buffers;
+use buffers::impl_buffer_map_layout;
+
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::DeriveInput;
+use syn::{parse_macro_input, DeriveInput};
 
 #[proc_macro_derive(Stream)]
 pub fn simple_stream_macro(item: TokenStream) -> TokenStream {
@@ -58,3 +61,18 @@ pub fn delivery_label_macro(item: TokenStream) -> TokenStream {
     }
     .into()
 }
+
+// The result error is the compiler error message to be displayed.
+type Result<T> = std::result::Result<T, String>;
+
+#[proc_macro_derive(Joined)]
+pub fn derive_joined(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    match impl_buffer_map_layout(input) {
+        Ok(tokens) => tokens,
+        Err(msg) => quote! {
+            compile_error!(#msg);
+        }
+        .into(),
+    }
+}

src/buffer/buffer_map.rs

@@ -365,121 +365,15 @@ mod tests {
     };
 
     use bevy_ecs::prelude::World;
+    use bevy_impulse_derive::Joined;
 
-    #[derive(Clone)]
+    #[derive(Clone, Joined)]
     struct TestJoinedValue {
         integer: i64,
         float: f64,
         string: String,
     }
 
-    impl BufferMapLayout for TestJoinedValue {
-        fn is_compatible(buffers: &BufferMap) -> Result<(), IncompatibleLayout> {
-            let mut compatibility = IncompatibleLayout::default();
-            compatibility.require_buffer::<i64>("integer", buffers);
-            compatibility.require_buffer::<f64>("float", buffers);
-            compatibility.require_buffer::<String>("string", buffers);
-            compatibility.into_result()
-        }
-
-        fn buffered_count(
-            buffers: &BufferMap,
-            session: Entity,
-            world: &World,
-        ) -> Result<usize, OperationError> {
-            let integer_count = world
-                .get_entity(buffers.get("integer").unwrap().id())
-                .or_broken()?
-                .buffered_count::<i64>(session)?;
-
-            let float_count = world
-                .get_entity(buffers.get("float").unwrap().id())
-                .or_broken()?
-                .buffered_count::<f64>(session)?;
-
-            let string_count = world
-                .get_entity(buffers.get("string").unwrap().id())
-                .or_broken()?
-                .buffered_count::<String>(session)?;
-
-            Ok([integer_count, float_count, string_count]
-                .iter()
-                .min()
-                .copied()
-                .unwrap_or(0))
-        }
-
-        fn ensure_active_session(
-            buffers: &BufferMap,
-            session: Entity,
-            world: &mut World,
-        ) -> OperationResult {
-            world
-                .get_entity_mut(buffers.get("integer").unwrap().id())
-                .or_broken()?
-                .ensure_session::<i64>(session)?;
-
-            world
-                .get_entity_mut(buffers.get("float").unwrap().id())
-                .or_broken()?
-                .ensure_session::<f64>(session)?;
-
-            world
-                .get_entity_mut(buffers.get("string").unwrap().id())
-                .or_broken()?
-                .ensure_session::<String>(session)?;
-
-            Ok(())
-        }
-    }
-
-    impl JoinedValue for TestJoinedValue {
-        type Buffers = TestJoinedValueBuffers;
-
-        fn pull(
-            buffers: &BufferMap,
-            session: Entity,
-            world: &mut World,
-        ) -> Result<Self, OperationError> {
-            let integer = world
-                .get_entity_mut(buffers.get("integer").unwrap().id())
-                .or_broken()?
-                .pull_from_buffer::<i64>(session)?;
-
-            let float = world
-                .get_entity_mut(buffers.get("float").unwrap().id())
-                .or_broken()?
-                .pull_from_buffer::<f64>(session)?;
-
-            let string = world
-                .get_entity_mut(buffers.get("string").unwrap().id())
-                .or_broken()?
-                .pull_from_buffer::<String>(session)?;
-
-            Ok(Self {
-                integer,
-                float,
-                string,
-            })
-        }
-    }
-
-    struct TestJoinedValueBuffers {
-        integer: Buffer<i64>,
-        float: Buffer<f64>,
-        string: Buffer<String>,
-    }
-
-    impl From<TestJoinedValueBuffers> for BufferMap {
-        fn from(value: TestJoinedValueBuffers) -> Self {
-            let mut buffers = BufferMap::default();
-            buffers.insert(Cow::Borrowed("integer"), value.integer);
-            buffers.insert(Cow::Borrowed("float"), value.float);
-            buffers.insert(Cow::Borrowed("string"), value.string);
-            buffers
-        }
-    }
-
     #[test]
     fn test_joined_value() {
         let mut context = TestingContext::minimal_plugins();