executor.hpp

Go to the documentation of this file.

// nros-cpp: Executor class
// Freestanding C++ — no exceptions, no STL required
 
#ifndef NROS_CPP_EXECUTOR_HPP
#define NROS_CPP_EXECUTOR_HPP
 
#include <cstdint>
#include <cstddef>
 
#include "nros/result.hpp"
#include "nros/nros_cpp_config_generated.h"
 
#include "nros_cpp_ffi.h"
 
namespace nros {
 
// Forward declarations
class Node;
class NodeBuilder;
 
class Executor {
  public:
    Executor() : storage_(), initialized_(false) {}
 
    static Result create(Executor& out, const char* locator = nullptr, uint8_t domain_id = 0) {
        return create(out, locator, domain_id, "nros_cpp");
    }
 
    static Result create(Executor& out, const char* locator, uint8_t domain_id,
                         const char* session_name) {
        // -3 = NROS_CPP_RET_INVALID_ARGUMENT (generated header).
        if (session_name == nullptr) {
            return Result(-3);
        }
        nros_cpp_ret_t ret = nros_cpp_init(locator, domain_id, session_name, nullptr, out.storage_);
        if (ret == 0) {
            out.initialized_ = true;
        }
        return Result(ret);
    }
 
    Result create_node(Node& out, const char* name, const char* ns = nullptr);
 
    NodeBuilder node_builder(const char* name);
 
    Result spin_once(int32_t timeout_ms = 10) {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
        return Result(nros_cpp_spin_once(storage_, timeout_ms));
    }
 
    Result ping(int32_t timeout_ms) {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
        return Result(nros_cpp_executor_ping(storage_, timeout_ms));
    }
 
    Result spin(uint32_t duration_ms, int32_t poll_ms = 10) {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
        // Phase 118.C: budget by wall-clock. Iteration-count budgeting
        // (`elapsed += timeout`) breaks when `nros_cpp_spin_once` returns
        // early on a signaled condvar — the loop collapses into
        // milliseconds. Same fix Future::wait() got in Phase 89.2.
        const uint64_t start_ns = nros_cpp_time_ns();
        const uint64_t budget_ns = static_cast<uint64_t>(duration_ms) * 1000000ULL;
        Result last = Result::success();
        while (true) {
            last = Result(nros_cpp_spin_once(storage_, poll_ms));
            if (!last.ok()) return last;
            const uint64_t now_ns = nros_cpp_time_ns();
            if (now_ns - start_ns >= budget_ns) break;
        }
        return last;
    }
 
    bool ok() const { return initialized_; }
 
    void* handle() { return storage_; }
 
    Result shutdown() {
        if (!initialized_) return Result::success();
        nros_cpp_ret_t ret = nros_cpp_fini(storage_);
        initialized_ = false;
        return Result(ret);
    }
 
    ~Executor() {
        if (initialized_) {
            nros_cpp_fini(storage_);
            initialized_ = false;
        }
    }
 
    // Move semantics (non-copyable)
    Executor(Executor&& other) : initialized_(other.initialized_) {
        for (unsigned i = 0; i < sizeof(storage_); ++i) {
            storage_[i] = other.storage_[i];
            other.storage_[i] = 0;
        }
        other.initialized_ = false;
    }
 
    Executor& operator=(Executor&& other) {
        if (this != &other) {
            if (initialized_) {
                nros_cpp_fini(storage_);
            }
            for (unsigned i = 0; i < sizeof(storage_); ++i) {
                storage_[i] = other.storage_[i];
                other.storage_[i] = 0;
            }
            initialized_ = other.initialized_;
            other.initialized_ = false;
        }
        return *this;
    }
 
  private:
    Executor(const Executor&) = delete;
    Executor& operator=(const Executor&) = delete;
 
    alignas(8) uint8_t storage_[NROS_CPP_EXECUTOR_STORAGE_SIZE];
    bool initialized_;
};
 
} // namespace nros
 
#endif // NROS_CPP_EXECUTOR_HPP