service.hpp

Go to the documentation of this file.

// nros-cpp: Service server class
// Freestanding C++ — no exceptions, no STL required
 
#ifndef NROS_CPP_SERVICE_HPP
#define NROS_CPP_SERVICE_HPP
 
#include <cstdint>
#include <cstddef>
 
#include "nros/config.hpp"
#include "nros/result.hpp"
#include "nros/size_bound.hpp" // nros::rx_buffer_capacity<M> — the receive-buffer size
 
#include "nros_cpp_ffi.h"
 
// Phase 189.M3.3.e — `nros_cpp_service_server_register` is excluded from
// cbindgen (its Rust signature uses `RawServiceCallback`, an external-crate
// type alias cbindgen names without defining). Declare it locally with a plain
// function-pointer typedef matching the ABI (`bool(req, req_len, resp,
// resp_cap, resp_len, ctx)`).
extern "C" {
typedef bool (*nros_cpp_service_request_callback_t)(const uint8_t* req, size_t req_len,
                                                    uint8_t* resp, size_t resp_cap,
                                                    size_t* resp_len, void* ctx);
 
nros_cpp_ret_t nros_cpp_service_server_register(const nros_cpp_node_t* node,
                                                const char* service_name, const char* type_name,
                                                const char* type_hash, nros_cpp_qos_t qos,
                                                nros_cpp_service_request_callback_t callback,
                                                void* context, uint8_t sched_context,
                                                size_t* out_handle_id);
} // extern "C"
 
namespace nros {
 
template <typename S> class Service {
  public:
    using RequestType = typename S::Request;
    using ResponseType = typename S::Response;
 
    using TypedServiceFn = void (*)(const RequestType& request, ResponseType& response);
    using TypedServiceFnWithCtx = void (*)(const RequestType& request, ResponseType& response,
                                           void* ctx);
 
    Result take_request(RequestType& req, int64_t& seq_id) {
        return try_recv_request_sized<::nros::rx_buffer_capacity<RequestType>::value>(req, seq_id);
    }
 
    template <size_t Cap> Result try_recv_request_sized(RequestType& req, int64_t& seq_id) {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
        uint8_t buf[Cap];
        size_t len = 0;
        int64_t seq = 0;
        nros_cpp_ret_t ret =
            nros_cpp_service_server_take_request_raw(storage_, buf, sizeof(buf), &len, &seq);
        if (ret != 0) return Result(ret);
        if (len == 0) return Result(ErrorCode::TryAgain);
        if (RequestType::ffi_deserialize(buf, len, &req) != 0) return Result(ErrorCode::Error);
        seq_id = seq;
        return Result::success();
    }
 
    [[deprecated("Service::try_recv_request is deprecated; use Service::take_request")]] Result
    try_recv_request(RequestType& req, int64_t& seq_id) {
        return take_request(req, seq_id);
    }
 
    Result send_response(int64_t seq_id, const ResponseType& resp) {
        if (!initialized_) return Result(ErrorCode::NotInitialized);
        uint8_t buf[::nros::detail::buffer_bounds<ResponseType>::tx];
        size_t len = 0;
        if (ResponseType::ffi_serialize(&resp, buf, sizeof(buf), &len) != 0) {
            return Result(ErrorCode::Error);
        }
        return Result(nros_cpp_service_server_send_response_raw(storage_, seq_id, buf, len));
    }
 
    [[deprecated("Service::send_reply() is deprecated; use Service::send_response()")]] Result
    send_reply(int64_t seq_id, const ResponseType& resp) {
        return send_response(seq_id, resp);
    }
 
    bool is_valid() const { return initialized_; }
 
    ~Service() {
        if (initialized_ && !callback_mode_) {
            nros_cpp_service_server_destroy(storage_);
        }
        initialized_ = false;
    }
 
    // Move semantics (non-copyable). Poll-style relocation goes through the
    // `nros_cpp_service_server_relocate` runtime call (Phase 84.C1). A
    // callback-style service must NOT be moved after register — the arena holds
    // `this` as the trampoline context (Phase 189.M3.3.e); the move only
    // transfers bookkeeping and leaves that pointer stale, so don't.
    Service(Service&& other)
        : initialized_(other.initialized_), user_fn_(other.user_fn_),
          user_fn_ctx_(other.user_fn_ctx_), user_ctx_(other.user_ctx_),
          handle_id_(other.handle_id_), callback_mode_(other.callback_mode_) {
        if (other.initialized_ && !other.callback_mode_) {
            nros_cpp_service_server_relocate(other.storage_, storage_);
        }
        other.initialized_ = false;
    }
 
    Service& operator=(Service&& other) {
        if (this != &other) {
            if (initialized_ && !callback_mode_) {
                nros_cpp_service_server_destroy(storage_);
            }
            initialized_ = other.initialized_;
            user_fn_ = other.user_fn_;
            user_fn_ctx_ = other.user_fn_ctx_;
            user_ctx_ = other.user_ctx_;
            handle_id_ = other.handle_id_;
            callback_mode_ = other.callback_mode_;
            if (other.initialized_ && !other.callback_mode_) {
                nros_cpp_service_server_relocate(other.storage_, storage_);
            }
            other.initialized_ = false;
        }
        return *this;
    }
 
    Service() : storage_(), initialized_(false) {}
 
    size_t handle_id() const { return handle_id_; }
 
  private:
    Service(const Service&) = delete;
    Service& operator=(const Service&) = delete;
 
    friend class Node;
 
    static bool request_trampoline(const uint8_t* req, size_t req_len, uint8_t* resp,
                                   size_t resp_cap, size_t* resp_len, void* ctx) {
        auto* self = static_cast<Service*>(ctx);
        if (self == nullptr) return false;
        RequestType request;
        if (RequestType::ffi_deserialize(req, req_len, &request) != 0) return false;
        ResponseType response;
        if (self->user_fn_ != nullptr) {
            self->user_fn_(request, response);
        } else if (self->user_fn_ctx_ != nullptr) {
            self->user_fn_ctx_(request, response, self->user_ctx_);
        } else {
            return false;
        }
        size_t len = 0;
        if (ResponseType::ffi_serialize(&response, resp, resp_cap, &len) != 0) return false;
        *resp_len = len;
        return true;
    }
 
    alignas(8) uint8_t storage_[NROS_SERVICE_SERVER_SIZE];
    bool initialized_;
    // Callback-style state (Phase 189.M3.3.e); unused in poll mode.
    TypedServiceFn user_fn_ = nullptr;
    TypedServiceFnWithCtx user_fn_ctx_ = nullptr;
    void* user_ctx_ = nullptr;
    size_t handle_id_ = static_cast<size_t>(-1);
    bool callback_mode_ = false;
};
 
} // namespace nros
 
