concurrency.h

// SPDX-FileCopyrightText: © 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include <atomic>
#include <cassert>
#include <semaphore>
 
#include <moodycamel/lightweightsemaphore.h>

class AtomicBoolRAII
{
private:
  std::atomic<bool> &m_flag;
 
public:
  explicit AtomicBoolRAII (std::atomic<bool> &flag) : m_flag (flag)
  {
    m_flag.store (true, std::memory_order_release);
  }
 
  ~AtomicBoolRAII () { m_flag.store (false, std::memory_order_release); }
 
  // Disable copy and move operations
  AtomicBoolRAII (const AtomicBoolRAII &) = delete;
  AtomicBoolRAII &operator= (const AtomicBoolRAII &) = delete;
  AtomicBoolRAII (AtomicBoolRAII &&) = delete;
  AtomicBoolRAII &operator= (AtomicBoolRAII &&) = delete;
};

template <typename SemaphoreType = std::binary_semaphore> class SemaphoreRAII
{
public:
  explicit SemaphoreRAII (SemaphoreType &semaphore, bool force_acquire = false)
      : semaphore_ (semaphore)
  {
    if (force_acquire)
      {
        if constexpr (
          std::is_same_v<SemaphoreType, moodycamel::LightweightSemaphore>)
          {
            semaphore_.wait ();
          }
        else
          {
            semaphore_.acquire ();
          }
        acquired_ = true;
      }
    else
      {
        if constexpr (
          std::is_same_v<SemaphoreType, moodycamel::LightweightSemaphore>)
          {
            acquired_ = semaphore_.tryWait ();
          }
        else
          {
            acquired_ = semaphore_.try_acquire ();
          }
      }
  }

  ~SemaphoreRAII ()
  {
    if (acquired_)
      {
        if constexpr (
          std::is_same_v<SemaphoreType, moodycamel::LightweightSemaphore>)
          {
            semaphore_.signal ();
          }
        else
          {
            semaphore_.release ();
          }
      }
  }
 
  SemaphoreRAII (const SemaphoreRAII &) = delete;
  SemaphoreRAII &operator= (const SemaphoreRAII &) = delete;
  SemaphoreRAII (SemaphoreRAII &&) = default;
  SemaphoreRAII &operator= (SemaphoreRAII &&) = default;

  bool try_acquire ()
  {
    if (!acquired_)
      {
        if constexpr (
          std::is_same_v<SemaphoreType, moodycamel::LightweightSemaphore>)
          {
            acquired_ = semaphore_.tryWait ();
          }
        else
          {
            acquired_ = semaphore_.try_acquire ();
          }
      }
    return acquired_;
  }

  void release ()
  {
    if (acquired_)
      {
        if constexpr (
          std::is_same_v<SemaphoreType, moodycamel::LightweightSemaphore>)
          {
            semaphore_.signal ();
          }
        else
          {
            semaphore_.release ();
          }
        acquired_ = false;
      }
  }

  bool is_acquired () const { return acquired_; }
 
private:
  SemaphoreType &semaphore_; 
  bool acquired_ = false;    
};