poll_signal.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_POLL_SIGNAL_HPP
#define ZPP_INCLUDE_ZPP_POLL_SIGNAL_HPP
 
#ifdef CONFIG_POLL
 
#include <zephyr/kernel.h>
#include <zephyr/sys/__assert.h>
 
#include <limits>
#include <optional>
 
namespace zpp {
 
template<typename T_PollSignal>
class poll_signal_base {
public:
  using native_type = struct k_poll_signal;
  using native_pointer = native_type *;
  using native_const_pointer = native_type const *;
protected:
  poll_signal_base() noexcept
  {
  }
public:
  std::optional<int> check() noexcept
  {
    unsigned int signaled{0};
    int result{0};
 
    k_poll_signal_check(native_handle(), &signaled, &result);
 
    if (signaled != 0) {
      return { result };
    } else {
      return {};
    }
  }
 
  bool raise(int result) noexcept
  {
    auto rc = k_poll_signal_raise(native_handle(), result);
    if (rc == 0) {
      return true;
    } else {
      return false;
    }
  }
 
  void reset() noexcept
  {
    k_poll_signal_reset(native_handle());
  }
 
  auto native_handle() noexcept -> native_pointer
  {
    return static_cast<T_PollSignal*>(this)->native_handle();
  }
 
  auto native_handle() const noexcept -> native_const_pointer
  {
    return static_cast<const T_PollSignal*>(this)->native_handle();
  }
public:
  poll_signal_base(const poll_signal_base&) = delete;
  poll_signal_base(poll_signal_base&&) = delete;
  poll_signal_base& operator=(const poll_signal_base&) = delete;
  poll_signal_base& operator=(poll_signal_base&&) = delete;
};
 
class poll_signal
  : public poll_signal_base<poll_signal>
{
public:
  poll_signal() noexcept
  {
    k_poll_signal_init(&m_signal);
  }
 
  auto native_handle() noexcept -> native_pointer
  {
    return &m_signal;
  }
 
  auto native_handle() const noexcept -> native_const_pointer
  {
    return &m_signal;
  }
private:
  native_type m_signal;
public:
  poll_signal(const poll_signal&) = delete;
  poll_signal(poll_signal&&) = delete;
  poll_signal& operator=(const poll_signal&) = delete;
  poll_signal& operator=(poll_signal&&) = delete;
};
 
class poll_signal_ref
  : public poll_signal_base<poll_signal_ref>
{
public:
  poll_signal_ref(native_pointer s) noexcept
    : m_signal_ptr(s)
  {
    __ASSERT_NO_MSG(m_signal_ptr != nullptr);
  }
 
  template<typename T_PollSignal>
  poll_signal_ref(T_PollSignal& s) noexcept
    : m_signal_ptr(s.native_handle())
  {
    __ASSERT_NO_MSG(m_signal_ptr != nullptr);
  }
 
  poll_signal_ref& operator=(native_pointer s) noexcept
  {
    m_signal_ptr = s;
    __ASSERT_NO_MSG(m_signal_ptr != nullptr);
    return *this;
  }
 
  template<typename T_PollSignal>
  poll_signal_ref& operator=(T_PollSignal& s) noexcept
  {
    m_signal_ptr = s.native_handle();
    __ASSERT_NO_MSG(m_signal_ptr != nullptr);
    return *this;
  }
 
  auto native_handle() noexcept -> native_pointer
  {
    return m_signal_ptr;
  }
 
  auto native_handle() const noexcept -> native_const_pointer
  {
    return m_signal_ptr;
  }
private:
  native_pointer m_signal_ptr{ nullptr };
public:
  poll_signal_ref() = delete;
};
 
} // namespace zpp
 
#endif // CONFIG_POLL
 
#endif // ZPP_INCLUDE_ZPP_POLL_SIGNAL_HPP