Refactored out ComponentId in Event trait

Author: oscar-benderstone

crates/bevy_ecs/src/event/base.rs

@@ -94,23 +94,23 @@ use core::{
     note = "consider annotating `{Self}` with `#[derive(Event)]`"
 )]
 pub trait Event: Send + Sync + 'static {
-    /// Generates the [`ComponentId`] for this event type.
+    /// Generates the [`EventKey`] for this event type.
     ///
     /// If this type has already been registered,
-    /// this will return the existing [`ComponentId`].
+    /// this will return the existing [`EventKey`].
     ///
     /// This is used by various dynamically typed observer APIs,
     /// such as [`World::trigger_targets_dynamic`].
     ///
     /// # Warning
     ///
     /// This method should not be overridden by implementers,
-    /// and should always correspond to the implementation of [`event_key`](Event::component_id).
-    fn register_component_id(world: &mut World) -> ComponentId {
-        world.register_component::<EventWrapperComponent<Self>>()
+    /// and should always correspond to the implementation of [`event_type`](Event::event_type).
+    fn register_event_type(world: &mut World) -> EventKey {
+        EventKey(world.register_component::<EventWrapperComponent<Self>>())
     }
 
-    /// Fetches the [`ComponentId`] for this event type,
+    /// Fetches the [`EventKey`] for this event type,
     /// if it has already been generated.
     ///
     /// This is used by various dynamically typed observer APIs,
@@ -119,9 +119,12 @@ pub trait Event: Send + Sync + 'static {
     /// # Warning
     ///
     /// This method should not be overridden by implementers,
-    /// and should always correspond to the implementation of [`register_component_id`](Event::register_component_id).
-    fn component_id(world: &World) -> Option<ComponentId> {
-        world.component_id::<EventWrapperComponent<Self>>()
+    /// and should always correspond to the implementation of
+    /// [`register_event_type`](Event::register_event_type).
+    fn event_type(world: &World) -> Option<EventKey> {
+        world
+            .component_id::<EventWrapperComponent<Self>>()
+            .map(EventKey)
     }
 }
 

crates/bevy_ecs/src/observer/mod.rs

@@ -786,10 +786,10 @@ impl World {
     }
 
     pub(crate) fn trigger_with_caller<E: Event>(&mut self, mut event: E, caller: MaybeLocation) {
-        let event_id = E::register_component_id(self);
+        let event_type = E::register_event_type(self);
         // SAFETY: We just registered `event_id` with the type of `event`
         unsafe {
-            self.trigger_dynamic_ref_with_caller(event_id, &mut event, caller);
+            self.trigger_dynamic_ref_with_caller(event_type, &mut event, caller);
         }
     }
 
@@ -799,22 +799,22 @@ impl World {
     /// or use the event after it has been modified by observers.
     #[track_caller]
     pub fn trigger_ref<E: Event>(&mut self, event: &mut E) {
-        let event_id = E::register_component_id(self);
+        let event_type = E::register_event_type(self);
         // SAFETY: We just registered `event_id` with the type of `event`
-        unsafe { self.trigger_dynamic_ref_with_caller(event_id, event, MaybeLocation::caller()) };
+        unsafe { self.trigger_dynamic_ref_with_caller(event_type, event, MaybeLocation::caller()) };
     }
 
     unsafe fn trigger_dynamic_ref_with_caller<E: Event>(
         &mut self,
-        event_id: ComponentId,
+        event_type: EventKey,
         event_data: &mut E,
         caller: MaybeLocation,
     ) {
         let mut world = DeferredWorld::from(self);
         // SAFETY: `event_data` is accessible as the type represented by `event_id`
         unsafe {
             world.trigger_observers_with_data::<_, ()>(
-                EventKey(event_id),
+                event_type,
                 None,
                 None,
                 core::iter::empty::<ComponentId>(),
@@ -841,10 +841,10 @@ impl World {
         targets: impl TriggerTargets,
         caller: MaybeLocation,
     ) {
-        let event_id = E::register_component_id(self);
+        let event_type = E::register_event_type(self);
         // SAFETY: We just registered `event_id` with the type of `event`
         unsafe {
-            self.trigger_targets_dynamic_ref_with_caller(event_id, &mut event, targets, caller);
+            self.trigger_targets_dynamic_ref_with_caller(event_type, &mut event, targets, caller);
         }
     }
 
@@ -859,9 +859,9 @@ impl World {
         event: &mut E,
         targets: impl TriggerTargets,
     ) {
-        let event_id = E::register_component_id(self);
+        let event_type = E::register_event_type(self);
         // SAFETY: We just registered `event_id` with the type of `event`
-        unsafe { self.trigger_targets_dynamic_ref(event_id, event, targets) };
+        unsafe { self.trigger_targets_dynamic_ref(event_type, event, targets) };
     }
 
     /// Triggers the given [`EntityEvent`] for the given `targets`, which will run any [`Observer`]s watching for it.
@@ -876,13 +876,13 @@ impl World {
     #[track_caller]
     pub unsafe fn trigger_targets_dynamic<E: EntityEvent, Targets: TriggerTargets>(
         &mut self,
-        event_id: ComponentId,
+        event_type: EventKey,
         mut event_data: E,
         targets: Targets,
     ) {
         // SAFETY: `event_data` is accessible as the type represented by `event_id`
         unsafe {
-            self.trigger_targets_dynamic_ref(event_id, &mut event_data, targets);
+            self.trigger_targets_dynamic_ref(event_type, &mut event_data, targets);
         };
     }
 
@@ -898,12 +898,12 @@ impl World {
     #[track_caller]
     pub unsafe fn trigger_targets_dynamic_ref<E: EntityEvent, Targets: TriggerTargets>(
         &mut self,
-        event_id: ComponentId,
+        event_type: EventKey,
         event_data: &mut E,
         targets: Targets,
     ) {
         self.trigger_targets_dynamic_ref_with_caller(
-            event_id,
+            event_type,
             event_data,
             targets,
             MaybeLocation::caller(),
@@ -915,7 +915,7 @@ impl World {
     /// See `trigger_targets_dynamic_ref`
     unsafe fn trigger_targets_dynamic_ref_with_caller<E: EntityEvent, Targets: TriggerTargets>(
         &mut self,
-        event_id: ComponentId,
+        event_type: EventKey,
         event_data: &mut E,
         targets: Targets,
         caller: MaybeLocation,
@@ -926,7 +926,7 @@ impl World {
             // SAFETY: `event_data` is accessible as the type represented by `event_id`
             unsafe {
                 world.trigger_observers_with_data::<_, E::Traversal>(
-                    EventKey(event_id),
+                    event_type,
                     None,
                     None,
                     targets.components(),
@@ -940,7 +940,7 @@ impl World {
                 // SAFETY: `event_data` is accessible as the type represented by `event_id`
                 unsafe {
                     world.trigger_observers_with_data::<_, E::Traversal>(
-                        EventKey(event_id),
+                        event_type,
                         Some(target_entity),
                         Some(target_entity),
                         targets.components(),
@@ -1323,14 +1323,14 @@ mod tests {
     fn observer_multiple_events() {
         let mut world = World::new();
         world.init_resource::<Order>();
-        let on_remove = Remove::register_component_id(&mut world);
+        let on_remove = Remove::register_event_type(&mut world);
         world.spawn(
             // SAFETY: Add and Remove are both unit types, so this is safe
             unsafe {
                 Observer::new(|_: On<Add, A>, mut res: ResMut<Order>| {
                     res.observed("add/remove");
                 })
-                .with_event(EventKey(on_remove))
+                .with_event(on_remove)
             },
         );
 
@@ -1597,14 +1597,14 @@ mod tests {
     fn observer_dynamic_trigger() {
         let mut world = World::new();
         world.init_resource::<Order>();
-        let event_a = Remove::register_component_id(&mut world);
+        let event_a = Remove::register_event_type(&mut world);
 
         // SAFETY: we registered `event_a` above and it matches the type of EventA
         let observe = unsafe {
             Observer::with_dynamic_runner(|mut world, _trigger, _ptr, _propagate| {
                 world.resource_mut::<Order>().observed("event_a");
             })
-            .with_event(EventKey(event_a))
+            .with_event(event_a)
         };
         world.spawn(observe);
 

crates/bevy_ecs/src/observer/runner.rs

@@ -443,13 +443,13 @@ fn hook_on_add<E: Event, B: Bundle, S: ObserverSystem<E, B>>(
     HookContext { entity, .. }: HookContext,
 ) {
     world.commands().queue(move |world: &mut World| {
-        let event_id = E::register_component_id(world);
+        let event_type = E::register_event_type(world);
         let mut components = vec![];
         B::component_ids(&mut world.components_registrator(), &mut |id| {
             components.push(id);
         });
         if let Some(mut observer) = world.get_mut::<Observer>(entity) {
-            observer.descriptor.events.push(EventKey(event_id));
+            observer.descriptor.events.push(event_type);
             observer.descriptor.components.extend(components);
 
             let system: &mut dyn Any = observer.system.as_mut();

crates/bevy_ecs/src/world/deferred_world.rs

@@ -804,7 +804,7 @@ impl<'w> DeferredWorld<'w> {
             }
             Observers::invoke::<_>(
                 self.reborrow(),
-                event.clone(),
+                event,
                 Some(current_target),
                 original_target,
                 components.clone(),

crates/bevy_ecs/src/world/mod.rs

@@ -21,7 +21,7 @@ use crate::{
     error::{DefaultErrorHandler, ErrorHandler},
     event::BufferedEvent,
     lifecycle::{ComponentHooks, ADD, DESPAWN, INSERT, REMOVE, REPLACE},
-    prelude::{Add, Despawn, EventKey, Insert, Remove, Replace},
+    prelude::{Add, Despawn, Insert, Remove, Replace},
 };
 pub use bevy_ecs_macros::FromWorld;
 use bevy_utils::prelude::DebugName;
@@ -152,20 +152,20 @@ impl World {
     #[inline]
     fn bootstrap(&mut self) {
         // The order that we register these events is vital to ensure that the constants are correct!
-        let on_add = Add::register_component_id(self);
-        assert_eq!(ADD, EventKey(on_add));
+        let on_add = Add::register_event_type(self);
+        assert_eq!(ADD, on_add);
 
-        let on_insert = Insert::register_component_id(self);
-        assert_eq!(INSERT, EventKey(on_insert));
+        let on_insert = Insert::register_event_type(self);
+        assert_eq!(INSERT, on_insert);
 
-        let on_replace = Replace::register_component_id(self);
-        assert_eq!(REPLACE, EventKey(on_replace));
+        let on_replace = Replace::register_event_type(self);
+        assert_eq!(REPLACE, on_replace);
 
-        let on_remove = Remove::register_component_id(self);
-        assert_eq!(REMOVE, EventKey(on_remove));
+        let on_remove = Remove::register_event_type(self);
+        assert_eq!(REMOVE, on_remove);
 
-        let on_despawn = Despawn::register_component_id(self);
-        assert_eq!(DESPAWN, EventKey(on_despawn));
+        let on_despawn = Despawn::register_event_type(self);
+        assert_eq!(DESPAWN, on_despawn);
 
         // This sets up `Disabled` as a disabling component, via the FromWorld impl
         self.init_resource::<DefaultQueryFilters>();