zpp::thread Class Reference

The class thread repecents a single Zephyr thread. More...

#include <thread.hpp>

Public Member Functions
constexpr	thread () noexcept
	Creates a object which doesn't represent a Zephyr thread. More...
constexpr	thread (thread_id tid) noexcept
	Creates a object which represents Zephyr thread with tid. More...
template<typename T_Heap , typename T_Callback , typename... T_CallbackArgs, std::enable_if_t< std::is_nothrow_invocable_v< T_Callback, T_CallbackArgs... >, bool > = true>
constexpr	thread (thread_data &td, thread_stack &&tstack, const thread_attr &attr, T_Heap *heap, T_Callback &&f, T_CallbackArgs &&... args) noexcept
	Creates a object which represents a new Zephyr thread. More...
template<typename T_Callback , typename T_CallbackArg , std::enable_if_t< std::is_nothrow_invocable_v< T_Callback, T_CallbackArg >, bool > = true>
constexpr	thread (thread_data &td, thread_stack &&tstack, const thread_attr &attr, T_Callback f, T_CallbackArg arg) noexcept
	Creates a object which represents a new Zephyr thread. More...
template<typename T_Callback , std::enable_if_t< std::is_nothrow_invocable_v< T_Callback >, bool > = true>
constexpr	thread (thread_data &td, thread_stack &&tstack, const thread_attr &attr, T_Callback f) noexcept
	Creates a object which represents a new Zephyr thread. More...
constexpr	thread (thread &&other) noexcept
	Move constructor. More...
constexpr thread &	operator= (thread &&other) noexcept
	Move assignment operator. More...
	~thread () noexcept
	Destructor, will abort the thread. More...
constexpr	operator bool () const noexcept
	check if this object manages a thread More...
constexpr void	detach () noexcept
	Detach this object from the thread. More...
auto	wakeup () noexcept
	wakeup the thread this object mamages. More...
auto	start () noexcept
	start the thread this object mamages. More...
auto	abort () noexcept
	abort the thread this object mamages. More...
auto	resume () noexcept
	resume the thread this object mamages. More...
auto	join () noexcept
	join the thread this object mamages. More...
auto	suspend () noexcept
	suspend the thread this object mamages. More...
auto	priority () noexcept
	Get priority of the thread this object mamages. More...
auto	set_priority (thread_prio prio) const noexcept
	Set priority of the thread this object mamages. More...
auto	set_name (const char *name) noexcept
	Set name of the thread this object mamages. More...
auto	name () const noexcept
	Get name of the thread this object mamages. More...
	thread (const thread &)=delete
thread &	operator= (const thread &)=delete

Detailed Description

The class thread repecents a single Zephyr thread.

Definition at line 147 of file thread.hpp.

Constructor & Destructor Documentation

thread() [1/7]

constexpr zpp::thread::thread ( )

inlineconstexprnoexcept

Creates a object which doesn't represent a Zephyr thread.

Definition at line 199 of file thread.hpp.

  {
  }

thread() [2/7]

constexpr zpp::thread::thread ( thread_id  tid )

inlineexplicitconstexprnoexcept

Creates a object which represents Zephyr thread with tid.

Parameters

tid	The ID to manage

Definition at line 208 of file thread.hpp.

    : m_tid(tid)
  {
  }

thread() [3/7]

template<typename T_Heap , typename T_Callback , typename... T_CallbackArgs, std::enable_if_t< std::is_nothrow_invocable_v< T_Callback, T_CallbackArgs... >, bool > = true>

constexpr zpp::thread::thread ( thread_data &  td, thread_stack &&  tstack, const thread_attr &  attr, T_Heap *  heap, T_Callback &&  f, T_CallbackArgs &&...  args  )

inlineconstexprnoexcept

Creates a object which represents a new Zephyr thread.

Parameters

tcb	The TCB to use
attr	The creation attributes to use
f	The thread entry point
args	The arguments to pass to f

Definition at line 224 of file thread.hpp.

  {
    typedef typename std::decay<T_Heap>::type CallInfoHeap;
    typedef typename std::decay<T_Callback>::type CallInfoF;
    typedef std::tuple<typename std::decay<T_CallbackArgs>::type...> CallInfoArgs;
 
    static_assert(std::is_invocable_v<T_Callback, T_CallbackArgs...>);
    static_assert(std::is_nothrow_invocable_v<T_Callback, T_CallbackArgs...>);
 
    struct call_info {
      CallInfoHeap* m_heap;
      CallInfoF     m_f;
      CallInfoArgs  m_args;
    };
 
    void* vp = heap->try_allocate(sizeof(call_info), alignof(call_info));
 
    if (vp != nullptr) {
 
      auto cip = std::construct_at(reinterpret_cast<call_info*>(vp),
                    heap,
                    decay_copy(std::forward<T_Callback>(f)),
                    decay_copy(std::forward_as_tuple(args...)));
 
      __ASSERT_NO_MSG(cip != nullptr);
 
      auto tid = k_thread_create(
            td.native_handle(),
            tstack.data(),
            tstack.size(),
            &callback_helper<call_info>,
            reinterpret_cast<void*>(cip),
            nullptr,
            nullptr,
            attr.native_prio(),
            attr.native_options(),
            attr.native_delay());
 
      m_tid = thread_id(tid);
    }
  }

