// -*- C++ -*-
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef _LIBCPP_MUTEX
#define _LIBCPP_MUTEX

/*
    mutex synopsis

namespace std
{

class mutex
{
public:
     constexpr mutex() noexcept;
     ~mutex();

    mutex(const mutex&) = delete;
    mutex& operator=(const mutex&) = delete;

    void lock();
    bool try_lock();
    void unlock();

    typedef pthread_mutex_t* native_handle_type;
    native_handle_type native_handle();
};

class recursive_mutex
{
public:
     recursive_mutex();
     ~recursive_mutex();

    recursive_mutex(const recursive_mutex&) = delete;
    recursive_mutex& operator=(const recursive_mutex&) = delete;

    void lock();
    bool try_lock() noexcept;
    void unlock();

    typedef pthread_mutex_t* native_handle_type;
    native_handle_type native_handle();
};

class timed_mutex
{
public:
     timed_mutex();
     ~timed_mutex();

    timed_mutex(const timed_mutex&) = delete;
    timed_mutex& operator=(const timed_mutex&) = delete;

    void lock();
    bool try_lock();
    template <class Rep, class Period>
        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
    void unlock();
};

class recursive_timed_mutex
{
public:
     recursive_timed_mutex();
     ~recursive_timed_mutex();

    recursive_timed_mutex(const recursive_timed_mutex&) = delete;
    recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;

    void lock();
    bool try_lock() noexcept;
    template <class Rep, class Period>
        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
    void unlock();
};

struct defer_lock_t { explicit defer_lock_t() = default; };
struct try_to_lock_t { explicit try_to_lock_t() = default; };
struct adopt_lock_t { explicit adopt_lock_t() = default; };

inline constexpr defer_lock_t  defer_lock{};
inline constexpr try_to_lock_t try_to_lock{};
inline constexpr adopt_lock_t  adopt_lock{};

template <class Mutex>
class lock_guard
{
public:
    typedef Mutex mutex_type;

    explicit lock_guard(mutex_type& m);
    lock_guard(mutex_type& m, adopt_lock_t);
    ~lock_guard();

    lock_guard(lock_guard const&) = delete;
    lock_guard& operator=(lock_guard const&) = delete;
};

template <class... MutexTypes>
class scoped_lock // C++17
{
public:
    using mutex_type = Mutex;  // Only if sizeof...(MutexTypes) == 1

    explicit scoped_lock(MutexTypes&... m);
    scoped_lock(adopt_lock_t, MutexTypes&... m);
    ~scoped_lock();
    scoped_lock(scoped_lock const&) = delete;
    scoped_lock& operator=(scoped_lock const&) = delete;
private:
    tuple<MutexTypes&...> pm; // exposition only
};

template <class Mutex>
class unique_lock
{
public:
    typedef Mutex mutex_type;
    unique_lock() noexcept;
    explicit unique_lock(mutex_type& m);
    unique_lock(mutex_type& m, defer_lock_t) noexcept;
    unique_lock(mutex_type& m, try_to_lock_t);
    unique_lock(mutex_type& m, adopt_lock_t);
    template <class Clock, class Duration>
        unique_lock(mutex_type& m, const chrono::time_point<Clock, Duration>& abs_time);
    template <class Rep, class Period>
        unique_lock(mutex_type& m, const chrono::duration<Rep, Period>& rel_time);
    ~unique_lock();

    unique_lock(unique_lock const&) = delete;
    unique_lock& operator=(unique_lock const&) = delete;

    unique_lock(unique_lock&& u) noexcept;
    unique_lock& operator=(unique_lock&& u) noexcept;

    void lock();
    bool try_lock();

    template <class Rep, class Period>
        bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
    template <class Clock, class Duration>
        bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);

    void unlock();

    void swap(unique_lock& u) noexcept;
    mutex_type* release() noexcept;

    bool owns_lock() const noexcept;
    explicit operator bool () const noexcept;
    mutex_type* mutex() const noexcept;
};

template <class Mutex>
  void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;

template <class L1, class L2, class... L3>
  int try_lock(L1&, L2&, L3&...);
template <class L1, class L2, class... L3>
  void lock(L1&, L2&, L3&...);

struct once_flag
{
    constexpr once_flag() noexcept;

    once_flag(const once_flag&) = delete;
    once_flag& operator=(const once_flag&) = delete;
};

template<class Callable, class ...Args>
  void call_once(once_flag& flag, Callable&& func, Args&&... args);

}  // std

*/

