flag.hpp

#pragma once
 
#include <atomic>
#include <cstdint>
 
namespace LibXR
{
 
namespace Flag
{
 
class Atomic
{
 public:
  Atomic() = default;
 
  void Set() noexcept { value_.store(1u, std::memory_order_release); }
 
  void Clear() noexcept { value_.store(0u, std::memory_order_release); }
 
  [[nodiscard]] bool IsSet() const noexcept
  {
    return value_.load(std::memory_order_acquire) != 0u;
  }
 
  [[nodiscard]] bool TestAndSet() noexcept
  {
    return value_.exchange(1u, std::memory_order_acq_rel) != 0u;
  }
 
  [[nodiscard]] bool TestAndClear() noexcept
  {
    return value_.exchange(0u, std::memory_order_acq_rel) != 0u;
  }
 
  [[nodiscard]] bool Exchange(bool set_value) noexcept
  {
    return value_.exchange(set_value ? 1u : 0u, std::memory_order_acq_rel) != 0u;
  }
 
  Atomic(const Atomic&) = delete;
  Atomic& operator=(const Atomic&) = delete;
 
 private:
  std::atomic<uint8_t> value_{
      0u};  
};
 
class Plain
{
 public:
  Plain() = default;
 
  void Set() noexcept { value_ = true; }
 
  void Clear() noexcept { value_ = false; }
 
  [[nodiscard]] bool IsSet() const noexcept { return value_; }
 
  [[nodiscard]] bool TestAndSet() noexcept
  {
    bool old = value_;
    value_ = true;
    return old;
  }
 
  [[nodiscard]] bool TestAndClear() noexcept
  {
    bool old = value_;
    value_ = false;
    return old;
  }
 
  [[nodiscard]] bool Exchange(bool set_value) noexcept
  {
    bool old = value_;
    value_ = set_value;
    return old;
  }
 
 private:
  bool value_{
      false};  
};
 
template <typename FlagT>
class ScopedRestore
{
 public:
  explicit ScopedRestore(FlagT& flag, bool set_value = true)
      : flag_(flag), prev_(flag_.Exchange(set_value))
  {
  }
 
  ~ScopedRestore() { (void)flag_.Exchange(prev_); }
 
  ScopedRestore(const ScopedRestore&) = delete;
  ScopedRestore& operator=(const ScopedRestore&) = delete;
 
 private:
  FlagT& flag_;  
  bool prev_;    
};
 
}  // namespace Flag
}  // namespace LibXR