nros_generated.h

Go to the documentation of this file.

 
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
 
#include "nros/visibility.h"
#include "nros/nros_config_generated.h"
 
/* Forward declarations for callback typedefs that reference these
 * structs before they appear in source-order output. Without these,
 * gcc treats `struct nros_timer_t *` inside a callback parameter list
 * as a parameter-local incomplete type that doesn't match the later
 * file-scope struct definition. */
#ifdef __cplusplus
extern "C" {
#endif
struct nros_executor_t;
struct nros_node_t;
struct nros_publisher_t;
struct nros_subscription_t;
struct nros_service_t;
struct nros_client_t;
struct nros_timer_t;
struct nros_guard_condition_t;
struct nros_action_server_t;
struct nros_action_client_t;
struct nros_lifecycle_state_machine_t;
struct nros_support_t;
struct nros_clock_t;
struct nros_parameter_t;
struct nros_parameter_server_t;
struct nros_goal_handle_t;
struct nros_goal_uuid_t;
#ifdef __cplusplus
}
#endif
 
 
#ifndef NROS_GENERATED_H
#define NROS_GENERATED_H
 
/* Warning: this file is autogenerated. Don't modify this manually. */
 
#define NROS_MAX_LOCATOR_LEN 128
 
#define NROS_MAX_NAME_LEN 64
 
#define NROS_MAX_NAMESPACE_LEN 128
 
#define MAX_RMW_NAME_LEN 32
 
#define NROS_MAX_TOPIC_LEN 256
 
#define NROS_MAX_SERVICE_NAME_LEN 256
 
#define NROS_MAX_ACTION_NAME_LEN 256
 
#define NROS_MAX_TYPE_NAME_LEN 256
 
#define NROS_MAX_TYPE_HASH_LEN 128
 
#define NROS_MAX_CONCURRENT_GOALS 4
 
#define NROS_SERIALIZATION_FORMAT_ID 1
 
#define NROS_MAX_PARAM_NAME_LEN 64
 
#define NROS_MAX_PARAM_STRING_LEN 128
 
#define NROS_LIFECYCLE_STATE_UNCONFIGURED 1
 
#define NROS_LIFECYCLE_STATE_INACTIVE 2
 
#define NROS_LIFECYCLE_STATE_ACTIVE 3
 
#define NROS_LIFECYCLE_STATE_FINALIZED 4
 
#define NROS_LIFECYCLE_STATE_ERROR_PROCESSING 5
 
#define NROS_LIFECYCLE_TRANSITION_CONFIGURE 1
 
#define NROS_LIFECYCLE_TRANSITION_ACTIVATE 2
 
#define NROS_LIFECYCLE_TRANSITION_DEACTIVATE 3
 
#define NROS_LIFECYCLE_TRANSITION_CLEANUP 4
 
#define NROS_LIFECYCLE_TRANSITION_SHUTDOWN_UNCONFIGURED 5
 
#define NROS_LIFECYCLE_TRANSITION_SHUTDOWN_INACTIVE 6
 
#define NROS_LIFECYCLE_TRANSITION_SHUTDOWN_ACTIVE 7
 
#define NROS_LIFECYCLE_TRANSITION_ERROR_RECOVERY 8
 
#define NROS_LIFECYCLE_RET_OK 0
 
#define NROS_LIFECYCLE_RET_FAILURE 1
 
#define NROS_LIFECYCLE_RET_ERROR 2
 
#define NROS_DOMAIN_ID_INHERIT UINT32_MAX
 
#define NROS_DOMAIN_ID_EXPLICIT_ZERO 255
 
typedef enum nros_clock_type_t {
  NROS_CLOCK_UNINITIALIZED = 0,
  NROS_CLOCK_ROS_TIME = 1,
  NROS_CLOCK_SYSTEM_TIME = 2,
  NROS_CLOCK_STEADY_TIME = 3,
} nros_clock_type_t;
 
typedef enum nros_clock_state_t {
  NROS_CLOCK_STATE_UNINITIALIZED = 0,
  NROS_CLOCK_STATE_READY = 1,
  NROS_CLOCK_STATE_SHUTDOWN = 2,
} nros_clock_state_t;
 
typedef enum nros_parameter_server_state_t {
  NROS_PARAM_SERVER_STATE_UNINITIALIZED = 0,
  NROS_PARAM_SERVER_STATE_READY = 1,
  NROS_PARAM_SERVER_STATE_SHUTDOWN = 2,
} nros_parameter_server_state_t;
 
typedef enum nros_parameter_type_t {
  NROS_PARAMETER_NOT_SET = 0,
  NROS_PARAMETER_BOOL = 1,
  NROS_PARAMETER_INTEGER = 2,
  NROS_PARAMETER_DOUBLE = 3,
  NROS_PARAMETER_STRING = 4,
  NROS_PARAMETER_BYTE_ARRAY = 5,
  NROS_PARAMETER_BOOL_ARRAY = 6,
  NROS_PARAMETER_INTEGER_ARRAY = 7,
  NROS_PARAMETER_DOUBLE_ARRAY = 8,
  NROS_PARAMETER_STRING_ARRAY = 9,
} nros_parameter_type_t;
 
typedef enum nros_executor_state_t {
  NROS_EXECUTOR_STATE_UNINITIALIZED = 0,
  NROS_EXECUTOR_STATE_INITIALIZED = 1,
  NROS_EXECUTOR_STATE_SPINNING = 2,
  NROS_EXECUTOR_STATE_SHUTDOWN = 3,
} nros_executor_state_t;
 
typedef enum nros_executor_semantics_t {
  NROS_SEMANTICS_RCLCPP_EXECUTOR = 0,
  NROS_SEMANTICS_LOGICAL_EXECUTION_TIME = 1,
} nros_executor_semantics_t;
 
typedef enum nros_support_state_t {
  NROS_SUPPORT_STATE_UNINITIALIZED = 0,
  NROS_SUPPORT_STATE_INITIALIZED = 1,
  NROS_SUPPORT_STATE_SHUTDOWN = 2,
} nros_support_state_t;
 
typedef enum nros_action_client_state_t {
  NROS_ACTION_CLIENT_STATE_UNINITIALIZED = 0,
  NROS_ACTION_CLIENT_STATE_INITIALIZED = 1,
  NROS_ACTION_CLIENT_STATE_SHUTDOWN = 2,
  NROS_ACTION_CLIENT_STATE_POLLING = 3,
} nros_action_client_state_t;
 
typedef enum nros_goal_status_t {
  NROS_GOAL_STATUS_UNKNOWN = 0,
  NROS_GOAL_STATUS_ACCEPTED = 1,
  NROS_GOAL_STATUS_EXECUTING = 2,
  NROS_GOAL_STATUS_CANCELING = 3,
  NROS_GOAL_STATUS_SUCCEEDED = 4,
  NROS_GOAL_STATUS_CANCELED = 5,
  NROS_GOAL_STATUS_ABORTED = 6,
} nros_goal_status_t;
 
typedef enum nros_node_state_t {
  NROS_NODE_STATE_UNINITIALIZED = 0,
  NROS_NODE_STATE_INITIALIZED = 1,
  NROS_NODE_STATE_SHUTDOWN = 2,
} nros_node_state_t;
 
typedef enum nros_action_server_state_t {
  NROS_ACTION_SERVER_STATE_UNINITIALIZED = 0,
  NROS_ACTION_SERVER_STATE_INITIALIZED = 1,
  NROS_ACTION_SERVER_STATE_SHUTDOWN = 2,
  NROS_ACTION_SERVER_STATE_POLLING = 3,
} nros_action_server_state_t;
 
typedef enum nros_goal_response_t {
  NROS_GOAL_REJECT = 0,
  NROS_GOAL_ACCEPT_AND_EXECUTE = 1,
  NROS_GOAL_ACCEPT_AND_DEFER = 2,
} nros_goal_response_t;
 
typedef enum nros_cancel_response_t {
  NROS_CANCEL_REJECT = 0,
  NROS_CANCEL_ACCEPT = 1,
} nros_cancel_response_t;
 
typedef enum nros_qos_reliability_t {
  NROS_QOS_RELIABILITY_BEST_EFFORT = 0,
  NROS_QOS_RELIABILITY_RELIABLE = 1,
} nros_qos_reliability_t;
 
typedef enum nros_qos_durability_t {
  NROS_QOS_DURABILITY_VOLATILE = 0,
  NROS_QOS_DURABILITY_TRANSIENT_LOCAL = 1,
} nros_qos_durability_t;
 
typedef enum nros_qos_history_t {
  NROS_QOS_HISTORY_KEEP_LAST = 0,
  NROS_QOS_HISTORY_KEEP_ALL = 1,
} nros_qos_history_t;
 
typedef enum nros_qos_liveliness_t {
  NROS_QOS_LIVELINESS_NONE = 0,
  NROS_QOS_LIVELINESS_AUTOMATIC = 1,
  NROS_QOS_LIVELINESS_MANUAL_BY_TOPIC = 2,
  NROS_QOS_LIVELINESS_MANUAL_BY_NODE = 3,
} nros_qos_liveliness_t;
 
typedef enum nros_cancel_return_code_t {
  NROS_CANCEL_RC_OK = 0,
  NROS_CANCEL_RC_REJECTED = 1,
  NROS_CANCEL_RC_UNKNOWN_GOAL = 2,
  NROS_CANCEL_RC_GOAL_TERMINATED = 3,
} nros_cancel_return_code_t;
 
typedef enum nros_subscription_state_t {
  NROS_SUBSCRIPTION_STATE_UNINITIALIZED = 0,
  NROS_SUBSCRIPTION_STATE_INITIALIZED = 1,
  NROS_SUBSCRIPTION_STATE_SHUTDOWN = 2,
  NROS_SUBSCRIPTION_STATE_POLLING = 3,
} nros_subscription_state_t;
 
