action_client.hpp

Go to the documentation of this file.

// nros-cpp: Action client class
// Freestanding C++ — no exceptions, no STL required
 
#ifndef NROS_CPP_ACTION_CLIENT_HPP
#define NROS_CPP_ACTION_CLIENT_HPP
 
#include <cstdint>
#include <cstddef>
#include <string.h>
 
#include "nros/config.hpp"
#include "nros/result.hpp"
#include "nros/future.hpp"
#include "nros/stream.hpp"
 
// Phase 118.D: FFI declarations sourced from cbindgen-generated
// `nros_cpp_ffi.h`. cbindgen renders Rust `*const [u8; 16]` /
// `*mut [u8; 16]` parameters as C++ pointer-to-array
// (`const uint8_t (*goal_id)[16]`); member-function bodies below
// take `goal_id` as a 16-byte array (decays to `uint8_t*`) and
// `reinterpret_cast` at the call site to bridge the two ABI
// equivalent shapes.
#include "nros_cpp_ffi.h"
 
extern "C" {
typedef void (*nros_cpp_action_client_goal_response_callback_t)(bool accepted,
                                                                const uint8_t goal_id[16],
                                                                void* ctx);
typedef void (*nros_cpp_action_client_feedback_callback_t)(const uint8_t goal_id[16],
                                                           const uint8_t* data, size_t len,
                                                           void* ctx);
typedef void (*nros_cpp_action_client_result_callback_t)(const uint8_t goal_id[16], int32_t status,
                                                         const uint8_t* data, size_t len,
                                                         void* ctx);
 
nros_cpp_ret_t nros_cpp_action_client_set_callbacks(
    void* handle, nros_cpp_action_client_goal_response_callback_t goal_response,
    nros_cpp_action_client_feedback_callback_t feedback,
    nros_cpp_action_client_result_callback_t result, void* context);
} // extern "C"
 
