workqueue.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2026 Kamil Lulko <kamil.lulko@gmail.com>
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * This file is part of oveRTOS.
 */
 
#pragma once
 
#ifdef CONFIG_OVE_WORKQUEUE
 
#include <ove/workqueue.h>
#include <ove/types.hpp>
#include <ove/error.hpp>
 
namespace ove
{
 
template <typename F>
concept WorkHandler = std::convertible_to<F, ove_work_fn>;
 
template <size_t StackSize = 0> class Workqueue
{
      public:
    Workqueue(const char *name, ove_prio_t prio)
        requires(StackSize > 0)
    {
#ifdef CONFIG_OVE_ZERO_HEAP
        static_assert(StackSize > 0, "StackSize must be > 0 in zero-heap mode");
        int err = ove_workqueue_init(&handle_, &storage_, name, prio, StackSize, stack_);
#else
        int err = ove_workqueue_create(&handle_, name, prio, StackSize);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~Workqueue() noexcept
    {
        if (!handle_)
            return;
#ifdef CONFIG_OVE_ZERO_HEAP
        ove_workqueue_deinit(handle_);
#else
        ove_workqueue_destroy(handle_);
#endif
    }
 
    Workqueue(const Workqueue &) = delete;
    Workqueue &operator=(const Workqueue &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    Workqueue(Workqueue &&) = delete;
    Workqueue &operator=(Workqueue &&) = delete;
#else
    Workqueue(Workqueue &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    Workqueue &operator=(Workqueue &&other) noexcept
    {
        if (this != &other) {
            if (handle_)
                ove_workqueue_destroy(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_workqueue_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_workqueue_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_workqueue_storage_t storage_ = {};
    OVE_THREAD_STACK_MEMBER_(stack_, StackSize > 0 ? StackSize : 1);
#endif
};
 
class Work
{
      public:
    template <typename F>
    explicit Work(F handler)
        requires WorkHandler<F>
    {
#ifdef CONFIG_OVE_ZERO_HEAP
        int err = ove_work_init_static(&handle_, &storage_, handler);
#else
        int err = ove_work_init(&handle_, handler);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~Work() noexcept
    {
        if (!handle_)
            return;
#ifndef CONFIG_OVE_ZERO_HEAP
        ove_work_free(handle_);
#endif
    }
 
    Work(const Work &) = delete;
    Work &operator=(const Work &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    Work(Work &&) = delete;
    Work &operator=(Work &&) = delete;
#else
    Work(Work &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    Work &operator=(Work &&other) noexcept
    {
        if (this != &other) {
            if (handle_)
                ove_work_free(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    template <size_t S> [[nodiscard]] Result<void> submit(Workqueue<S> &wq) noexcept
    {
        return from_rc(ove_work_submit(wq.handle(), handle_));
    }
 
    template <size_t S>
    [[nodiscard]] Result<void> submit_delayed(Workqueue<S> &wq, uint32_t delay_ms) noexcept
    {
        return from_rc(ove_work_submit_delayed(wq.handle(), handle_, delay_ms));
    }
 
    [[nodiscard]] Result<void> cancel() noexcept
    {
        return from_rc(ove_work_cancel(handle_));
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_work_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_work_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_work_storage_t storage_ = {};
#endif
};
 
} /* namespace ove */
 
#endif /* CONFIG_OVE_WORKQUEUE */