eventgroup.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
 
#include <ove/eventgroup.h>
#include <ove/types.hpp>
#include <ove/error.hpp>
 
#ifdef CONFIG_OVE_EVENTGROUP
 
namespace ove
{
 
class EventGroup
{
      public:
    EventGroup()
    {
#ifdef CONFIG_OVE_ZERO_HEAP
        int err = ove_eventgroup_init(&handle_, &storage_);
#else
        int err = ove_eventgroup_create(&handle_);
#endif
        OVE_STATIC_INIT_ASSERT(err == OVE_OK);
    }
 
    ~EventGroup() noexcept
    {
        if (!handle_)
            return;
#ifdef CONFIG_OVE_ZERO_HEAP
        ove_eventgroup_deinit(handle_);
#else
        ove_eventgroup_destroy(handle_);
#endif
    }
 
    EventGroup(const EventGroup &) = delete;
    EventGroup &operator=(const EventGroup &) = delete;
 
#ifdef CONFIG_OVE_ZERO_HEAP
    EventGroup(EventGroup &&) = delete;
    EventGroup &operator=(EventGroup &&) = delete;
#else
    EventGroup(EventGroup &&other) noexcept : handle_(other.handle_)
    {
        other.handle_ = nullptr;
    }
 
    EventGroup &operator=(EventGroup &&other) noexcept
    {
        if (this != &other) {
            if (handle_)
                ove_eventgroup_destroy(handle_);
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }
#endif
 
    [[nodiscard]] ove_eventbits_t set_bits(ove_eventbits_t bits)
    {
        return ove_eventgroup_set_bits(handle_, bits);
    }
 
    [[nodiscard]] ove_eventbits_t clear_bits(ove_eventbits_t bits)
    {
        return ove_eventgroup_clear_bits(handle_, bits);
    }
 
    [[nodiscard]] Result<ove_eventbits_t> wait_bits(ove_eventbits_t bits, uint32_t flags,
                            std::chrono::nanoseconds timeout) noexcept
    {
        ove_eventbits_t result = 0;
        const int rc = ove_eventgroup_wait_bits(handle_, bits, flags,
                            to_timeout_ns(timeout), &result);
        return from_rc(rc, result);
    }
 
    [[nodiscard]] Result<ove_eventbits_t>
    wait_bits_until(ove_eventbits_t bits, uint32_t flags,
            steady_clock::time_point deadline) noexcept
    {
        ove_eventbits_t result = 0;
        const int rc = ove_eventgroup_wait_bits_until(handle_, bits, flags,
                                  to_deadline_ns(deadline), &result);
        return from_rc(rc, result);
    }
 
    [[nodiscard]] ove_eventbits_t set_bits_from_isr(ove_eventbits_t bits)
    {
        return ove_eventgroup_set_bits_from_isr(handle_, bits);
    }
 
    ove_eventbits_t get_bits() const
    {
        return ove_eventgroup_get_bits(handle_);
    }
 
    bool valid() const
    {
        return handle_ != nullptr;
    }
 
    ove_eventgroup_t handle() const
    {
        return handle_;
    }
 
      private:
    ove_eventgroup_t handle_ = nullptr;
#ifdef CONFIG_OVE_ZERO_HEAP
    ove_eventgroup_storage_t storage_ = {};
#endif
};
 
} // namespace ove
 
#endif /* CONFIG_OVE_EVENTGROUP */