serialized_service.hpp

#pragma once
 
#include <atomic>
#include <cstdint>
 
namespace LibXR
{
 
class SerializedService
{
 public:
  SerializedService() = default;
 
  template <typename Handler>
  bool Invoke(uint32_t events, Handler&& handler) noexcept
  {
    if ((events == 0U) || ((events & OWNER_BIT) != 0U))
    {
      return false;
    }
 
    uint32_t observed = state_.fetch_or(events, std::memory_order_release) | events;
 
    while ((observed & OWNER_BIT) == 0U)
    {
      // Another owner may have consumed this invocation's event and released the state
      // before our CAS. An empty state means there is no remaining work to claim.
      if ((observed & EVENT_MASK) == 0U)
      {
        return false;
      }
 
      const uint32_t desired = observed | OWNER_BIT;
      if (state_.compare_exchange_weak(observed, desired, std::memory_order_acquire,
                                       std::memory_order_relaxed))
      {
        break;
      }
    }
 
    if ((observed & OWNER_BIT) != 0U)
    {
      return false;
    }
 
    while (true)
    {
      const uint32_t snapshot =
          state_.exchange(OWNER_BIT, std::memory_order_acq_rel) & EVENT_MASK;
      if (snapshot != 0U)
      {
        handler(snapshot);
      }
 
      uint32_t expected = OWNER_BIT;
      if (state_.compare_exchange_strong(expected, 0U, std::memory_order_release,
                                         std::memory_order_acquire))
      {
        return true;
      }
      // A publisher ORed new events while OWNER_BIT was set. Keep ownership and consume
      // the next snapshot; release cannot race past an already-published event.
    }
  }
 
  SerializedService(const SerializedService&) = delete;
  SerializedService& operator=(const SerializedService&) = delete;
 
 private:
  static constexpr uint32_t OWNER_BIT = 1U << 31U;
  static constexpr uint32_t EVENT_MASK = ~OWNER_BIT;
 
  std::atomic<uint32_t> state_{0U};
};
 
}  // namespace LibXR