typedef enum nros_publisher_state_t {
  NROS_PUBLISHER_STATE_UNINITIALIZED = 0,
  NROS_PUBLISHER_STATE_INITIALIZED = 1,
  NROS_PUBLISHER_STATE_SHUTDOWN = 2,
} nros_publisher_state_t;
 
typedef enum nros_executor_handle_invocation_t {
  NROS_EXECUTOR_ON_NEW_DATA = 0,
  NROS_EXECUTOR_ALWAYS = 1,
} nros_executor_handle_invocation_t;
 
typedef enum nros_timer_state_t {
  NROS_TIMER_STATE_UNINITIALIZED = 0,
  NROS_TIMER_STATE_RUNNING = 1,
  NROS_TIMER_STATE_CANCELED = 2,
  NROS_TIMER_STATE_SHUTDOWN = 3,
} nros_timer_state_t;
 
typedef enum nros_service_state_t {
  NROS_SERVICE_STATE_UNINITIALIZED = 0,
  NROS_SERVICE_STATE_INITIALIZED = 1,
  NROS_SERVICE_STATE_SHUTDOWN = 2,
  NROS_SERVICE_STATE_POLLING = 3,
} nros_service_state_t;
 
typedef enum nros_client_state_t {
  NROS_CLIENT_STATE_UNINITIALIZED = 0,
  NROS_CLIENT_STATE_INITIALIZED = 1,
  NROS_CLIENT_STATE_REGISTERED = 2,
  NROS_CLIENT_STATE_SHUTDOWN = 3,
  NROS_CLIENT_STATE_POLLING = 4,
} nros_client_state_t;
 
typedef enum nros_guard_condition_state_t {
  NROS_GUARD_CONDITION_STATE_UNINITIALIZED = 0,
  NROS_GUARD_CONDITION_STATE_INITIALIZED = 1,
  NROS_GUARD_CONDITION_STATE_SHUTDOWN = 2,
} nros_guard_condition_state_t;
 
enum nros_sched_class_t
#if defined(__cplusplus) || __STDC_VERSION__ >= 202311L
  : uint8_t
#endif // defined(__cplusplus) || __STDC_VERSION__ >= 202311L
 {
  NROS_SCHED_CLASS_FIFO = 0,
  NROS_SCHED_CLASS_EDF = 1,
  NROS_SCHED_CLASS_SPORADIC = 2,
  NROS_SCHED_CLASS_BEST_EFFORT = 3,
  NROS_SCHED_CLASS_TIME_TRIGGERED = 4,
};
#ifndef __cplusplus
#if __STDC_VERSION__ >= 202311L
typedef enum nros_sched_class_t nros_sched_class_t;
#else
typedef uint8_t nros_sched_class_t;
#endif // __STDC_VERSION__ >= 202311L
#endif // __cplusplus
 
enum nros_sched_priority_t
#if defined(__cplusplus) || __STDC_VERSION__ >= 202311L
  : uint8_t
#endif // defined(__cplusplus) || __STDC_VERSION__ >= 202311L
 {
  NROS_SCHED_PRIORITY_CRITICAL = 0,
  NROS_SCHED_PRIORITY_NORMAL = 1,
  NROS_SCHED_PRIORITY_BEST_EFFORT = 2,
};
#ifndef __cplusplus
#if __STDC_VERSION__ >= 202311L
typedef enum nros_sched_priority_t nros_sched_priority_t;
#else
typedef uint8_t nros_sched_priority_t;
#endif // __STDC_VERSION__ >= 202311L
#endif // __cplusplus
 
enum nros_deadline_policy_t
#if defined(__cplusplus) || __STDC_VERSION__ >= 202311L
  : uint8_t
#endif // defined(__cplusplus) || __STDC_VERSION__ >= 202311L
 {
  NROS_DEADLINE_POLICY_RELEASED = 0,
  NROS_DEADLINE_POLICY_ACTIVATED = 1,
  NROS_DEADLINE_POLICY_INHERITED = 2,
};
#ifndef __cplusplus
#if __STDC_VERSION__ >= 202311L
typedef enum nros_deadline_policy_t nros_deadline_policy_t;
#else
typedef uint8_t nros_deadline_policy_t;
#endif // __STDC_VERSION__ >= 202311L
#endif // __cplusplus
 
typedef struct nros_clock_t {
  enum nros_clock_type_t type;
  enum nros_clock_state_t state;
  uint64_t _steady_epoch_ns;
} nros_clock_t;
 
typedef int nros_ret_t;
 
typedef struct nros_time_t {
  int32_t sec;
  uint32_t nanosec;
} nros_time_t;
 
typedef struct nros_duration_t {
  int32_t sec;
  uint32_t nanosec;
} nros_duration_t;
 
typedef struct nros_parameter_array_t {
  const void *data;
  size_t len;
} nros_parameter_array_t;
 
typedef union nros_parameter_value_t {
  bool bool_value;
  int64_t integer_value;
  double double_value;
  uint8_t string_value[NROS_MAX_PARAM_STRING_LEN];
  struct nros_parameter_array_t array_value;
} nros_parameter_value_t;
 
typedef struct nros_parameter_t {
  uint8_t name[NROS_MAX_PARAM_NAME_LEN];
  enum nros_parameter_type_t type;
  union nros_parameter_value_t value;
} nros_parameter_t;
 
typedef bool (*nros_parameter_callback_t)(const char *name,
                                          const struct nros_parameter_t *param,
                                          void *context);
 
typedef struct nros_parameter_server_t {
  enum nros_parameter_server_state_t state;
  size_t capacity;
  size_t count;
  struct nros_parameter_t *parameters;
  nros_parameter_callback_t callback;
  void *callback_context;
} nros_parameter_server_t;
 
typedef struct nros_support_t {
  enum nros_support_state_t state;
  uint8_t domain_id;
  uint8_t locator[NROS_MAX_LOCATOR_LEN];
  size_t locator_len;
  uint64_t _opaque[SESSION_OPAQUE_U64S];
} nros_support_t;
 
typedef bool (*nros_executor_trigger_t)(const bool *ready, size_t count, void *context);
 
typedef struct nros_executor_t {
  enum nros_executor_state_t state;
  uint64_t timeout_ns;
  enum nros_executor_semantics_t semantics;
  const struct nros_support_t *support;
  nros_executor_trigger_t trigger;
  void *trigger_context;
  size_t handle_count;
  size_t max_handles;
  size_t subscription_count;
  size_t timer_count;
  size_t service_count;
  uint64_t invocation_time_ns;
  bool in_dispatch;
  uint64_t _opaque[EXECUTOR_OPAQUE_U64S];
} nros_executor_t;
 
typedef struct nros_transport_ops_t {
  uint32_t abi_version;
  uint32_t _reserved;
  void *user_data;
  nros_ret_t (*open)(void *user_data, const void *params);
  void (*close)(void *user_data);
  nros_ret_t (*write)(void *user_data, const uint8_t *buf, size_t len);
  int32_t (*read)(void *user_data, uint8_t *buf, size_t len, uint32_t timeout_ms);
} nros_transport_ops_t;
 
typedef struct nros_goal_uuid_t {
  uint8_t uuid[16];
} nros_goal_uuid_t;
 
typedef void (*nros_goal_response_callback_t)(const struct nros_goal_uuid_t *goal_uuid,
                                              bool accepted,
                                              void *context);
 
typedef void (*nros_feedback_callback_t)(const struct nros_goal_uuid_t *goal_uuid,
                                         const uint8_t *feedback,
                                         size_t feedback_len,
                                         void *context);
 
typedef void (*nros_result_callback_t)(const struct nros_goal_uuid_t *goal_uuid,
                                       enum nros_goal_status_t status,
                                       const uint8_t *result,
                                       size_t result_len,
                                       void *context);
 
typedef struct nros_node_ref_t {
  uint8_t node_id;
  uint32_t generation;
} nros_node_ref_t;
 
typedef uint8_t nros_sched_context_id_t;
 
typedef struct ActionClientInternal {
  int32_t arena_entry_index;
  void *executor_ptr;
} ActionClientInternal;
 
typedef struct nros_action_client_t {
  enum nros_action_client_state_t state;
  uint8_t action_name[NROS_MAX_ACTION_NAME_LEN];
  size_t action_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  nros_goal_response_callback_t goal_response_callback;
  nros_feedback_callback_t feedback_callback;
  nros_result_callback_t result_callback;
  void *context;
  struct nros_node_ref_t node;
  nros_sched_context_id_t sched_context_id;
  struct ActionClientInternal _internal;
  uint64_t _opaque[ACTION_CLIENT_OPAQUE_U64S];
} nros_action_client_t;
 
typedef struct nros_qos_override_t {
  const char *topic;
  uint8_t role;
  uint8_t policy;
  uint32_t value;
} nros_qos_override_t;
 
typedef struct nros_node_t {
  enum nros_node_state_t state;
  uint8_t name[NROS_MAX_NAME_LEN];
  size_t name_len;
  uint8_t namespace_[NROS_MAX_NAMESPACE_LEN];
  size_t namespace_len;
  const struct nros_support_t *support;
  uint8_t rmw_name[MAX_RMW_NAME_LEN];
  size_t rmw_name_len;
  uint32_t domain_id_override;
  uint8_t sched_context_id;
  uint8_t _reserved[3];
  uint8_t node_id;
  const struct nros_executor_t *executor;
  const struct nros_qos_override_t *qos_overrides;
  size_t qos_overrides_len;
} nros_node_t;
 
typedef struct nros_action_type_t {
  const char *type_name;
  const char *type_hash;
  size_t goal_serialized_size_max;
  size_t result_serialized_size_max;
  size_t feedback_serialized_size_max;
} nros_action_type_t;
 
typedef struct nros_action_client_options_t {
  nros_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} nros_action_client_options_t;
 
typedef struct nros_wake_state_t {
  uint64_t _opaque[2];
} nros_wake_state_t;
 
typedef struct nros_goal_handle_t {
  struct nros_goal_uuid_t uuid;
} nros_goal_handle_t;
 