namespace nros {
 
template <typename A> class ActionClient {
  public:
    using GoalType = typename A::Goal;
    using ResultType = typename A::Result;
    using FeedbackType = typename A::Feedback;
 
    struct GoalAccept {
        uint8_t goal_id[16];
        bool accepted;
 
        static const size_t SERIALIZED_SIZE_MAX = 32;
        static int ffi_deserialize(const uint8_t* data, size_t len, GoalAccept* out) {
            if (!out || len < 17) return -1;
            for (int i = 0; i < 16; ++i)
                out->goal_id[i] = data[i];
            out->accepted = data[16] != 0;
            return 0;
        }
    };
 
    Result send_goal(const GoalType& goal, uint8_t goal_id[16]) {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
 
        uint8_t buf[GoalType::SERIALIZED_SIZE_MAX];
        size_t len = 0;
        if (GoalType::ffi_serialize(&goal, buf, sizeof(buf), &len) != 0) {
            return Result(ErrorCode::Error);
        }
        return Result(nros_cpp_action_client_send_goal(storage_, buf, len,
                                                       reinterpret_cast<uint8_t(*)[16]>(goal_id)));
    }
 
    Result get_result(const uint8_t goal_id[16], ResultType& result) {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
 
        uint8_t buf[ResultType::SERIALIZED_SIZE_MAX];
        size_t len = 0;
        nros_cpp_ret_t ret = nros_cpp_action_client_get_result(
            storage_, executor_, reinterpret_cast<const uint8_t(*)[16]>(goal_id), buf, sizeof(buf),
            &len);
        if (ret != 0) return Result(ret);
 
        if (ResultType::ffi_deserialize(buf, len, &result) != 0) {
            return Result(ErrorCode::Error);
        }
        return Result::success();
    }
 
    // =================================================================
    // Future-based API — non-blocking, polled via Future<T>
    // =================================================================
 
    Future<GoalAccept> send_goal_future(const GoalType& goal) {
        if (!initialized_) return Future<GoalAccept>();
 
        uint8_t buf[GoalType::SERIALIZED_SIZE_MAX];
        size_t len = 0;
        if (GoalType::ffi_serialize(&goal, buf, sizeof(buf), &len) != 0) {
            return Future<GoalAccept>();
        }
 
        uint8_t goal_id[16];
        nros_cpp_ret_t ret = nros_cpp_action_client_send_goal_async(
            storage_, buf, len, reinterpret_cast<uint8_t(*)[16]>(goal_id));
        if (ret != 0) return Future<GoalAccept>();
 
        return Future<GoalAccept>(storage_, &nros_cpp_action_client_try_recv_goal_response,
                                  0 // slot 0 (single outstanding goal request)
        );
    }
 
    Future<ResultType> get_result_future(const uint8_t goal_id[16]) {
        if (!initialized_) return Future<ResultType>();
 
        nros_cpp_ret_t ret = nros_cpp_action_client_get_result_async(
            storage_, reinterpret_cast<const uint8_t(*)[16]>(goal_id));
        if (ret != 0) return Future<ResultType>();
 
        return Future<ResultType>(storage_, &nros_cpp_action_client_try_recv_result,
                                  0 // slot 0 (single outstanding result request)
        );
    }
 
    Result try_recv_feedback(FeedbackType& feedback) {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
 
        uint8_t buf[FeedbackType::SERIALIZED_SIZE_MAX];
        size_t len = 0;
        nros_cpp_ret_t ret =
            nros_cpp_action_client_try_recv_feedback(storage_, buf, sizeof(buf), &len);
        if (ret != 0) return Result(ret);
        if (len == 0) return Result(ErrorCode::TryAgain);
        if (FeedbackType::ffi_deserialize(buf, len, &feedback) != 0) {
            return Result(ErrorCode::Error);
        }
        return Result::success();
    }
 
    Stream<FeedbackType>& feedback_stream() {
        if (initialized_ && !feedback_stream_.is_valid()) {
            feedback_stream_.bind(storage_, &nros_cpp_action_client_try_recv_feedback);
        }
        return feedback_stream_;
    }
 
    const Stream<FeedbackType>& feedback_stream() const { return feedback_stream_; }
 
    // =================================================================
    // Async (non-blocking) API — callbacks invoked during spin_once()
    // =================================================================
 
    struct SendGoalOptions {
        void (*goal_response)(bool accepted, const uint8_t goal_id[16], void* ctx);
        void (*feedback)(const uint8_t goal_id[16], const uint8_t* data, size_t len, void* ctx);
        void (*result)(const uint8_t goal_id[16], int32_t status, const uint8_t* data, size_t len,
                       void* ctx);
        void* context;
 
        SendGoalOptions() : goal_response(0), feedback(0), result(0), context(0) {}
    };
 
    Result send_goal_async(const GoalType& goal, uint8_t goal_id[16]) {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
 
        uint8_t buf[GoalType::SERIALIZED_SIZE_MAX];
        size_t len = 0;
        if (GoalType::ffi_serialize(&goal, buf, sizeof(buf), &len) != 0) {
            return Result(ErrorCode::Error);
        }
        return Result(nros_cpp_action_client_send_goal_async(
            storage_, buf, len, reinterpret_cast<uint8_t(*)[16]>(goal_id)));
    }
 
    Result get_result_async(const uint8_t goal_id[16]) {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
        return Result(nros_cpp_action_client_get_result_async(
            storage_, reinterpret_cast<const uint8_t(*)[16]>(goal_id)));
    }
 
    Result set_callbacks(const SendGoalOptions& options) {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
        return Result(nros_cpp_action_client_set_callbacks(
            storage_, options.goal_response, options.feedback, options.result, options.context));
    }
 
    void poll() {
        if (!initialized_) return;
        nros_cpp_action_client_poll(storage_);
    }
 
    bool is_valid() const { return initialized_; }
 
    ~ActionClient() {
        if (initialized_) {
            nros_cpp_action_client_destroy(storage_);
            initialized_ = false;
        }
        feedback_stream_ = Stream<FeedbackType>();
    }
 
    // Move semantics (non-copyable). Relocation goes through the
    // `nros_cpp_action_client_relocate` runtime call (Phase 84.C1).
    // The feedback stream is rebound to the new storage afterwards.
    ActionClient(ActionClient&& other)
        : executor_(other.executor_), initialized_(other.initialized_) {
        if (other.initialized_) {
            nros_cpp_action_client_relocate(other.storage_, storage_);
            other.initialized_ = false;
        }
        other.feedback_stream_ = Stream<FeedbackType>();
    }
 
    ActionClient& operator=(ActionClient&& other) {
        if (this != &other) {
            if (initialized_) {
                nros_cpp_action_client_destroy(storage_);
                feedback_stream_ = Stream<FeedbackType>();
            }
            executor_ = other.executor_;
            initialized_ = other.initialized_;
            if (other.initialized_) {
                nros_cpp_action_client_relocate(other.storage_, storage_);
                other.initialized_ = false;
            }
            other.feedback_stream_ = Stream<FeedbackType>();
        }
        return *this;
    }
 
    ActionClient() : executor_(nullptr), initialized_(false) {}
 
  private:
    ActionClient(const ActionClient&) = delete;
    ActionClient& operator=(const ActionClient&) = delete;
 
    friend class Node;
 
    alignas(8) uint8_t storage_[NROS_CPP_ACTION_CLIENT_STORAGE_SIZE];
    void* executor_; // Stashed executor handle (Phase 82) for blocking helpers
    bool initialized_;
    Stream<FeedbackType> feedback_stream_;
    // Phase 87.6: action name buffer moved C++-side.
    char action_name_[256] = {};
};
 
} // namespace nros
 
