no cows on this farm

maniwani · maniwani · commit 9efed83f6e78 · 2023-02-19T20:01:22.000-08:00
diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
@@ -4,8 +4,7 @@ use bevy_ecs::{
     prelude::*,
     schedule::{
         apply_state_transition, common_conditions::run_once as run_once_condition,
-        run_enter_schedule, BoxedScheduleLabel, IntoSystemConfig, IntoSystemSetConfigs,
-        ScheduleLabel,
+        run_enter_schedule, IntoSystemConfig, IntoSystemSetConfigs, ScheduleId, ScheduleLabel,
     },
 };
 use bevy_utils::{tracing::debug, HashMap, HashSet};
@@ -69,11 +68,11 @@ pub struct App {
     /// The schedule that systems are added to by default.
     ///
     /// This is initially set to [`CoreSchedule::Main`].
-    pub default_schedule_label: BoxedScheduleLabel,
+    pub default_schedule_label: ScheduleId,
     /// The schedule that controls the outer loop of schedule execution.
     ///
     /// This is initially set to [`CoreSchedule::Outer`].
-    pub outer_schedule_label: BoxedScheduleLabel,
+    pub outer_schedule_label: ScheduleId,
     sub_apps: HashMap<AppLabelId, SubApp>,
     plugin_registry: Vec<Box<dyn Plugin>>,
     plugin_name_added: HashSet<String>,
@@ -163,7 +162,7 @@ impl SubApp {
     pub fn run(&mut self) {
         self.app
             .world
-            .run_schedule_ref(&*self.app.outer_schedule_label);
+            .run_schedule_by_id(self.app.outer_schedule_label);
         self.app.world.clear_trackers();
     }
 
@@ -223,8 +222,8 @@ impl App {
             sub_apps: HashMap::default(),
             plugin_registry: Vec::default(),
             plugin_name_added: Default::default(),
-            default_schedule_label: Box::new(CoreSchedule::Main),
-            outer_schedule_label: Box::new(CoreSchedule::Outer),
+            default_schedule_label: ScheduleId::of(&CoreSchedule::Main),
+            outer_schedule_label: ScheduleId::of(&CoreSchedule::Outer),
             is_building_plugin: false,
         }
     }
@@ -245,7 +244,7 @@ impl App {
         {
             #[cfg(feature = "trace")]
             let _bevy_frame_update_span = info_span!("main app").entered();
-            self.world.run_schedule_ref(&*self.outer_schedule_label);
+            self.world.run_schedule_by_id(self.outer_schedule_label);
         }
         for (_label, sub_app) in self.sub_apps.iter_mut() {
             #[cfg(feature = "trace")]
@@ -375,7 +374,7 @@ impl App {
     pub fn add_system<P>(&mut self, system: impl IntoSystemConfig<P>) -> &mut Self {
         let mut schedules = self.world.resource_mut::<Schedules>();
 
-        if let Some(default_schedule) = schedules.get_mut(&*self.default_schedule_label) {
+        if let Some(default_schedule) = schedules.get_mut_by_id(self.default_schedule_label) {
             default_schedule.add_system(system);
         } else {
             let schedule_label = &self.default_schedule_label;
@@ -403,7 +402,7 @@ impl App {
     pub fn add_systems<P>(&mut self, systems: impl IntoSystemConfigs<P>) -> &mut Self {
         let mut schedules = self.world.resource_mut::<Schedules>();
 
-        if let Some(default_schedule) = schedules.get_mut(&*self.default_schedule_label) {
+        if let Some(default_schedule) = schedules.get_mut_by_id(self.default_schedule_label) {
             default_schedule.add_systems(systems);
         } else {
             let schedule_label = &self.default_schedule_label;
@@ -498,7 +497,7 @@ impl App {
     pub fn configure_set(&mut self, set: impl IntoSystemSetConfig) -> &mut Self {
         self.world
             .resource_mut::<Schedules>()
-            .get_mut(&*self.default_schedule_label)
+            .get_mut_by_id(self.default_schedule_label)
             .unwrap()
             .configure_set(set);
         self
@@ -508,7 +507,7 @@ impl App {
     pub fn configure_sets(&mut self, sets: impl IntoSystemSetConfigs) -> &mut Self {
         self.world
             .resource_mut::<Schedules>()
-            .get_mut(&*self.default_schedule_label)
+            .get_mut_by_id(self.default_schedule_label)
             .unwrap()
             .configure_sets(sets);
         self
@@ -992,8 +991,9 @@ impl App {
     ) -> &mut Self {
         let mut schedules = self.world.resource_mut::<Schedules>();
 
-        if schedules.get(&label).is_none() {
-            schedules.insert(label.dyn_clone(), Schedule::new());
+        let id = ScheduleId::of(&label);
+        if !schedules.contains_by_id(id) {
+            schedules.insert_by_id(id, Schedule::new());
         }
 
         let schedule = schedules.get_mut(&label).unwrap();
diff --git a/crates/bevy_ecs/src/schedule/schedule.rs b/crates/bevy_ecs/src/schedule/schedule.rs
@@ -43,14 +43,14 @@ impl Schedules {
     /// and the old schedule is returned. Otherwise, `None` is returned.
     pub fn insert(&mut self, label: impl ScheduleLabel, schedule: Schedule) -> Option<Schedule> {
         let id = ScheduleId::of(&label);
-        self.insert_with_id(id, schedule)
+        self.insert_by_id(id, schedule)
     }
 
     /// Inserts a schedule into the map.
     ///
     /// If the map already had an entry for `id`, `schedule` is inserted,
     /// and the old schedule is returned. Otherwise, `None` is returned.
-    pub fn insert_with_id(&mut self, id: ScheduleId, schedule: Schedule) -> Option<Schedule> {
+    pub fn insert_by_id(&mut self, id: ScheduleId, schedule: Schedule) -> Option<Schedule> {
         if self.inner.contains_key(&id) {
             warn!("schedule with label {:?} already exists", id);
         }
@@ -60,27 +60,47 @@ impl Schedules {
     /// Removes the schedule corresponding to the `label` from the map, returning it if it existed.
     pub fn remove(&mut self, label: &dyn ScheduleLabel) -> Option<Schedule> {
         let id = ScheduleId::of(label);
+        self.remove_by_id(id)
+    }
+
+    /// Removes the schedule corresponding to the `id` from the map, returning it if it existed.
+    pub fn remove_by_id(&mut self, id: ScheduleId) -> Option<Schedule> {
         if !self.inner.contains_key(&id) {
             warn!("schedule with label {:?} not found", id);
         }
         self.inner.remove(&id)
     }
 
-    /// Does a schedule with the provided label already exist?
+    /// Does a schedule associated with the provided `label` already exist?
     pub fn contains(&self, label: &dyn ScheduleLabel) -> bool {
         let id = ScheduleId::of(label);
+        self.contains_by_id(id)
+    }
+
+    /// Does a schedule associated with the provided `id` already exist?
+    pub fn contains_by_id(&self, id: ScheduleId) -> bool {
         self.inner.contains_key(&id)
     }
 
     /// Returns a reference to the schedule associated with `label`, if it exists.
     pub fn get(&self, label: &dyn ScheduleLabel) -> Option<&Schedule> {
         let id = ScheduleId::of(label);
+        self.get_by_id(id)
+    }
+
+    /// Returns a reference to the schedule associated with `id`, if it exists.
+    pub fn get_by_id(&self, id: ScheduleId) -> Option<&Schedule> {
         self.inner.get(&id)
     }
 
     /// Returns a mutable reference to the schedule associated with `label`, if it exists.
     pub fn get_mut(&mut self, label: &dyn ScheduleLabel) -> Option<&mut Schedule> {
         let id = ScheduleId::of(label);
+        self.get_mut_by_id(id)
+    }
+
+    /// Returns a mutable reference to the schedule associated with `id`, if it exists.
+    pub fn get_mut_by_id(&mut self, id: ScheduleId) -> Option<&mut Schedule> {
         self.inner.get_mut(&id)
     }
 
diff --git a/crates/bevy_ecs/src/schedule/set.rs b/crates/bevy_ecs/src/schedule/set.rs
@@ -1,5 +1,4 @@
 use std::any::TypeId;
-use std::borrow::Cow;
 use std::collections::hash_map::DefaultHasher;
 use std::fmt::Debug;
 use std::hash::{Hash, Hasher};
@@ -16,7 +15,7 @@ use crate::system::{
     ExclusiveSystemParamFunction, IsExclusiveFunctionSystem, IsFunctionSystem, SystemParamFunction,
 };
 
-type Interner = RwLock<HashMap<UniqueValueHash, Cow<'static, str>>>;
+type Interner = RwLock<HashMap<UniqueValueHash, &'static str>>;
 static INTERNER: OnceCell<Interner> = OnceCell::new();
 
 /// The [`TypeId`](std::any::TypeId) of a value and its [`DynHash`] output when hashed with the [`DefaultHasher`].
@@ -42,15 +41,12 @@ impl ScheduleId {
         let type_id = TypeId::of::<S>();
 
         let key = UniqueValueHash(type_id, hash);
-        let mut map = INTERNER.get_or_init(|| default()).write().unwrap();
-        let str = map
-            .entry(key)
-            .or_insert_with(|| {
-                let string = format!("{:?}", label);
-                let str: &'static str = Box::leak(string.into_boxed_str());
-                str.into()
-            })
-            .as_ref();
+        let mut map = INTERNER.get_or_init(default).write().unwrap();
+        let str = *map.entry(key).or_insert_with(|| {
+            let string = format!("{:?}", label);
+            let str: &'static str = Box::leak(string.into_boxed_str());
+            str
+        });
 
         ScheduleId(key, str)
     }
@@ -115,15 +111,12 @@ impl SystemSetId {
         let type_id = TypeId::of::<S>();
 
         let key = UniqueValueHash(type_id, hash);
-        let mut map = INTERNER.get_or_init(|| default()).write().unwrap();
-        let str = map
-            .entry(key)
-            .or_insert_with(|| {
-                let string = format!("{:?}", set);
-                let str: &'static str = Box::leak(string.into_boxed_str());
-                str.into()
-            })
-            .as_ref();
+        let mut map = INTERNER.get_or_init(default).write().unwrap();
+        let str = *map.entry(key).or_insert_with(|| {
+            let string = format!("{:?}", set);
+            let str: &'static str = Box::leak(string.into_boxed_str());
+            str
+        });
 
         SystemSetId(key, str)
     }
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
@@ -1721,35 +1721,33 @@ impl World {
     ///
     /// Panics if the requested schedule does not exist, or the [`Schedules`] resource was not added.
     pub fn run_schedule(&mut self, label: impl ScheduleLabel) {
-        self.run_schedule_ref(&label);
+        let id = ScheduleId::of(&label);
+        self.run_schedule_by_id(id);
     }
 
-    /// Runs the [`Schedule`] associated with the `label` a single time.
+    /// Runs the [`Schedule`] associated with the `id` a single time.
     ///
-    /// Unlike the `run_schedule` method, this method takes the label by reference, which can save a clone.
+    /// Unlike the `run_schedule` method, this method takes avoids a clone.
     ///
-    /// The [`Schedule`] is fetched from the [`Schedules`] resource of the world by its label,
+    /// The [`Schedule`] is fetched from the [`Schedules`] resource of the world by its ID,
     /// and system state is cached.
     ///
     /// For simple testing use cases, call [`Schedule::run(&mut world)`](Schedule::run) instead.
     ///
     /// # Panics
     ///
     /// Panics if the requested schedule does not exist, or the [`Schedules`] resource was not added.
-    pub fn run_schedule_ref(&mut self, label: &dyn ScheduleLabel) {
+    pub fn run_schedule_by_id(&mut self, id: ScheduleId) {
         let mut schedule = self
             .resource_mut::<Schedules>()
-            .remove(label)
-            .unwrap_or_else(|| panic!("The schedule with the label {label:?} was not found."));
-
-        let id = ScheduleId::of(label);
+            .remove_by_id(id)
+            .unwrap_or_else(|| panic!("The schedule with the label {id:?} was not found."));
 
         // TODO: move this span to Schdule::run
         #[cfg(feature = "trace")]
-        let _span = bevy_utils::tracing::info_span!("schedule", name = ?label).entered();
+        let _span = bevy_utils::tracing::info_span!("schedule", name = ?id).entered();
         schedule.run(self);
-        self.resource_mut::<Schedules>()
-            .insert_with_id(id, schedule);
+        self.resource_mut::<Schedules>().insert_by_id(id, schedule);
     }
 }
 