typedef enum nros_goal_response_t (*nros_goal_callback_t)(struct nros_action_server_t *server,
                                                          const struct nros_goal_handle_t *goal,
                                                          const uint8_t *goal_request,
                                                          size_t goal_len,
                                                          void *context);
 
typedef enum nros_cancel_response_t (*nros_cancel_callback_t)(struct nros_action_server_t *server,
                                                              const struct nros_goal_handle_t *goal,
                                                              void *context);
 
typedef void (*nros_accepted_callback_t)(struct nros_action_server_t *server,
                                         const struct nros_goal_handle_t *goal,
                                         void *context);
 
typedef struct nros_qos_t {
  enum nros_qos_reliability_t reliability;
  enum nros_qos_durability_t durability;
  enum nros_qos_history_t history;
  enum nros_qos_liveliness_t liveliness_kind;
  int depth;
  uint32_t deadline_ms;
  uint32_t lifespan_ms;
  uint32_t liveliness_lease_ms;
  uint8_t avoid_ros_namespace_conventions;
  uint8_t tx_express;
} nros_qos_t;
 
typedef struct ActionServerInternal {
  ActionServerRawHandle handle;
  void *executor_ptr;
  enum nros_goal_response_t (*c_goal_callback)(struct nros_action_server_t*,
                                               const struct nros_goal_handle_t*,
                                               const uint8_t*,
                                               size_t,
                                               void*);
  nros_cancel_callback_t c_cancel_callback;
  nros_accepted_callback_t c_accepted_callback;
  void *c_context;
  struct nros_action_server_t *server_ptr;
} ActionServerInternal;
 
typedef struct nros_action_server_t {
  enum nros_action_server_state_t state;
  uint8_t action_name[NROS_MAX_ACTION_NAME_LEN];
  size_t action_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  nros_goal_callback_t goal_callback;
  nros_cancel_callback_t cancel_callback;
  nros_accepted_callback_t accepted_callback;
  void *context;
  struct nros_node_ref_t node;
  struct nros_qos_t qos;
  nros_sched_context_id_t sched_context_id;
  struct ActionServerInternal _internal;
  uint64_t _opaque[ACTION_SERVER_OPAQUE_U64S];
} nros_action_server_t;
 
typedef struct nros_action_server_options_t {
  nros_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} nros_action_server_options_t;
 
typedef void (*nros_subscription_callback_t)(const uint8_t *data, size_t len, void *context);
 
typedef struct nros_subscription_t {
  enum nros_subscription_state_t state;
  uint8_t topic_name[NROS_MAX_TOPIC_LEN];
  size_t topic_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  nros_subscription_callback_t callback;
  void *context;
  struct nros_node_ref_t node;
  struct nros_qos_t qos;
  size_t handle_id;
  nros_sched_context_id_t sched_context_id;
  uint64_t _opaque[SUBSCRIPTION_OPAQUE_U64S];
} nros_subscription_t;
 
typedef struct nros_liveliness_changed_status_t {
  uint16_t alive_count;
  uint16_t not_alive_count;
  int16_t alive_count_change;
  int16_t not_alive_count_change;
} nros_liveliness_changed_status_t;
 
typedef void (*nros_event_liveliness_changed_cb_t)(struct nros_subscription_t *sub,
                                                   struct nros_liveliness_changed_status_t status,
                                                   void *user_context);
 
typedef struct nros_count_status_t {
  uint32_t total_count;
  uint32_t total_count_change;
} nros_count_status_t;
 
typedef void (*nros_event_subscriber_count_cb_t)(struct nros_subscription_t *sub,
                                                 struct nros_count_status_t status,
                                                 void *user_context);
 
typedef struct nros_publisher_t {
  enum nros_publisher_state_t state;
  uint8_t topic_name[NROS_MAX_TOPIC_LEN];
  size_t topic_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  struct nros_node_ref_t node;
  uint64_t _opaque[PUBLISHER_OPAQUE_U64S];
} nros_publisher_t;
 
typedef void (*nros_event_publisher_count_cb_t)(struct nros_publisher_t *pub_,
                                                struct nros_count_status_t status,
                                                void *user_context);
 
typedef bool (*nros_node_visit_fn)(void *ctx,
                                   const char *node_name,
                                   const char *node_namespace,
                                   const char *enclave);
 
typedef bool (*nros_names_and_types_visit_fn)(void *ctx,
                                              const char *name,
                                              const char *const *types,
                                              size_t types_count);
 
typedef struct nros_endpoint_info_t {
  const char *node_name;
  const char *node_namespace;
  const char *topic_type;
  bool is_publisher;
  uint8_t endpoint_gid[24];
} nros_endpoint_info_t;
 
typedef bool (*nros_endpoint_info_visit_fn)(void *ctx, const struct nros_endpoint_info_t *info);
 
typedef struct nros_node_options_t {
  uint8_t namespace_[NROS_MAX_NAMESPACE_LEN];
  size_t namespace_len;
  uint8_t rmw_name[MAX_RMW_NAME_LEN];
  size_t rmw_name_len;
  uint8_t locator[NROS_MAX_LOCATOR_LEN];
  size_t locator_len;
  uint32_t domain_id_override;
  uint8_t sched_context_id;
  uint8_t _reserved[3];
} nros_node_options_t;
 
typedef void (*nros_subscription_info_callback_t)(const uint8_t *data,
                                                  size_t len,
                                                  const uint8_t *attachment,
                                                  size_t attachment_len,
                                                  void *context);
 
typedef void (*nros_timer_callback_t)(struct nros_timer_t *timer, void *context);
 
typedef struct nros_timer_t {
  enum nros_timer_state_t state;
  uint64_t period_ns;
  uint64_t last_call_time_ns;
  nros_timer_callback_t callback;
  void *context;
  const struct nros_support_t *support;
  size_t handle_id;
  void *_executor;
} nros_timer_t;
 
typedef bool (*nros_service_callback_t)(const uint8_t *request_data,
                                        size_t request_len,
                                        uint8_t *response_data,
                                        size_t response_capacity,
                                        size_t *response_len,
                                        void *context);
 
typedef struct ServiceServerInternal {
  int32_t arena_entry_index;
  void *executor_ptr;
} ServiceServerInternal;
 
typedef struct nros_service_t {
  enum nros_service_state_t state;
  uint8_t service_name[NROS_MAX_SERVICE_NAME_LEN];
  size_t service_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  nros_service_callback_t callback;
  void *context;
  struct nros_node_ref_t node;
  struct nros_qos_t qos;
  nros_sched_context_id_t sched_context_id;
  struct ServiceServerInternal _internal;
  uint64_t _opaque[SERVICE_SERVER_OPAQUE_U64S];
} nros_service_t;
 
typedef void (*nros_response_callback_t)(const uint8_t *response, size_t response_len, void *context);
 
typedef struct ServiceClientInternal {
  int32_t arena_entry_index;
  void *executor_ptr;
  uint32_t timeout_ms;
} ServiceClientInternal;
 
typedef struct nros_client_t {
  enum nros_client_state_t state;
  uint8_t service_name[NROS_MAX_SERVICE_NAME_LEN];
  size_t service_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  nros_response_callback_t response_callback;
  void *context;
  struct nros_node_ref_t node;
  struct nros_qos_t qos;
  nros_sched_context_id_t sched_context_id;
  struct ServiceClientInternal _internal;
  uint64_t _opaque[SERVICE_CLIENT_OPAQUE_U64S];
} nros_client_t;
 
typedef void (*nros_guard_condition_callback_t)(void *context);
 
typedef struct nros_guard_condition_t {
  enum nros_guard_condition_state_t state;
  bool triggered;
  nros_guard_condition_callback_t callback;
  void *context;
  const struct nros_support_t *_support;
  size_t handle_id;
  bool _guard_valid;
  uint64_t _guard_opaque[GUARD_HANDLE_OPAQUE_U64S];
} nros_guard_condition_t;
 
typedef struct nros_sched_context_t {
  nros_sched_class_t class_;
  nros_sched_priority_t priority;
  nros_deadline_policy_t deadline_policy;
  uint32_t period_us;
  uint32_t budget_us;
  uint32_t deadline_us;
  uint8_t os_pri;
  uint32_t tt_window_offset_us;
  uint32_t tt_window_duration_us;
} nros_sched_context_t;
 
typedef void (*nros_shutdown_callback_t)(void *context);
 
typedef uint32_t nros_shutdown_callback_handle_t;
 
typedef struct nros_lifecycle_state_machine_t {
  bool initialized;
  uint8_t _pad[7];
  uint64_t storage[NROS_LIFECYCLE_CTX_OPAQUE_U64S];
} nros_lifecycle_state_machine_t;
 
typedef uint8_t (*nros_lifecycle_callback_t)(void *context);
 
typedef struct nros_publisher_options_t {
  uint8_t _reserved[4];
} nros_publisher_options_t;
 
typedef struct nros_message_type_t {
  const char *type_name;
  const char *type_hash;
  size_t serialized_size_max;
} nros_message_type_t;
 
typedef struct nros_service_type_t {
  const char *type_name;
  const char *type_hash;
} nros_service_type_t;
 
typedef struct nros_service_options_t {
  nros_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} nros_service_options_t;
 
typedef struct nros_client_options_t {
  nros_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} nros_client_options_t;
 
typedef struct nros_subscription_options_t {
  nros_sched_context_id_t sched_context;
  uint8_t message_info;
  uint8_t _reserved[2];
} nros_subscription_options_t;
 
typedef struct nros_integrity_status_t {
  int64_t gap;
  bool duplicate;
  int8_t crc_valid;
} nros_integrity_status_t;
 
#define NROS_RET_OK 0
 
#define NROS_RET_ERROR -1
 
#define NROS_RET_TIMEOUT -2
 
#define NROS_RET_INVALID_ARGUMENT -3
 
#define NROS_RET_NOT_FOUND -4
 
