mutex.hpp

Go to the documentation of this file.

 
#ifndef ZPP_INCLUDE_ZPP_MUTEX_HPP
#define ZPP_INCLUDE_ZPP_MUTEX_HPP
 
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
 
#include <chrono>
 
#include <zpp/result.hpp>
#include <zpp/error_code.hpp>
 
namespace zpp {
 
template<typename T_Mutex>
class mutex_base
{
public:
  using native_type = struct k_mutex;
  using native_pointer = native_type*;
  using native_const_pointer = native_type const *;
protected:
  constexpr mutex_base() noexcept
  {
  }
 
public:
  [[nodiscard]] auto lock() noexcept
  {
    result<void, error_code> res;
 
    auto rc = k_mutex_lock(native_handle(), K_FOREVER);
    if (rc == 0) {
      res.assign_value();
    } else {
      res.assign_error(to_error_code(-rc));
    }
 
    return res;
  }
 
  [[nodiscard]] auto try_lock() noexcept
  {
    result<void, error_code> res;
 
    auto rc = k_mutex_lock(native_handle(), K_NO_WAIT);
    if (rc == 0) {
      res.assign_value();
    } else {
      res.assign_error(to_error_code(-rc));
    }
 
    return res;
  }
 
  template<class T_Rep, class T_Period>
  [[nodiscard]] auto
  try_lock_for(const std::chrono::duration<T_Rep, T_Period>& timeout) noexcept
  {
    using namespace std::chrono;
 
    result<void, error_code> res;
 
    auto rc = k_mutex_lock(native_handle(), to_timeout(timeout));
    if (rc == 0) {
      res.assign_value();
    } else {
      res.assign_error(to_error_code(-rc));
    }
 
    return res;
  }
 
  [[nodiscard]] auto unlock() noexcept
  {
    result<void, error_code> res;
 
    auto rc = k_mutex_unlock(native_handle());
    if (rc == 0) {
      res.assign_value();
    } else {
      res.assign_error(to_error_code(-rc));
    }
 
    return res;
  }
 
  auto native_handle() noexcept -> native_pointer
  {
    return static_cast<T_Mutex*>(this)->native_handle();
  }
 
  auto native_handle() const noexcept -> native_const_pointer
  {
    return static_cast<const T_Mutex*>(this)->native_handle();
  }
public:
  mutex_base(const mutex_base&) = delete;
  mutex_base(mutex_base&&) = delete;
  mutex_base& operator=(const mutex_base&) = delete;
  mutex_base& operator=(mutex_base&&) = delete;
};
 
class mutex : public mutex_base<mutex> {
public:
  mutex() noexcept
  {
    k_mutex_init(&m_mutex);
  }
 
  constexpr auto native_handle() noexcept -> native_pointer
  {
    return &m_mutex;
  }
 
  constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return &m_mutex;
  }
private:
  native_type m_mutex{};
public:
  mutex(const mutex&) = delete;
  mutex(mutex&&) = delete;
  mutex& operator=(const mutex&) = delete;
  mutex& operator=(mutex&&) = delete;
};
 
class mutex_ref : public mutex_base<mutex_ref> {
public:
  explicit constexpr mutex_ref(native_pointer m) noexcept
    : m_mutex_ptr(m)
  {
    __ASSERT_NO_MSG(m_mutex_ptr != nullptr);
  }
 
  template<class T_Mutex>
  explicit constexpr mutex_ref(T_Mutex& m) noexcept
    : m_mutex_ptr(m.native_handle())
  {
    __ASSERT_NO_MSG(m_mutex_ptr != nullptr);
  }
 
  constexpr mutex_ref& operator=(native_pointer m) noexcept
  {
    m_mutex_ptr = m;
    __ASSERT_NO_MSG(m_mutex_ptr != nullptr);
    return *this;
  }
 
  template<class T_Mutex>
  constexpr mutex_ref& operator=(T_Mutex& m) noexcept
  {
    m_mutex_ptr = m.native_handle();
    __ASSERT_NO_MSG(m_mutex_ptr != nullptr);
    return *this;
  }
 
  constexpr auto native_handle() noexcept -> native_pointer
  {
    return m_mutex_ptr;
  }
 
  constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return m_mutex_ptr;
  }
private:
  native_pointer m_mutex_ptr{ nullptr };
public:
  mutex_ref() = delete;
};
 
} // namespace zpp
 
#endif // ZPP_INCLUDE_ZPP_MUTEX_HPP