nros.hpp

Go to the documentation of this file.

// nros-cpp: Umbrella header
// Include this single header to get the full nros C++ API.
//
// Freestanding C++ compatible — no STL, no exceptions, no RTTI required.
 
#ifndef NROS_CPP_HPP
#define NROS_CPP_HPP
 
// Phase 118.D — pull cbindgen-generated FFI before any wrapper hpp so
// `nros/qos.hpp`'s `#ifndef NROS_CPP_FFI_H` guard skips its local
// fallback definitions in favor of the canonical types.
#include "nros_cpp_ffi.h"
 
#include "nros/log.hpp"
#include "nros/result.hpp"
// Issue 0789 — the clock / time / duration surface. `node.now()` and
// `node.get_clock()->now()` are what a ported rclcpp publisher calls to
// stamp a header, so the umbrella carries all three. Phase 379 W5 moved
// `duration.hpp` ABOVE `qos.hpp`: the QoS deadline / lifespan / lease
// accessors take and return `nros::Duration`. `qos.hpp` also includes it
// directly, so this order is legibility rather than load-bearing.
#include "nros/duration.hpp"
#include "nros/time.hpp"
#include "nros/clock.hpp"
#include "nros/qos.hpp"
#include "nros/options.hpp"
#include "nros/future.hpp"
#include "nros/stream.hpp"
// RFC-0088 D5 — nros::SerializationFormat / format_of<M> / linked_format().
#include "nros/serialization_format.hpp"
// Phase 84.G8: node.hpp no longer pulls in the heavy entity headers —
// each entity header carries its own out-of-line `Node::create_X<>()`
// template definition. The umbrella pulls in every entity explicitly so
// `#include <nros/nros.hpp>` still yields the full API.
#include "nros/node.hpp"
#include "nros/publisher.hpp"
#include "nros/subscription.hpp"
#include "nros/service.hpp"
#include "nros/client.hpp"
#include "nros/action_server.hpp"
#include "nros/action_client.hpp"
#include "nros/polling_action_server.hpp"
#include "nros/polling_action_client.hpp"
#include "nros/polling_subscription.hpp"
#include "nros/parameter.hpp"
#include "nros/tick_ctx.hpp"
#include "nros/lifecycle.hpp"
 
namespace nros {
 
inline void* global_handle() {
    if (!Node::global_initialized()) return nullptr;
    return Node::global_storage();
}
 
inline Result spin_once(int32_t timeout_ms = 10) {
    if (!Node::global_initialized()) {
        return Result(ErrorCode::NotInitialized);
    }
    return Result(nros_cpp_spin_once(Node::global_storage(), timeout_ms));
}
 
inline Result pre_shutdown(ShutdownCallback callback, void* context = nullptr,
                           PreShutdownCallbackHandle* out = nullptr) {
    void* executor = global_handle();
    if (executor == nullptr) {
        return Result(ErrorCode::NotInitialized);
    }
    nros_cpp_shutdown_callback_handle_t raw = NROS_CPP_SHUTDOWN_CALLBACK_HANDLE_INVALID;
    nros_cpp_ret_t ret = nros_cpp_add_pre_shutdown_callback(executor, callback, context, &raw);
    if (out != nullptr) *out = PreShutdownCallbackHandle(raw);
    return Result(ret);
}
 
inline Result on_shutdown(ShutdownCallback callback, void* context = nullptr,
                          OnShutdownCallbackHandle* out = nullptr) {
    void* executor = global_handle();
    if (executor == nullptr) {
        return Result(ErrorCode::NotInitialized);
    }
    nros_cpp_shutdown_callback_handle_t raw = NROS_CPP_SHUTDOWN_CALLBACK_HANDLE_INVALID;
    nros_cpp_ret_t ret = nros_cpp_add_on_shutdown_callback(executor, callback, context, &raw);
    if (out != nullptr) *out = OnShutdownCallbackHandle(raw);
    return Result(ret);
}
 
inline bool remove_pre_shutdown_callback(PreShutdownCallbackHandle handle) {
    void* executor = global_handle();
    if (executor == nullptr) return false;
    return nros_cpp_remove_pre_shutdown_callback(executor, handle.value()) == 0;
}
 
inline bool remove_on_shutdown_callback(OnShutdownCallbackHandle handle) {
    void* executor = global_handle();
    if (executor == nullptr) return false;
    return nros_cpp_remove_on_shutdown_callback(executor, handle.value()) == 0;
}
 
inline Result spin() {
    if (!Node::global_initialized()) {
        return Result(ErrorCode::NotInitialized);
    }
    Result last = Result::success();
    while (ok()) {
        last = Result(nros_cpp_spin_once(Node::global_storage(), 10));
        if (!last.ok()) return last;
    }
    return last;
}
 
inline Result spin(uint32_t duration_ms, int32_t poll_ms = 10) {
    if (!Node::global_initialized()) {
        return Result(ErrorCode::NotInitialized);
    }
    // Issue 0329 — forward to the single budgeted-spin CFFI entry point. This
    // loop previously budgeted by ITERATION count (`elapsed += timeout`), which
    // collapsed to milliseconds when `spin_once` returned early on a signaled
    // wake — the exact bug `Executor::spin` fixed in Phase 118.C. The correct
    // wall-clock budget now lives once, Rust-side, in `nros_cpp_spin_for`.
    return Result(nros_cpp_spin_for(Node::global_storage(), duration_ms, poll_ms));
}
 
} // namespace nros
 
#ifdef NROS_CPP_STD
#include "nros/std_compat.hpp"
#endif
 
#endif // NROS_CPP_HPP