sem.hpp

Go to the documentation of this file.

//
// Copyright (c) 2019 Erwin Rol <erwin@erwinrol.com>
//
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef ZPP_INCLUDE_ZPP_SEM_HPP
#define ZPP_INCLUDE_ZPP_SEM_HPP
 
#include <zpp/thread.hpp>
 
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
 
#include <chrono>
#include <limits>
 
namespace zpp {
 
template<typename T_Sem>
class sem_base
{
public:
  using native_type = struct k_sem;
  using native_pointer = native_type*;
  using native_const_pointer = native_type const *;
 
  using counter_type = uint32_t;
 
  constexpr static counter_type max_count =
        std::numeric_limits<counter_type>::max();
protected:
  constexpr sem_base() noexcept
  {
  }
public:
  [[nodiscard]] bool take() noexcept
  {
    if (k_sem_take(native_handle(), K_FOREVER) == 0) {
      return true;
    } else {
      return false;
    }
  }
 
  [[nodiscard]] bool try_take() noexcept
  {
    if (k_sem_take(native_handle(), K_NO_WAIT) == 0) {
      return true;
    } else {
      return false;
    }
  }
 
  template<class T_Rep, class T_Period>
  [[nodiscard]] bool
  try_take_for(const std::chrono::duration<T_Rep, T_Period>&
            timeout_duration) noexcept
  {
    if (k_sem_take(native_handle(), to_timeout(timeout_duration)) == 0) {
      return true;
    } else {
      return false;
    }
  }
 
  void give() noexcept
  {
    k_sem_give(native_handle());
  }
 
  void reset() noexcept
  {
    k_sem_reset(native_handle());
  }
 
  counter_type count() noexcept
  {
    return k_sem_count_get(native_handle());
  }
 
  void operator++(int) noexcept
  {
    give();
  }
 
  void operator--(int) noexcept
  {
    while (!take()) {
      this_thread::yield();
    }
  }
 
  void operator+=(int n) noexcept
  {
    while (n-- > 0) {
      give();
    }
  }
 
  void operator-=(int n) noexcept
  {
    while (n-- > 0) {
      while (!take()) {
        this_thread::yield();
      }
    }
  }
 
  auto native_handle() noexcept -> native_pointer
  {
    return static_cast<T_Sem*>(this)->native_handle();
  }
 
  auto native_handle() const noexcept -> native_const_pointer
  {
    return static_cast<const T_Sem*>(this)->native_handle();
  }
public:
  sem_base(const sem_base&) = delete;
  sem_base(sem_base&&) = delete;
  sem_base& operator=(const sem_base&) = delete;
  sem_base& operator=(sem_base&&) = delete;
};
 
 
class sem : public sem_base<sem> {
public:
  sem(counter_type initial_count, counter_type count_limit) noexcept
  {
    k_sem_init(&m_sem, initial_count, count_limit);
  }
 
  explicit sem(counter_type initial_count) noexcept
    : sem(initial_count, max_count)
  {
  }
 
  //
  sem() noexcept
    : sem(0, max_count)
  {
  }
 
  constexpr auto native_handle() noexcept -> native_pointer
  {
    return &m_sem;
  }
 
  constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    return &m_sem;
  }
private:
  native_type m_sem;
public:
  sem(const sem&) = delete;
  sem(sem&&) = delete;
  sem& operator=(const sem&) = delete;
  sem& operator=(sem&&) = delete;
};
 
class sem_ref : public sem_base<sem_ref> {
public:
  explicit constexpr sem_ref(native_pointer s) noexcept
    : m_sem_ptr(s)
  {
    __ASSERT_NO_MSG(m_sem_ptr != nullptr);
  }
 
  template<class T_Sem>
  explicit constexpr sem_ref(T_Sem& s) noexcept
    : m_sem_ptr(s.native_handle())
  {
    __ASSERT_NO_MSG(m_sem_ptr != nullptr);
  }
 
  constexpr sem_ref& operator=(native_pointer s) noexcept
  {
    m_sem_ptr = s;
    __ASSERT_NO_MSG(m_sem_ptr != nullptr);
    return *this;
  }
 
  template<class T_Sem>
  constexpr sem_ref& operator=(T_Sem& s) noexcept
  {
    m_sem_ptr = s.native_handle();
    __ASSERT_NO_MSG(m_sem_ptr != nullptr);
    return *this;
  }
 
  constexpr auto native_handle() noexcept -> native_pointer
  {
    __ASSERT_NO_MSG(m_sem_ptr != nullptr);
 
    return m_sem_ptr;
  }
 
  constexpr auto native_handle() const noexcept -> native_const_pointer
  {
    __ASSERT_NO_MSG(m_sem_ptr != nullptr);
 
    return m_sem_ptr;
  }
private:
  native_pointer m_sem_ptr{ nullptr };
public:
  sem_ref() = delete;
};
 
} // namespace zpp
 
#endif // ZPP_INCLUDE_ZPP_SEM_HPP