process: rollback token based ctor, prep to move continuation to process

src/entt/process/process.hpp

@@ -58,11 +58,6 @@ namespace entt {
  */
 template<typename Delta>
 class basic_process: private std::enable_shared_from_this<basic_process<Delta>> {
-    class process_arg_t {
-        friend class basic_process<Delta>;
-        explicit process_arg_t() = default;
-    };
-
     enum class state : std::uint8_t {
         idle = 0,
         running,
@@ -83,13 +78,11 @@ class basic_process: private std::enable_shared_from_this<basic_process<Delta>>
     virtual void aborted() {}
 
 public:
-    /*! @brief Process constructor token. */
-    using token_type = process_arg_t;
     /*! @brief Type used to provide elapsed time. */
     using delta_type = Delta;
 
     /*! @brief Default constructor. */
-    constexpr basic_process(token_type)
+    constexpr basic_process()
         : current{state::idle} {}
 
     /*! @brief Default destructor. */
@@ -113,20 +106,6 @@ public:
      */
     basic_process &operator=(basic_process &&) noexcept = default;
 
-    /**
-     * @brief Factory method.
-     * @tparam Type Type of process to create.
-     * @tparam Allocator Type of allocator used to manage memory and elements.
-     * @tparam Args Types of arguments to use to initialize the process.
-     * @param alloc The allocator to use.
-     * @param args Parameters to use to initialize the process.
-     * @return A properly initialized process.
-     */
-    template<typename Type, typename Allocator, typename... Args>
-    static std::shared_ptr<Type> allocate(const Allocator &alloc, Args &&...args) {
-        return std::allocate_shared<Type>(alloc, process_arg_t{}, std::forward<Args>(args)...);
-    }
-
     /*! @brief Aborts a process if it's still alive, otherwise does nothing. */
     void abort() {
         if(alive()) {
@@ -282,8 +261,6 @@ private:
  */
 template<typename Delta, typename Func>
 struct basic_process_adaptor: public basic_process<Delta>, private Func {
-    /*! @brief Process constructor token. */
-    using token_type = typename basic_process<Delta>::token_type;
     /*! @brief Type used to provide elapsed time. */
     using delta_type = typename basic_process<Delta>::delta_type;
 
@@ -294,8 +271,8 @@ struct basic_process_adaptor: public basic_process<Delta>, private Func {
      * @param args Parameters to use to initialize the actual process.
      */
     template<typename... Args>
-    basic_process_adaptor(const token_type token, Args &&...args)
-        : basic_process<Delta>{token},
+    basic_process_adaptor(Args &&...args)
+        : basic_process<Delta>{},
           Func{std::forward<Args>(args)...} {}
 
     /**

src/entt/process/scheduler.hpp

@@ -202,7 +202,7 @@ public:
      */
     template<typename Proc, typename... Args>
     basic_scheduler &attach(Args &&...args) {
-        handlers.first().emplace_back().task = process_type::template allocate<Proc>(handlers.second(), std::forward<Args>(args)...);
+        handlers.first().emplace_back().task = std::allocate_shared<Proc>(handlers.second(), std::forward<Args>(args)...);
         return *this;
     }
 
@@ -276,7 +276,7 @@ public:
         auto *curr = &handlers.first().back();
         for(; curr->next; curr = curr->next.get()) {}
         curr->next = std::allocate_shared<handler_type>(handlers.second());
-        curr->next->task = process_type::template allocate<Proc>(handlers.second(), std::forward<Args>(args)...);
+        curr->next->task = std::allocate_shared<Proc>(handlers.second(), std::forward<Args>(args)...);
         return *this;
     }
 
@@ -332,7 +332,7 @@ public:
         for(auto &&curr: handlers.first()) {
             curr.task->abort();
 
-            if (immediate) {
+            if(immediate) {
                 curr.task->tick({});
             }
         }

test/entt/process/process.cpp

@@ -36,153 +36,153 @@ public:
 };
 
 TEST(Process, Basics) {
-    auto process = entt::basic_process<int>::allocate<test_process<int>>(std::allocator<void>{});
+    test_process<int> process{};
 
-    ASSERT_FALSE(process->alive());
-    ASSERT_FALSE(process->finished());
-    ASSERT_FALSE(process->paused());
-    ASSERT_FALSE(process->rejected());
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
 
-    process->succeed();
-    process->fail();
-    process->abort();
-    process->pause();
-    process->unpause();
+    process.succeed();
+    process.fail();
+    process.abort();
+    process.pause();
+    process.unpause();
 
-    ASSERT_FALSE(process->alive());
-    ASSERT_FALSE(process->finished());
-    ASSERT_FALSE(process->paused());
-    ASSERT_FALSE(process->rejected());
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
 
-    process->tick(0);
+    process.tick(0);
 
-    ASSERT_TRUE(process->alive());
-    ASSERT_FALSE(process->finished());
-    ASSERT_FALSE(process->paused());
-    ASSERT_FALSE(process->rejected());
+    ASSERT_TRUE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
 
-    process->pause();
+    process.pause();
 
-    ASSERT_TRUE(process->alive());
-    ASSERT_FALSE(process->finished());
-    ASSERT_TRUE(process->paused());
-    ASSERT_FALSE(process->rejected());
+    ASSERT_TRUE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_TRUE(process.paused());
+    ASSERT_FALSE(process.rejected());
 
-    process->unpause();
+    process.unpause();
 
-    ASSERT_TRUE(process->alive());
-    ASSERT_FALSE(process->finished());
-    ASSERT_FALSE(process->paused());
-    ASSERT_FALSE(process->rejected());
+    ASSERT_TRUE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
 
-    process->fail();
+    process.fail();
 
-    ASSERT_FALSE(process->alive());
-    ASSERT_FALSE(process->finished());
-    ASSERT_FALSE(process->paused());
-    ASSERT_FALSE(process->rejected());
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
 
-    process->tick(0);
+    process.tick(0);
 
-    ASSERT_FALSE(process->alive());
-    ASSERT_FALSE(process->finished());
-    ASSERT_FALSE(process->paused());
-    ASSERT_TRUE(process->rejected());
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_TRUE(process.rejected());
 }
 
 TEST(Process, Succeeded) {
-    auto process = entt::basic_process<test::empty>::allocate<test_process<test::empty>>(std::allocator<void>{});
-
-    process->tick({});
-    process->tick({});
-    process->succeed();
-    process->tick({});
-
-    ASSERT_FALSE(process->alive());
-    ASSERT_TRUE(process->finished());
-    ASSERT_FALSE(process->paused());
-    ASSERT_FALSE(process->rejected());
-
-    ASSERT_TRUE(process->update_invoked);
-    ASSERT_TRUE(process->succeeded_invoked);
-    ASSERT_FALSE(process->failed_invoked);
-    ASSERT_FALSE(process->aborted_invoked);
+    test_process<test::empty> process{};
+
+    process.tick({});
+    process.tick({});
+    process.succeed();
+    process.tick({});
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_TRUE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
+
+    ASSERT_TRUE(process.update_invoked);
+    ASSERT_TRUE(process.succeeded_invoked);
+    ASSERT_FALSE(process.failed_invoked);
+    ASSERT_FALSE(process.aborted_invoked);
 }
 
 TEST(Process, Fail) {
-    auto process = entt::basic_process<int>::allocate<test_process<int>>(std::allocator<void>{});
-
-    process->tick(0);
-    process->tick(0);
-    process->fail();
-    process->tick(0);
-
-    ASSERT_FALSE(process->alive());
-    ASSERT_FALSE(process->finished());
-    ASSERT_FALSE(process->paused());
-    ASSERT_TRUE(process->rejected());
-
-    ASSERT_TRUE(process->update_invoked);
-    ASSERT_FALSE(process->succeeded_invoked);
-    ASSERT_TRUE(process->failed_invoked);
-    ASSERT_FALSE(process->aborted_invoked);
+    test_process<int> process{};
+
+    process.tick(0);
+    process.tick(0);
+    process.fail();
+    process.tick(0);
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_TRUE(process.rejected());
+
+    ASSERT_TRUE(process.update_invoked);
+    ASSERT_FALSE(process.succeeded_invoked);
+    ASSERT_TRUE(process.failed_invoked);
+    ASSERT_FALSE(process.aborted_invoked);
 }
 
 TEST(Process, Data) {
-    auto process = entt::basic_process<test::empty>::allocate<test_process<test::empty>>(std::allocator<void>{});
+    test_process<test::empty> process{};
     int value = 0;
 
-    process->tick({});
-    process->tick({}, &value);
-    process->succeed();
-    process->tick({}, &value);
+    process.tick({});
+    process.tick({}, &value);
+    process.succeed();
+    process.tick({}, &value);
 
-    ASSERT_FALSE(process->alive());
-    ASSERT_TRUE(process->finished());
-    ASSERT_FALSE(process->paused());
-    ASSERT_FALSE(process->rejected());
+    ASSERT_FALSE(process.alive());
+    ASSERT_TRUE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_FALSE(process.rejected());
 
     ASSERT_EQ(value, 1);
-    ASSERT_TRUE(process->update_invoked);
-    ASSERT_TRUE(process->succeeded_invoked);
-    ASSERT_FALSE(process->failed_invoked);
-    ASSERT_FALSE(process->aborted_invoked);
+    ASSERT_TRUE(process.update_invoked);
+    ASSERT_TRUE(process.succeeded_invoked);
+    ASSERT_FALSE(process.failed_invoked);
+    ASSERT_FALSE(process.aborted_invoked);
 }
 
 TEST(Process, AbortNextTick) {
-    auto process = entt::basic_process<int>::allocate<test_process<int>>(std::allocator<void>{});
+    test_process<int> process{};
 
-    process->tick(0);
-    process->abort();
-    process->tick(0);
+    process.tick(0);
+    process.abort();
+    process.tick(0);
 
-    ASSERT_FALSE(process->alive());
-    ASSERT_FALSE(process->finished());
-    ASSERT_FALSE(process->paused());
-    ASSERT_TRUE(process->rejected());
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_TRUE(process.rejected());
 
-    ASSERT_TRUE(process->update_invoked);
-    ASSERT_FALSE(process->succeeded_invoked);
-    ASSERT_FALSE(process->failed_invoked);
-    ASSERT_TRUE(process->aborted_invoked);
+    ASSERT_TRUE(process.update_invoked);
+    ASSERT_FALSE(process.succeeded_invoked);
+    ASSERT_FALSE(process.failed_invoked);
+    ASSERT_TRUE(process.aborted_invoked);
 }
 
 TEST(Process, AbortImmediately) {
-    auto process = entt::basic_process<test::empty>::allocate<test_process<test::empty>>(std::allocator<void>{});
+    test_process<test::empty> process{};
 
-    process->tick({});
-    process->abort();
-    process->tick({});
+    process.tick({});
+    process.abort();
+    process.tick({});
 
-    ASSERT_FALSE(process->alive());
-    ASSERT_FALSE(process->finished());
-    ASSERT_FALSE(process->paused());
-    ASSERT_TRUE(process->rejected());
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.finished());
+    ASSERT_FALSE(process.paused());
+    ASSERT_TRUE(process.rejected());
 
-    ASSERT_TRUE(process->update_invoked);
-    ASSERT_FALSE(process->succeeded_invoked);
-    ASSERT_FALSE(process->failed_invoked);
-    ASSERT_TRUE(process->aborted_invoked);
+    ASSERT_TRUE(process.update_invoked);
+    ASSERT_FALSE(process.succeeded_invoked);
+    ASSERT_FALSE(process.failed_invoked);
+    ASSERT_TRUE(process.aborted_invoked);
 }
 
 TEST(ProcessAdaptor, Resolved) {
@@ -193,12 +193,12 @@ TEST(ProcessAdaptor, Resolved) {
         resolve();
     };
 
-    auto process = entt::basic_process<std::uint32_t>::allocate<entt::process_adaptor<decltype(lambda)>>(std::allocator<void>{}, lambda);
+    entt::process_adaptor<decltype(lambda)> process{lambda};
 
-    process->tick(0u);
-    process->tick(0u);
+    process.tick(0u);
+    process.tick(0u);
 
-    ASSERT_TRUE(process->finished());
+    ASSERT_TRUE(process.finished());
     ASSERT_TRUE(updated);
 }
 
@@ -210,12 +210,12 @@ TEST(ProcessAdaptor, Rejected) {
         rejected();
     };
 
-    auto process = entt::basic_process<std::uint32_t>::allocate<entt::process_adaptor<decltype(lambda)>>(std::allocator<void>{}, lambda);
+    entt::process_adaptor<decltype(lambda)> process{lambda};
 
-    process->tick(0u);
-    process->tick(0u);
+    process.tick(0u);
+    process.tick(0u);
 
-    ASSERT_TRUE(process->rejected());
+    ASSERT_TRUE(process.rejected());
     ASSERT_TRUE(updated);
 }
 
@@ -226,10 +226,10 @@ TEST(ProcessAdaptor, Data) {
         resolve();
     };
 
-    auto process = entt::basic_process<std::uint32_t>::allocate<entt::process_adaptor<decltype(lambda)>>(std::allocator<void>{}, lambda);
+    entt::process_adaptor<decltype(lambda)> process{lambda};
 
-    process->tick(0u, &value);
+    process.tick(0u, &value);
 
-    ASSERT_TRUE(process->finished());
+    ASSERT_TRUE(process.finished());
     ASSERT_EQ(value, 2);
 }

test/entt/process/scheduler.cpp

@@ -6,8 +6,6 @@
 #include <entt/process/scheduler.hpp>
 
 class foo_process: public entt::process {
-    using token_type = typename entt::process::token_type;
-
     void update(const delta_type, void *) override {
         on_update();
     }
@@ -17,8 +15,8 @@ class foo_process: public entt::process {
     }
 
 public:
-    foo_process(const token_type token, std::function<void()> upd, std::function<void()> abort)
-        : entt::process{token},
+    foo_process(std::function<void()> upd, std::function<void()> abort)
+        : entt::process{},
           on_update{std::move(upd)},
           on_aborted{std::move(abort)} {}