References zpp::decay_copy(), and zpp::base_heap< T_Heap >::try_allocate().

thread() [4/7]

template<typename T_Callback , typename T_CallbackArg , std::enable_if_t< std::is_nothrow_invocable_v< T_Callback, T_CallbackArg >, bool > = true>

constexpr zpp::thread::thread ( thread_data &  td, thread_stack &&  tstack, const thread_attr &  attr, T_Callback  f, T_CallbackArg  arg  )

inlineconstexprnoexcept

Creates a object which represents a new Zephyr thread.

Parameters

tcb	The TCB to use
attr	The creation attributes to use
f	The thread entry point
args	The arguments to pass to f

Definition at line 284 of file thread.hpp.

  {
    using func_t = void (*)(T_CallbackArg) noexcept;
 
    static_assert(sizeof(T_CallbackArg) <= sizeof(void*));
    static_assert(std::is_invocable_v<T_Callback, T_CallbackArg>);
    static_assert(std::is_nothrow_invocable_v<T_Callback, T_CallbackArg>);
    static_assert(std::is_invocable_v<func_t, T_CallbackArg>);
    static_assert(std::is_nothrow_invocable_v<func_t, T_CallbackArg>);
    static_assert(sizeof(func_t) <= sizeof(void*));
    static_assert(alignof(T_CallbackArg) <= alignof(void*));
    static_assert(std::is_trivial_v<T_CallbackArg>);
 
    func_t fp = f;
 
    void* arg_vp{};
    std::construct_at(reinterpret_cast<T_CallbackArg*>(&arg_vp), arg);
 
    auto tid = k_thread_create(
          td.native_handle(),
          tstack.data(),
          tstack.size(),
          &callback_helper<func_t, T_CallbackArg>,
          reinterpret_cast<void*>(fp),
          arg_vp,
          nullptr,
          attr.native_prio(),
          attr.native_options(),
          attr.native_delay());
 
    m_tid = thread_id(tid);
  }

thread() [5/7]

template<typename T_Callback , std::enable_if_t< std::is_nothrow_invocable_v< T_Callback >, bool > = true>

constexpr zpp::thread::thread ( thread_data &  td, thread_stack &&  tstack, const thread_attr &  attr, T_Callback  f  )

inlineconstexprnoexcept

Creates a object which represents a new Zephyr thread.

Parameters

tcb	The TCB to use
attr	The creation attributes to use
f	The thread entry point
args	The arguments to pass to f

Definition at line 334 of file thread.hpp.

  {
    using func_t = void (*)() noexcept;
 
    static_assert(std::is_invocable_v<T_Callback>);
    static_assert(std::is_nothrow_invocable_v<T_Callback>);
    static_assert(std::is_invocable_v<func_t>);
    static_assert(std::is_nothrow_invocable_v<func_t>);
    static_assert(sizeof(func_t) <= sizeof(void*));
 
    func_t fp = f;
 
    auto tid = k_thread_create(
          td.native_handle(),
          tstack.data(),
          tstack.size(),
          &callback_helper_void<func_t>,
          reinterpret_cast<void*>(fp),
          nullptr,
          nullptr,
          attr.native_prio(),
          attr.native_options(),
          attr.native_delay());
 
    m_tid = thread_id(tid);
  }

thread() [6/7]

constexpr zpp::thread::thread ( thread &&  other )

inlineconstexprnoexcept

Move constructor.

Parameters

other

the thread to move to this thread object, after the move other will not manage the thread anymore

Definition at line 372 of file thread.hpp.

    : m_tid(other.m_tid)
  {
    other.m_tid = thread_id::any();
  }

References zpp::thread_id::any().

~thread()

zpp::thread::~thread ( )

inlinenoexcept

Destructor, will abort the thread.

Definition at line 395 of file thread.hpp.

  {
    if (m_tid) {
      k_thread_abort(m_tid.native_handle());
    }
  }

thread() [7/7]

zpp::thread::thread ( const thread &  )

delete

Member Function Documentation

abort()

auto zpp::thread::abort ( )

inlinenoexcept

abort the thread this object mamages.

Definition at line 452 of file thread.hpp.

  {
    result<void, error_code> res(error_result(error_code::k_inval));
 
    if (m_tid) {
      k_thread_abort(m_tid.native_handle());
      m_tid = thread_id::any();
      res.assign_value();
    }
 
    return res;
  }

References zpp::thread_id::any(), zpp::result< T_Ok, T_Error >::assign_value(), and zpp::k_inval.

detach()

constexpr void zpp::thread::detach ( )

inlineconstexprnoexcept

Detach this object from the thread.

Definition at line 414 of file thread.hpp.

  {
    m_tid = thread_id::any();
  }

References zpp::thread_id::any().

join()

auto zpp::thread::join ( )

inlinenoexcept

