guard_condition.hpp

Go to the documentation of this file.

// nros-cpp: Guard condition class
// Freestanding C++ — no exceptions, no STL required
 
#ifndef NROS_RCLCPP_GUARD_CONDITION_HPP
#define NROS_RCLCPP_GUARD_CONDITION_HPP
 
#include <cstdint>
#include <cstddef>
 
#include "rclcpp/detail/config.hpp"
#include "rclcpp/result.hpp"
#include "rclcpp/detail/hosted_block.hpp"
 
#include "rclcpp/detail/nros_cpp_ffi.h"
 
// phase-427 W7 — `Node` is DEFINED in `rclcpp::` (RFC-0089: that namespace is
// the home). The friend declaration below is qualified, and a qualified friend
// names an existing entity rather than introducing one, so the name has to be
// declared first — and in `rclcpp::`, because an elaborated `class Node;` in
// `rclcpp::` would declare a second, distinct class.
namespace rclcpp {
class Node;
}
 
namespace rclcpp {
 
class GuardCondition {
  public:
    Result trigger() {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
        return Result(nros_cpp_guard_condition_trigger(storage_));
    }
 
    bool is_valid() const { return initialized_; }
 
    bool is_triggered() const {
        if (!initialized_) return false;
        return nros_cpp_guard_condition_is_triggered(storage_);
    }
 
    Result clear() {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
        return Result(nros_cpp_guard_condition_clear(storage_));
    }
 
    ~GuardCondition() {
        release();
        // The closure block (if any) is freed here, after the entry that could
        // call into it.
        detail::destroy_hosted_block(closure_);
    }
 
    // Move semantics (non-copyable). Relocation goes through the
    // `nros_cpp_guard_condition_relocate` runtime call (Phase 84.C1).
    GuardCondition(GuardCondition&& other)
        : initialized_(other.initialized_), closure_(other.closure_), executor_(other.executor_),
          handle_id_(other.handle_id_) {
        if (other.initialized_) {
            nros_cpp_guard_condition_relocate(other.storage_, storage_);
            other.initialized_ = false;
        }
        other.closure_ = nullptr;
        other.executor_ = nullptr;
        other.handle_id_ = 0;
    }
 
    GuardCondition& operator=(GuardCondition&& other) {
        if (this != &other) {
            release();
            if (other.initialized_) {
                nros_cpp_guard_condition_relocate(other.storage_, storage_);
                initialized_ = true;
                other.initialized_ = false;
            }
            executor_ = other.executor_;
            handle_id_ = other.handle_id_;
            other.executor_ = nullptr;
            other.handle_id_ = 0;
            detail::destroy_hosted_block(closure_);
            closure_ = other.closure_;
            other.closure_ = nullptr;
        }
        return *this;
    }
 
    GuardCondition()
        : storage_(), initialized_(false), closure_(nullptr), executor_(nullptr), handle_id_(0) {}
 
    void attach_closure_block(detail::HostedBlockBase* block) {
        detail::destroy_hosted_block(closure_);
        closure_ = block;
    }
 
  private:
    void release() {
        if (initialized_) {
            if (executor_ != nullptr) {
                (void)nros_cpp_guard_condition_release(executor_, handle_id_);
            }
            nros_cpp_guard_condition_destroy(storage_);
            initialized_ = false;
        }
        executor_ = nullptr;
        handle_id_ = 0;
    }
 
    GuardCondition(const GuardCondition&) = delete;
    GuardCondition& operator=(const GuardCondition&) = delete;
 
    friend class ::rclcpp::Node;
 
    alignas(8) uint8_t storage_[NROS_GUARD_CONDITION_SIZE];
    bool initialized_;
 
    void* closure_;
 
    void* executor_;
    size_t handle_id_;
};
 
} // namespace rclcpp
 
#endif // NROS_RCLCPP_GUARD_CONDITION_HPP