rmw_vtable.h

Go to the documentation of this file.

#ifndef NROS_RMW_VTABLE_H
#define NROS_RMW_VTABLE_H
 
#include <stdint.h>
#include <stddef.h>
 
#include "nros/rmw_ret.h"
#include "nros/rmw_entity.h"
#include "nros/rmw_event.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct nros_rmw_vtable_t {
    /* ---- Session lifecycle ---- */
    nros_rmw_ret_t (*open)(const char *locator, uint8_t mode,
                           uint32_t domain_id, const char *node_name,
                           nros_rmw_session_t *out);
    nros_rmw_ret_t (*close)(nros_rmw_session_t *session);
    nros_rmw_ret_t (*drive_io)(nros_rmw_session_t *session, int32_t timeout_ms);
 
    /* ---- Publisher ---- */
    nros_rmw_ret_t (*create_publisher)(nros_rmw_session_t *session,
        const char *topic_name, const char *type_name, const char *type_hash,
        uint32_t domain_id, const nros_rmw_qos_t *qos,
        nros_rmw_publisher_t *out);
    void (*destroy_publisher)(nros_rmw_publisher_t *publisher);
    nros_rmw_ret_t (*publish_raw)(nros_rmw_publisher_t *publisher,
        const uint8_t *data, size_t len);
 
    /* ---- Subscriber ---- */
    nros_rmw_ret_t (*create_subscriber)(nros_rmw_session_t *session,
        const char *topic_name, const char *type_name, const char *type_hash,
        uint32_t domain_id, const nros_rmw_qos_t *qos,
        nros_rmw_subscriber_t *out);
    void (*destroy_subscriber)(nros_rmw_subscriber_t *subscriber);
    int32_t (*try_recv_raw)(nros_rmw_subscriber_t *subscriber,
        uint8_t *buf, size_t buf_len);
    int32_t (*has_data)(nros_rmw_subscriber_t *subscriber);
 
    /* ---- Service Server ---- */
    /* Phase 193.1b — `qos` applies to both the request + reply endpoints
       (one profile per service, mirrors create_publisher/subscriber). */
    nros_rmw_ret_t (*create_service_server)(nros_rmw_session_t *session,
        const char *service_name, const char *type_name, const char *type_hash,
        uint32_t domain_id, const nros_rmw_qos_t *qos,
        nros_rmw_service_server_t *out);
    void (*destroy_service_server)(nros_rmw_service_server_t *server);
    int32_t (*try_recv_request)(nros_rmw_service_server_t *server,
        uint8_t *buf, size_t buf_len, int64_t *seq_out);
    int32_t (*has_request)(nros_rmw_service_server_t *server);
    nros_rmw_ret_t (*send_reply)(nros_rmw_service_server_t *server,
        int64_t seq, const uint8_t *data, size_t len);
 
    /* ---- Service Client ---- */
    nros_rmw_ret_t (*create_service_client)(nros_rmw_session_t *session,
        const char *service_name, const char *type_name, const char *type_hash,
        uint32_t domain_id, const nros_rmw_qos_t *qos,
        nros_rmw_service_client_t *out);
    void (*destroy_service_client)(nros_rmw_service_client_t *client);
    int32_t (*call_raw)(nros_rmw_service_client_t *client,
        const uint8_t *request, size_t req_len,
        uint8_t *reply_buf, size_t reply_buf_len);
 
    nros_rmw_ret_t (*send_request_raw)(nros_rmw_service_client_t *client,
        const uint8_t *request, size_t req_len);
 
    int32_t (*try_recv_reply_raw)(nros_rmw_service_client_t *client,
        uint8_t *reply_buf, size_t reply_buf_len);
 
    /* ---- Phase 108 — status events (optional) ---- */
    nros_rmw_ret_t (*register_subscriber_event)(
        nros_rmw_subscriber_t *subscriber,
        nros_rmw_event_kind_t  kind,
        uint32_t               deadline_ms,
        nros_rmw_event_callback_t cb,
        void                  *user_context);
 
    nros_rmw_ret_t (*register_publisher_event)(
        nros_rmw_publisher_t  *publisher,
        nros_rmw_event_kind_t  kind,
        uint32_t               deadline_ms,
        nros_rmw_event_callback_t cb,
        void                  *user_context);
 
    nros_rmw_ret_t (*assert_publisher_liveliness)(
        nros_rmw_publisher_t *publisher);
 
    int32_t (*next_deadline_ms)(const nros_rmw_session_t *session);
 
    nros_rmw_ret_t (*set_wake_callback)(nros_rmw_session_t *session,
                                         void (*cb)(void *ctx),
                                         void *ctx);
 
    nros_rmw_ret_t (*pub_loan)(nros_rmw_publisher_t *publisher,
                                size_t                requested_len,
                                uint8_t             **out_buf,
                                size_t               *out_cap,
                                void                **out_token);
 
    nros_rmw_ret_t (*pub_commit)(nros_rmw_publisher_t *publisher,
                                  void                 *token,
                                  size_t                actual_len);
 
    void (*pub_discard)(nros_rmw_publisher_t *publisher, void *token);
 
    int32_t (*sub_borrow)(nros_rmw_subscriber_t *subscriber,
                           const uint8_t        **out_buf,
                           size_t                *out_len,
                           void                 **out_token);
 
    void (*sub_release)(nros_rmw_subscriber_t *subscriber, void *token);
 
    int32_t (*service_server_available)(
        nros_rmw_service_client_t *client);
 
    int32_t (*try_recv_sequence)(nros_rmw_subscriber_t *subscriber,
                                  uint8_t              *buf,
                                  size_t                per_msg_cap,
                                  size_t                max_msgs,
                                  size_t               *out_lens);
 
    nros_rmw_ret_t (*publish_streamed)(
        nros_rmw_publisher_t *publisher,
        void (*size_cb)(size_t *out_total_len, void *user_ctx),
        void (*chunk_cb)(uint8_t *out_buf, size_t cap,
                         size_t *out_written, void *user_ctx),
        void *user_ctx);
 
    nros_rmw_ret_t (*ping_session)(
        nros_rmw_session_t *session,
        int32_t             timeout_ms);
 
    /* ---- Phase 231 (RFC-0038) — zero-copy in-place subscription take ---- */
 
    int32_t (*subscriber_supports_in_place)(
        nros_rmw_subscriber_t *subscriber);
 
    int32_t (*process_raw_in_place)(
        nros_rmw_subscriber_t *subscriber,
        void                  *ctx,
        void                 (*cb)(void *ctx, const uint8_t *ptr, size_t len));
} nros_rmw_vtable_t;
 
nros_rmw_ret_t nros_rmw_cffi_register(const nros_rmw_vtable_t *vtable);
 
nros_rmw_ret_t nros_rmw_cffi_register_named(const char *name,
                                            const nros_rmw_vtable_t *vtable);
 
const nros_rmw_vtable_t *nros_rmw_cffi_lookup(const char *name);
 
size_t nros_rmw_cffi_registered_names(const char **buf, size_t cap);
 
size_t nros_rmw_cffi_walk_init_section(void);
 
#if (defined(__GNUC__) || defined(__clang__)) && !defined(__ZEPHYR__) &&       \
    !defined(__NuttX__) && !defined(ESP_PLATFORM) && !defined(__VXWORKS__)
#define NROS_RMW_REGISTER_BACKEND(REGISTER_FN)                                 \
    __attribute__((constructor)) static void nros_rmw_ctor_##REGISTER_FN(      \
        void) {                                                                \
        (void) REGISTER_FN();                                                  \
    }
#else
/* Embedded / unsupported toolchain: board calls nros_rmw_<x>_register(). */
#define NROS_RMW_REGISTER_BACKEND(REGISTER_FN)
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* NROS_RMW_VTABLE_H */