Add derive macro for DeliveryLabel (#30)

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

Author: mxgrey

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_impulse"
-version = "0.0.1"
+version = "0.0.2"
 edition = "2021"
 authors = ["Grey <mxgrey@intrinsic.ai>"]
 license = "Apache-2.0"
@@ -11,7 +11,7 @@ keywords = ["reactive", "workflow", "behavior", "agent", "bevy"]
 categories = ["science::robotics", "asynchronous", "concurrency", "game-development"]
 
 [dependencies]
-bevy_impulse_derive = { path = "macros", version = "0.0.1" }
+bevy_impulse_derive = { path = "macros", version = "0.0.2" }
 bevy_ecs = "0.12"
 bevy_utils = "0.12"
 bevy_hierarchy = "0.12"

macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "bevy_impulse_derive"
-version = "0.0.1"
+version = "0.0.2"
 edition = "2021"
 authors = ["Grey <mxgrey@intrinsic.ai>"]
 license = "Apache-2.0"

macros/src/lib.rs

@@ -24,12 +24,37 @@ pub fn simple_stream_macro(item: TokenStream) -> TokenStream {
     let ast: DeriveInput = syn::parse(item).unwrap();
     let struct_name = &ast.ident;
     let (impl_generics, type_generics, where_clause) = &ast.generics.split_for_impl();
-    // let bevy_impulse_path: Path =
 
     quote! {
-        impl #impl_generics Stream for #struct_name #type_generics #where_clause {
+        impl #impl_generics ::bevy_impulse::Stream for #struct_name #type_generics #where_clause {
             type Container = ::bevy_impulse::DefaultStreamContainer<Self>;
         }
     }
     .into()
 }
+
+#[proc_macro_derive(DeliveryLabel)]
+pub fn delivery_label_macro(item: TokenStream) -> TokenStream {
+    let ast: DeriveInput = syn::parse(item).unwrap();
+    let struct_name = &ast.ident;
+    let (impl_generics, type_generics, where_clause) = &ast.generics.split_for_impl();
+
+    quote! {
+        impl #impl_generics ::bevy_impulse::DeliveryLabel for #struct_name #type_generics #where_clause {
+            fn dyn_clone(&self) -> Box<dyn DeliveryLabel> {
+                ::std::boxed::Box::new(::std::clone::Clone::clone(self))
+            }
+
+            fn as_dyn_eq(&self) -> &dyn ::bevy_impulse::utils::DynEq {
+                self
+            }
+
+            fn dyn_hash(&self, mut state: &mut dyn ::std::hash::Hasher) {
+                let ty_id = ::std::any::TypeId::of::<Self>();
+                ::std::hash::Hash::hash(&ty_id, &mut state);
+                ::std::hash::Hash::hash(self, &mut state);
+            }
+        }
+    }
+    .into()
+}

src/impulse.rs

@@ -485,11 +485,30 @@ mod tests {
     }
 
     #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-    struct TestLabel;
+    struct UnitLabel;
 
