libxr_cb.hpp

#pragma once
 
#include <concepts>
#include <cstring>
#include <tuple>
#include <type_traits>
#include <utility>
 
#include "libxr_def.hpp"
 
namespace LibXR
{
 
template <typename CallableType, typename BoundArgType, typename... CallbackArgs>
concept CallbackFunctionCompatible = requires(CallableType callable)
{
  static_cast<void (*)(bool, BoundArgType, CallbackArgs...)>(callable);
};
 
template <typename... Args>
struct CallbackBlockHeader
{
  using InvokeFunType = void (*)(void*, bool, Args...);
 
  InvokeFunType run_fun_ = nullptr;
};
 
template <typename ArgType, typename... Args>
class CallbackBlock : public CallbackBlockHeader<Args...>
{
 public:
  using FunctionType = void (*)(bool, ArgType, Args...);
 
  CallbackBlock(FunctionType fun, ArgType&& arg)
      : CallbackBlockHeader<Args...>{&InvokeThunk}, fun_(fun), arg_(std::move(arg))
  {
  }
 
  CallbackBlock(const CallbackBlock& other) = delete;
  CallbackBlock& operator=(const CallbackBlock& other) = delete;
 
  static void InvokeThunk(void* cb_block, bool in_isr, Args... args)
  {
    auto* cb = static_cast<CallbackBlock<ArgType, Args...>*>(cb_block);
    cb->Invoke(in_isr, std::forward<Args>(args)...);
  }
 
 protected:
  void Invoke(bool in_isr, Args... args)
  {
    if (!fun_)
    {
      return;
    }
    fun_(in_isr, arg_, std::forward<Args>(args)...);
  }
 
  FunctionType fun_;  
  ArgType arg_;       
};
 
template <typename ArgType, typename... Args>
class GuardedCallbackBlock : public CallbackBlock<ArgType, Args...>
{
 public:
  GuardedCallbackBlock(typename CallbackBlock<ArgType, Args...>::FunctionType fun,
                       ArgType&& arg)
      : CallbackBlock<ArgType, Args...>(fun, std::move(arg))
  {
    this->run_fun_ = &InvokeThunk;
  }
 
  static void InvokeThunk(void* cb_block, bool in_isr, Args... args)
  {
    auto* cb = static_cast<GuardedCallbackBlock<ArgType, Args...>*>(cb_block);
 
    if (!cb->running_)
    {
      cb->running_ = true;
      auto cur_args = std::tuple<std::decay_t<Args>...>{std::forward<Args>(args)...};
      do
      {
        cb->pending_ = false;
        std::apply([&](auto&... a) { cb->Invoke(in_isr, a...); }, cur_args);
        if (cb->pending_)
        {
          cur_args = cb->pending_args_;
        }
      } while (cb->pending_);
      cb->running_ = false;
      return;
    }
 
    // 重入时只保留最新一组参数，把递归调用压平成串行重放。
    // On reentry, keep only the latest argument pack so recursive callback chains are
    // flattened into serialized replay.
    cb->pending_args_ = std::tuple<std::decay_t<Args>...>{std::forward<Args>(args)...};
    cb->pending_ = true;
  }
 
 private:
  bool running_ = false;
  bool pending_ = false;
  std::tuple<std::decay_t<Args>...> pending_args_{};
};
 
template <typename... Args>
class Callback
{
  static void FunctionDefault(void*, bool, Args...) {}
  inline static CallbackBlockHeader<Args...> empty_cb_block_ = {&FunctionDefault};
 
 public:
  template <typename BoundArgType, typename CallableType>
  requires CallbackFunctionCompatible<CallableType, BoundArgType, Args...>
  [[nodiscard]] static Callback Create(CallableType fun, BoundArgType arg)
  {
    using FunctionType = typename CallbackBlock<BoundArgType, Args...>::FunctionType;
    auto cb_block =
        new CallbackBlock<BoundArgType, Args...>(static_cast<FunctionType>(fun),
                                                 std::move(arg));
    return Callback(cb_block);
  }
 
  template <typename BoundArgType, typename CallableType>
  requires CallbackFunctionCompatible<CallableType, BoundArgType, Args...>
  [[nodiscard]] static Callback CreateGuarded(CallableType fun, BoundArgType arg)
  {
    using FunctionType = typename CallbackBlock<BoundArgType, Args...>::FunctionType;
    auto cb_block =
        new GuardedCallbackBlock<BoundArgType, Args...>(static_cast<FunctionType>(fun),
                                                        std::move(arg));
    return Callback(cb_block);
  }
 
  Callback() : cb_block_(&empty_cb_block_) {}
 
  Callback(const Callback&) = default;
  Callback& operator=(const Callback&) = default;
 
  Callback(Callback&& other) noexcept
      : cb_block_(std::exchange(other.cb_block_, &empty_cb_block_))
  {
  }
 
  Callback& operator=(Callback&& other) noexcept
  {
    if (this != &other)
    {
      cb_block_ = std::exchange(other.cb_block_, &empty_cb_block_);
    }
    return *this;
  }
 
  template <typename... PassArgs>
  void Run(bool in_isr, PassArgs&&... args) const
  {
    cb_block_->run_fun_(cb_block_, in_isr, std::forward<PassArgs>(args)...);
  }
 
  bool Empty() const { return cb_block_ == &empty_cb_block_; }
 
 private:
  explicit Callback(CallbackBlockHeader<Args...>* cb_block)
      : cb_block_((cb_block != nullptr) ? cb_block : &empty_cb_block_)
  {
  }
 
  CallbackBlockHeader<Args...>* cb_block_ =
      &empty_cb_block_;  
};
 
}  // namespace LibXR