#define NROS_RET_ALREADY_EXISTS -5
 
#define NROS_RET_FULL -6
 
#define NROS_RET_NOT_INIT -7
 
#define NROS_RET_BAD_SEQUENCE -8
 
#define NROS_RET_STALE_NODE -17
 
#define NROS_RET_SERVICE_FAILED -9
 
#define NROS_RET_PUBLISH_FAILED -10
 
#define NROS_RET_SUBSCRIPTION_FAILED -11
 
#define NROS_RET_NOT_ALLOWED -12
 
#define NROS_RET_REJECTED -13
 
#define NROS_RET_TRY_AGAIN -14
 
#define NROS_RET_REENTRANT -15
 
#define NROS_RET_UNSUPPORTED -16
 
#define NROS_SHUTDOWN_CALLBACK_HANDLE_INVALID 4294967295
 
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
 
extern const struct nros_qos_t NROS_QOS_DEFAULT;
 
extern const struct nros_qos_t NROS_QOS_SENSOR_DATA;
 
extern const struct nros_qos_t NROS_QOS_SERVICES;
 
extern const uint32_t NROS_TRANSPORT_OPS_ABI_VERSION_V1;
 
extern size_t nros_platform_heap_used_bytes(void);
 
extern size_t nros_platform_heap_total_bytes(void);
 
NROS_PUBLIC size_t nros_heap_used_bytes(void);
 
NROS_PUBLIC size_t nros_heap_peak_bytes(void);
 
NROS_PUBLIC size_t nros_heap_platform_used_bytes(void);
 
NROS_PUBLIC size_t nros_heap_total_bytes(void);
 
extern uint32_t nros_platform_critical_section_acquire(void);
 
extern void nros_platform_critical_section_release(uint32_t token);
 
NROS_PUBLIC int32_t nros_cdr_write_encaps_header(uint8_t **ptr, const uint8_t *end);
 
NROS_PUBLIC
int64_t nros_cdr_begin_dheader(uint8_t **ptr,
                               const uint8_t *end,
                               const uint8_t *origin);
 
NROS_PUBLIC
int32_t nros_cdr_end_dheader(int64_t mark,
                             uint8_t **ptr,
                             const uint8_t *end,
                             const uint8_t *origin);
 
NROS_PUBLIC
int64_t nros_cdr_begin_dheader_read(const uint8_t **ptr,
                                    const uint8_t *end,
                                    const uint8_t *origin);
 
NROS_PUBLIC
int32_t nros_cdr_end_dheader_read(int64_t scope,
                                  const uint8_t **ptr,
                                  const uint8_t *end,
                                  const uint8_t *origin);
 
NROS_PUBLIC
int32_t nros_cdr_write_bool(uint8_t **ptr,
                            const uint8_t *end,
                            const uint8_t *origin,
                            bool value);
 
NROS_PUBLIC
int32_t nros_cdr_write_u8(uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint8_t value);
 
NROS_PUBLIC
int32_t nros_cdr_write_i8(uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int8_t value);
 
NROS_PUBLIC
int32_t nros_cdr_write_u16(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           uint16_t value);
 
NROS_PUBLIC
int32_t nros_cdr_write_i16(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           int16_t value);
 
NROS_PUBLIC
int32_t nros_cdr_write_u32(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           uint32_t value);
 
NROS_PUBLIC
int32_t nros_cdr_write_i32(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           int32_t value);
 
NROS_PUBLIC
int32_t nros_cdr_write_u64(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           uint64_t value);
 
NROS_PUBLIC
int32_t nros_cdr_write_i64(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           int64_t value);
 
NROS_PUBLIC
int32_t nros_cdr_write_f32(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           float value);
 
NROS_PUBLIC
int32_t nros_cdr_write_f64(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           double value);
 
NROS_PUBLIC
int32_t nros_cdr_write_string(uint8_t **ptr,
                              const uint8_t *end,
                              const uint8_t *origin,
                              const char *value);
 
NROS_PUBLIC
int32_t nros_cdr_write_string_n(uint8_t **ptr,
                                const uint8_t *end,
                                const uint8_t *origin,
                                const char *data,
                                size_t data_len);
 
NROS_PUBLIC
int32_t nros_cdr_read_bool(const uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           bool *value);
 
NROS_PUBLIC
int32_t nros_cdr_read_u8(const uint8_t **ptr,
                         const uint8_t *end,
                         const uint8_t *origin,
                         uint8_t *value);
 
NROS_PUBLIC
int32_t nros_cdr_read_i8(const uint8_t **ptr,
                         const uint8_t *end,
                         const uint8_t *origin,
                         int8_t *value);
 
NROS_PUBLIC
int32_t nros_cdr_read_u16(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint16_t *value);
 
NROS_PUBLIC
int32_t nros_cdr_read_i16(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int16_t *value);
 
NROS_PUBLIC
int32_t nros_cdr_read_u32(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint32_t *value);
 
NROS_PUBLIC
int32_t nros_cdr_read_i32(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int32_t *value);
 
NROS_PUBLIC
int32_t nros_cdr_read_u64(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint64_t *value);
 
NROS_PUBLIC
int32_t nros_cdr_read_i64(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int64_t *value);
 
NROS_PUBLIC
int32_t nros_cdr_read_f32(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          float *value);
 
NROS_PUBLIC
int32_t nros_cdr_read_f64(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          double *value);
 
NROS_PUBLIC
int32_t nros_cdr_read_string(const uint8_t **ptr,
                             const uint8_t *end,
                             const uint8_t *origin,
                             char *value,
                             size_t max_len);
 
NROS_PUBLIC struct nros_clock_t nros_clock_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_clock_init(struct nros_clock_t *clock,
                           enum nros_clock_type_t clock_type);
 
NROS_PUBLIC
nros_ret_t nros_clock_get_now(const struct nros_clock_t *clock,
                              struct nros_time_t *time_out);
 
NROS_PUBLIC
nros_ret_t nros_clock_get_now_ns(const struct nros_clock_t *clock,
                                 int64_t *nanoseconds);
 
NROS_PUBLIC bool nros_clock_is_valid(const struct nros_clock_t *clock);
 
NROS_PUBLIC enum nros_clock_type_t nros_clock_get_type(const struct nros_clock_t *clock);
 
NROS_PUBLIC nros_ret_t nros_clock_fini(struct nros_clock_t *clock);
 
NROS_PUBLIC nros_ret_t nros_enable_ros_time_override(const struct nros_clock_t *clock);
 
NROS_PUBLIC nros_ret_t nros_disable_ros_time_override(const struct nros_clock_t *clock);
 
NROS_PUBLIC
nros_ret_t nros_is_enabled_ros_time_override(const struct nros_clock_t *clock,
                                             bool *is_enabled);
 
NROS_PUBLIC
nros_ret_t nros_set_ros_time_override(const struct nros_clock_t *clock,
                                      int64_t nanoseconds);
 
NROS_PUBLIC
nros_ret_t nros_get_ros_time_override(const struct nros_clock_t *clock,
                                      int64_t *nanoseconds);
 
NROS_PUBLIC bool nros_clock_time_started(const struct nros_clock_t *clock);
 
NROS_PUBLIC struct nros_time_t nros_time_from_nanoseconds(int64_t nanoseconds);
 
NROS_PUBLIC struct nros_duration_t nros_duration_from_nanoseconds(int64_t nanoseconds);
 
NROS_PUBLIC int64_t nros_time_to_nanoseconds(const struct nros_time_t *time);
 
NROS_PUBLIC
struct nros_time_t nros_time_add(struct nros_time_t time,
                                 struct nros_duration_t duration);
 
NROS_PUBLIC
struct nros_time_t nros_time_sub(struct nros_time_t time,
                                 struct nros_duration_t duration);
 
NROS_PUBLIC int nros_time_compare(struct nros_time_t a, struct nros_time_t b);
 
NROS_PUBLIC struct nros_parameter_server_t nros_parameter_server_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_parameter_server_init(struct nros_parameter_server_t *server,
                                      struct nros_parameter_t *storage,
                                      size_t capacity);
 
NROS_PUBLIC
nros_ret_t nros_parameter_server_set_callback(struct nros_parameter_server_t *server,
                                              nros_parameter_callback_t callback,
                                              void *context);
 
NROS_PUBLIC
nros_ret_t nros_parameter_declare_string(struct nros_parameter_server_t *server,
                                         const char *name,
                                         const char *default_value);
 
NROS_PUBLIC
nros_ret_t nros_parameter_get_string(const struct nros_parameter_server_t *server,
                                     const char *name,
                                     char *value,
                                     size_t max_len);
 
NROS_PUBLIC
nros_ret_t nros_parameter_set_string(struct nros_parameter_server_t *server,
                                     const char *name,
                                     const char *value);
 
NROS_PUBLIC bool nros_parameter_has(const struct nros_parameter_server_t *server, const char *name);
 
NROS_PUBLIC
enum nros_parameter_type_t nros_parameter_get_type(const struct nros_parameter_server_t *server,
                                                   const char *name);
 
NROS_PUBLIC size_t nros_parameter_server_get_count(const struct nros_parameter_server_t *server);
 
NROS_PUBLIC nros_ret_t nros_parameter_server_fini(struct nros_parameter_server_t *server);
 
NROS_PUBLIC nros_ret_t nros_executor_register_parameter_services(struct nros_executor_t *executor);
 
NROS_PUBLIC
nros_ret_t nros_executor_declare_param_string(struct nros_executor_t *executor,
                                              const char *name,
                                              const char *value);
 
NROS_PUBLIC
nros_ret_t nros_executor_get_param_string(struct nros_executor_t *executor,
                                          const char *name,
                                          char *out_value,
                                          size_t max_len);
 
NROS_PUBLIC
nros_ret_t nros_executor_set_param_string(struct nros_executor_t *executor,
                                          const char *name,
                                          const char *value);
 
NROS_PUBLIC bool nros_executor_has_param(struct nros_executor_t *executor, const char *name);
 