#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
#  include <__cxx03/mutex>
#else
#  include <__chrono/steady_clock.h>
#  include <__chrono/time_point.h>
#  include <__condition_variable/condition_variable.h>
#  include <__config>
#  include <__mutex/lock_guard.h>
#  include <__mutex/mutex.h>
#  include <__mutex/once_flag.h>
#  include <__mutex/tag_types.h>
#  include <__mutex/unique_lock.h>
#  include <__thread/id.h>
#  include <__thread/support.h>
#  include <__utility/forward.h>
#  include <limits>
#  ifndef _LIBCPP_CXX03_LANG
#    include <tuple>
#  endif
#  include <version>

#  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#    pragma GCC system_header
#  endif

_LIBCPP_PUSH_MACROS
#  include <__undef_macros>

_LIBCPP_BEGIN_NAMESPACE_STD

#  if _LIBCPP_HAS_THREADS

class _LIBCPP_EXPORTED_FROM_ABI recursive_mutex {
  __libcpp_recursive_mutex_t __m_;

public:
  recursive_mutex();
  ~recursive_mutex();

  recursive_mutex(const recursive_mutex&)            = delete;
  recursive_mutex& operator=(const recursive_mutex&) = delete;

  void lock();
  bool try_lock() _NOEXCEPT;
  void unlock() _NOEXCEPT;

  typedef __libcpp_recursive_mutex_t* native_handle_type;

  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__m_; }
};

class _LIBCPP_EXPORTED_FROM_ABI timed_mutex {
  mutex __m_;
  condition_variable __cv_;
  bool __locked_;

public:
  timed_mutex();
  ~timed_mutex();

  timed_mutex(const timed_mutex&)            = delete;
  timed_mutex& operator=(const timed_mutex&) = delete;

public:
  void lock();
  bool try_lock() _NOEXCEPT;
  template <class _Rep, class _Period>
  _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
    return try_lock_until(chrono::steady_clock::now() + __d);
  }

  template <class _Clock, class _Duration>
  _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
    using namespace chrono;
    unique_lock<mutex> __lk(__m_);
    bool __no_timeout = _Clock::now() < __t;
    while (__no_timeout && __locked_)
      __no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout;
    if (!__locked_) {
      __locked_ = true;
      return true;
    }
    return false;
  }

  void unlock() _NOEXCEPT;
};

class _LIBCPP_EXPORTED_FROM_ABI recursive_timed_mutex {
  mutex __m_;
  condition_variable __cv_;
  size_t __count_;
  __thread_id __id_;

public:
  recursive_timed_mutex();
  ~recursive_timed_mutex();

  recursive_timed_mutex(const recursive_timed_mutex&)            = delete;
  recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;

  void lock();
  bool try_lock() _NOEXCEPT;
  template <class _Rep, class _Period>
  _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
    return try_lock_until(chrono::steady_clock::now() + __d);
  }

  template <class _Clock, class _Duration>
  _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
    using namespace chrono;
    __thread_id __id = this_thread::get_id();
    unique_lock<mutex> __lk(__m_);
    if (__id == __id_) {
      if (__count_ == numeric_limits<size_t>::max())
        return false;
      ++__count_;
      return true;
    }
    bool __no_timeout = _Clock::now() < __t;
    while (__no_timeout && __count_ != 0)
      __no_timeout = __cv_.wait_until(__lk, __t) == cv_status::no_timeout;
    if (__count_ == 0) {
      __count_ = 1;
      __id_    = __id;
      return true;
    }
    return false;
  }

  void unlock() _NOEXCEPT;
};

template <class _L0, class _L1>
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1) {
  unique_lock<_L0> __u0(__l0, try_to_lock_t());
  if (__u0.owns_lock()) {
    if (__l1.try_lock()) {
      __u0.release();
      return -1;
    } else
      return 1;
  }
  return 0;
}

#    ifndef _LIBCPP_CXX03_LANG

template <class _L0, class _L1, class _L2, class... _L3>
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
  int __r = 0;
  unique_lock<_L0> __u0(__l0, try_to_lock);
  if (__u0.owns_lock()) {
    __r = std::try_lock(__l1, __l2, __l3...);
    if (__r == -1)
      __u0.release();
    else
      ++__r;
  }
  return __r;
}

#    endif // _LIBCPP_CXX03_LANG

// We're using unique_lock to implement the functions, which thread annotations don't support. So we have to disable
// the analysis inside the function.
template <class _L0, class _L1>
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1)
    _LIBCPP_ACQUIRE_CAPABILITY(__l0, __l1) {
  while (true) {
    {
      unique_lock<_L0> __u0(__l0);
      if (__l1.try_lock()) {
        __u0.release();
        break;
      }
    }
    __libcpp_thread_yield();
    {
      unique_lock<_L1> __u1(__l1);
      if (__l0.try_lock()) {
        __u1.release();
        break;
      }
    }
    __libcpp_thread_yield();
  }
}

