Implement the new task scheduler and remove the old one

src/PowerPlant.cpp

@@ -108,14 +108,13 @@ void PowerPlant::log(const LogLevel& level, std::stringstream& message) {
     log(level, message.str());
 }
 
-void PowerPlant::add_idle_task(const NUClear::id_t& id,
-                               const util::ThreadPoolDescriptor& pool_descriptor,
-                               std::function<void()>&& task) {
-    scheduler.add_idle_task(id, pool_descriptor, std::move(task));
+void PowerPlant::add_idle_task(const util::ThreadPoolDescriptor& pool_descriptor,
+                               const std::shared_ptr<threading::Reaction>& task) {
+    scheduler.add_idle_task(pool_descriptor, task);
 }
 
-void PowerPlant::remove_idle_task(const NUClear::id_t& id, const util::ThreadPoolDescriptor& pool_descriptor) {
-    scheduler.remove_idle_task(id, pool_descriptor);
+void PowerPlant::remove_idle_task(const util::ThreadPoolDescriptor& pool_descriptor, const NUClear::id_t& id) {
+    scheduler.remove_idle_task(pool_descriptor, id);
 }
 
 void PowerPlant::shutdown() {
@@ -128,7 +127,7 @@ void PowerPlant::shutdown() {
     emit(std::make_unique<dsl::word::Shutdown>());
 
     // Shutdown the scheduler
-    scheduler.shutdown();
+    scheduler.stop();
 }
 
 bool PowerPlant::running() const {

src/PowerPlant.hpp

@@ -36,7 +36,7 @@
 #include "LogLevel.hpp"
 #include "id.hpp"
 #include "threading/ReactionTask.hpp"
-#include "threading/TaskScheduler.hpp"
+#include "threading/scheduler/Scheduler.hpp"
 #include "util/FunctionFusion.hpp"
 #include "util/demangle.hpp"
 
@@ -158,27 +158,25 @@ class PowerPlant {
      * Adds an idle task to the task scheduler.
      *
      * This function adds an idle task to the task scheduler, which will be executed when the thread pool associated
-     * with the given `pool_id` has no other tasks to execute. The `task` parameter is a callable object that
-     * represents the idle task to be executed.
+     * with the given `pool_id` has no other tasks to execute. The `task` parameter is a Reaction from which a task will
+     * be submitted when the pool is idle.
      *
-     * @param id The ID of the task.
      * @param pool_descriptor The descriptor for the thread pool to test for idle
-     * @param task The idle task to be executed.
+     * @param reaction        The reaction to be executed when idle
      */
-    void add_idle_task(const NUClear::id_t& id,
-                       const util::ThreadPoolDescriptor& pool_descriptor,
-                       std::function<void()>&& task);
+    void add_idle_task(const util::ThreadPoolDescriptor& pool_descriptor,
+                       const std::shared_ptr<threading::Reaction>& reaction);
 
     /**
      * Removes an idle task from the task scheduler.
      *
      * This function removes an idle task from the task scheduler. The `id` and `pool_id` parameters are used to
      * identify the idle task to be removed.
      *
-     * @param id The ID of the task.
      * @param pool_descriptor The descriptor for the thread pool to test for idle
+     * @param id              The reaction id of the task to be removed
      */
-    void remove_idle_task(const NUClear::id_t& id, const util::ThreadPoolDescriptor& pool_descriptor);
+    void remove_idle_task(const util::ThreadPoolDescriptor& pool_descriptor, const NUClear::id_t& id);
 
     /**
      * Submits a new task to the ThreadPool to be queued and then executed.
@@ -320,7 +318,7 @@ class PowerPlant {
     /// A list of tasks that must be run when the powerplant starts up
     std::vector<std::function<void()>> tasks;
     /// Our TaskScheduler that handles distributing task to the pool threads
-    threading::TaskScheduler scheduler;
+    threading::scheduler::Scheduler scheduler;
     /// Our vector of Reactors, will get destructed when this vector is
     std::vector<std::unique_ptr<NUClear::Reactor>> reactors;
     /// True if the powerplant is running

src/dsl/word/Idle.hpp

@@ -45,12 +45,10 @@ namespace dsl {
 
             // Our unbinder to remove this reaction
             reaction->unbinders.push_back([pool_descriptor](const threading::Reaction& r) {  //
-                r.reactor.powerplant.remove_idle_task(r.id, pool_descriptor);
+                r.reactor.powerplant.remove_idle_task(pool_descriptor, r.id);
             });
 
-            reaction->reactor.powerplant.add_idle_task(reaction->id, pool_descriptor, [reaction] {
-                reaction->reactor.powerplant.submit(reaction->get_task());
-            });
+            reaction->reactor.powerplant.add_idle_task(pool_descriptor, reaction);
         }
 
         /**