join the thread this object mamages.

Definition at line 483 of file thread.hpp.

  {
    result<void, error_code> res(error_result(error_code::k_inval));
 
    if (m_tid) {
      auto rc = k_thread_join(m_tid.native_handle(), K_FOREVER);
      if (rc == 0) {
        res.assign_value();
      } else {
        res.assign_error(to_error_code(-rc));
      }
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_error(), zpp::result< T_Ok, T_Error >::assign_value(), zpp::k_inval, and zpp::to_error_code().

Referenced by ZTEST().

name()

auto zpp::thread::name ( ) const

inlinenoexcept

Get name of the thread this object mamages.

Returns

The thread name or nullptr

Definition at line 573 of file thread.hpp.

  {
    result<const char*, error_code> res(error_result(error_code::k_inval));
 
    if (m_tid) {
      auto rc = k_thread_name_get(m_tid.native_handle());
      if (rc == nullptr) {
        res.assign_error(error_code::k_notsup); // TODO
      } else {
        res.assign_value(rc);
      }
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_error(), zpp::result< T_Ok, T_Error >::assign_value(), zpp::k_inval, and zpp::k_notsup.

operator bool()

constexpr zpp::thread::operator bool ( ) const

inlineexplicitconstexprnoexcept

check if this object manages a thread

Returns

true if this object manages a thread

Definition at line 407 of file thread.hpp.

                                                    {
    return !!m_tid;
  }

operator=() [1/2]

thread& zpp::thread::operator= ( const thread &  )

delete

operator=() [2/2]

constexpr thread& zpp::thread::operator= ( thread &&  other )

inlineconstexprnoexcept

Move assignment operator.

Parameters

other

the thread to move to this thread object, after the move other will not manage the thread anymore

Definition at line 384 of file thread.hpp.

  {
    m_tid = other.m_tid;
    other.m_tid = thread_id::any();
 
    return *this;
  }

References zpp::thread_id::any().

priority()

auto zpp::thread::priority ( )

inlinenoexcept

Get priority of the thread this object mamages.

Returns

Thread priority

Definition at line 519 of file thread.hpp.

  {
    result<thread_prio, error_code> res(error_result(error_code::k_inval));
 
    if (m_tid) {
      res = thread_prio( k_thread_priority_get(m_tid.native_handle()) );
    }
 
    return res;
  }

References zpp::k_inval.

resume()

auto zpp::thread::resume ( )

inlinenoexcept

resume the thread this object mamages.

Definition at line 468 of file thread.hpp.

  {
    result<void, error_code> res(error_result(error_code::k_inval));
 
    if (m_tid) {
      k_thread_resume(m_tid.native_handle());
      res.assign_value();
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_value(), and zpp::k_inval.

set_name()

auto zpp::thread::set_name ( const char *  name )

inlinenoexcept

Set name of the thread this object mamages.

Parameters

name	The new thread name

Definition at line 552 of file thread.hpp.

  {
    result<void, error_code> res(error_result(error_code::k_inval));
 
    if (m_tid) {
      auto rc = k_thread_name_set(m_tid.native_handle(), name);
      if (rc == 0) {
        res.assign_value();
      } else {
        res.assign_error(to_error_code(-rc));
      }
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_error(), zpp::result< T_Ok, T_Error >::assign_value(), zpp::k_inval, and zpp::to_error_code().

set_priority()

auto zpp::thread::set_priority ( thread_prio  prio ) const

inlinenoexcept

Set priority of the thread this object mamages.

Parameters

prio	The new thread priority

Definition at line 535 of file thread.hpp.

  {
    result<void, error_code> res(error_result(error_code::k_inval));
 
    if (m_tid) {
      k_thread_priority_set(m_tid.native_handle(), prio.native_value());
      res.assign_value();
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_value(), and zpp::k_inval.

start()

auto zpp::thread::start ( )

inlinenoexcept

start the thread this object mamages.

Definition at line 437 of file thread.hpp.

  {
    result<void, error_code> res(error_result(error_code::k_inval));
 
    if (m_tid) {
      k_thread_start(m_tid.native_handle());
      res.assign_value();
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_value(), and zpp::k_inval.

suspend()

auto zpp::thread::suspend ( )

inlinenoexcept

suspend the thread this object mamages.

Definition at line 502 of file thread.hpp.

  {
    result<void, error_code> res(error_result(error_code::k_inval));
 
    if (m_tid) {
      k_thread_suspend(m_tid.native_handle());
      res.assign_value();
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_value(), and zpp::k_inval.

wakeup()

auto zpp::thread::wakeup ( )

inlinenoexcept

wakeup the thread this object mamages.

Definition at line 422 of file thread.hpp.

  {
    result<void, error_code> res(error_result(error_code::k_inval));
 
    if (m_tid) {
      k_wakeup(m_tid.native_handle());
      res.assign_value();
    }
 
    return res;
  }

References zpp::result< T_Ok, T_Error >::assign_value(), and zpp::k_inval.

---

The documentation for this class was generated from the following file:

• include/zpp/thread.hpp