// Phase 84.G8: out-of-line definition of Node::create_action_client<A>().
#include "nros/node.hpp"
 
namespace nros {
 
template <typename A>
Result Node::create_action_client(ActionClient<A>& out, const char* action_name, const QoS& qos) {
    if (!initialized_) return Result(ErrorCode::NotInitialized);
    nros_cpp_qos_t ffi_qos;
    ffi_qos.reliability = static_cast<nros_cpp_qos_reliability_t>(qos.reliability_raw());
    ffi_qos.durability = static_cast<nros_cpp_qos_durability_t>(qos.durability_raw());
    ffi_qos.history = static_cast<nros_cpp_qos_history_t>(qos.history_raw());
    ffi_qos.liveliness_kind = static_cast<nros_cpp_qos_liveliness_t>(qos.liveliness_raw());
    ffi_qos.depth = qos.depth();
    ffi_qos.deadline_ms = qos.deadline_ms();
    ffi_qos.lifespan_ms = qos.lifespan_ms();
    ffi_qos.liveliness_lease_ms = qos.liveliness_lease_ms();
    ffi_qos.avoid_ros_namespace_conventions = qos.avoid_ros_namespace_conventions() ? 1 : 0;
    nros_cpp_ret_t ret = nros_cpp_action_client_create(&handle_, action_name, A::TYPE_NAME,
                                                       A::Goal::TYPE_HASH, ffi_qos, out.storage_);
    if (ret == 0) {
        // Phase 87.6: action_name buffer lives C++-side now.
        size_t name_len = 0;
        while (action_name[name_len] != '\0' && name_len + 1 < sizeof(out.action_name_)) {
            out.action_name_[name_len] = action_name[name_len];
            ++name_len;
        }
        out.action_name_[name_len] = '\0';
        out.executor_ = executor_handle_;
        out.initialized_ = true;
    }
    return Result(ret);
}
 
} // namespace nros
 
#endif // NROS_CPP_ACTION_CLIENT_HPP