#    ifndef _LIBCPP_CXX03_LANG

template <class _L0, class _L1, class _L2, class... _L3>
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS void __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
  while (true) {
    switch (__i) {
    case 0: {
      unique_lock<_L0> __u0(__l0);
      __i = std::try_lock(__l1, __l2, __l3...);
      if (__i == -1) {
        __u0.release();
        return;
      }
    }
      ++__i;
      __libcpp_thread_yield();
      break;
    case 1: {
      unique_lock<_L1> __u1(__l1);
      __i = std::try_lock(__l2, __l3..., __l0);
      if (__i == -1) {
        __u1.release();
        return;
      }
    }
      if (__i == sizeof...(_L3) + 1)
        __i = 0;
      else
        __i += 2;
      __libcpp_thread_yield();
      break;
    default:
      std::__lock_first(__i - 2, __l2, __l3..., __l0, __l1);
      return;
    }
  }
}

// We're using unique_lock to implement the functions, which thread annotations don't support. So we have to disable
// the analysis inside the function.
template <class _L0, class _L1, class _L2, class... _L3>
_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3)
#      if defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 2101
    _LIBCPP_ACQUIRE_CAPABILITY(__l0, __l1, __l2, __l3...)
#      endif
{
  std::__lock_first(0, __l0, __l1, __l2, __l3...);
}

#    endif // _LIBCPP_CXX03_LANG

#    if _LIBCPP_STD_VER >= 17
template <class... _Mutexes>
class scoped_lock;

template <>
class scoped_lock<> {
public:
  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock() {}
  ~scoped_lock() = default;

  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(adopt_lock_t) {}

  scoped_lock(scoped_lock const&)            = delete;
  scoped_lock& operator=(scoped_lock const&) = delete;
};

template <class _Mutex>
class _LIBCPP_SCOPED_LOCKABLE scoped_lock<_Mutex> {
public:
  typedef _Mutex mutex_type;

private:
  mutex_type& __m_;

public:
  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(mutex_type& __m) _LIBCPP_ACQUIRE_CAPABILITY(__m)
      : __m_(__m) {
    __m_.lock();
  }

  _LIBCPP_RELEASE_CAPABILITY _LIBCPP_HIDE_FROM_ABI ~scoped_lock() { __m_.unlock(); }

  [[nodiscard]]
  _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(adopt_lock_t, mutex_type& __m) _LIBCPP_REQUIRES_CAPABILITY(__m)
      : __m_(__m) {}

  scoped_lock(scoped_lock const&)            = delete;
  scoped_lock& operator=(scoped_lock const&) = delete;
};

template <class... _MArgs>
class scoped_lock {
  static_assert(sizeof...(_MArgs) > 1, "At least 2 lock types required");
  typedef tuple<_MArgs&...> _MutexTuple;

public:
  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI explicit scoped_lock(_MArgs&... __margs) : __t_(__margs...) {
    std::lock(__margs...);
  }

  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI scoped_lock(adopt_lock_t, _MArgs&... __margs) : __t_(__margs...) {}

  _LIBCPP_HIDE_FROM_ABI ~scoped_lock() { __unlock_unpack(make_index_sequence<sizeof...(_MArgs)>(), __t_); }

  scoped_lock(scoped_lock const&)            = delete;
  scoped_lock& operator=(scoped_lock const&) = delete;

private:
  template <size_t... _Indx>
  _LIBCPP_HIDE_FROM_ABI static void __unlock_unpack(index_sequence<_Indx...>, _MutexTuple& __mt) {
    (std::get<_Indx>(__mt).unlock(), ...);
  }

  _MutexTuple __t_;
};
_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(scoped_lock);

#    endif // _LIBCPP_STD_VER >= 17
#  endif   // _LIBCPP_HAS_THREADS

_LIBCPP_END_NAMESPACE_STD

_LIBCPP_POP_MACROS

#  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 23
#    include <typeinfo>
#  endif

#  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
#    include <atomic>
#    include <concepts>
#    include <cstdlib>
#    include <cstring>
#    include <ctime>
#    include <initializer_list>
#    include <iosfwd>
#    include <new>
#    include <optional>
#    include <stdexcept>
#    include <system_error>
#    include <type_traits>
#  endif
#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)

#endif // _LIBCPP_MUTEX
