scheduler: basic type model with default for common cases

src/entt/process/scheduler.hpp

@@ -7,6 +7,7 @@
 #include <type_traits>
 #include <utility>
 #include <vector>
+#include "fwd.hpp"
 #include "process.hpp"
 
 namespace entt {
@@ -38,11 +39,11 @@ namespace entt {
  * @tparam Delta Type to use to provide elapsed time.
  */
 template<typename Delta>
-class scheduler {
+class basic_scheduler {
     struct process_handler {
         using instance_type = std::unique_ptr<void, void (*)(void *)>;
-        using update_fn_type = bool(scheduler &, std::size_t, Delta, void *);
-        using abort_fn_type = void(scheduler &, std::size_t, bool);
+        using update_fn_type = bool(basic_scheduler &, std::size_t, Delta, void *);
+        using abort_fn_type = void(basic_scheduler &, std::size_t, bool);
         using next_type = std::unique_ptr<process_handler>;
 
         instance_type instance;
@@ -58,8 +59,8 @@ class scheduler {
         template<typename Proc, typename... Args>
         continuation then(Args &&...args) {
             static_assert(std::is_base_of_v<process<Proc, Delta>, Proc>, "Invalid process type");
-            auto proc = typename process_handler::instance_type{new Proc{std::forward<Args>(args)...}, &scheduler::deleter<Proc>};
-            handler->next.reset(new process_handler{std::move(proc), &scheduler::update<Proc>, &scheduler::abort<Proc>, nullptr});
+            auto proc = typename process_handler::instance_type{new Proc{std::forward<Args>(args)...}, &basic_scheduler::deleter<Proc>};
+            handler->next.reset(new process_handler{std::move(proc), &basic_scheduler::update<Proc>, &basic_scheduler::abort<Proc>, nullptr});
             handler = handler->next.get();
             return *this;
         }
@@ -74,7 +75,7 @@ class scheduler {
     };
 
     template<typename Proc>
-    [[nodiscard]] static bool update(scheduler &owner, std::size_t pos, const Delta delta, void *data) {
+    [[nodiscard]] static bool update(basic_scheduler &owner, std::size_t pos, const Delta delta, void *data) {
         auto *process = static_cast<Proc *>(owner.handlers[pos].instance.get());
         process->tick(delta, data);
 
@@ -94,7 +95,7 @@ class scheduler {
     }
 
     template<typename Proc>
-    static void abort(scheduler &owner, std::size_t pos, const bool immediately) {
+    static void abort(basic_scheduler &owner, std::size_t pos, const bool immediately) {
         static_cast<Proc *>(owner.handlers[pos].instance.get())->abort(immediately);
     }
 
@@ -104,18 +105,20 @@ class scheduler {
     }
 
 public:
+    /*! @brief Unsigned integer type. */
+    using delta_type = Delta;
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
 
     /*! @brief Default constructor. */
-    scheduler()
+    basic_scheduler()
         : handlers{} {}
 
     /*! @brief Default move constructor. */
-    scheduler(scheduler &&) = default;
+    basic_scheduler(basic_scheduler &&) = default;
 
     /*! @brief Default move assignment operator. @return This scheduler. */
-    scheduler &operator=(scheduler &&) = default;
+    basic_scheduler &operator=(basic_scheduler &&) = default;
 
     /**
      * @brief Number of processes currently scheduled.
@@ -171,8 +174,8 @@ public:
     template<typename Proc, typename... Args>
     auto attach(Args &&...args) {
         static_assert(std::is_base_of_v<process<Proc, Delta>, Proc>, "Invalid process type");
-        auto proc = typename process_handler::instance_type{new Proc{std::forward<Args>(args)...}, &scheduler::deleter<Proc>};
-        auto &&ref = handlers.emplace_back(process_handler{std::move(proc), &scheduler::update<Proc>, &scheduler::abort<Proc>, nullptr});
+        auto proc = typename process_handler::instance_type{new Proc{std::forward<Args>(args)...}, &basic_scheduler::deleter<Proc>};
+        auto &&ref = handlers.emplace_back(process_handler{std::move(proc), &basic_scheduler::update<Proc>, &basic_scheduler::abort<Proc>, nullptr});
         // forces the process to exit the uninitialized state
         ref.update(*this, handlers.size() - 1u, {}, nullptr);
         return continuation{&handlers.back()};
@@ -246,7 +249,7 @@ public:
      * @param delta Elapsed time.
      * @param data Optional data.
      */
-    void update(const Delta delta, void *data = nullptr) {
+    void update(const delta_type delta, void *data = nullptr) {
         for(auto pos = handlers.size(); pos; --pos) {
             const auto curr = pos - 1u;
 

test/entt/process/scheduler.cpp

@@ -4,7 +4,7 @@
 #include <entt/process/process.hpp>
 #include <entt/process/scheduler.hpp>
 
-struct foo_process: entt::process<foo_process, int> {
+struct foo_process: entt::process<foo_process, entt::scheduler::delta_type> {
     foo_process(std::function<void()> upd, std::function<void()> abort)
         : on_update{upd}, on_aborted{abort} {}
 
@@ -20,7 +20,7 @@ struct foo_process: entt::process<foo_process, int> {
     std::function<void()> on_aborted;
 };
 
-struct succeeded_process: entt::process<succeeded_process, int> {
+struct succeeded_process: entt::process<succeeded_process, entt::scheduler::delta_type> {
     void update(delta_type, void *) {
         ++invoked;
         succeed();
@@ -29,7 +29,7 @@ struct succeeded_process: entt::process<succeeded_process, int> {
     static inline unsigned int invoked;
 };
 
-struct failed_process: entt::process<failed_process, int> {
+struct failed_process: entt::process<failed_process, entt::scheduler::delta_type> {
     void update(delta_type, void *) {
         ++invoked;
         fail();
@@ -46,7 +46,7 @@ struct Scheduler: ::testing::Test {
 };
 
 TEST_F(Scheduler, Functionalities) {
-    entt::scheduler<int> scheduler{};
+    entt::scheduler scheduler{};
 
     bool updated = false;
     bool aborted = false;
@@ -77,7 +77,7 @@ TEST_F(Scheduler, Functionalities) {
 }
 
 TEST_F(Scheduler, Then) {
-    entt::scheduler<int> scheduler;
+    entt::scheduler scheduler;
 
     // failing process with successor
     scheduler.attach<succeeded_process>()
@@ -106,7 +106,7 @@ TEST_F(Scheduler, Then) {
 }
 
 TEST_F(Scheduler, Functor) {
-    entt::scheduler<int> scheduler;
+    entt::scheduler scheduler;
 
     bool first_functor = false;
     bool second_functor = false;
@@ -135,7 +135,7 @@ TEST_F(Scheduler, Functor) {
 }
 
 TEST_F(Scheduler, SpawningProcess) {
-    entt::scheduler<int> scheduler;
+    entt::scheduler scheduler;
 
     scheduler.attach([&scheduler](auto, void *, auto resolve, auto) {
         scheduler.attach<succeeded_process>().then<failed_process>();