feat: delete copy and move

Author: shuai132

include/coro/channel.hpp

@@ -19,6 +19,11 @@ struct channel {
     close();
   }
 
+  channel(const channel&) = delete;
+  channel(channel&&) = delete;
+  channel& operator=(const channel&) = delete;
+  channel& operator=(channel&&) = delete;
+
   struct send_awaitable {
     channel* ch_;
     T value_;

include/coro/condition_variable.hpp

@@ -30,6 +30,11 @@ struct condition_variable_t {
  public:
   condition_variable_t() : head_(nullptr), tail_(nullptr) {}
 
+  condition_variable_t(const condition_variable_t&) = delete;
+  condition_variable_t(condition_variable_t&&) = delete;
+  condition_variable_t& operator=(const condition_variable_t&) = delete;
+  condition_variable_t& operator=(condition_variable_t&&) = delete;
+
   // Wait releases the mutex and suspends the coroutine
   // When resumed by notify, the mutex is NOT automatically re-acquired
   // You must manually re-acquire the lock after wait returns

include/coro/event.hpp

@@ -28,6 +28,11 @@ struct event_t {
     wg_.add(1);  // Start with counter = 1 (unset state)
   }
 
+  event_t(const event_t&) = delete;
+  event_t(event_t&&) = delete;
+  event_t& operator=(const event_t&) = delete;
+  event_t& operator=(event_t&&) = delete;
+
   // Set the event and wake up all waiting coroutines
   // All current and future waiters will proceed until clear() is called
   // Usage: evt.set();

include/coro/executor_basic_task.hpp include/coro/executor_base.hppinclude/coro/executor_basic_task.hpp renamed to include/coro/executor_base.hpp

@@ -12,7 +12,7 @@
 #include "executor.hpp"
 
 namespace coro {
-class executor_basic_task : public coro::executor {
+class executor_base : public coro::executor {
  protected:
   struct DelayedTask {
     std::chrono::steady_clock::time_point execute_at;
@@ -61,12 +61,17 @@ class executor_basic_task : public coro::executor {
   }
 
  public:
-  executor_basic_task() = default;
+  executor_base() = default;
 
-  ~executor_basic_task() override {
-    executor_basic_task::stop();
+  ~executor_base() override {
+    executor_base::stop();
   }
 
+  executor_base(const executor_base&) = delete;
+  executor_base(executor_base&&) = delete;
+  executor_base& operator=(const executor_base&) = delete;
+  executor_base& operator=(executor_base&&) = delete;
+
   void dispatch(std::function<void()> fn) override {
     if (running_thread_id_.load(std::memory_order_acquire) == std::hash<std::thread::id>{}(std::this_thread::get_id())) {
       fn();

include/coro/executor_loop.hpp

@@ -13,7 +13,7 @@
 #include "executor_poll.hpp"
 
 namespace coro {
-class executor_loop : public executor_basic_task {
+class executor_loop : public executor_base {
  private:
   std::condition_variable condition_;
 
@@ -23,6 +23,11 @@ class executor_loop : public executor_basic_task {
     executor_loop::stop();
   };
 
+  executor_loop(const executor_loop&) = delete;
+  executor_loop(executor_loop&&) = delete;
+  executor_loop& operator=(const executor_loop&) = delete;
+  executor_loop& operator=(executor_loop&&) = delete;
+
   void run_loop() {
     running_thread_id_.store(std::hash<std::thread::id>{}(std::this_thread::get_id()), std::memory_order_release);
     for (;;) {
@@ -76,17 +81,17 @@ class executor_loop : public executor_basic_task {
   }
 
   void post_delayed_ns(std::function<void()> fn, const uint64_t delay_ns) override {
-    executor_basic_task::post_delayed_ns(std::move(fn), delay_ns);
+    executor_base::post_delayed_ns(std::move(fn), delay_ns);
     condition_.notify_one();
   }
 
   void post(std::function<void()> fn) override {
-    executor_basic_task::post(std::move(fn));
+    executor_base::post(std::move(fn));
     condition_.notify_one();
   }
 
   void stop() override {
-    executor_basic_task::stop();
+    executor_base::stop();
     condition_.notify_one();
   }
 };

include/coro/executor_poll.hpp

@@ -1,14 +1,19 @@
 #pragma once
 
-#include "executor_basic_task.hpp"
+#include "executor_base.hpp"
 
 namespace coro {
 
-class executor_poll : public executor_basic_task {
+class executor_poll : public executor_base {
  public:
   executor_poll() = default;
   ~executor_poll() override = default;
 
+  executor_poll(const executor_poll&) = delete;
+  executor_poll(executor_poll&&) = delete;
+  executor_poll& operator=(const executor_poll&) = delete;
+  executor_poll& operator=(executor_poll&&) = delete;
+
   void poll() {
     if (!running_thread_id_.load(std::memory_order_acquire)) {
       running_thread_id_.store(std::hash<std::thread::id>{}(std::this_thread::get_id()), std::memory_order_release);

include/coro/latch.hpp

@@ -30,6 +30,11 @@ struct latch_t {
     }
   }
 
+  latch_t(const latch_t&) = delete;
+  latch_t(latch_t&&) = delete;
+  latch_t& operator=(const latch_t&) = delete;
+  latch_t& operator=(latch_t&&) = delete;
+
   // Count down the latch by n (default 1)
   // When the count reaches zero, all waiting coroutines are resumed
   void count_down(int n = 1) {

include/coro/semaphore.hpp

@@ -31,6 +31,11 @@ struct counting_semaphore_t {
   explicit counting_semaphore_t(int desired, int least_max_value = INT_MAX)
       : counter_(desired), max_value_(least_max_value), head_(nullptr), tail_(nullptr) {}
 
+  counting_semaphore_t(const counting_semaphore_t&) = delete;
+  counting_semaphore_t(counting_semaphore_t&&) = delete;
+  counting_semaphore_t& operator=(const counting_semaphore_t&) = delete;
+  counting_semaphore_t& operator=(counting_semaphore_t&&) = delete;
+
   // Acquire n permits (default 1)
   // Suspends if not enough permits are available
   struct acquire_awaitable {

include/coro/wait_group.hpp

@@ -28,6 +28,11 @@ struct wait_group_t {
  public:
   wait_group_t() : counter_(0), head_(nullptr), tail_(nullptr) {}
 
+  wait_group_t(const wait_group_t&) = delete;
+  wait_group_t(wait_group_t&&) = delete;
+  wait_group_t& operator=(const wait_group_t&) = delete;
+  wait_group_t& operator=(wait_group_t&&) = delete;
+
   // Add delta to the wait group counter
   // Similar to Go's wg.Add(delta)
   void add(int delta) {