sys_mutex.hpp

Go to the documentation of this file.

 
#ifndef ZPP_INCLUDE_ZPP_SYS_MUTEX_HPP
#define ZPP_INCLUDE_ZPP_SYS_MUTEX_HPP
 
#ifdef CONFIG_USERSPACE
 
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
 
#include <chrono>
 
namespace zpp {
 
template<typename T_Mutex>
class sys_mutex_base
{
public:
  using native_type = struct sys_mutex;
  using native_pointer = native_type*;
  using native_cont_pointer = native_type const *;
protected:
  constexpr sys_mutex_base() noexcept = default;
 
public:
  [[nodiscard]] bool lock() noexcept
  {
    if (sys_mutex_lock(native_handle(), K_FOREVER) == 0) {
      return true;
    } else {
      return false;
    }
  }
 
  [[nodiscard]] bool try_lock() noexcept
  {
    if (sys_mutex_lock(native_handle(), K_NO_WAIT) == 0) {
      return true;
    } else {
      return false;
    }
  }
 
  template<class T_Rep, class T_Period>
  [[nodiscard]] bool
  try_lock_for(const std::chrono::duration<T_Rep, T_Period>& timeout) noexcept
  {
    using namespace std::chrono;
 
    if (sys_mutex_lock(native_handle(), to_timeout(timeout)) == 0)
    {
      return true;
    } else {
      return false;
    }
  }
 
  [[nodiscard]] bool unlock() noexcept
  {
    if (sys_mutex_unlock(native_handle()) == 0) {
      return true;
    } else {
      return false;
    }
  }
 
  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:
  sys_mutex_base(const sys_mutex_base&) = delete;
  sys_mutex_base(sys_mutex_base&&) = delete;
  sys_mutex_base& operator=(const sys_mutex_base&) = delete;
  sys_mutex_base& operator=(sys_mutex_base&&) = delete;
};
 
class sys_mutex : public sys_mutex_base<sys_mutex> {
public:
  sys_mutex() noexcept
  {
    sys_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:
  sys_mutex(const sys_mutex&) = delete;
  sys_mutex(sys_mutex&&) = delete;
  sys_mutex& operator=(const sys_mutex&) = delete;
  sys_mutex& operator=(sys_mutex&&) = delete;
};
 
class sys_mutex_ref : public sys_mutex_base<sys_mutex_ref> {
public:
  explicit constexpr sys_mutex_ref(native_pointer m) noexcept
    : m_mutex_ptr(m)
  {
    __ASSERT_NO_MSG(m_mutex_ptr != nullptr);
  }
 
  template<class T_Mutex>
  explicit constexpr sys_mutex_ref(T_Mutex& m) noexcept
    : m_mutex_ptr(m.native_handle())
  {
    __ASSERT_NO_MSG(m_mutex_ptr != nullptr);
  }
 
  constexpr sys_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 sys_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:
  sys_mutex_ref() = delete;
};
 
} // namespace zpp
 
#endif // CONFIG_USERSPACE
 
#endif // ZPP_INCLUDE_ZPP_SYS_MUTEX_HPP