// Phase 84.G8: out-of-line definition of Node::create_service<S>().
#include "nros/node.hpp"
 
namespace nros {
 
template <typename S>
Result Node::create_service(Service<S>& out, const char* service_name, const QoS& qos) {
    if (!initialized_) return Result(ErrorCode::NotInitialized);
    nros_cpp_qos_t ffi_qos = detail::qos_to_ffi(qos);
    nros_cpp_ret_t ret = nros_cpp_service_server_create(
        &handle_, service_name, S::TYPE_NAME, S::Request::TYPE_HASH, ffi_qos, out.storage_);
    if (ret == 0) {
        out.initialized_ = true;
    }
    return Result(ret);
}
 
// Phase 189.M3.3.e — callback-style (arena-registered) service. The arena owns
// the server + dispatches `out`'s request handler during spin_once, so the
// handle is real and `options.sched_context` is functional.
template <typename S, typename F, typename>
Result Node::create_service(Service<S>& out, const char* service_name, F callback, const QoS& qos,
                            const ServiceOptions& options) {
    if (!initialized_) return Result(ErrorCode::NotInitialized);
    nros_cpp_qos_t ffi_qos = detail::qos_to_ffi(qos);
 
    // Store the user handler (compile error if F isn't convertible).
    out.user_fn_ = typename Service<S>::TypedServiceFn(callback);
    out.user_fn_ctx_ = nullptr;
    out.user_ctx_ = nullptr;
 
    uint8_t sched = (options.sched_context == SCHED_CONTEXT_UNSET)
                        ? 0u
                        : static_cast<uint8_t>(options.sched_context);
    size_t handle = static_cast<size_t>(-1);
    nros_cpp_ret_t ret = nros_cpp_service_server_register(
        &handle_, service_name, S::TYPE_NAME, S::Request::TYPE_HASH, ffi_qos,
        reinterpret_cast<nros_cpp_service_request_callback_t>(&Service<S>::request_trampoline),
        &out, sched, &handle);
    if (ret == 0) {
        out.handle_id_ = handle;
        out.callback_mode_ = true;
        out.initialized_ = true;
    }
    return Result(ret);
}
 
} // namespace nros
 
#endif // NROS_CPP_SERVICE_HPP