callback_gate.h

#pragma once
 
#include <condition_variable>
#include <memory>
#include <mutex>
 
namespace BT::details
{
 
/**
 * @brief Synchronization gate used to coordinate callbacks with object teardown.
 *
 * Callbacks enter the gate with tryStart() and must signal completion when done
 * (use Guard for RAII). During teardown, call close() to reject new callbacks
 * and closeAndDrain() to block until the callbacks still running have completed.
 */
class CallbackGate
{
public:
  using Ptr = std::shared_ptr<CallbackGate>;
 
  /// RAII helper that signals the completion of a callback entered with tryStart()
  class Guard
  {
  public:
    explicit Guard(Ptr gate) : gate_(std::move(gate))
    {}
 
    Guard(const Guard&) = delete;
    Guard& operator=(const Guard&) = delete;
    Guard(Guard&&) = delete;
    Guard& operator=(Guard&&) = delete;
 
    ~Guard()
    {
      gate_->completed();
    }
 
  private:
    Ptr gate_;
  };
 
  /// Returns false if the gate has been closed and the callback must not run.
  bool tryStart()
  {
    const std::lock_guard lk(mutex_);
    if(!accepting_callbacks_)
    {
      return false;
    }
    running_callbacks_++;
    return true;
  }
 
  /// Reject new callbacks, without waiting for the running ones.
  void close()
  {
    const std::lock_guard lk(mutex_);
    accepting_callbacks_ = false;
  }
 
  /// Reject new callbacks and wait until callbacks already running have completed.
  void closeAndDrain()
  {
    std::unique_lock lk(mutex_);
    accepting_callbacks_ = false;
    condition_variable_.wait(lk, [this] { return running_callbacks_ == 0; });
  }
 
private:
  void completed()
  {
    const std::lock_guard lk(mutex_);
    running_callbacks_--;
    if(running_callbacks_ == 0 && !accepting_callbacks_)
    {
      condition_variable_.notify_all();
    }
  }
 
  std::mutex mutex_;
  std::condition_variable condition_variable_;
  bool accepting_callbacks_ = true;
  size_t running_callbacks_ = 0;
};
 
}  // namespace BT::details