extern uint64_t nros_platform_clock_ns(void);
 
extern void nros_platform_sleep_us(size_t us);
 
extern uint64_t nros_platform_time_now_ns(void);
 
NROS_PUBLIC void nros_set_trace_sink(void (*sink)(uint32_t, uint32_t));
 
NROS_PUBLIC nros_ret_t nros_set_custom_transport(const struct nros_transport_ops_t *ops);
 
NROS_PUBLIC nros_ret_t nros_clear_custom_transport(void);
 
NROS_PUBLIC nros_ret_t nros_has_custom_transport(void);
 
NROS_PUBLIC struct nros_action_client_t nros_action_client_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_action_client_init(struct nros_action_client_t *client,
                                   const struct nros_node_t *node,
                                   const char *action_name,
                                   const struct nros_action_type_t *type_info);
 
NROS_PUBLIC struct nros_action_client_options_t nros_action_client_get_default_options(void);
 
NROS_PUBLIC
nros_ret_t nros_action_client_init_with_options(struct nros_action_client_t *client,
                                                const struct nros_node_t *node,
                                                const char *action_name,
                                                const struct nros_action_type_t *type_info,
                                                const struct nros_action_client_options_t *options);
 
NROS_PUBLIC
nros_ret_t nros_action_client_set_feedback_callback(struct nros_action_client_t *client,
                                                    nros_feedback_callback_t callback,
                                                    void *context);
 
NROS_PUBLIC
nros_ret_t nros_action_client_set_result_callback(struct nros_action_client_t *client,
                                                  nros_result_callback_t callback,
                                                  void *context);
 
NROS_PUBLIC
nros_ret_t nros_action_client_wait_for_action_server(struct nros_action_client_t *client,
                                                     struct nros_executor_t *executor,
                                                     uint32_t timeout_ms);
 
NROS_PUBLIC
bool nros_action_client_action_server_is_ready(const struct nros_action_client_t *client,
                                               struct nros_executor_t *executor);
 
NROS_PUBLIC
nros_ret_t nros_action_send_goal(struct nros_action_client_t *client,
                                 struct nros_executor_t *executor,
                                 const uint8_t *goal,
                                 size_t goal_len,
                                 struct nros_goal_uuid_t *goal_uuid);
 
NROS_PUBLIC
nros_ret_t nros_action_cancel_goal(struct nros_action_client_t *client,
                                   const struct nros_goal_uuid_t *goal_uuid);
 
NROS_PUBLIC
nros_ret_t nros_action_get_result(struct nros_action_client_t *client,
                                  struct nros_executor_t *executor,
                                  const struct nros_goal_uuid_t *goal_uuid,
                                  enum nros_goal_status_t *status,
                                  uint8_t *result,
                                  size_t result_capacity,
                                  size_t *result_len);
 
NROS_PUBLIC nros_ret_t nros_action_try_recv_feedback(struct nros_action_client_t *client);
 
NROS_PUBLIC
nros_ret_t nros_action_send_goal_async(struct nros_action_client_t *client,
                                       const uint8_t *goal,
                                       size_t goal_len,
                                       struct nros_goal_uuid_t *goal_uuid);
 
NROS_PUBLIC
nros_ret_t nros_action_get_result_async(struct nros_action_client_t *client,
                                        const struct nros_goal_uuid_t *goal_uuid);
 
NROS_PUBLIC
nros_ret_t nros_action_client_set_goal_response_callback(struct nros_action_client_t *client,
                                                         nros_goal_response_callback_t callback,
                                                         void *context);
 
NROS_PUBLIC nros_ret_t nros_action_client_poll(struct nros_action_client_t *client);
 
NROS_PUBLIC nros_ret_t nros_action_client_fini(struct nros_action_client_t *client);
 
NROS_PUBLIC
nros_ret_t nros_action_client_init_polling(struct nros_action_client_t *client,
                                           const struct nros_node_t *node,
                                           const struct nros_action_type_t *type_info,
                                           const char *action_name);
 
NROS_PUBLIC
nros_ret_t nros_action_client_send_goal_raw(struct nros_action_client_t *client,
                                            const uint8_t *goal_cdr,
                                            size_t goal_len,
                                            uint8_t (*goal_id_out)[16]);
 
NROS_PUBLIC
int32_t nros_action_client_try_recv_goal_response_raw(struct nros_action_client_t *client,
                                                      uint8_t *buf,
                                                      size_t buf_len);
 
NROS_PUBLIC
nros_ret_t nros_action_client_send_get_result_request_raw(struct nros_action_client_t *client,
                                                          const uint8_t (*goal_id)[16]);
 
NROS_PUBLIC
int32_t nros_action_client_try_recv_result_raw(struct nros_action_client_t *client,
                                               uint8_t *buf,
                                               size_t buf_len);
 
NROS_PUBLIC
nros_ret_t nros_action_client_send_cancel_request_raw(struct nros_action_client_t *client,
                                                      const uint8_t (*goal_id)[16]);
 
NROS_PUBLIC
int32_t nros_action_client_try_recv_cancel_response_raw(struct nros_action_client_t *client,
                                                        uint8_t *buf,
                                                        size_t buf_len);
 
