callback_manager.h

#ifndef PRODUCTION_BORG_MGMT_NODE_PROXY_SAFEPOWER_SAFEPOWER_AGENT_CALLBACK_MANAGER_H_
#define PRODUCTION_BORG_MGMT_NODE_PROXY_SAFEPOWER_SAFEPOWER_AGENT_CALLBACK_MANAGER_H_

#include <memory>
#include <vector>

#include "absl/base/thread_annotations.h"
#include "absl/functional/any_invocable.h"
#include "absl/synchronization/mutex.h"

namespace safepower_agent {

class CallbackManager {
 private:
  struct HandleImpl;

 public:
  using Callback = absl::AnyInvocable<void() &&>;

  class [[nodiscard]] Handle {
   public:
    Handle() = default;
    ~Handle() = default;

    Handle(Handle&& other) = default;
    Handle& operator=(Handle&& other) = default;

    explicit Handle(std::shared_ptr<HandleImpl> impl);

    // Returns true if the callback is still queued or is currently executing.
    bool pending() const ABSL_LOCKS_EXCLUDED(impl_->mutex);
    // Returns true if the callback has fully finished executing.
    bool executed() const ABSL_LOCKS_EXCLUDED(impl_->mutex);
    // Attempts to cancel the callback. Returns true if successfully cancelled,
    // or false if the callback is already executing, already executed, or
    // already cancelled.
    bool TryCancel() ABSL_LOCKS_EXCLUDED(impl_->mutex);
    // Wait for the callback to either be cancelled or executed.
    // Wait is guaranteed to finish if TryCancel is called (and the callback
    // finishes executing if it was already running).
    void Wait() ABSL_LOCKS_EXCLUDED(impl_->mutex);

   private:
    std::shared_ptr<HandleImpl> impl_ = nullptr;
  };

  CallbackManager() = default;
  ~CallbackManager() = default;

  // Assumption: Callbacks do not query, cancel  or otherwise reference
  // any handles.

  Handle RunFirst(Callback callback) ABSL_LOCKS_EXCLUDED(mutex_);
  Handle RunLast(Callback callback) ABSL_LOCKS_EXCLUDED(mutex_);
  void RunCallbacks() ABSL_LOCKS_EXCLUDED(mutex_);

 private:
  enum class State {
    kPending,
    kExecuting,
    kExecuted,
    kCancelled,
  };

  struct HandleImpl {
    absl::Mutex mutex;
    Callback callback;
    State state ABSL_GUARDED_BY(mutex) = State::kPending;
  };

  static void RunCallbackIfValid(const std::weak_ptr<HandleImpl>& weak_handle);

  absl::Mutex mutex_;
  std::vector<std::weak_ptr<HandleImpl>> run_first_ ABSL_GUARDED_BY(mutex_);
  std::vector<std::weak_ptr<HandleImpl>> run_last_ ABSL_GUARDED_BY(mutex_);
};

}  // namespace safepower_agent

#endif  // PRODUCTION_BORG_MGMT_NODE_PROXY_SAFEPOWER_SAFEPOWER_AGENT_CALLBACK_MANAGER_H_