-    // TODO(luca) create a proc-macro for this, because library crates can't
-    // export proc macros we will need to create a new macros only crate
-    impl DeliveryLabel for TestLabel {
+    // TODO(@mxgrey) Figure out how to make the DeliveryLabel macro usable
+    // within the core bevy_impulse library
+    impl DeliveryLabel for UnitLabel {
+        fn dyn_clone(&self) -> Box<dyn DeliveryLabel> {
+            Box::new(self.clone())
+        }
+
+        fn as_dyn_eq(&self) -> &dyn DynEq {
+            self
+        }
+
+        fn dyn_hash(&self, mut state: &mut dyn std::hash::Hasher) {
+            let ty_id = std::any::TypeId::of::<Self>();
+            std::hash::Hash::hash(&ty_id, &mut state);
+            std::hash::Hash::hash(self, &mut state);
+        }
+    }
+
+    #[derive(Clone, Debug, PartialEq, Eq, Hash)]
+    struct StatefulLabel(u64);
+
+    impl DeliveryLabel for StatefulLabel {
         fn dyn_clone(&self) -> Box<dyn DeliveryLabel> {
             Box::new(self.clone())
         }
@@ -534,9 +553,38 @@ mod tests {
         service: Service<Arc<Mutex<u64>>, ()>,
         context: &mut TestingContext,
     ) {
-        let queuing_service = service.instruct(TestLabel);
-        let preempting_service = service.instruct(TestLabel.preempt());
+        // Test for a unit struct
+        verify_preemption_matrix(
+            service.instruct(UnitLabel),
+            service.instruct(UnitLabel.preempt()),
+            context,
+        );
+
+        // Test for a stateful struct
+        verify_preemption_matrix(
+            service.instruct(StatefulLabel(5)),
+            service.instruct(StatefulLabel(5).preempt()),
+            context,
+        );
 
+        // Test for a unit struct
+        verify_queuing_matrix(service.instruct(UnitLabel), context);
+
+        // Test for a stateful struct
+        verify_queuing_matrix(service.instruct(StatefulLabel(7)), context);
+
+        // Test for a unit struct
+        verify_ensured_matrix(service, UnitLabel, context);
+
+        // Test for a stateful struct
+        verify_ensured_matrix(service, StatefulLabel(2), context);
+    }
+
+    fn verify_preemption_matrix(
+        queuing_service: Service<Arc<Mutex<u64>>, ()>,
+        preempting_service: Service<Arc<Mutex<u64>>, ()>,
+        context: &mut TestingContext,
+    ) {
         // Test by queuing up a bunch of requests before preempting them all at once.
         verify_preemption(1, queuing_service, preempting_service, context);
         verify_preemption(2, queuing_service, preempting_service, context);
@@ -548,25 +596,6 @@ mod tests {
         verify_preemption(2, preempting_service, preempting_service, context);
         verify_preemption(3, preempting_service, preempting_service, context);
         verify_preemption(4, preempting_service, preempting_service, context);
-
-        // Test by queuing up a bunch of requests and making sure they all get
-        // delivered.
-        verify_queuing(2, queuing_service, context);
-        verify_queuing(3, queuing_service, context);
-        verify_queuing(4, queuing_service, context);
-        verify_queuing(5, queuing_service, context);
-
-        // Test by queuing up a mix of ensured and unensured requests, and then
-        // sending in one that preempts them all. The ensured requests should
-        // remain in the queue and execute despite the preempter. The unensured
-        // requests should all be cancelled.
-        verify_ensured([false, true, false, true], service, context);
-        verify_ensured([true, false, false, false], service, context);
-        verify_ensured([true, true, false, false], service, context);
-        verify_ensured([false, false, true, true], service, context);
-        verify_ensured([true, false, false, true], service, context);
-        verify_ensured([false, false, false, false], service, context);
-        verify_ensured([true, true, true, true], service, context);
     }
 
     fn verify_preemption(
@@ -603,6 +632,18 @@ mod tests {
         assert!(context.no_unhandled_errors());
     }
 
+    fn verify_queuing_matrix(
+        queuing_service: Service<Arc<Mutex<u64>>, ()>,
+        context: &mut TestingContext,
+    ) {
+        // Test by queuing up a bunch of requests and making sure they all get
+        // delivered.
+        verify_queuing(2, queuing_service, context);
+        verify_queuing(3, queuing_service, context);
+        verify_queuing(4, queuing_service, context);
+        verify_queuing(5, queuing_service, context);
+    }
+
     fn verify_queuing(
         queue_size: usize,
         queuing_service: Service<Arc<Mutex<u64>>, ()>,
@@ -628,9 +669,33 @@ mod tests {
         assert!(context.no_unhandled_errors());
     }
 
-    fn verify_ensured(
+    fn verify_ensured_matrix<L: DeliveryLabel + Clone>(
+        service: Service<Arc<Mutex<u64>>, ()>,
+        label: L,
+        context: &mut TestingContext,
+    ) {
+        // Test by queuing up a mix of ensured and unensured requests, and then
+        // sending in one that preempts them all. The ensured requests should
+        // remain in the queue and execute despite the preempter. The unensured
+        // requests should all be cancelled.
+        verify_ensured([false, true, false, true], service, label.clone(), context);
+        verify_ensured([true, false, false, false], service, label.clone(), context);
+        verify_ensured([true, true, false, false], service, label.clone(), context);
+        verify_ensured([false, false, true, true], service, label.clone(), context);
+        verify_ensured([true, false, false, true], service, label.clone(), context);
+        verify_ensured(
+            [false, false, false, false],
+            service,
+            label.clone(),
+            context,
+        );
+        verify_ensured([true, true, true, true], service, label.clone(), context);
+    }
+
+    fn verify_ensured<L: DeliveryLabel + Clone>(
         queued: impl IntoIterator<Item = bool>,
         service: Service<Arc<Mutex<u64>>, ()>,
+        label: L,
         context: &mut TestingContext,
     ) {
         let counter = Arc::new(Mutex::new(0_u64));
@@ -640,9 +705,9 @@ mod tests {
         for ensured in queued {
             let srv = if ensured {
                 expected_count += 1;
-                service.instruct(TestLabel.ensure())
+                service.instruct(label.clone().ensure())
             } else {
-                service.instruct(TestLabel)
+                service.instruct(label.clone())
             };
 
             let promise = context
@@ -653,7 +718,10 @@ mod tests {
 
         let mut preempter = context.command(|commands| {
             commands
-                .request(Arc::clone(&counter), service.instruct(TestLabel.preempt()))
+                .request(
+                    Arc::clone(&counter),
+                    service.instruct(label.clone().preempt()),
+                )
                 .take_response()
         });
 

src/service.rs

@@ -26,6 +26,7 @@ use bevy_ecs::{
     prelude::{Commands, Component, Entity, Event, World},
     schedule::ScheduleLabel,
 };
+pub use bevy_impulse_derive::DeliveryLabel;
 use bevy_utils::{define_label, intern::Interned};
 use std::{any::TypeId, collections::HashSet};
 use thiserror::Error as ThisError;
@@ -196,6 +197,11 @@ define_label!(
     DELIVERY_LABEL_INTERNER
 );
 
+pub mod utils {
+    /// Used by the procedural macro for DeliveryLabel
+    pub use bevy_utils::label::DynEq;
+}
+
 /// When using a service, you can bundle in delivery instructions that affect
 /// how multiple requests to the same service may interact with each other.
 ///