NROS_PUBLIC
nros_ret_t nros_action_client_set_goal_response_wake_callback(struct nros_action_client_t *client,
                                                              struct nros_wake_state_t *state,
                                                              void (*cb)(void*),
                                                              void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_action_client_set_cancel_response_wake_callback(struct nros_action_client_t *client,
                                                                struct nros_wake_state_t *state,
                                                                void (*cb)(void*),
                                                                void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_action_client_set_result_wake_callback(struct nros_action_client_t *client,
                                                       struct nros_wake_state_t *state,
                                                       void (*cb)(void*),
                                                       void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_action_client_set_feedback_wake_callback(struct nros_action_client_t *client,
                                                         struct nros_wake_state_t *state,
                                                         void (*cb)(void*),
                                                         void *ctx);
 
NROS_PUBLIC
int32_t nros_action_client_try_recv_feedback_raw(struct nros_action_client_t *client,
                                                 uint8_t *buf,
                                                 size_t buf_len,
                                                 uint8_t (*goal_id_out)[16]);
 
NROS_PUBLIC nros_ret_t nros_goal_uuid_generate(struct nros_goal_uuid_t *uuid);
 
NROS_PUBLIC
bool nros_goal_uuid_equal(const struct nros_goal_uuid_t *a,
                          const struct nros_goal_uuid_t *b);
 
NROS_PUBLIC const char *nros_goal_status_to_string(enum nros_goal_status_t status);
 
NROS_PUBLIC struct nros_action_server_t nros_action_server_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_action_server_init(struct nros_action_server_t *server,
                                   const struct nros_node_t *node,
                                   const char *action_name,
                                   const struct nros_action_type_t *type_info,
                                   nros_goal_callback_t goal_callback,
                                   nros_cancel_callback_t cancel_callback,
                                   nros_accepted_callback_t accepted_callback,
                                   void *context);
 
NROS_PUBLIC
nros_ret_t nros_action_server_init_with_qos(struct nros_action_server_t *server,
                                            const struct nros_node_t *node,
                                            const char *action_name,
                                            const struct nros_action_type_t *type_info,
                                            nros_goal_callback_t goal_callback,
                                            nros_cancel_callback_t cancel_callback,
                                            nros_accepted_callback_t accepted_callback,
                                            void *context,
                                            const struct nros_qos_t *qos);
 
NROS_PUBLIC struct nros_action_server_options_t nros_action_server_get_default_options(void);
 
NROS_PUBLIC
nros_ret_t nros_action_server_init_with_options(struct nros_action_server_t *server,
                                                const struct nros_node_t *node,
                                                const char *action_name,
                                                const struct nros_action_type_t *type_info,
                                                nros_goal_callback_t goal_callback,
                                                nros_cancel_callback_t cancel_callback,
                                                nros_accepted_callback_t accepted_callback,
                                                void *context,
                                                const struct nros_qos_t *qos,
                                                const struct nros_action_server_options_t *options);
 
NROS_PUBLIC
nros_ret_t nros_action_publish_feedback(struct nros_action_server_t *server,
                                        const struct nros_goal_handle_t *goal,
                                        const uint8_t *feedback,
                                        size_t feedback_len);
 
NROS_PUBLIC
nros_ret_t nros_action_succeed(struct nros_action_server_t *server,
                               const struct nros_goal_handle_t *goal,
                               const uint8_t *result,
                               size_t result_len);
 
NROS_PUBLIC
nros_ret_t nros_action_abort(struct nros_action_server_t *server,
                             const struct nros_goal_handle_t *goal,
                             const uint8_t *result,
                             size_t result_len);
 
NROS_PUBLIC
nros_ret_t nros_action_canceled(struct nros_action_server_t *server,
                                const struct nros_goal_handle_t *goal,
                                const uint8_t *result,
                                size_t result_len);
 
NROS_PUBLIC
nros_ret_t nros_action_execute(struct nros_action_server_t *server,
                               const struct nros_goal_handle_t *goal);
 
NROS_PUBLIC
nros_ret_t nros_action_server_get_active_goal_count(struct nros_action_server_t *server,
                                                    size_t *out);
 
NROS_PUBLIC
nros_ret_t nros_action_get_goal_status(const struct nros_action_server_t *server,
                                       const struct nros_goal_handle_t *goal,
                                       enum nros_goal_status_t *status);
 
NROS_PUBLIC nros_ret_t nros_action_server_fini(struct nros_action_server_t *server);
 
NROS_PUBLIC
nros_ret_t nros_action_server_init_polling(struct nros_action_server_t *server,
                                           const struct nros_node_t *node,
                                           const struct nros_action_type_t *type_info,
                                           const char *action_name);
 
NROS_PUBLIC
int32_t nros_action_server_try_recv_goal_request_raw(struct nros_action_server_t *server,
                                                     uint8_t *buf,
                                                     size_t buf_len,
                                                     uint8_t (*goal_id_out)[16],
                                                     int64_t *sequence_number_out);
 
NROS_PUBLIC
nros_ret_t nros_action_server_accept_goal_raw(struct nros_action_server_t *server,
                                              const uint8_t (*goal_id)[16],
                                              int64_t sequence_number);
 
NROS_PUBLIC
nros_ret_t nros_action_server_reject_goal_raw(struct nros_action_server_t *server,
                                              int64_t sequence_number);
 
NROS_PUBLIC
nros_ret_t nros_action_server_publish_feedback_raw(struct nros_action_server_t *server,
                                                   const uint8_t (*goal_id)[16],
                                                   const uint8_t *feedback_cdr,
                                                   size_t feedback_len);
 
NROS_PUBLIC
nros_ret_t nros_action_server_complete_goal_raw(struct nros_action_server_t *server,
                                                const uint8_t (*goal_id)[16],
                                                enum nros_goal_status_t status,
                                                const uint8_t *result_cdr,
                                                size_t result_len);
 
NROS_PUBLIC
int32_t nros_action_server_try_recv_cancel_request_raw(struct nros_action_server_t *server,
                                                       uint8_t (*goal_id_out)[16],
                                                       int64_t *sequence_number_out,
                                                       enum nros_goal_status_t *current_status_out);
 
NROS_PUBLIC
nros_ret_t nros_action_server_send_cancel_reply_raw(struct nros_action_server_t *server,
                                                    int64_t sequence_number,
                                                    enum nros_cancel_return_code_t return_code,
                                                    const uint8_t (*accepted)[16],
                                                    size_t accepted_count);
 
NROS_PUBLIC
int32_t nros_action_server_try_handle_get_result_raw(struct nros_action_server_t *server,
                                                     const uint8_t *default_result_cdr,
                                                     size_t default_result_len);
 
NROS_PUBLIC
nros_ret_t nros_action_server_set_goal_wake_callback(struct nros_action_server_t *server,
                                                     struct nros_wake_state_t *state,
                                                     void (*cb)(void*),
                                                     void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_action_server_set_cancel_wake_callback(struct nros_action_server_t *server,
                                                       struct nros_wake_state_t *state,
                                                       void (*cb)(void*),
                                                       void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_action_server_set_get_result_wake_callback(struct nros_action_server_t *server,
                                                           struct nros_wake_state_t *state,
                                                           void (*cb)(void*),
                                                           void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_subscription_set_liveliness_changed_callback(struct nros_subscription_t *_sub,
                                                             nros_event_liveliness_changed_cb_t _cb,
                                                             void *_user_context);
 
NROS_PUBLIC
nros_ret_t nros_subscription_set_requested_deadline_missed_callback(struct nros_subscription_t *_sub,
                                                                    uint32_t _deadline_ms,
                                                                    nros_event_subscriber_count_cb_t _cb,
                                                                    void *_user_context);
 
NROS_PUBLIC
nros_ret_t nros_subscription_set_message_lost_callback(struct nros_subscription_t *_sub,
                                                       nros_event_subscriber_count_cb_t _cb,
                                                       void *_user_context);
 
NROS_PUBLIC
nros_ret_t nros_publisher_set_liveliness_lost_callback(struct nros_publisher_t *_pub_,
                                                       nros_event_publisher_count_cb_t _cb,
                                                       void *_user_context);
 
NROS_PUBLIC
nros_ret_t nros_publisher_set_offered_deadline_missed_callback(struct nros_publisher_t *_pub_,
                                                               uint32_t _deadline_ms,
                                                               nros_event_publisher_count_cb_t _cb,
                                                               void *_user_context);
 
NROS_PUBLIC struct nros_executor_t nros_executor_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_executor_init(struct nros_executor_t *executor,
                              const struct nros_support_t *support,
                              size_t max_handles);
 
NROS_PUBLIC
nros_ret_t nros_executor_set_timeout(struct nros_executor_t *executor,
                                     uint64_t timeout_ns);
 
NROS_PUBLIC nros_ret_t nros_executor_ping(struct nros_executor_t *executor, int32_t timeout_ms);
 
NROS_PUBLIC
nros_ret_t nros_executor_get_node_names(struct nros_executor_t *executor,
                                        nros_node_visit_fn visit,
                                        void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_executor_get_topic_names_and_types(struct nros_executor_t *executor,
                                                   nros_names_and_types_visit_fn visit,
                                                   void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_executor_get_service_names_and_types(struct nros_executor_t *executor,
                                                     nros_names_and_types_visit_fn visit,
                                                     void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_executor_count_publishers(struct nros_executor_t *executor,
                                          const char *topic_name,
                                          size_t *out_count);
 
NROS_PUBLIC
nros_ret_t nros_executor_count_subscribers(struct nros_executor_t *executor,
                                           const char *topic_name,
                                           size_t *out_count);
 
NROS_PUBLIC
nros_ret_t nros_executor_get_publisher_names_and_types_by_node(struct nros_executor_t *executor,
                                                               const char *node_name,
                                                               const char *node_namespace,
                                                               nros_names_and_types_visit_fn visit,
                                                               void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_executor_get_subscriber_names_and_types_by_node(struct nros_executor_t *executor,
                                                                const char *node_name,
                                                                const char *node_namespace,
                                                                nros_names_and_types_visit_fn visit,
                                                                void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_executor_get_service_names_and_types_by_node(struct nros_executor_t *executor,
                                                             const char *node_name,
                                                             const char *node_namespace,
                                                             nros_names_and_types_visit_fn visit,
                                                             void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_executor_get_client_names_and_types_by_node(struct nros_executor_t *executor,
                                                            const char *node_name,
                                                            const char *node_namespace,
                                                            nros_names_and_types_visit_fn visit,
                                                            void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_executor_get_publishers_info_by_topic(struct nros_executor_t *executor,
                                                      const char *topic_name,
                                                      nros_endpoint_info_visit_fn visit,
                                                      void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_executor_get_subscriptions_info_by_topic(struct nros_executor_t *executor,
                                                         const char *topic_name,
                                                         nros_endpoint_info_visit_fn visit,
                                                         void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_executor_set_semantics(struct nros_executor_t *executor,
                                       enum nros_executor_semantics_t semantics);
 
NROS_PUBLIC
nros_ret_t nros_executor_node_init(struct nros_executor_t *executor,
                                   struct nros_node_t *node,
                                   const char *name,
                                   const struct nros_node_options_t *options);
 
NROS_PUBLIC
nros_ret_t nros_executor_set_trigger(struct nros_executor_t *executor,
                                     nros_executor_trigger_t trigger,
                                     void *context);
 
NROS_PUBLIC bool nros_executor_trigger_any(const bool *ready, size_t count, void *context);
 
NROS_PUBLIC bool nros_executor_trigger_all(const bool *ready, size_t count, void *context);
 
NROS_PUBLIC bool nros_executor_trigger_always(const bool *ready, size_t count, void *context);
 
NROS_PUBLIC bool nros_executor_trigger_one(const bool *ready, size_t count, void *context);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_subscription(struct nros_executor_t *executor,
                                          struct nros_subscription_t *subscription,
                                          enum nros_executor_handle_invocation_t invocation);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_subscription_raw_with_info(struct nros_executor_t *executor,
                                                        const struct nros_node_t *node,
                                                        const char *topic_name,
                                                        const char *type_name,
                                                        const char *type_hash,
                                                        const struct nros_qos_t *qos,
                                                        nros_subscription_info_callback_t callback,
                                                        void *context);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_timer(struct nros_executor_t *executor,
                                   struct nros_timer_t *timer);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_subscription_in_group(struct nros_executor_t *executor,
                                                   struct nros_subscription_t *subscription,
                                                   enum nros_executor_handle_invocation_t invocation,
                                                   const char *callback_group);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_timer_in_group(struct nros_executor_t *executor,
                                            struct nros_timer_t *timer,
                                            const char *callback_group);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_service(struct nros_executor_t *executor,
                                     struct nros_service_t *service);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_client(struct nros_executor_t *executor,
                                    struct nros_client_t *client);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_guard_condition(struct nros_executor_t *executor,
                                             struct nros_guard_condition_t *guard);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_action_server(struct nros_executor_t *executor,
                                           struct nros_action_server_t *server);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_action_client(struct nros_executor_t *executor,
                                           struct nros_action_client_t *client);
 
NROS_PUBLIC
nros_ret_t nros_executor_spin_some(struct nros_executor_t *executor,
                                   uint64_t timeout_ns);
 
NROS_PUBLIC nros_ret_t nros_executor_spin(struct nros_executor_t *executor);
 
NROS_PUBLIC
nros_ret_t nros_executor_spin_period(struct nros_executor_t *executor,
                                     uint64_t period_ns);
 
NROS_PUBLIC
nros_ret_t nros_executor_spin_one_period(struct nros_executor_t *executor,
                                         uint64_t period_ns);
 
NROS_PUBLIC nros_ret_t nros_executor_stop(struct nros_executor_t *executor);
 
NROS_PUBLIC nros_ret_t nros_executor_fini(struct nros_executor_t *executor);
 
NROS_PUBLIC int nros_executor_get_handle_count(const struct nros_executor_t *executor);
 
NROS_PUBLIC bool nros_executor_is_valid(const struct nros_executor_t *executor);
 
NROS_PUBLIC int nros_executor_get_remaining_handles(const struct nros_executor_t *executor);
 
NROS_PUBLIC nros_sched_context_id_t nros_executor_default_sched_context_id(void);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_time_triggered_dispatcher(struct nros_executor_t *executor,
                                                       uint32_t major_frame_us);
 
NROS_PUBLIC
nros_ret_t nros_executor_create_sched_context(struct nros_executor_t *executor,
                                              const struct nros_sched_context_t *cfg,
                                              nros_sched_context_id_t *out_sc_id);
 
NROS_PUBLIC
nros_ret_t nros_executor_bind_handle_to_sched_context(struct nros_executor_t *executor,
                                                      size_t handle,
                                                      nros_sched_context_id_t sc_id);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_pre_shutdown_callback(struct nros_executor_t *executor,
                                                   nros_shutdown_callback_t callback,
                                                   void *context,
                                                   nros_shutdown_callback_handle_t *out_handle);
 
NROS_PUBLIC
nros_ret_t nros_executor_add_on_shutdown_callback(struct nros_executor_t *executor,
                                                  nros_shutdown_callback_t callback,
                                                  void *context,
                                                  nros_shutdown_callback_handle_t *out_handle);
 
NROS_PUBLIC
nros_ret_t nros_executor_remove_pre_shutdown_callback(struct nros_executor_t *executor,
                                                      nros_shutdown_callback_handle_t handle);
 
NROS_PUBLIC
nros_ret_t nros_executor_remove_on_shutdown_callback(struct nros_executor_t *executor,
                                                     nros_shutdown_callback_handle_t handle);
 
NROS_PUBLIC struct nros_guard_condition_t nros_guard_condition_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_guard_condition_init(struct nros_guard_condition_t *guard,
                                     const struct nros_support_t *support);
 
NROS_PUBLIC
nros_ret_t nros_guard_condition_set_callback(struct nros_guard_condition_t *guard,
                                             nros_guard_condition_callback_t callback,
                                             void *context);
 
NROS_PUBLIC nros_ret_t nros_guard_condition_trigger(struct nros_guard_condition_t *guard);
 
NROS_PUBLIC bool nros_guard_condition_is_triggered(const struct nros_guard_condition_t *guard);
 
NROS_PUBLIC nros_ret_t nros_guard_condition_clear(struct nros_guard_condition_t *guard);
 
NROS_PUBLIC bool nros_guard_condition_is_valid(const struct nros_guard_condition_t *guard);
 
NROS_PUBLIC nros_ret_t nros_guard_condition_fini(struct nros_guard_condition_t *guard);
 
NROS_PUBLIC struct nros_lifecycle_state_machine_t nros_lifecycle_get_zero_initialized(void);
 
NROS_PUBLIC nros_ret_t nros_lifecycle_init(struct nros_lifecycle_state_machine_t *sm);
 
NROS_PUBLIC nros_ret_t nros_lifecycle_fini(struct nros_lifecycle_state_machine_t *sm);
 
NROS_PUBLIC
nros_ret_t nros_lifecycle_change_state(struct nros_lifecycle_state_machine_t *sm,
                                       uint8_t transition_id);
 
NROS_PUBLIC
uint8_t nros_lifecycle_get_current_state(const struct nros_lifecycle_state_machine_t *sm);
 
NROS_PUBLIC
nros_ret_t nros_lifecycle_register_on_configure(struct nros_lifecycle_state_machine_t *sm,
                                                nros_lifecycle_callback_t cb,
                                                void *context);
 
NROS_PUBLIC
nros_ret_t nros_lifecycle_register_on_activate(struct nros_lifecycle_state_machine_t *sm,
                                               nros_lifecycle_callback_t cb,
                                               void *context);
 
NROS_PUBLIC
nros_ret_t nros_lifecycle_register_on_deactivate(struct nros_lifecycle_state_machine_t *sm,
                                                 nros_lifecycle_callback_t cb,
                                                 void *context);
 
NROS_PUBLIC
nros_ret_t nros_lifecycle_register_on_cleanup(struct nros_lifecycle_state_machine_t *sm,
                                              nros_lifecycle_callback_t cb,
                                              void *context);
 
NROS_PUBLIC
nros_ret_t nros_lifecycle_register_on_shutdown(struct nros_lifecycle_state_machine_t *sm,
                                               nros_lifecycle_callback_t cb,
                                               void *context);
 
NROS_PUBLIC
nros_ret_t nros_lifecycle_register_on_error(struct nros_lifecycle_state_machine_t *sm,
                                            nros_lifecycle_callback_t cb,
                                            void *context);
 
NROS_PUBLIC nros_ret_t nros_executor_register_lifecycle_services(struct nros_executor_t *executor);
 
NROS_PUBLIC uint8_t nros_executor_lifecycle_get_current_state(struct nros_executor_t *executor);
 
NROS_PUBLIC
nros_ret_t nros_executor_lifecycle_change_state(struct nros_executor_t *executor,
                                                uint8_t transition_id);
 
NROS_PUBLIC
nros_ret_t nros_executor_lifecycle_register_on_configure(struct nros_executor_t *executor,
                                                         nros_lifecycle_callback_t cb,
                                                         void *context);
 
NROS_PUBLIC
nros_ret_t nros_executor_lifecycle_register_on_activate(struct nros_executor_t *executor,
                                                        nros_lifecycle_callback_t cb,
                                                        void *context);
 
NROS_PUBLIC
nros_ret_t nros_executor_lifecycle_register_on_deactivate(struct nros_executor_t *executor,
                                                          nros_lifecycle_callback_t cb,
                                                          void *context);
 
NROS_PUBLIC
nros_ret_t nros_executor_lifecycle_register_on_cleanup(struct nros_executor_t *executor,
                                                       nros_lifecycle_callback_t cb,
                                                       void *context);
 
NROS_PUBLIC
nros_ret_t nros_executor_lifecycle_register_on_shutdown(struct nros_executor_t *executor,
                                                        nros_lifecycle_callback_t cb,
                                                        void *context);
 
NROS_PUBLIC
nros_ret_t nros_executor_lifecycle_register_on_error(struct nros_executor_t *executor,
                                                     nros_lifecycle_callback_t cb,
                                                     void *context);
 
NROS_PUBLIC
nros_ret_t nros_node_set_qos_overrides(struct nros_node_t *node,
                                       const struct nros_qos_override_t *overrides,
                                       size_t len);
 
NROS_PUBLIC struct nros_node_options_t nros_node_get_default_options(void);
 
NROS_PUBLIC struct nros_node_t nros_node_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_node_init(struct nros_node_t *node,
                          const struct nros_support_t *support,
                          const char *name,
                          const char *namespace_);
 
NROS_PUBLIC
nros_ret_t nros_node_init_ex(struct nros_node_t *node,
                             const struct nros_support_t *support,
                             const char *name,
                             const struct nros_node_options_t *options);
 
NROS_PUBLIC nros_ret_t nros_node_fini(struct nros_node_t *node);
 
NROS_PUBLIC const char *nros_node_get_name(const struct nros_node_t *node);
 
NROS_PUBLIC const char *nros_node_get_namespace(const struct nros_node_t *node);
 
NROS_PUBLIC const char *nros_node_get_serialization_format(const struct nros_node_t *node);
 
NROS_PUBLIC const void *nros_node_get_logger(const struct nros_node_t *node);
 
NROS_PUBLIC struct nros_publisher_options_t nros_publisher_get_default_options(void);
 
NROS_PUBLIC struct nros_publisher_t nros_publisher_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_publisher_init(struct nros_publisher_t *publisher,
                               const struct nros_node_t *node,
                               const struct nros_message_type_t *type_info,
                               const char *topic_name);
 
NROS_PUBLIC
nros_ret_t nros_publisher_init_with_qos(struct nros_publisher_t *publisher,
                                        const struct nros_node_t *node,
                                        const struct nros_message_type_t *type_info,
                                        const char *topic_name,
                                        const struct nros_qos_t *qos);
 
NROS_PUBLIC
nros_ret_t nros_publisher_init_with_options(struct nros_publisher_t *publisher,
                                            const struct nros_node_t *node,
                                            const struct nros_message_type_t *type_info,
                                            const char *topic_name,
                                            const struct nros_qos_t *qos,
                                            const struct nros_publisher_options_t *options);
 
NROS_PUBLIC
nros_ret_t nros_publish_raw(const struct nros_publisher_t *publisher,
                            const uint8_t *data,
                            size_t len);
 
NROS_PUBLIC
nros_ret_t nros_publisher_publish_streamed(const struct nros_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_PUBLIC nros_ret_t nros_publisher_assert_liveliness(const struct nros_publisher_t *publisher);
 
NROS_PUBLIC
nros_ret_t nros_publisher_loan(const struct nros_publisher_t *publisher,
                               size_t requested_len,
                               uint8_t **out_buf,
                               size_t *out_cap,
                               void **out_token);
 
NROS_PUBLIC
nros_ret_t nros_publisher_commit(const struct nros_publisher_t *publisher,
                                 void *token,
                                 size_t actual_len);
 
NROS_PUBLIC
nros_ret_t nros_publisher_discard(const struct nros_publisher_t *publisher,
                                  void *token);
 
NROS_PUBLIC nros_ret_t nros_publisher_fini(struct nros_publisher_t *publisher);
 
NROS_PUBLIC const char *nros_publisher_get_topic_name(const struct nros_publisher_t *publisher);
 
NROS_PUBLIC bool nros_publisher_is_valid(const struct nros_publisher_t *publisher);
 
NROS_PUBLIC struct nros_service_t nros_service_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_service_init(struct nros_service_t *service,
                             const struct nros_node_t *node,
                             const struct nros_service_type_t *type_info,
                             const char *service_name,
                             nros_service_callback_t callback,
                             void *context);
 
NROS_PUBLIC
nros_ret_t nros_service_init_with_qos(struct nros_service_t *service,
                                      const struct nros_node_t *node,
                                      const struct nros_service_type_t *type_info,
                                      const char *service_name,
                                      nros_service_callback_t callback,
                                      void *context,
                                      const struct nros_qos_t *qos);
 
NROS_PUBLIC struct nros_service_options_t nros_service_get_default_options(void);
 
NROS_PUBLIC
nros_ret_t nros_service_init_with_options(struct nros_service_t *service,
                                          const struct nros_node_t *node,
                                          const struct nros_service_type_t *type_info,
                                          const char *service_name,
                                          nros_service_callback_t callback,
                                          void *context,
                                          const struct nros_qos_t *qos,
                                          const struct nros_service_options_t *options);
 
NROS_PUBLIC nros_ret_t nros_service_fini(struct nros_service_t *service);
 
NROS_PUBLIC
nros_ret_t nros_service_init_polling(struct nros_service_t *service,
                                     const struct nros_node_t *node,
                                     const struct nros_service_type_t *type_info,
                                     const char *service_name);
 
NROS_PUBLIC struct nros_wake_state_t nros_wake_state_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_service_set_wake_callback(struct nros_service_t *service,
                                          struct nros_wake_state_t *state,
                                          void (*cb)(void*),
                                          void *ctx);
 
NROS_PUBLIC
nros_ret_t nros_client_set_wake_callback(struct nros_client_t *client,
                                         struct nros_wake_state_t *state,
                                         void (*cb)(void*),
                                         void *ctx);
 
NROS_PUBLIC
int32_t nros_service_take_request_raw(struct nros_service_t *service,
                                      uint8_t *buf,
                                      size_t buf_len,
                                      int64_t *sequence_number);
 
NROS_PUBLIC
nros_ret_t nros_service_send_response_raw(struct nros_service_t *service,
                                          int64_t sequence_number,
                                          const uint8_t *data,
                                          size_t len);
 
NROS_PUBLIC
nros_ret_t nros_service_take_request(struct nros_service_t *service,
                                     uint8_t *_request_data,
                                     size_t _request_capacity,
                                     size_t *_request_len,
                                     int64_t *_sequence_number);
 
NROS_PUBLIC const char *nros_service_get_service_name(const struct nros_service_t *service);
 
NROS_PUBLIC bool nros_service_is_valid(const struct nros_service_t *service);
 
NROS_PUBLIC struct nros_client_t nros_client_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_client_init(struct nros_client_t *client,
                            const struct nros_node_t *node,
                            const struct nros_service_type_t *type_info,
                            const char *service_name);
 
NROS_PUBLIC
nros_ret_t nros_client_init_with_qos(struct nros_client_t *client,
                                     const struct nros_node_t *node,
                                     const struct nros_service_type_t *type_info,
                                     const char *service_name,
                                     const struct nros_qos_t *qos);
 
NROS_PUBLIC struct nros_client_options_t nros_client_get_default_options(void);
 
NROS_PUBLIC
nros_ret_t nros_client_init_with_options(struct nros_client_t *client,
                                         const struct nros_node_t *node,
                                         const struct nros_service_type_t *type_info,
                                         const char *service_name,
                                         const struct nros_qos_t *qos,
                                         const struct nros_client_options_t *options);
 
NROS_PUBLIC nros_ret_t nros_client_fini(struct nros_client_t *client);
 
NROS_PUBLIC
nros_ret_t nros_client_init_polling(struct nros_client_t *client,
                                    const struct nros_node_t *node,
                                    const struct nros_service_type_t *type_info,
                                    const char *service_name);
 
NROS_PUBLIC
nros_ret_t nros_client_send_request_raw(struct nros_client_t *client,
                                        const uint8_t *data,
                                        size_t len);
 
NROS_PUBLIC
int32_t nros_client_take_response_raw(struct nros_client_t *client,
                                      uint8_t *buf,
                                      size_t buf_len);
 
NROS_PUBLIC
nros_ret_t nros_client_set_response_callback(struct nros_client_t *client,
                                             nros_response_callback_t callback,
                                             void *context);
 
NROS_PUBLIC nros_ret_t nros_client_set_timeout(struct nros_client_t *client, uint32_t timeout_ms);
 
NROS_PUBLIC nros_ret_t nros_client_server_available(struct nros_client_t *client, int32_t *out);
 
NROS_PUBLIC
nros_ret_t nros_client_wait_for_service(struct nros_client_t *client,
                                        uint32_t timeout_ms);
 
NROS_PUBLIC bool nros_client_service_is_ready(const struct nros_client_t *client);
 
NROS_PUBLIC
nros_ret_t nros_client_send_request_async(struct nros_client_t *client,
                                          const uint8_t *request_data,
                                          size_t request_len);
 
NROS_PUBLIC
nros_ret_t nros_client_take_response(struct nros_client_t *client,
                                     uint8_t *response_data,
                                     size_t response_capacity,
                                     size_t *response_len);
 
NROS_PUBLIC
nros_ret_t nros_client_call(struct nros_client_t *client,
                            const uint8_t *request_data,
                            size_t request_len,
                            uint8_t *response_data,
                            size_t response_capacity,
                            size_t *response_len);
 
NROS_PUBLIC const char *nros_client_get_service_name(const struct nros_client_t *client);
 
NROS_PUBLIC bool nros_client_is_valid(const struct nros_client_t *client);
 
NROS_PUBLIC struct nros_subscription_t nros_subscription_get_zero_initialized(void);
 
NROS_PUBLIC struct nros_subscription_options_t nros_subscription_get_default_options(void);
 
NROS_PUBLIC
nros_ret_t nros_subscription_init(struct nros_subscription_t *subscription,
                                  const struct nros_node_t *node,
                                  const struct nros_message_type_t *type_info,
                                  const char *topic_name,
                                  nros_subscription_callback_t callback,
                                  void *context);
 
NROS_PUBLIC
nros_ret_t nros_subscription_init_with_qos(struct nros_subscription_t *subscription,
                                           const struct nros_node_t *node,
                                           const struct nros_message_type_t *type_info,
                                           const char *topic_name,
                                           nros_subscription_callback_t callback,
                                           void *context,
                                           const struct nros_qos_t *qos);
 
NROS_PUBLIC
nros_ret_t nros_subscription_init_with_options(struct nros_subscription_t *subscription,
                                               const struct nros_node_t *node,
                                               const struct nros_message_type_t *type_info,
                                               const char *topic_name,
                                               nros_subscription_callback_t callback,
                                               void *context,
                                               const struct nros_qos_t *qos,
                                               const struct nros_subscription_options_t *options);
 
NROS_PUBLIC
nros_ret_t nros_subscription_init_polling(struct nros_subscription_t *subscription,
                                          const struct nros_node_t *node,
                                          const struct nros_message_type_t *type_info,
                                          const char *topic_name);
 
NROS_PUBLIC
nros_ret_t nros_subscription_init_polling_with_qos(struct nros_subscription_t *subscription,
                                                   const struct nros_node_t *node,
                                                   const struct nros_message_type_t *type_info,
                                                   const char *topic_name,
                                                   const struct nros_qos_t *qos);
 
NROS_PUBLIC
nros_ret_t nros_subscription_set_wake_callback(struct nros_subscription_t *subscription,
                                               struct nros_wake_state_t *state,
                                               void (*cb)(void*),
                                               void *ctx);
 
NROS_PUBLIC
int32_t nros_subscription_take_serialized(struct nros_subscription_t *subscription,
                                          uint8_t *buf,
                                          size_t buf_len);
 
NROS_PUBLIC
int32_t nros_subscription_take_validated(struct nros_subscription_t *subscription,
                                         uint8_t *buf,
                                         size_t buf_len,
                                         struct nros_integrity_status_t *out_status);
 
NROS_PUBLIC
int32_t nros_subscription_borrow(struct nros_subscription_t *subscription,
                                 const uint8_t **out_buf,
                                 size_t *out_len,
                                 void **out_token);
 
NROS_PUBLIC
nros_ret_t nros_subscription_release(struct nros_subscription_t *subscription,
                                     void *token);
 
NROS_PUBLIC
int32_t nros_subscription_take_sequence(struct nros_subscription_t *subscription,
                                        uint8_t *buf,
                                        size_t per_msg_cap,
                                        size_t max_msgs,
                                        size_t *out_lens);
 
NROS_PUBLIC nros_ret_t nros_subscription_fini(struct nros_subscription_t *subscription);
 
NROS_PUBLIC
const char *nros_subscription_get_topic_name(const struct nros_subscription_t *subscription);
 
NROS_PUBLIC bool nros_subscription_is_valid(const struct nros_subscription_t *subscription);
 
NROS_PUBLIC struct nros_support_t nros_support_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_support_init(struct nros_support_t *support,
                             const char *locator,
                             uint8_t domain_id);
 
NROS_PUBLIC
nros_ret_t nros_support_init_named(struct nros_support_t *support,
                                   const char *locator,
                                   uint8_t domain_id,
                                   const char *session_name);
 
NROS_PUBLIC
nros_ret_t nros_support_init_rmw(struct nros_support_t *support,
                                 const char *locator,
                                 uint8_t domain_id,
                                 const char *session_name,
                                 const char *rmw);
 
NROS_PUBLIC nros_ret_t nros_support_fini(struct nros_support_t *support);
 
NROS_PUBLIC bool nros_support_is_valid(const struct nros_support_t *support);
 
NROS_PUBLIC struct nros_timer_t nros_timer_get_zero_initialized(void);
 
NROS_PUBLIC
nros_ret_t nros_timer_init(struct nros_timer_t *timer,
                           const struct nros_support_t *support,
                           uint64_t period_ns,
                           nros_timer_callback_t callback,
                           void *context);
 
NROS_PUBLIC nros_ret_t nros_timer_cancel(struct nros_timer_t *timer);
 
NROS_PUBLIC nros_ret_t nros_timer_reset(struct nros_timer_t *timer);
 
NROS_PUBLIC nros_ret_t nros_timer_fini(struct nros_timer_t *timer);
 
NROS_PUBLIC bool nros_timer_is_valid(const struct nros_timer_t *timer);
 
NROS_PUBLIC uint64_t nros_timer_get_period(const struct nros_timer_t *timer);
 
NROS_PUBLIC
uint64_t nros_timer_get_time_until_next_call(const struct nros_timer_t *timer,
                                             uint64_t current_time_ns);
 
#ifdef __cplusplus
}  // extern "C"
#endif  // __cplusplus
 
#endif  /* NROS_GENERATED_H */