process: basic_process_adaptor vs process_adaptor

TODO

@@ -37,5 +37,4 @@ TODO:
 * use any for meta_custom_node
 * avoid copying meta_type/data/func nodes
 * paged vector as a standalone class
-* basic_process_adaptor vs process_adaptor with default delta type
 * update process/scheduler natvis and doc after rework

src/entt/process/fwd.hpp

@@ -9,9 +9,19 @@ namespace entt {
 template<typename>
 class basic_process;
 
+template<typename, typename>
+class basic_process_adaptor;
+
 /*! @brief Alias declaration for the most common use case. */
 using process = basic_process<std::uint32_t>;
 
+/**
+ * @brief Alias declaration for the most common use case.
+ * @tparam Func Actual type of process.
+ */
+template<typename Func>
+using process_adaptor = basic_process_adaptor<std::uint32_t, Func>;
+
 template<typename, typename = std::allocator<void>>
 class basic_scheduler;
 

src/entt/process/process.hpp

@@ -288,7 +288,7 @@ private:
  * @tparam Delta Type to use to provide elapsed time.
  */
 template<typename Delta, typename Func>
-struct process_adaptor: public basic_process<Delta>, private 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. */
@@ -301,7 +301,7 @@ struct process_adaptor: public basic_process<Delta>, private Func {
      * @param args Parameters to use to initialize the actual process.
      */
     template<typename... Args>
-    process_adaptor(const token_type token, Args &&...args)
+    basic_process_adaptor(const token_type token, Args &&...args)
         : basic_process<Delta>{token},
           Func{std::forward<Args>(args)...} {}
 

src/entt/process/scheduler.hpp

@@ -259,7 +259,7 @@ public:
      */
     template<typename Func>
     basic_scheduler &attach(Func &&func) {
-        using Proc = process_adaptor<Delta, std::decay_t<Func>>;
+        using Proc = basic_process_adaptor<Delta, std::decay_t<Func>>;
         return attach<Proc>(std::forward<Func>(func));
     }
 
@@ -288,7 +288,7 @@ public:
      */
     template<typename Func>
     basic_scheduler &then(Func &&func) {
-        using Proc = process_adaptor<Delta, std::decay_t<Func>>;
+        using Proc = basic_process_adaptor<Delta, std::decay_t<Func>>;
         return then<Proc>(std::forward<Func>(func));
     }
 

test/entt/process/process.cpp

@@ -186,16 +186,16 @@ TEST(Process, AbortImmediately) {
 
 TEST(ProcessAdaptor, Resolved) {
     bool updated = false;
-    auto lambda = [&updated](std::uint64_t, void *, auto resolve, auto) {
+    auto lambda = [&updated](std::uint32_t, void *, auto resolve, auto) {
         ASSERT_FALSE(updated);
         updated = true;
         resolve();
     };
 
-    auto process = entt::basic_process<std::uint64_t>::allocate<entt::process_adaptor<std::uint64_t, decltype(lambda)>>(std::allocator<void>{}, lambda);
+    auto process = entt::basic_process<std::uint32_t>::allocate<entt::process_adaptor<decltype(lambda)>>(std::allocator<void>{}, lambda);
 
-    process->tick(0);
-    process->tick(0);
+    process->tick(0u);
+    process->tick(0u);
 
     ASSERT_TRUE(process->finished());
     ASSERT_TRUE(updated);
@@ -203,16 +203,16 @@ TEST(ProcessAdaptor, Resolved) {
 
 TEST(ProcessAdaptor, Rejected) {
     bool updated = false;
-    auto lambda = [&updated](std::uint64_t, void *, auto, auto rejected) {
+    auto lambda = [&updated](std::uint32_t, void *, auto, auto rejected) {
         ASSERT_FALSE(updated);
         updated = true;
         rejected();
     };
 
-    auto process = entt::basic_process<std::uint64_t>::allocate<entt::process_adaptor<std::uint64_t, decltype(lambda)>>(std::allocator<void>{}, lambda);
+    auto process = entt::basic_process<std::uint32_t>::allocate<entt::process_adaptor<decltype(lambda)>>(std::allocator<void>{}, lambda);
 
-    process->tick(0);
-    process->tick(0);
+    process->tick(0u);
+    process->tick(0u);
 
     ASSERT_TRUE(process->rejected());
     ASSERT_TRUE(updated);
@@ -220,14 +220,14 @@ TEST(ProcessAdaptor, Rejected) {
 
 TEST(ProcessAdaptor, Data) {
     int value = 0;
-    auto lambda = [](std::uint64_t, void *data, auto resolve, auto) {
+    auto lambda = [](std::uint32_t, void *data, auto resolve, auto) {
         *static_cast<int *>(data) = 2;
         resolve();
     };
 
-    auto process = entt::basic_process<std::uint64_t>::allocate<entt::process_adaptor<std::uint64_t, decltype(lambda)>>(std::allocator<void>{}, lambda);
+    auto process = entt::basic_process<std::uint32_t>::allocate<entt::process_adaptor<decltype(lambda)>>(std::allocator<void>{}, lambda);
 
-    process->tick(0, &value);
+    process->tick(0u, &value);
 
     ASSERT_TRUE(process->finished());
     ASSERT_EQ(value, 2);