Merge branch 'main' into feature/condition_variable

jbaldwin · web-flow · commit 9fea175a4950 · 2025-03-22T09:38:49.000-06:00
diff --git a/README.md b/README.md
@@ -454,7 +454,7 @@ int main()
 
     // This task does 'work' and counts down on the latch when completed.  The final child task to
     // complete will end up resuming the latch task when the latch's count reaches zero.
-    auto make_worker_task = [](std::shared_ptr<coro::io_scheduler>& tp, coro::latch& l, int64_t i) -> coro::task<void>
+    auto make_worker_task = [](std::shared_ptr<coro::io_scheduler> tp, coro::latch& l, int64_t i) -> coro::task<void>
     {
         // Schedule the worker task onto the thread pool.
         co_await tp->schedule();
diff --git a/examples/coro_latch.cpp b/examples/coro_latch.cpp
@@ -27,7 +27,7 @@ int main()
 
     // This task does 'work' and counts down on the latch when completed.  The final child task to
     // complete will end up resuming the latch task when the latch's count reaches zero.
-    auto make_worker_task = [](std::shared_ptr<coro::io_scheduler>& tp, coro::latch& l, int64_t i) -> coro::task<void>
+    auto make_worker_task = [](std::shared_ptr<coro::io_scheduler> tp, coro::latch& l, int64_t i) -> coro::task<void>
     {
         // Schedule the worker task onto the thread pool.
         co_await tp->schedule();
diff --git a/src/detail/task_self_deleting.cpp b/src/detail/task_self_deleting.cpp
@@ -20,7 +20,7 @@ promise_self_deleting::promise_self_deleting(promise_self_deleting&& other)
 
 auto promise_self_deleting::operator=(promise_self_deleting&& other) -> promise_self_deleting&
 {
-    if (std::addressof(other) != nullptr)
+    if (std::addressof(other) != this)
     {
         m_executor_size = std::exchange(other.m_executor_size, nullptr);
     }
diff --git a/test/net/test_dns_resolver.cpp b/test/net/test_dns_resolver.cpp
@@ -12,7 +12,7 @@ TEST_CASE("dns_resolver basic", "[dns]")
         coro::io_scheduler::options{.pool = coro::thread_pool::options{.thread_count = 1}});
     coro::net::dns::resolver<coro::io_scheduler> dns_resolver{scheduler, std::chrono::milliseconds{5000}};
 
-    auto make_host_by_name_task = [](std::shared_ptr<coro::io_scheduler>&          scheduler,
+    auto make_host_by_name_task = [](std::shared_ptr<coro::io_scheduler>           scheduler,
                                      coro::net::dns::resolver<coro::io_scheduler>& dns_resolver,
                                      coro::net::hostname                           hn) -> coro::task<void>
     {
diff --git a/test/net/test_tcp_server.cpp b/test/net/test_tcp_server.cpp
@@ -14,9 +14,9 @@ TEST_CASE("tcp_server ping server", "[tcp_server]")
     auto scheduler = coro::io_scheduler::make_shared(
         coro::io_scheduler::options{.pool = coro::thread_pool::options{.thread_count = 1}});
 
-    auto make_client_task = [](std::shared_ptr<coro::io_scheduler>& scheduler,
-                               const std::string&                   client_msg,
-                               const std::string&                   server_msg) -> coro::task<void>
+    auto make_client_task = [](std::shared_ptr<coro::io_scheduler> scheduler,
+                               const std::string&                  client_msg,
+                               const std::string&                  server_msg) -> coro::task<void>
     {
         co_await scheduler->schedule();
         coro::net::tcp::client client{scheduler};
@@ -49,7 +49,7 @@ TEST_CASE("tcp_server ping server", "[tcp_server]")
         co_return;
     };
 
-    auto make_server_task = [](std::shared_ptr<coro::io_scheduler>& scheduler,
+    auto make_server_task = [](std::shared_ptr<coro::io_scheduler> scheduler,
                                const std::string&                   client_msg,
                                const std::string&                   server_msg) -> coro::task<void>
     {
@@ -99,7 +99,7 @@ TEST_CASE("tcp_server concurrent polling on the same socket", "[tcp_server]")
     auto scheduler = coro::io_scheduler::make_shared(coro::io_scheduler::options{
         .execution_strategy = coro::io_scheduler::execution_strategy_t::process_tasks_inline});
 
-    auto make_server_task = [](std::shared_ptr<coro::io_scheduler>& scheduler) -> coro::task<std::string>
+    auto make_server_task = [](std::shared_ptr<coro::io_scheduler> scheduler) -> coro::task<std::string>
     {
         auto make_read_task = [](coro::net::tcp::client client) -> coro::task<void>
         {
@@ -144,7 +144,7 @@ TEST_CASE("tcp_server concurrent polling on the same socket", "[tcp_server]")
         co_return data;
     };
 
-    auto make_client_task = [](std::shared_ptr<coro::io_scheduler>& scheduler) -> coro::task<std::string>
+    auto make_client_task = [](std::shared_ptr<coro::io_scheduler> scheduler) -> coro::task<std::string>
     {
         co_await scheduler->schedule();
         coro::net::tcp::client client{scheduler};
diff --git a/test/test_io_scheduler.cpp b/test/test_io_scheduler.cpp
@@ -598,10 +598,10 @@ TEST_CASE("io_scheduler self generating coroutine (stack overflow check)", "[io_
     std::vector<coro::task<void>> tasks;
     tasks.reserve(total);
 
-    auto func = [](std::shared_ptr<coro::io_scheduler>& s,
-                   uint64_t&                            counter,
-                   auto                                 f,
-                   std::vector<coro::task<void>>&       tasks) -> coro::task<void>
+    auto func = [](std::shared_ptr<coro::io_scheduler> s,
+                   uint64_t&                           counter,
+                   auto                                f,
+                   std::vector<coro::task<void>>&      tasks) -> coro::task<void>
     {
         co_await s->schedule();
         ++counter;
diff --git a/test/test_shared_mutex.cpp b/test/test_shared_mutex.cpp
@@ -92,7 +92,7 @@ TEST_CASE("mutex many shared and exclusive waiters interleaved", "[shared_mutex]
 
     std::atomic<bool> read_value{false};
 
-    auto make_exclusive_task = [](std::shared_ptr<coro::io_scheduler>&    s,
+    auto make_exclusive_task = [](std::shared_ptr<coro::io_scheduler>     s,
                                   coro::shared_mutex<coro::io_scheduler>& m,
                                   std::atomic<bool>&                      read_value) -> coro::task<void>
     {
@@ -112,11 +112,11 @@ TEST_CASE("mutex many shared and exclusive waiters interleaved", "[shared_mutex]
         co_return;
     };
 
-    auto make_shared_tasks_task = [](std::shared_ptr<coro::io_scheduler>&    s,
+    auto make_shared_tasks_task = [](std::shared_ptr<coro::io_scheduler>     s,
                                      coro::shared_mutex<coro::io_scheduler>& m,
                                      std::atomic<bool>&                      read_value) -> coro::task<void>
     {
-        auto make_shared_task = [](std::shared_ptr<coro::io_scheduler>&    s,
+        auto make_shared_task = [](std::shared_ptr<coro::io_scheduler>     s,
                                    coro::shared_mutex<coro::io_scheduler>& m,
                                    std::atomic<bool>&                      read_value) -> coro::task<bool>
         {

Original file line number	Diff line number	Diff line change
`@@ -454,7 +454,7 @@ int main()`
`454`	`454`
`455`	`455`	`// This task does 'work' and counts down on the latch when completed. The final child task to`
`456`	`456`	`// complete will end up resuming the latch task when the latch's count reaches zero.`
`457`		`- auto make_worker_task = [](std::shared_ptr<coro::io_scheduler>& tp, coro::latch& l, int64_t i) -> coro::task<void>`
	`457`	`+ auto make_worker_task = [](std::shared_ptr<coro::io_scheduler> tp, coro::latch& l, int64_t i) -> coro::task<void>`
`458`	`458`	`{`
`459`	`459`	`// Schedule the worker task onto the thread pool.`
`460`	`460`	`co_await tp->schedule();`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ int main()`
`27`	`27`
`28`	`28`	`// This task does 'work' and counts down on the latch when completed. The final child task to`
`29`	`29`	`// complete will end up resuming the latch task when the latch's count reaches zero.`
`30`		`- auto make_worker_task = [](std::shared_ptr<coro::io_scheduler>& tp, coro::latch& l, int64_t i) -> coro::task<void>`
	`30`	`+ auto make_worker_task = [](std::shared_ptr<coro::io_scheduler> tp, coro::latch& l, int64_t i) -> coro::task<void>`
`31`	`31`	`{`
`32`	`32`	`// Schedule the worker task onto the thread pool.`
`33`	`33`	`co_await tp->schedule();`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ promise_self_deleting::promise_self_deleting(promise_self_deleting&& other)`
`20`	`20`
`21`	`21`	`auto promise_self_deleting::operator=(promise_self_deleting&& other) -> promise_self_deleting&`
`22`	`22`	`{`
`23`		`- if (std::addressof(other) != nullptr)`
	`23`	`+ if (std::addressof(other) != this)`
`24`	`24`	`{`
`25`	`25`	`m_executor_size = std::exchange(other.m_executor_size, nullptr);`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ TEST_CASE("dns_resolver basic", "[dns]")`
`12`	`12`	`coro::io_scheduler::options{.pool = coro::thread_pool::options{.thread_count = 1}});`
`13`	`13`	`coro::net::dns::resolver<coro::io_scheduler> dns_resolver{scheduler, std::chrono::milliseconds{5000}};`
`14`	`14`
`15`		`- auto make_host_by_name_task = [](std::shared_ptr<coro::io_scheduler>& scheduler,`
	`15`	`+ auto make_host_by_name_task = [](std::shared_ptr<coro::io_scheduler> scheduler,`
`16`	`16`	`coro::net::dns::resolver<coro::io_scheduler>& dns_resolver,`
`17`	`17`	`coro::net::hostname hn) -> coro::task<void>`
`18`	`18`	`{`
Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ TEST_CASE("mutex many shared and exclusive waiters interleaved", "[shared_mutex]`
`92`	`92`
`93`	`93`	`std::atomic<bool> read_value{false};`
`94`	`94`
`95`		`- auto make_exclusive_task = [](std::shared_ptr<coro::io_scheduler>& s,`
	`95`	`+ auto make_exclusive_task = [](std::shared_ptr<coro::io_scheduler> s,`
`96`	`96`	`coro::shared_mutex<coro::io_scheduler>& m,`
`97`	`97`	`std::atomic<bool>& read_value) -> coro::task<void>`
`98`	`98`	`{`
`@@ -112,11 +112,11 @@ TEST_CASE("mutex many shared and exclusive waiters interleaved", "[shared_mutex]`
`112`	`112`	`co_return;`
`113`	`113`	`};`
`114`	`114`
`115`		`- auto make_shared_tasks_task = [](std::shared_ptr<coro::io_scheduler>& s,`
	`115`	`+ auto make_shared_tasks_task = [](std::shared_ptr<coro::io_scheduler> s,`
`116`	`116`	`coro::shared_mutex<coro::io_scheduler>& m,`
`117`	`117`	`std::atomic<bool>& read_value) -> coro::task<void>`
`118`	`118`	`{`
`119`		`- auto make_shared_task = [](std::shared_ptr<coro::io_scheduler>& s,`
	`119`	`+ auto make_shared_task = [](std::shared_ptr<coro::io_scheduler> s,`
`120`	`120`	`coro::shared_mutex<coro::io_scheduler>& m,`
`121`	`121`	`std::atomic<bool>& read_value) -> coro::task<bool>`
`122`	`122`	`{`