types.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/ove.h>
#include <cstdint>
#include <cstddef>
#include <chrono>
#include <concepts>
#include <type_traits>
#include <utility>
 
namespace ove
{
 
/* ------------------------------------------------------------------ */
/*  C++20 Concepts                                                    */
/* ------------------------------------------------------------------ */
 
template <typename F>
concept ThreadEntry = std::convertible_to<F, void (*)(void *)>;
 
/* ------------------------------------------------------------------ */
/*  Compile-time C-ABI shape check                                    */
/* ------------------------------------------------------------------ */
/*
 * Pin the OVE_ERR_* numeric values at compile time.  Mirrors Rust's
 * `_assert_codes_match()` (bindings/rust/ove/src/error.rs:127-150)
 * and Zig's `comptime { std.debug.assert(...) }` block
 * (bindings/zig/ove/src/error.zig:88-102).  If a future C-header
 * rename or renumber drifts an OVE_ERR_* value, every C++ TU that
 * includes <ove/types.hpp> (i.e. every TU in apps/cpp and the C++
 * binding) fails to build with a clear message — the silent-drift
 * surface that bit Rust's mangled-name audit is closed at the C++
 * boundary too.
 */
static_assert(OVE_ERR_NOT_REGISTERED == -1, "OVE_ERR_NOT_REGISTERED drifted");
static_assert(OVE_ERR_INVALID_PARAM == -2, "OVE_ERR_INVALID_PARAM drifted");
static_assert(OVE_ERR_NO_MEMORY == -3, "OVE_ERR_NO_MEMORY drifted");
static_assert(OVE_ERR_TIMEOUT == -4, "OVE_ERR_TIMEOUT drifted");
static_assert(OVE_ERR_NOT_SUPPORTED == -5, "OVE_ERR_NOT_SUPPORTED drifted");
static_assert(OVE_ERR_QUEUE_FULL == -6, "OVE_ERR_QUEUE_FULL drifted");
static_assert(OVE_ERR_ML_FAILED == -7, "OVE_ERR_ML_FAILED drifted");
static_assert(OVE_ERR_NET_REFUSED == -8, "OVE_ERR_NET_REFUSED drifted");
static_assert(OVE_ERR_NET_UNREACHABLE == -9, "OVE_ERR_NET_UNREACHABLE drifted");
static_assert(OVE_ERR_NET_ADDR_IN_USE == -10, "OVE_ERR_NET_ADDR_IN_USE drifted");
static_assert(OVE_ERR_NET_RESET == -11, "OVE_ERR_NET_RESET drifted");
static_assert(OVE_ERR_NET_DNS_FAIL == -12, "OVE_ERR_NET_DNS_FAIL drifted");
static_assert(OVE_ERR_NET_CLOSED == -13, "OVE_ERR_NET_CLOSED drifted");
static_assert(OVE_ERR_BUS_NACK == -14, "OVE_ERR_BUS_NACK drifted");
static_assert(OVE_ERR_BUS_BUSY == -15, "OVE_ERR_BUS_BUSY drifted");
static_assert(OVE_ERR_BUS_ERROR == -16, "OVE_ERR_BUS_ERROR drifted");
static_assert(OVE_ERR_QUEUE_EMPTY == -17, "OVE_ERR_QUEUE_EMPTY drifted");
static_assert(OVE_ERR_WOULD_BLOCK == -18, "OVE_ERR_WOULD_BLOCK drifted");
static_assert(OVE_ERR_EOF == -19, "OVE_ERR_EOF drifted");
static_assert(OVE_ERR_INVAL == -20, "OVE_ERR_INVAL drifted");
static_assert(OVE_ERR_NOT_FOUND == -21, "OVE_ERR_NOT_FOUND drifted");
 
/* ------------------------------------------------------------------ */
/*  Duration / timeout types                                          */
/* ------------------------------------------------------------------ */
 
inline constexpr std::chrono::nanoseconds wait_forever = std::chrono::nanoseconds::max();
 
template <typename Rep, typename Period>
inline constexpr uint64_t to_timeout_ns(std::chrono::duration<Rep, Period> d) noexcept
{
    const auto ns = std::chrono::duration_cast<std::chrono::nanoseconds>(d);
    if (ns.count() < 0)
        return 0u;
    if (ns == std::chrono::nanoseconds::max())
        return OVE_WAIT_FOREVER;
    return static_cast<uint64_t>(ns.count());
}
 
struct steady_clock {
    using duration = std::chrono::nanoseconds;
    using rep = duration::rep;
    using period = duration::period;
    using time_point = std::chrono::time_point<steady_clock>;
    static constexpr bool is_steady = true;
 
    static time_point now() noexcept
    {
        return time_point(duration(ove_time_now_steady_ns()));
    }
};
 
inline constexpr uint64_t to_deadline_ns(steady_clock::time_point tp) noexcept
{
    const auto since_epoch = tp.time_since_epoch();
    if (since_epoch == std::chrono::nanoseconds::max())
        return OVE_WAIT_FOREVER;
    if (since_epoch.count() < 0)
        return 0u;
    return static_cast<uint64_t>(since_epoch.count());
}
 
} // namespace ove