nros_generated.h

Go to the documentation of this file.

 
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
 
#include "rclc/visibility_control.h"
#include "rclc/detail/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 rcl_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 rclc_executor_t;
struct rcl_node_t;
struct rcl_publisher_t;
struct rcl_subscription_t;
struct rcl_service_t;
struct rcl_client_t;
struct rcl_timer_t;
struct rcl_guard_condition_t;
struct rcl_action_server_t;
struct rcl_action_client_t;
struct rcl_lifecycle_state_machine_t;
struct rclc_support_t;
struct rcl_clock_t;
struct rclc_goal_handle_t;
struct rclc_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 RCLC_LIFECYCLE_STATE_UNCONFIGURED 1
 
#define RCLC_LIFECYCLE_STATE_INACTIVE 2
 
#define RCLC_LIFECYCLE_STATE_ACTIVE 3
 
#define RCLC_LIFECYCLE_STATE_FINALIZED 4
 
#define RCLC_LIFECYCLE_STATE_ERROR_PROCESSING 5
 
#define RCLC_LIFECYCLE_TRANSITION_CONFIGURE 1
 
#define RCLC_LIFECYCLE_TRANSITION_CLEANUP 2
 
#define RCLC_LIFECYCLE_TRANSITION_ACTIVATE 3
 
#define RCLC_LIFECYCLE_TRANSITION_DEACTIVATE 4
 
#define RCLC_LIFECYCLE_TRANSITION_SHUTDOWN_UNCONFIGURED 5
 
#define RCLC_LIFECYCLE_TRANSITION_SHUTDOWN_INACTIVE 6
 
#define RCLC_LIFECYCLE_TRANSITION_SHUTDOWN_ACTIVE 7
 
#define RCLC_LIFECYCLE_TRANSITION_ERROR_RECOVERY 60
 
#define RCLC_LIFECYCLE_RET_OK 0
 
#define RCLC_LIFECYCLE_RET_FAILURE 1
 
#define RCLC_LIFECYCLE_RET_ERROR 2
 
#define NROS_DOMAIN_ID_INHERIT UINT32_MAX
 
#define NROS_PUBLISHER_GID_SIZE 24
 
#define RCLC_SERVICE_TYPED_OK 0
 
#define RCLC_SERVICE_TYPED_ERR_REQUEST_DESERIALIZE -1
 
#define RCLC_SERVICE_TYPED_ERR_RESPONSE_SERIALIZE -2
 
#define RCLC_SERVICE_TYPED_ERR_REQUEST_SERIALIZE -3
 
#define RCLC_SERVICE_TYPED_ERR_RESPONSE_DESERIALIZE -4
 
#define RCLC_SERVICE_TYPED_ERR_NO_CALLBACK -5
 
#define NROS_DOMAIN_ID_EXPLICIT_ZERO 255
 
typedef enum rcl_clock_type_t {
  RCL_CLOCK_UNINITIALIZED = 0,
  RCL_ROS_TIME = 1,
  RCL_SYSTEM_TIME = 2,
  RCL_STEADY_TIME = 3,
} rcl_clock_type_t;
 
typedef enum rclc_clock_state_t {
  RCLC_CLOCK_STATE_UNINITIALIZED = 0,
  RCLC_CLOCK_STATE_READY = 1,
  RCLC_CLOCK_STATE_SHUTDOWN = 2,
} rclc_clock_state_t;
 
typedef enum rclc_action_client_state_t {
  RCLC_ACTION_CLIENT_STATE_UNINITIALIZED = 0,
  RCLC_ACTION_CLIENT_STATE_INITIALIZED = 1,
  RCLC_ACTION_CLIENT_STATE_SHUTDOWN = 2,
} rclc_action_client_state_t;
 
typedef enum rclc_goal_status_t {
  RCLC_GOAL_STATUS_UNKNOWN = 0,
  RCLC_GOAL_STATUS_ACCEPTED = 1,
  RCLC_GOAL_STATUS_EXECUTING = 2,
  RCLC_GOAL_STATUS_CANCELING = 3,
  RCLC_GOAL_STATUS_SUCCEEDED = 4,
  RCLC_GOAL_STATUS_CANCELED = 5,
  RCLC_GOAL_STATUS_ABORTED = 6,
} rclc_goal_status_t;
 
typedef enum rclc_node_state_t {
  RCLC_NODE_STATE_UNINITIALIZED = 0,
  RCLC_NODE_STATE_INITIALIZED = 1,
  RCLC_NODE_STATE_SHUTDOWN = 2,
} rclc_node_state_t;
 
typedef enum rclc_support_state_t {
  RCLC_SUPPORT_STATE_UNINITIALIZED = 0,
  RCLC_SUPPORT_STATE_INITIALIZED = 1,
  RCLC_SUPPORT_STATE_SHUTDOWN = 2,
} rclc_support_state_t;
 
typedef enum rclc_executor_state_t {
  RCLC_EXECUTOR_STATE_UNINITIALIZED = 0,
  RCLC_EXECUTOR_STATE_INITIALIZED = 1,
  RCLC_EXECUTOR_STATE_SPINNING = 2,
  RCLC_EXECUTOR_STATE_SHUTDOWN = 3,
} rclc_executor_state_t;
 
typedef enum rclc_executor_semantics_t {
  RCLCPP_EXECUTOR = 0,
  LET = 1,
} rclc_executor_semantics_t;
 
typedef enum rclc_action_server_state_t {
  RCLC_ACTION_SERVER_STATE_UNINITIALIZED = 0,
  RCLC_ACTION_SERVER_STATE_INITIALIZED = 1,
  RCLC_ACTION_SERVER_STATE_SHUTDOWN = 2,
} rclc_action_server_state_t;
 
typedef enum rclc_goal_response_t {
  RCLC_GOAL_REJECT = 0,
  RCLC_GOAL_ACCEPT_AND_EXECUTE = 1,
  RCLC_GOAL_ACCEPT_AND_DEFER = 2,
} rclc_goal_response_t;
 
typedef enum rclc_cancel_response_t {
  RCLC_CANCEL_REJECT = 0,
  RCLC_CANCEL_ACCEPT = 1,
} rclc_cancel_response_t;
 
typedef enum rclc_qos_reliability_t {
  RCLC_QOS_RELIABILITY_BEST_EFFORT = 0,
  RCLC_QOS_RELIABILITY_RELIABLE = 1,
  RCLC_QOS_RELIABILITY_SYSTEM_DEFAULT = 2,
  RCLC_QOS_RELIABILITY_UNKNOWN = 3,
} rclc_qos_reliability_t;
 
typedef enum rclc_qos_durability_t {
  RCLC_QOS_DURABILITY_VOLATILE = 0,
  RCLC_QOS_DURABILITY_TRANSIENT_LOCAL = 1,
  RCLC_QOS_DURABILITY_SYSTEM_DEFAULT = 2,
  RCLC_QOS_DURABILITY_UNKNOWN = 3,
} rclc_qos_durability_t;
 
typedef enum rclc_qos_history_t {
  RCLC_QOS_HISTORY_KEEP_LAST = 0,
  RCLC_QOS_HISTORY_KEEP_ALL = 1,
  RCLC_QOS_HISTORY_SYSTEM_DEFAULT = 2,
  RCLC_QOS_HISTORY_UNKNOWN = 3,
} rclc_qos_history_t;
 
typedef enum rclc_qos_liveliness_t {
  RCLC_QOS_LIVELINESS_NONE = 0,
  RCLC_QOS_LIVELINESS_AUTOMATIC = 1,
  RCLC_QOS_LIVELINESS_MANUAL_BY_TOPIC = 2,
  RCLC_QOS_LIVELINESS_MANUAL_BY_NODE = 3,
  RCLC_QOS_LIVELINESS_UNKNOWN = 4,
} rclc_qos_liveliness_t;
 
typedef enum rclc_cancel_return_code_t {
  RCLC_CANCEL_RC_OK = 0,
  RCLC_CANCEL_RC_REJECTED = 1,
  RCLC_CANCEL_RC_UNKNOWN_GOAL = 2,
  RCLC_CANCEL_RC_GOAL_TERMINATED = 3,
} rclc_cancel_return_code_t;
 
typedef enum rclc_subscription_state_t {
  RCLC_SUBSCRIPTION_STATE_UNINITIALIZED = 0,
  RCLC_SUBSCRIPTION_STATE_INITIALIZED = 1,
  RCLC_SUBSCRIPTION_STATE_SHUTDOWN = 2,
} rclc_subscription_state_t;
 
typedef enum rclc_publisher_state_t {
  RCLC_PUBLISHER_STATE_UNINITIALIZED = 0,
  RCLC_PUBLISHER_STATE_INITIALIZED = 1,
  RCLC_PUBLISHER_STATE_SHUTDOWN = 2,
} rclc_publisher_state_t;
 
typedef enum rclc_executor_handle_invocation_t {
  ON_NEW_DATA = 0,
  ALWAYS = 1,
} rclc_executor_handle_invocation_t;
 
typedef enum rclc_timer_state_t {
  RCLC_TIMER_STATE_UNINITIALIZED = 0,
  RCLC_TIMER_STATE_RUNNING = 1,
  RCLC_TIMER_STATE_CANCELED = 2,
  RCLC_TIMER_STATE_SHUTDOWN = 3,
} rclc_timer_state_t;
 
typedef enum rclc_service_state_t {
  RCLC_SERVICE_STATE_UNINITIALIZED = 0,
  RCLC_SERVICE_STATE_INITIALIZED = 1,
  RCLC_SERVICE_STATE_SHUTDOWN = 2,
} rclc_service_state_t;
 
typedef enum rclc_client_state_t {
  RCLC_CLIENT_STATE_UNINITIALIZED = 0,
  RCLC_CLIENT_STATE_INITIALIZED = 1,
  RCLC_CLIENT_STATE_REGISTERED = 2,
  RCLC_CLIENT_STATE_SHUTDOWN = 3,
} rclc_client_state_t;
 
enum rclc_sched_class_t
#if defined(__cplusplus) || __STDC_VERSION__ >= 202311L
  : uint8_t
#endif // defined(__cplusplus) || __STDC_VERSION__ >= 202311L
 {
  RCLC_SCHED_CLASS_FIFO = 0,
  RCLC_SCHED_CLASS_EDF = 1,
  RCLC_SCHED_CLASS_SPORADIC = 2,
  RCLC_SCHED_CLASS_BEST_EFFORT = 3,
  RCLC_SCHED_CLASS_TIME_TRIGGERED = 4,
};
#ifndef __cplusplus
#if __STDC_VERSION__ >= 202311L
typedef enum rclc_sched_class_t rclc_sched_class_t;
#else
typedef uint8_t rclc_sched_class_t;
#endif // __STDC_VERSION__ >= 202311L
#endif // __cplusplus
 
enum rclc_sched_priority_t
#if defined(__cplusplus) || __STDC_VERSION__ >= 202311L
  : uint8_t
#endif // defined(__cplusplus) || __STDC_VERSION__ >= 202311L
 {
  RCLC_SCHED_PRIORITY_CRITICAL = 0,
  RCLC_SCHED_PRIORITY_NORMAL = 1,
  RCLC_SCHED_PRIORITY_BEST_EFFORT = 2,
};
#ifndef __cplusplus
#if __STDC_VERSION__ >= 202311L
typedef enum rclc_sched_priority_t rclc_sched_priority_t;
#else
typedef uint8_t rclc_sched_priority_t;
#endif // __STDC_VERSION__ >= 202311L
#endif // __cplusplus
 
enum rclc_deadline_policy_t
#if defined(__cplusplus) || __STDC_VERSION__ >= 202311L
  : uint8_t
#endif // defined(__cplusplus) || __STDC_VERSION__ >= 202311L
 {
  RCLC_DEADLINE_POLICY_RELEASED = 0,
  RCLC_DEADLINE_POLICY_ACTIVATED = 1,
  RCLC_DEADLINE_POLICY_INHERITED = 2,
};
#ifndef __cplusplus
#if __STDC_VERSION__ >= 202311L
typedef enum rclc_deadline_policy_t rclc_deadline_policy_t;
#else
typedef uint8_t rclc_deadline_policy_t;
#endif // __STDC_VERSION__ >= 202311L
#endif // __cplusplus
 
typedef enum rclc_guard_condition_state_t {
  RCLC_GUARD_CONDITION_STATE_UNINITIALIZED = 0,
  RCLC_GUARD_CONDITION_STATE_INITIALIZED = 1,
  RCLC_GUARD_CONDITION_STATE_SHUTDOWN = 2,
} rclc_guard_condition_state_t;
 
typedef struct rmw_publisher_allocation_t rmw_publisher_allocation_t;
 
typedef struct rmw_subscription_allocation_t rmw_subscription_allocation_t;
 
typedef struct rcl_allocator_t {
  void *(*allocate)(size_t size, void *state);
  void (*deallocate)(void *pointer, void *state);
  void *(*reallocate)(void *pointer, size_t size, void *state);
  void *(*zero_allocate)(size_t number_of_elements, size_t size_of_element, void *state);
  void *state;
} rcl_allocator_t;
 
typedef struct rcl_clock_t {
  enum rcl_clock_type_t type;
  enum rclc_clock_state_t state;
  uint64_t _steady_epoch_ns;
} rcl_clock_t;
 
typedef int rcl_ret_t;
 
typedef struct rclc_time_t {
  int32_t sec;
  uint32_t nanosec;
} rclc_time_t;
 
typedef struct rcl_duration_t {
  int32_t sec;
  uint32_t nanosec;
} rcl_duration_t;
 
typedef struct nros_transport_ops_t {
  uint32_t abi_version;
  uint32_t _reserved;
  void *user_data;
  rcl_ret_t (*open)(void *user_data, const void *params);
  void (*close)(void *user_data);
  rcl_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 rclc_node_ref_t {
  uint8_t node_id;
  uint32_t generation;
} rclc_node_ref_t;
 
typedef struct rclc_polling_action_client_t {
  enum rclc_action_client_state_t state;
  struct rclc_node_ref_t node;
  uint64_t _opaque[ACTION_CLIENT_OPAQUE_U64S];
} rclc_polling_action_client_t;
 
typedef struct rclc_action_endpoint_hashes_t {
  const char *send_goal;
  const char *cancel_goal;
  const char *get_result;
  const char *feedback;
  const char *status;
} rclc_action_endpoint_hashes_t;
 
typedef struct rclc_goal_uuid_t {
  uint8_t uuid[16];
} rclc_goal_uuid_t;
 
typedef void (*rclc_goal_response_callback_t)(const struct rclc_goal_uuid_t *goal_uuid,
                                              bool accepted,
                                              void *context);
 
typedef void (*rclc_feedback_callback_t)(const struct rclc_goal_uuid_t *goal_uuid,
                                         const uint8_t *feedback,
                                         size_t feedback_len,
                                         void *context);
 
typedef void (*rclc_result_callback_t)(const struct rclc_goal_uuid_t *goal_uuid,
                                       enum rclc_goal_status_t status,
                                       const uint8_t *result,
                                       size_t result_len,
                                       void *context);
 
typedef uint8_t rclc_sched_context_id_t;
 
typedef struct ActionClientInternal {
  int32_t arena_entry_index;
  void *executor_ptr;
} ActionClientInternal;
 
typedef struct rcl_action_client_t {
  enum rclc_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;
  struct rclc_action_endpoint_hashes_t endpoint_hashes;
  rclc_goal_response_callback_t goal_response_callback;
  rclc_feedback_callback_t feedback_callback;
  rclc_result_callback_t result_callback;
  void *context;
  struct rclc_node_ref_t node;
  rclc_sched_context_id_t sched_context_id;
  struct ActionClientInternal _internal;
} rcl_action_client_t;
 
typedef struct rcl_context_t {
  const struct rclc_support_t *_support;
} rcl_context_t;
 
typedef struct rclc_support_t {
  struct rcl_context_t context;
  enum rclc_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];
} rclc_support_t;
 
typedef struct rclc_executor_trigger_handle_t {
  void *entity;
  bool data_available;
} rclc_executor_trigger_handle_t;
 
typedef bool (*rclc_executor_trigger_t)(const struct rclc_executor_trigger_handle_t *handles,
                                        size_t size,
                                        void *obj);
 
typedef struct rclc_executor_t {
  enum rclc_executor_state_t state;
  uint64_t timeout_ns;
  enum rclc_executor_semantics_t semantics;
  const struct rclc_support_t *support;
  rclc_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;
  void *_handle_entities[NROS_EXECUTOR_MAX_HANDLES];
  void *_host;
  uint64_t _opaque[EXECUTOR_OPAQUE_U64S];
} rclc_executor_t;
 
typedef struct rclc_qos_override_t {
  const char *topic;
  uint8_t role;
  uint8_t policy;
  uint32_t value;
} rclc_qos_override_t;
 
typedef struct rcl_node_t {
  enum rclc_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 rclc_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 rclc_executor_t *executor;
  const struct rclc_qos_override_t *qos_overrides;
  size_t qos_overrides_len;
} rcl_node_t;
 
typedef int32_t (*rclc_message_serialize_fn_t)(const void *msg,
                                               uint8_t *buffer,
                                               size_t capacity,
                                               size_t *out_len);
 
typedef int32_t (*rclc_message_deserialize_fn_t)(const uint8_t *buffer, size_t len, void *msg);
 
typedef struct rclc_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;
  rclc_message_serialize_fn_t goal_serialize;
  rclc_message_deserialize_fn_t goal_deserialize;
  rclc_message_serialize_fn_t result_serialize;
  rclc_message_deserialize_fn_t result_deserialize;
  rclc_message_serialize_fn_t feedback_serialize;
  rclc_message_deserialize_fn_t feedback_deserialize;
  struct rclc_action_endpoint_hashes_t endpoint_hashes;
} rclc_action_type_t;
 
typedef struct rcl_action_client_options_t {
  rclc_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} rcl_action_client_options_t;
 
typedef struct rclc_wake_state_t {
  uint64_t _opaque[2];
} rclc_wake_state_t;
 
typedef struct rclc_polling_action_server_t {
  enum rclc_action_server_state_t state;
  struct rclc_node_ref_t node;
  uint64_t _opaque[ACTION_SERVER_OPAQUE_U64S];
} rclc_polling_action_server_t;
 
typedef struct rclc_goal_handle_t {
  struct rclc_goal_uuid_t uuid;
} rclc_goal_handle_t;
 
typedef enum rclc_goal_response_t (*rclc_goal_callback_t)(struct rcl_action_server_t *server,
                                                          const struct rclc_goal_handle_t *goal,
                                                          const uint8_t *goal_request,
                                                          size_t goal_len,
                                                          void *context);
 
typedef enum rclc_cancel_response_t (*rclc_cancel_callback_t)(struct rcl_action_server_t *server,
                                                              const struct rclc_goal_handle_t *goal,
                                                              void *context);
 
typedef void (*rclc_accepted_callback_t)(struct rcl_action_server_t *server,
                                         const struct rclc_goal_handle_t *goal,
                                         void *context);
 
typedef struct rclc_qos_t {
  enum rclc_qos_reliability_t reliability;
  enum rclc_qos_durability_t durability;
  enum rclc_qos_history_t history;
  enum rclc_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;
} rclc_qos_t;
 
typedef struct ActionServerInternal {
  ActionServerRawHandle handle;
  void *executor_ptr;
} ActionServerInternal;
 
typedef struct rcl_action_server_t {
  enum rclc_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;
  struct rclc_action_endpoint_hashes_t endpoint_hashes;
  rclc_goal_callback_t goal_callback;
  rclc_cancel_callback_t cancel_callback;
  rclc_accepted_callback_t accepted_callback;
  void *context;
  struct rclc_node_ref_t node;
  struct rclc_qos_t qos;
  rclc_sched_context_id_t sched_context_id;
  struct ActionServerInternal _internal;
} rcl_action_server_t;
 
typedef struct rcl_action_server_options_t {
  rclc_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} rcl_action_server_options_t;
 
typedef struct rclc_message_type_t {
  const char *type_name;
  const char *type_hash;
  size_t serialized_size_max;
  rclc_message_serialize_fn_t serialize;
  rclc_message_deserialize_fn_t deserialize;
} rclc_message_type_t;
 
typedef struct rcl_subscription_t {
  enum rclc_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;
  struct rclc_node_ref_t node;
  const struct rclc_message_type_t *type_support;
  struct rclc_qos_t qos;
  size_t handle_id;
  rclc_sched_context_id_t sched_context_id;
  void *_executor;
} rcl_subscription_t;
 
typedef struct rclc_liveliness_changed_status_t {
  uint16_t alive_count;
  uint16_t not_alive_count;
  int16_t alive_count_change;
  int16_t not_alive_count_change;
} rclc_liveliness_changed_status_t;
 
typedef void (*rclc_event_liveliness_changed_cb_t)(struct rcl_subscription_t *sub,
                                                   struct rclc_liveliness_changed_status_t status,
                                                   void *user_context);
 
typedef struct rclc_count_status_t {
  uint32_t total_count;
  uint32_t total_count_change;
} rclc_count_status_t;
 
typedef void (*rclc_event_subscriber_count_cb_t)(struct rcl_subscription_t *sub,
                                                 struct rclc_count_status_t status,
                                                 void *user_context);
 
typedef struct rcl_publisher_t {
  enum rclc_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 rclc_node_ref_t node;
  const struct rclc_message_type_t *type_support;
  uint64_t _opaque[PUBLISHER_OPAQUE_U64S];
} rcl_publisher_t;
 
typedef void (*rclc_event_publisher_count_cb_t)(struct rcl_publisher_t *pub_,
                                                struct rclc_count_status_t status,
                                                void *user_context);
 
typedef bool (*rclc_node_visit_fn)(void *ctx,
                                   const char *node_name,
                                   const char *node_namespace,
                                   const char *enclave);
 
typedef bool (*rclc_names_and_types_visit_fn)(void *ctx,
                                              const char *name,
                                              const char *const *types,
                                              size_t types_count);
 
typedef struct rclc_endpoint_info_t {
  const char *node_name;
  const char *node_namespace;
  const char *topic_type;
  bool is_publisher;
  uint8_t endpoint_gid[24];
} rclc_endpoint_info_t;
 
typedef bool (*rclc_endpoint_info_visit_fn)(void *ctx, const struct rclc_endpoint_info_t *info);
 
typedef struct rcl_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];
} rcl_node_options_t;
 
typedef void (*rclc_subscription_validated_callback_t)(const uint8_t *data,
                                                       size_t len,
                                                       int64_t gap,
                                                       bool duplicate,
                                                       int8_t crc_valid,
                                                       void *context);
 
typedef void (*rclc_subscription_callback_with_context_t)(const void *msg, void *context);
 
typedef void (*rclc_subscription_raw_callback_t)(const uint8_t *data, size_t len, void *context);
 
typedef void (*rclc_subscription_info_callback_t)(const uint8_t *data,
                                                  size_t len,
                                                  const uint8_t *attachment,
                                                  size_t attachment_len,
                                                  void *context);
 
typedef void (*rclc_timer_callback_with_context_t)(struct rcl_timer_t *timer, void *context);
 
typedef struct rcl_timer_t {
  enum rclc_timer_state_t state;
  uint64_t period_ns;
  rclc_timer_callback_with_context_t callback;
  void *context;
  const struct rcl_clock_t *clock;
  size_t handle_id;
  void *_executor;
} rcl_timer_t;
 
typedef struct ServiceServerInternal {
  int32_t arena_entry_index;
  void *executor_ptr;
} ServiceServerInternal;
 
typedef struct rcl_service_t {
  enum rclc_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;
  struct rclc_node_ref_t node;
  struct rclc_qos_t qos;
  rclc_sched_context_id_t sched_context_id;
  struct ServiceServerInternal _internal;
} rcl_service_t;
 
typedef bool (*rclc_service_raw_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 ServiceClientInternal {
  int32_t arena_entry_index;
  void *executor_ptr;
  uint32_t timeout_ms;
} ServiceClientInternal;
 
typedef struct rcl_client_t {
  enum rclc_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;
  struct rclc_node_ref_t node;
  struct rclc_qos_t qos;
  rclc_sched_context_id_t sched_context_id;
  struct ServiceClientInternal _internal;
} rcl_client_t;
 
typedef struct rclc_sched_context_t {
  rclc_sched_class_t class_;
  rclc_sched_priority_t priority;
  rclc_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;
} rclc_sched_context_t;
 
typedef void (*rclc_shutdown_callback_t)(void *context);
 
typedef uint32_t rclc_shutdown_callback_handle_t;
 
typedef void (*rclc_guard_condition_callback_t)(void *context);
 
typedef struct rcl_guard_condition_t {
  enum rclc_guard_condition_state_t state;
  bool triggered;
  rclc_guard_condition_callback_t callback;
  void *context;
  size_t handle_id;
  bool _guard_valid;
  uint64_t _guard_opaque[GUARD_HANDLE_OPAQUE_U64S];
} rcl_guard_condition_t;
 
typedef struct rcl_lifecycle_state_machine_t {
  bool initialized;
  uint8_t _pad[7];
  uint64_t storage[NROS_LIFECYCLE_CTX_OPAQUE_U64S];
} rcl_lifecycle_state_machine_t;
 
typedef uint8_t (*rclc_lifecycle_callback_t)(void *context);
 
typedef struct rcl_publisher_options_t {
  uint8_t _reserved[4];
} rcl_publisher_options_t;
 
typedef struct rclc_polling_service_t {
  enum rclc_service_state_t state;
  struct rclc_node_ref_t node;
  uint64_t _opaque[SERVICE_SERVER_OPAQUE_U64S];
} rclc_polling_service_t;
 
typedef struct rclc_service_type_t {
  const char *type_name;
  const char *type_hash;
  rclc_message_serialize_fn_t request_serialize;
  rclc_message_deserialize_fn_t request_deserialize;
  rclc_message_serialize_fn_t response_serialize;
  rclc_message_deserialize_fn_t response_deserialize;
} rclc_service_type_t;
 
typedef struct rcl_service_options_t {
  rclc_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} rcl_service_options_t;
 
typedef struct rclc_polling_client_t {
  enum rclc_client_state_t state;
  struct rclc_node_ref_t node;
  uint64_t _opaque[SERVICE_CLIENT_OPAQUE_U64S];
} rclc_polling_client_t;
 
typedef struct rcl_client_options_t {
  rclc_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} rcl_client_options_t;
 
typedef void (*rclc_response_callback_t)(const uint8_t *response, size_t response_len, void *context);
 
typedef struct rclc_polling_subscription_t {
  enum rclc_subscription_state_t state;
  struct rclc_node_ref_t node;
  const struct rclc_message_type_t *type_support;
  uint64_t _opaque[SUBSCRIPTION_OPAQUE_U64S];
} rclc_polling_subscription_t;
 
typedef struct rcl_subscription_options_t {
  rclc_sched_context_id_t sched_context;
  uint8_t message_info;
  uint8_t _reserved[2];
} rcl_subscription_options_t;
 
typedef struct rclc_integrity_status_t {
  int64_t gap;
  bool duplicate;
  int8_t crc_valid;
} rclc_integrity_status_t;
 
#define RCL_RET_OK 0
 
#define RCL_RET_ERROR -1
 
#define RCL_RET_TIMEOUT -2
 
#define RCL_RET_INVALID_ARGUMENT -3
 
#define RCLC_RET_NOT_FOUND -4
 
#define RCLC_RET_ALREADY_EXISTS -5
 
#define RCLC_RET_FULL -6
 
#define RCL_RET_NOT_INIT -7
 
#define RCLC_RET_BAD_SEQUENCE -8
 
#define RCLC_RET_STALE_NODE -17
 
#define RCLC_RET_SERVICE_FAILED -9
 
#define RCLC_RET_PUBLISH_FAILED -10
 
#define RCLC_RET_SUBSCRIPTION_FAILED -11
 
#define RCLC_RET_NOT_ALLOWED -12
 
#define RCLC_RET_REJECTED -13
 
#define RCLC_RET_TRY_AGAIN -14
 
#define RCLC_RET_REENTRANT -15
 
#define RCL_RET_UNSUPPORTED -16
 
#define RCLC_SHUTDOWN_CALLBACK_HANDLE_INVALID 4294967295
 
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
 
extern const struct rclc_qos_t RCLC_QOS_DEFAULT;
 
extern const struct rclc_qos_t RCLC_QOS_SENSOR_DATA;
 
extern const struct rclc_qos_t RCLC_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 rclc_heap_used_bytes(void);
 
NROS_PUBLIC size_t rclc_heap_peak_bytes(void);
 
NROS_PUBLIC size_t rclc_heap_platform_used_bytes(void);
 
NROS_PUBLIC size_t rclc_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 struct rcl_allocator_t rcl_get_default_allocator(void);
 
NROS_PUBLIC int32_t rclc_cdr_write_encaps_header(uint8_t **ptr, const uint8_t *end);
 
NROS_PUBLIC
int64_t rclc_cdr_begin_dheader(uint8_t **ptr,
                               const uint8_t *end,
                               const uint8_t *origin);
 
NROS_PUBLIC
int32_t rclc_cdr_end_dheader(int64_t mark,
                             uint8_t **ptr,
                             const uint8_t *end,
                             const uint8_t *origin);
 
NROS_PUBLIC
int64_t rclc_cdr_begin_dheader_read(const uint8_t **ptr,
                                    const uint8_t *end,
                                    const uint8_t *origin);
 
NROS_PUBLIC
int32_t rclc_cdr_end_dheader_read(int64_t scope,
                                  const uint8_t **ptr,
                                  const uint8_t *end,
                                  const uint8_t *origin);
 
NROS_PUBLIC
int32_t rclc_cdr_write_bool(uint8_t **ptr,
                            const uint8_t *end,
                            const uint8_t *origin,
                            bool value);
 
NROS_PUBLIC
int32_t rclc_cdr_write_u8(uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint8_t value);
 
NROS_PUBLIC
int32_t rclc_cdr_write_i8(uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int8_t value);
 
NROS_PUBLIC
int32_t rclc_cdr_write_u16(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           uint16_t value);
 
NROS_PUBLIC
int32_t rclc_cdr_write_i16(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           int16_t value);
 
NROS_PUBLIC
int32_t rclc_cdr_write_u32(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           uint32_t value);
 
NROS_PUBLIC
int32_t rclc_cdr_write_i32(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           int32_t value);
 
NROS_PUBLIC
int32_t rclc_cdr_write_u64(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           uint64_t value);
 
NROS_PUBLIC
int32_t rclc_cdr_write_i64(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           int64_t value);
 
NROS_PUBLIC
int32_t rclc_cdr_write_f32(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           float value);
 
NROS_PUBLIC
int32_t rclc_cdr_write_f64(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           double value);
 
NROS_PUBLIC
int32_t rclc_cdr_write_string(uint8_t **ptr,
                              const uint8_t *end,
                              const uint8_t *origin,
                              const char *value);
 
NROS_PUBLIC
int32_t rclc_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 rclc_cdr_read_bool(const uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           bool *value);
 
NROS_PUBLIC
int32_t rclc_cdr_read_u8(const uint8_t **ptr,
                         const uint8_t *end,
                         const uint8_t *origin,
                         uint8_t *value);
 
NROS_PUBLIC
int32_t rclc_cdr_read_i8(const uint8_t **ptr,
                         const uint8_t *end,
                         const uint8_t *origin,
                         int8_t *value);
 
NROS_PUBLIC
int32_t rclc_cdr_read_u16(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint16_t *value);
 
NROS_PUBLIC
int32_t rclc_cdr_read_i16(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int16_t *value);
 
NROS_PUBLIC
int32_t rclc_cdr_read_u32(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint32_t *value);
 
NROS_PUBLIC
int32_t rclc_cdr_read_i32(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int32_t *value);
 
NROS_PUBLIC
int32_t rclc_cdr_read_u64(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint64_t *value);
 
NROS_PUBLIC
int32_t rclc_cdr_read_i64(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int64_t *value);
 
NROS_PUBLIC
int32_t rclc_cdr_read_f32(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          float *value);
 
NROS_PUBLIC
int32_t rclc_cdr_read_f64(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          double *value);
 
NROS_PUBLIC
int32_t rclc_cdr_read_string(const uint8_t **ptr,
                             const uint8_t *end,
                             const uint8_t *origin,
                             char *value,
                             size_t max_len);
 
NROS_PUBLIC
int32_t rclc_cdr_align(const uint8_t **ptr,
                       const uint8_t *end,
                       const uint8_t *origin,
                       size_t alignment);
 
NROS_PUBLIC struct rcl_clock_t rclc_clock_get_zero_initialized(void);
 
NROS_PUBLIC
rcl_ret_t rcl_clock_init(enum rcl_clock_type_t clock_type,
                         struct rcl_clock_t *clock,
                         struct rcl_allocator_t *allocator);
 
NROS_PUBLIC
rcl_ret_t rclc_clock_get_now_time(const struct rcl_clock_t *clock,
                                  struct rclc_time_t *time_out);
 
NROS_PUBLIC rcl_ret_t rcl_clock_get_now(const struct rcl_clock_t *clock, int64_t *nanoseconds);
 
NROS_PUBLIC bool rclc_clock_is_valid(const struct rcl_clock_t *clock);
 
NROS_PUBLIC enum rcl_clock_type_t rclc_clock_get_type(const struct rcl_clock_t *clock);
 
NROS_PUBLIC rcl_ret_t rcl_clock_fini(struct rcl_clock_t *clock);
 
NROS_PUBLIC rcl_ret_t rcl_enable_ros_time_override(const struct rcl_clock_t *clock);
 
NROS_PUBLIC rcl_ret_t rcl_disable_ros_time_override(const struct rcl_clock_t *clock);
 
NROS_PUBLIC
rcl_ret_t rcl_is_enabled_ros_time_override(const struct rcl_clock_t *clock,
                                           bool *is_enabled);
 
NROS_PUBLIC
rcl_ret_t rcl_set_ros_time_override(const struct rcl_clock_t *clock,
                                    int64_t nanoseconds);
 
NROS_PUBLIC
rcl_ret_t rclc_get_ros_time_override(const struct rcl_clock_t *clock,
                                     int64_t *nanoseconds);
 
NROS_PUBLIC bool rcl_clock_time_started(const struct rcl_clock_t *clock);
 
NROS_PUBLIC struct rclc_time_t rclc_time_from_nanoseconds(int64_t nanoseconds);
 
NROS_PUBLIC struct rcl_duration_t rclc_duration_from_nanoseconds(int64_t nanoseconds);
 
NROS_PUBLIC int64_t rclc_time_to_nanoseconds(const struct rclc_time_t *time);
 
NROS_PUBLIC
struct rclc_time_t rclc_time_add(struct rclc_time_t time,
                                 struct rcl_duration_t duration);
 
NROS_PUBLIC
struct rclc_time_t rclc_time_sub(struct rclc_time_t time,
                                 struct rcl_duration_t duration);
 
NROS_PUBLIC int rclc_time_compare(struct rclc_time_t a, struct rclc_time_t b);
 
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 const char *rclc_qos_policy_kind_to_cstr(uint32_t policy);
 
NROS_PUBLIC void rclc_set_trace_sink(void (*sink)(uint32_t, uint32_t));
 
NROS_PUBLIC int32_t rclc_set_default_trace_sink(void (*sink)(uint32_t, uint32_t));
 
NROS_PUBLIC void rclc_monitors_arm(void);
 
NROS_PUBLIC void rclc_trace_set_take(uint8_t handle, bool on, int32_t stamp_offset);
 
NROS_PUBLIC void rclc_trace_set_timer_every(uint8_t handle, uint16_t every);
 
NROS_PUBLIC rcl_ret_t rclc_set_custom_transport(const struct nros_transport_ops_t *ops);
 
NROS_PUBLIC rcl_ret_t rclc_clear_custom_transport(void);
 
NROS_PUBLIC rcl_ret_t rclc_has_custom_transport(void);
 
NROS_PUBLIC
struct rclc_polling_action_client_t rclc_get_zero_initialized_polling_action_client(void);
 
NROS_PUBLIC struct rcl_action_client_t rcl_action_get_zero_initialized_client(void);
 
NROS_PUBLIC
rcl_ret_t rcl_action_client_init(struct rcl_action_client_t *client,
                                 const struct rcl_node_t *node,
                                 const struct rclc_action_type_t *type_info,
                                 const char *action_name,
                                 const struct rcl_action_client_options_t *options);
 
NROS_PUBLIC struct rcl_action_client_options_t rcl_action_client_get_default_options(void);
 
NROS_PUBLIC
rcl_ret_t rclc_action_client_set_feedback_callback(struct rcl_action_client_t *client,
                                                   rclc_feedback_callback_t callback,
                                                   void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_action_client_set_result_callback(struct rcl_action_client_t *client,
                                                 rclc_result_callback_t callback,
                                                 void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_action_client_wait_for_action_server(struct rcl_action_client_t *client,
                                                    struct rclc_executor_t *executor,
                                                    uint32_t timeout_ms);
 
NROS_PUBLIC const char *rcl_action_client_get_action_name(const struct rcl_action_client_t *client);
 
NROS_PUBLIC
bool rclc_action_client_action_server_is_ready(const struct rcl_action_client_t *client,
                                               struct rclc_executor_t *executor);
 
NROS_PUBLIC
rcl_ret_t rclc_action_send_goal(struct rcl_action_client_t *client,
                                struct rclc_executor_t *executor,
                                const uint8_t *goal,
                                size_t goal_len,
                                struct rclc_goal_uuid_t *goal_uuid);
 
NROS_PUBLIC
rcl_ret_t rclc_action_cancel_goal(struct rcl_action_client_t *client,
                                  const struct rclc_goal_uuid_t *goal_uuid);
 
NROS_PUBLIC
rcl_ret_t rclc_action_get_result(struct rcl_action_client_t *client,
                                 struct rclc_executor_t *executor,
                                 const struct rclc_goal_uuid_t *goal_uuid,
                                 enum rclc_goal_status_t *status,
                                 uint8_t *result,
                                 size_t result_capacity,
                                 size_t *result_len);
 
NROS_PUBLIC rcl_ret_t rclc_action_try_recv_feedback(struct rcl_action_client_t *client);
 
NROS_PUBLIC
rcl_ret_t rclc_action_send_goal_async(struct rcl_action_client_t *client,
                                      const uint8_t *goal,
                                      size_t goal_len,
                                      struct rclc_goal_uuid_t *goal_uuid);
 
NROS_PUBLIC
rcl_ret_t rclc_action_get_result_async(struct rcl_action_client_t *client,
                                       const struct rclc_goal_uuid_t *goal_uuid);
 
NROS_PUBLIC
rcl_ret_t rclc_action_client_set_goal_response_callback(struct rcl_action_client_t *client,
                                                        rclc_goal_response_callback_t callback,
                                                        void *context);
 
NROS_PUBLIC rcl_ret_t rclc_action_client_poll(struct rcl_action_client_t *client);
 
NROS_PUBLIC
rcl_ret_t rcl_action_client_fini(struct rcl_action_client_t *client,
                                 struct rcl_node_t *node);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_init(struct rclc_polling_action_client_t *client,
                                          const struct rcl_node_t *node,
                                          const struct rclc_action_type_t *type_info,
                                          const char *action_name);
 
NROS_PUBLIC rcl_ret_t rclc_polling_action_client_fini(struct rclc_polling_action_client_t *client);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_send_goal_raw(struct rclc_polling_action_client_t *client,
                                                   const uint8_t *goal_cdr,
                                                   size_t goal_len,
                                                   uint8_t (*goal_id_out)[16]);
 
NROS_PUBLIC
int32_t rclc_polling_action_client_try_recv_goal_response_raw(struct rclc_polling_action_client_t *client,
                                                              uint8_t *buf,
                                                              size_t buf_len);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_send_get_result_request_raw(struct rclc_polling_action_client_t *client,
                                                                 const uint8_t (*goal_id)[16]);
 
NROS_PUBLIC
int32_t rclc_polling_action_client_try_recv_result_raw(struct rclc_polling_action_client_t *client,
                                                       uint8_t *buf,
                                                       size_t buf_len);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_send_cancel_request_raw(struct rclc_polling_action_client_t *client,
                                                             const uint8_t (*goal_id)[16]);
 
NROS_PUBLIC
int32_t rclc_polling_action_client_try_recv_cancel_response_raw(struct rclc_polling_action_client_t *client,
                                                                uint8_t *buf,
                                                                size_t buf_len);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_set_goal_response_wake_callback(struct rclc_polling_action_client_t *client,
                                                                     struct rclc_wake_state_t *state,
                                                                     void (*cb)(void*),
                                                                     void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_set_cancel_response_wake_callback(struct rclc_polling_action_client_t *client,
                                                                       struct rclc_wake_state_t *state,
                                                                       void (*cb)(void*),
                                                                       void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_set_result_wake_callback(struct rclc_polling_action_client_t *client,
                                                              struct rclc_wake_state_t *state,
                                                              void (*cb)(void*),
                                                              void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_set_feedback_wake_callback(struct rclc_polling_action_client_t *client,
                                                                struct rclc_wake_state_t *state,
                                                                void (*cb)(void*),
                                                                void *ctx);
 
NROS_PUBLIC
int32_t rclc_polling_action_client_try_recv_feedback_raw(struct rclc_polling_action_client_t *client,
                                                         uint8_t *buf,
                                                         size_t buf_len,
                                                         uint8_t (*goal_id_out)[16]);
 
NROS_PUBLIC rcl_ret_t rclc_goal_uuid_generate(struct rclc_goal_uuid_t *uuid);
 
NROS_PUBLIC
bool rclc_goal_uuid_equal(const struct rclc_goal_uuid_t *a,
                          const struct rclc_goal_uuid_t *b);
 
NROS_PUBLIC const char *rclc_goal_status_to_string(enum rclc_goal_status_t status);
 
NROS_PUBLIC
struct rclc_polling_action_server_t rclc_get_zero_initialized_polling_action_server(void);
 
NROS_PUBLIC struct rcl_action_server_t rcl_action_get_zero_initialized_server(void);
 
NROS_PUBLIC
rcl_ret_t rclc_action_server_init_with_callbacks(struct rcl_action_server_t *server,
                                                 const struct rcl_node_t *node,
                                                 const char *action_name,
                                                 const struct rclc_action_type_t *type_info,
                                                 rclc_goal_callback_t goal_callback,
                                                 rclc_cancel_callback_t cancel_callback,
                                                 rclc_accepted_callback_t accepted_callback,
                                                 void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_action_server_init_with_qos(struct rcl_action_server_t *server,
                                           const struct rcl_node_t *node,
                                           const char *action_name,
                                           const struct rclc_action_type_t *type_info,
                                           rclc_goal_callback_t goal_callback,
                                           rclc_cancel_callback_t cancel_callback,
                                           rclc_accepted_callback_t accepted_callback,
                                           void *context,
                                           const struct rclc_qos_t *qos);
 
NROS_PUBLIC struct rcl_action_server_options_t rcl_action_server_get_default_options(void);
 
NROS_PUBLIC
rcl_ret_t rclc_action_server_init_with_options(struct rcl_action_server_t *server,
                                               const struct rcl_node_t *node,
                                               const char *action_name,
                                               const struct rclc_action_type_t *type_info,
                                               rclc_goal_callback_t goal_callback,
                                               rclc_cancel_callback_t cancel_callback,
                                               rclc_accepted_callback_t accepted_callback,
                                               void *context,
                                               const struct rclc_qos_t *qos,
                                               const struct rcl_action_server_options_t *options);
 
NROS_PUBLIC
rcl_ret_t rclc_action_publish_feedback_raw(struct rcl_action_server_t *server,
                                           const struct rclc_goal_handle_t *goal,
                                           const uint8_t *feedback,
                                           size_t feedback_len);
 
NROS_PUBLIC
rcl_ret_t rclc_action_succeed(struct rcl_action_server_t *server,
                              const struct rclc_goal_handle_t *goal,
                              const uint8_t *result,
                              size_t result_len);
 
NROS_PUBLIC
rcl_ret_t rclc_action_abort(struct rcl_action_server_t *server,
                            const struct rclc_goal_handle_t *goal,
                            const uint8_t *result,
                            size_t result_len);
 
NROS_PUBLIC
rcl_ret_t rclc_action_canceled(struct rcl_action_server_t *server,
                               const struct rclc_goal_handle_t *goal,
                               const uint8_t *result,
                               size_t result_len);
 
NROS_PUBLIC
rcl_ret_t rclc_action_execute(struct rcl_action_server_t *server,
                              const struct rclc_goal_handle_t *goal);
 
NROS_PUBLIC
rcl_ret_t rclc_action_server_get_active_goal_count(struct rcl_action_server_t *server,
                                                   size_t *out);
 
NROS_PUBLIC const char *rcl_action_server_get_action_name(const struct rcl_action_server_t *server);
 
NROS_PUBLIC
bool rclc_action_server_goal_exists(struct rcl_action_server_t *server,
                                    const struct rclc_goal_handle_t *goal);
 
NROS_PUBLIC
rcl_ret_t rclc_action_expire_goals(struct rcl_action_server_t *server,
                                   size_t *num_expired);
 
NROS_PUBLIC
rcl_ret_t rclc_action_get_goal_status(const struct rcl_action_server_t *server,
                                      const struct rclc_goal_handle_t *goal,
                                      enum rclc_goal_status_t *status);
 
NROS_PUBLIC
rcl_ret_t rcl_action_server_fini(struct rcl_action_server_t *server,
                                 struct rcl_node_t *node);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_init(struct rclc_polling_action_server_t *server,
                                          const struct rcl_node_t *node,
                                          const struct rclc_action_type_t *type_info,
                                          const char *action_name);
 
NROS_PUBLIC rcl_ret_t rclc_polling_action_server_fini(struct rclc_polling_action_server_t *server);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_get_active_goal_count(struct rclc_polling_action_server_t *server,
                                                           size_t *out);
 
NROS_PUBLIC
bool rclc_polling_action_server_goal_exists(struct rclc_polling_action_server_t *server,
                                            const struct rclc_goal_handle_t *goal);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_expire_goals(struct rclc_polling_action_server_t *server,
                                                  size_t *num_expired);
 
NROS_PUBLIC
int32_t rclc_polling_action_server_try_recv_goal_request_raw(struct rclc_polling_action_server_t *server,
                                                             uint8_t *buf,
                                                             size_t buf_len,
                                                             uint8_t (*goal_id_out)[16],
                                                             int64_t *sequence_number_out);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_accept_goal_raw(struct rclc_polling_action_server_t *server,
                                                     const uint8_t (*goal_id)[16],
                                                     int64_t sequence_number);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_reject_goal_raw(struct rclc_polling_action_server_t *server,
                                                     int64_t sequence_number);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_publish_feedback_raw(struct rclc_polling_action_server_t *server,
                                                          const uint8_t (*goal_id)[16],
                                                          const uint8_t *feedback_cdr,
                                                          size_t feedback_len);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_complete_goal_raw(struct rclc_polling_action_server_t *server,
                                                       const uint8_t (*goal_id)[16],
                                                       enum rclc_goal_status_t status,
                                                       const uint8_t *result_cdr,
                                                       size_t result_len);
 
NROS_PUBLIC
int32_t rclc_polling_action_server_try_recv_cancel_request_raw(struct rclc_polling_action_server_t *server,
                                                               uint8_t (*goal_id_out)[16],
                                                               int64_t *sequence_number_out,
                                                               enum rclc_goal_status_t *current_status_out);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_send_cancel_reply_raw(struct rclc_polling_action_server_t *server,
                                                           int64_t sequence_number,
                                                           enum rclc_cancel_return_code_t return_code,
                                                           const uint8_t (*accepted)[16],
                                                           size_t accepted_count);
 
NROS_PUBLIC
int32_t rclc_polling_action_server_try_handle_get_result_raw(struct rclc_polling_action_server_t *server,
                                                             const uint8_t *default_result_cdr,
                                                             size_t default_result_len);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_set_goal_wake_callback(struct rclc_polling_action_server_t *server,
                                                            struct rclc_wake_state_t *state,
                                                            void (*cb)(void*),
                                                            void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_set_cancel_wake_callback(struct rclc_polling_action_server_t *server,
                                                              struct rclc_wake_state_t *state,
                                                              void (*cb)(void*),
                                                              void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_set_get_result_wake_callback(struct rclc_polling_action_server_t *server,
                                                                  struct rclc_wake_state_t *state,
                                                                  void (*cb)(void*),
                                                                  void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_subscription_set_liveliness_changed_callback(struct rcl_subscription_t *_sub,
                                                            rclc_event_liveliness_changed_cb_t _cb,
                                                            void *_user_context);
 
NROS_PUBLIC
rcl_ret_t rclc_subscription_set_requested_deadline_missed_callback(struct rcl_subscription_t *_sub,
                                                                   uint32_t _deadline_ms,
                                                                   rclc_event_subscriber_count_cb_t _cb,
                                                                   void *_user_context);
 
NROS_PUBLIC
rcl_ret_t rclc_subscription_set_message_lost_callback(struct rcl_subscription_t *_sub,
                                                      rclc_event_subscriber_count_cb_t _cb,
                                                      void *_user_context);
 
NROS_PUBLIC
rcl_ret_t rclc_publisher_set_liveliness_lost_callback(struct rcl_publisher_t *_pub_,
                                                      rclc_event_publisher_count_cb_t _cb,
                                                      void *_user_context);
 
NROS_PUBLIC
rcl_ret_t rclc_publisher_set_offered_deadline_missed_callback(struct rcl_publisher_t *_pub_,
                                                              uint32_t _deadline_ms,
                                                              rclc_event_publisher_count_cb_t _cb,
                                                              void *_user_context);
 
NROS_PUBLIC struct rclc_executor_t rclc_executor_get_zero_initialized_executor(void);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_init(struct rclc_executor_t *executor,
                             struct rcl_context_t *context,
                             size_t number_of_handles,
                             const struct rcl_allocator_t *allocator);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_set_timeout(struct rclc_executor_t *executor,
                                    uint64_t timeout_ns);
 
NROS_PUBLIC rcl_ret_t rclc_executor_ping(struct rclc_executor_t *executor, int32_t timeout_ms);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_get_node_names(struct rclc_executor_t *executor,
                                       rclc_node_visit_fn visit,
                                       void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_get_topic_names_and_types(struct rclc_executor_t *executor,
                                                  rclc_names_and_types_visit_fn visit,
                                                  void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_get_service_names_and_types(struct rclc_executor_t *executor,
                                                    rclc_names_and_types_visit_fn visit,
                                                    void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_count_publishers(struct rclc_executor_t *executor,
                                         const char *topic_name,
                                         size_t *out_count);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_count_subscribers(struct rclc_executor_t *executor,
                                          const char *topic_name,
                                          size_t *out_count);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_wait_for_publishers(struct rclc_executor_t *executor,
                                            const char *topic_name,
                                            size_t count,
                                            uint32_t timeout_ms);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_wait_for_subscribers(struct rclc_executor_t *executor,
                                             const char *topic_name,
                                             size_t count,
                                             uint32_t timeout_ms);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_get_publisher_names_and_types_by_node(struct rclc_executor_t *executor,
                                                              const char *node_name,
                                                              const char *node_namespace,
                                                              rclc_names_and_types_visit_fn visit,
                                                              void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_get_subscriber_names_and_types_by_node(struct rclc_executor_t *executor,
                                                               const char *node_name,
                                                               const char *node_namespace,
                                                               rclc_names_and_types_visit_fn visit,
                                                               void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_get_service_names_and_types_by_node(struct rclc_executor_t *executor,
                                                            const char *node_name,
                                                            const char *node_namespace,
                                                            rclc_names_and_types_visit_fn visit,
                                                            void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_get_client_names_and_types_by_node(struct rclc_executor_t *executor,
                                                           const char *node_name,
                                                           const char *node_namespace,
                                                           rclc_names_and_types_visit_fn visit,
                                                           void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_get_publishers_info_by_topic(struct rclc_executor_t *executor,
                                                     const char *topic_name,
                                                     rclc_endpoint_info_visit_fn visit,
                                                     void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_get_subscriptions_info_by_topic(struct rclc_executor_t *executor,
                                                        const char *topic_name,
                                                        rclc_endpoint_info_visit_fn visit,
                                                        void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_set_semantics(struct rclc_executor_t *executor,
                                      enum rclc_executor_semantics_t semantics);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_node_init(struct rclc_executor_t *executor,
                                  struct rcl_node_t *node,
                                  const char *name,
                                  const struct rcl_node_options_t *options);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_set_trigger(struct rclc_executor_t *executor,
                                    rclc_executor_trigger_t trigger,
                                    void *context);
 
NROS_PUBLIC
bool rclc_executor_trigger_any(const struct rclc_executor_trigger_handle_t *handles,
                               size_t size,
                               void *obj);
 
NROS_PUBLIC
bool rclc_executor_trigger_all(const struct rclc_executor_trigger_handle_t *handles,
                               size_t size,
                               void *obj);
 
NROS_PUBLIC
bool rclc_executor_trigger_always(const struct rclc_executor_trigger_handle_t *handles,
                                  size_t size,
                                  void *obj);
 
NROS_PUBLIC
bool rclc_executor_trigger_one(const struct rclc_executor_trigger_handle_t *handles,
                               size_t size,
                               void *obj);
 
NROS_PUBLIC
bool rclc_executor_trigger_index(const struct rclc_executor_trigger_handle_t *handles,
                                 size_t size,
                                 void *obj);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_raw_validated(struct rclc_executor_t *executor,
                                                       struct rcl_subscription_t *subscription,
                                                       rclc_subscription_validated_callback_t callback,
                                                       void *context,
                                                       enum rclc_executor_handle_invocation_t invocation);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_with_context(struct rclc_executor_t *executor,
                                                      struct rcl_subscription_t *subscription,
                                                      void *msg,
                                                      rclc_subscription_callback_with_context_t callback,
                                                      void *context,
                                                      enum rclc_executor_handle_invocation_t invocation);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_raw(struct rclc_executor_t *executor,
                                             struct rcl_subscription_t *subscription,
                                             rclc_subscription_raw_callback_t callback,
                                             void *context,
                                             enum rclc_executor_handle_invocation_t invocation);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_raw_with_info(struct rclc_executor_t *executor,
                                                       const struct rcl_node_t *node,
                                                       const char *topic_name,
                                                       const char *type_name,
                                                       const char *type_hash,
                                                       const struct rclc_qos_t *qos,
                                                       rclc_subscription_info_callback_t callback,
                                                       void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_with_info(struct rclc_executor_t *executor,
                                                   struct rcl_subscription_t *subscription,
                                                   rclc_subscription_info_callback_t callback,
                                                   void *context,
                                                   enum rclc_executor_handle_invocation_t invocation);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_timer(struct rclc_executor_t *executor,
                                  struct rcl_timer_t *timer);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_in_group(struct rclc_executor_t *executor,
                                                  struct rcl_subscription_t *subscription,
                                                  rclc_subscription_raw_callback_t callback,
                                                  void *context,
                                                  enum rclc_executor_handle_invocation_t invocation,
                                                  const char *callback_group);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_timer_in_group(struct rclc_executor_t *executor,
                                           struct rcl_timer_t *timer,
                                           const char *callback_group);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_service_raw(struct rclc_executor_t *executor,
                                        struct rcl_service_t *service,
                                        rclc_service_raw_callback_t callback,
                                        void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_attach_client(struct rclc_executor_t *executor,
                                      struct rcl_client_t *client);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_attach_action_server(struct rclc_executor_t *executor,
                                             struct rcl_action_server_t *server);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_attach_action_client(struct rclc_executor_t *executor,
                                             struct rcl_action_client_t *client);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_remove_action_server(struct rclc_executor_t *executor,
                                             struct rcl_action_server_t *server);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_remove_action_client(struct rclc_executor_t *executor,
                                             struct rcl_action_client_t *client);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_remove_subscription(struct rclc_executor_t *executor,
                                            const struct rcl_subscription_t *subscription);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_remove_timer(struct rclc_executor_t *executor,
                                     const struct rcl_timer_t *timer);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_remove_service(struct rclc_executor_t *executor,
                                       const struct rcl_service_t *service);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_remove_client(struct rclc_executor_t *executor,
                                      const struct rcl_client_t *client);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_spin_some(struct rclc_executor_t *executor,
                                  uint64_t timeout_ns);
 
NROS_PUBLIC rcl_ret_t rclc_executor_spin(struct rclc_executor_t *executor);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_spin_period(struct rclc_executor_t *executor,
                                    uint64_t period_ns);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_spin_one_period(struct rclc_executor_t *executor,
                                        uint64_t period_ns);
 
NROS_PUBLIC rcl_ret_t rclc_executor_cancel(struct rclc_executor_t *executor);
 
NROS_PUBLIC bool rclc_executor_is_spinning(const struct rclc_executor_t *executor);
 
NROS_PUBLIC rcl_ret_t rclc_executor_fini(struct rclc_executor_t *executor);
 
NROS_PUBLIC int rclc_executor_get_handle_count(const struct rclc_executor_t *executor);
 
NROS_PUBLIC size_t rclc_executor_get_arena_used(const struct rclc_executor_t *executor);
 
NROS_PUBLIC size_t rclc_executor_get_arena_capacity(const struct rclc_executor_t *executor);
 
NROS_PUBLIC bool rclc_executor_is_valid(const struct rclc_executor_t *executor);
 
NROS_PUBLIC int rclc_executor_get_remaining_handles(const struct rclc_executor_t *executor);
 
NROS_PUBLIC rclc_sched_context_id_t rclc_executor_default_sched_context_id(void);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_time_triggered_dispatcher(struct rclc_executor_t *executor,
                                                      uint32_t major_frame_us);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_create_sched_context(struct rclc_executor_t *executor,
                                             const struct rclc_sched_context_t *cfg,
                                             rclc_sched_context_id_t *out_sc_id);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_bind_handle_to_sched_context(struct rclc_executor_t *executor,
                                                     size_t handle,
                                                     rclc_sched_context_id_t sc_id);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_pre_shutdown_callback(struct rclc_executor_t *executor,
                                                  rclc_shutdown_callback_t callback,
                                                  void *context,
                                                  rclc_shutdown_callback_handle_t *out_handle);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_add_on_shutdown_callback(struct rclc_executor_t *executor,
                                                 rclc_shutdown_callback_t callback,
                                                 void *context,
                                                 rclc_shutdown_callback_handle_t *out_handle);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_remove_pre_shutdown_callback(struct rclc_executor_t *executor,
                                                     rclc_shutdown_callback_handle_t handle);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_remove_on_shutdown_callback(struct rclc_executor_t *executor,
                                                    rclc_shutdown_callback_handle_t handle);
 
NROS_PUBLIC struct rcl_guard_condition_t rcl_get_zero_initialized_guard_condition(void);
 
NROS_PUBLIC
rcl_ret_t rclc_node_create_guard_condition(struct rcl_node_t *node,
                                           struct rcl_guard_condition_t *out,
                                           rclc_guard_condition_callback_t callback,
                                           void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_node_get_graph_guard_condition(struct rcl_node_t *node,
                                              struct rcl_guard_condition_t *out,
                                              rclc_guard_condition_callback_t callback,
                                              void *context);
 
NROS_PUBLIC rcl_ret_t rclc_guard_condition_trigger(struct rcl_guard_condition_t *guard);
 
NROS_PUBLIC rcl_ret_t rcl_trigger_guard_condition(struct rcl_guard_condition_t *guard);
 
NROS_PUBLIC bool rclc_guard_condition_is_triggered(const struct rcl_guard_condition_t *guard);
 
NROS_PUBLIC rcl_ret_t rclc_guard_condition_clear(struct rcl_guard_condition_t *guard);
 
NROS_PUBLIC bool rclc_guard_condition_is_valid(const struct rcl_guard_condition_t *guard);
 
NROS_PUBLIC rcl_ret_t rcl_guard_condition_fini(struct rcl_guard_condition_t *guard);
 
NROS_PUBLIC struct rcl_lifecycle_state_machine_t rclc_lifecycle_get_zero_initialized(void);
 
NROS_PUBLIC rcl_ret_t rclc_lifecycle_init(struct rcl_lifecycle_state_machine_t *sm);
 
NROS_PUBLIC rcl_ret_t rclc_lifecycle_fini(struct rcl_lifecycle_state_machine_t *sm);
 
NROS_PUBLIC
rcl_ret_t rclc_lifecycle_state_machine_change_state(struct rcl_lifecycle_state_machine_t *sm,
                                                    uint8_t transition_id);
 
NROS_PUBLIC
uint8_t rclc_lifecycle_get_current_state(const struct rcl_lifecycle_state_machine_t *sm);
 
NROS_PUBLIC
rcl_ret_t rclc_lifecycle_state_machine_register_on_configure(struct rcl_lifecycle_state_machine_t *sm,
                                                             rclc_lifecycle_callback_t cb,
                                                             void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_lifecycle_state_machine_register_on_activate(struct rcl_lifecycle_state_machine_t *sm,
                                                            rclc_lifecycle_callback_t cb,
                                                            void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_lifecycle_state_machine_register_on_deactivate(struct rcl_lifecycle_state_machine_t *sm,
                                                              rclc_lifecycle_callback_t cb,
                                                              void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_lifecycle_state_machine_register_on_cleanup(struct rcl_lifecycle_state_machine_t *sm,
                                                           rclc_lifecycle_callback_t cb,
                                                           void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_lifecycle_register_on_shutdown(struct rcl_lifecycle_state_machine_t *sm,
                                              rclc_lifecycle_callback_t cb,
                                              void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_lifecycle_register_on_error(struct rcl_lifecycle_state_machine_t *sm,
                                           rclc_lifecycle_callback_t cb,
                                           void *context);
 
NROS_PUBLIC const char *rclc_lifecycle_transition_label(uint8_t transition_id);
 
NROS_PUBLIC const char *rclc_lifecycle_state_label(uint8_t state_id);
 
NROS_PUBLIC uint8_t rclc_lifecycle_transition_start_state(uint8_t transition_id);
 
NROS_PUBLIC uint8_t rclc_lifecycle_transition_goal_state(uint8_t transition_id);
 
NROS_PUBLIC rcl_ret_t rclc_lifecycle_transition_graph(const uint8_t **out_ids, size_t *out_count);
 
NROS_PUBLIC rcl_ret_t rclc_executor_register_lifecycle_services(struct rclc_executor_t *executor);
 
NROS_PUBLIC uint8_t rclc_executor_lifecycle_get_current_state(struct rclc_executor_t *executor);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_change_state(struct rclc_executor_t *executor,
                                               uint8_t transition_id);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_configure(struct rclc_executor_t *executor,
                                                        rclc_lifecycle_callback_t cb,
                                                        void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_activate(struct rclc_executor_t *executor,
                                                       rclc_lifecycle_callback_t cb,
                                                       void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_deactivate(struct rclc_executor_t *executor,
                                                         rclc_lifecycle_callback_t cb,
                                                         void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_cleanup(struct rclc_executor_t *executor,
                                                      rclc_lifecycle_callback_t cb,
                                                      void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_shutdown(struct rclc_executor_t *executor,
                                                       rclc_lifecycle_callback_t cb,
                                                       void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_error(struct rclc_executor_t *executor,
                                                    rclc_lifecycle_callback_t cb,
                                                    void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_node_set_qos_overrides(struct rcl_node_t *node,
                                      const struct rclc_qos_override_t *overrides,
                                      size_t len);
 
NROS_PUBLIC struct rcl_node_options_t rcl_node_get_default_options(void);
 
NROS_PUBLIC struct rcl_node_t rcl_get_zero_initialized_node(void);
 
NROS_PUBLIC
rcl_ret_t rclc_node_init_default(struct rcl_node_t *node,
                                 const char *name,
                                 const char *namespace_,
                                 const struct rclc_support_t *support);
 
NROS_PUBLIC
rcl_ret_t rclc_node_init_ex(struct rcl_node_t *node,
                            const struct rclc_support_t *support,
                            const char *name,
                            const struct rcl_node_options_t *options);
 
NROS_PUBLIC rcl_ret_t rcl_node_fini(struct rcl_node_t *node);
 
NROS_PUBLIC const char *rcl_node_get_name(const struct rcl_node_t *node);
 
NROS_PUBLIC const char *rcl_node_get_namespace(const struct rcl_node_t *node);
 
NROS_PUBLIC
rcl_ret_t rclc_get_fully_qualified_name(const char *node_name,
                                        const char *node_namespace,
                                        char *buf,
                                        size_t buf_len,
                                        size_t *out_len);
 
NROS_PUBLIC
rcl_ret_t rclc_node_get_fully_qualified_name(const struct rcl_node_t *node,
                                             char *buf,
                                             size_t buf_len,
                                             size_t *out_len);
 
NROS_PUBLIC const char *rclc_node_get_serialization_format(const struct rcl_node_t *node);
 
NROS_PUBLIC const void *rclc_node_get_logger(const struct rcl_node_t *node);
 
NROS_PUBLIC bool rcl_node_is_valid(const struct rcl_node_t *node);
 
NROS_PUBLIC rcl_ret_t rcl_node_get_domain_id(const struct rcl_node_t *node, size_t *domain_id);
 
NROS_PUBLIC
rcl_ret_t rclc_node_resolve_name(const struct rcl_node_t *node,
                                 const char *input_name,
                                 bool only_expand,
                                 char *output_name,
                                 size_t output_size);
 
NROS_PUBLIC struct rcl_publisher_options_t rcl_publisher_get_default_options(void);
 
NROS_PUBLIC struct rcl_publisher_t rcl_get_zero_initialized_publisher(void);
 
NROS_PUBLIC
rcl_ret_t rclc_publisher_init_default(struct rcl_publisher_t *publisher,
                                      const struct rcl_node_t *node,
                                      const struct rclc_message_type_t *type_info,
                                      const char *topic_name);
 
NROS_PUBLIC
rcl_ret_t rclc_publisher_init_with_qos(struct rcl_publisher_t *publisher,
                                       const struct rcl_node_t *node,
                                       const struct rclc_message_type_t *type_info,
                                       const char *topic_name,
                                       const struct rclc_qos_t *qos);
 
NROS_PUBLIC
rcl_ret_t rclc_publisher_init_with_options(struct rcl_publisher_t *publisher,
                                           const struct rcl_node_t *node,
                                           const struct rclc_message_type_t *type_info,
                                           const char *topic_name,
                                           const struct rclc_qos_t *qos,
                                           const struct rcl_publisher_options_t *options);
 
NROS_PUBLIC
rcl_ret_t rclc_publish_raw(const struct rcl_publisher_t *publisher,
                           const uint8_t *data,
                           size_t len);
 
NROS_PUBLIC
rcl_ret_t rcl_publish(const struct rcl_publisher_t *publisher,
                      const void *ros_message,
                      struct rmw_publisher_allocation_t *allocation);
 
NROS_PUBLIC
rcl_ret_t rclc_publisher_publish_streamed(const struct rcl_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 rcl_ret_t rcl_publisher_assert_liveliness(const struct rcl_publisher_t *publisher);
 
NROS_PUBLIC
rcl_ret_t rclc_publisher_get_gid(const struct rcl_publisher_t *publisher,
                                 uint8_t *out_gid,
                                 size_t gid_capacity);
 
NROS_PUBLIC
rcl_ret_t rclc_publisher_loan(const struct rcl_publisher_t *publisher,
                              size_t requested_len,
                              uint8_t **out_buf,
                              size_t *out_cap,
                              void **out_token);
 
NROS_PUBLIC
rcl_ret_t rclc_publisher_commit(const struct rcl_publisher_t *publisher,
                                void *token,
                                size_t actual_len);
 
NROS_PUBLIC rcl_ret_t rclc_publisher_discard(const struct rcl_publisher_t *publisher, void *token);
 
NROS_PUBLIC
rcl_ret_t rclc_publisher_get_actual_qos(const struct rcl_publisher_t *publisher,
                                        struct rclc_qos_t *out_qos);
 
NROS_PUBLIC
rcl_ret_t rcl_publisher_fini(struct rcl_publisher_t *publisher,
                             struct rcl_node_t *node);
 
NROS_PUBLIC const char *rcl_publisher_get_topic_name(const struct rcl_publisher_t *publisher);
 
NROS_PUBLIC
rcl_ret_t rclc_publisher_get_subscription_count(const struct rcl_publisher_t *publisher,
                                                struct rclc_executor_t *executor,
                                                size_t *out_count);
 
NROS_PUBLIC bool rcl_publisher_is_valid(const struct rcl_publisher_t *publisher);
 
NROS_PUBLIC struct rclc_polling_service_t rclc_get_zero_initialized_polling_service(void);
 
NROS_PUBLIC struct rcl_service_t rcl_get_zero_initialized_service(void);
 
NROS_PUBLIC
rcl_ret_t rclc_service_init_with_qos(struct rcl_service_t *service,
                                     const struct rcl_node_t *node,
                                     const struct rclc_service_type_t *type_info,
                                     const char *service_name,
                                     const struct rclc_qos_t *qos);
 
NROS_PUBLIC
rcl_ret_t rclc_service_init_default(struct rcl_service_t *service,
                                    const struct rcl_node_t *node,
                                    const struct rclc_service_type_t *type_info,
                                    const char *service_name);
 
NROS_PUBLIC struct rcl_service_options_t rcl_service_get_default_options(void);
 
NROS_PUBLIC
rcl_ret_t rclc_service_init_with_options(struct rcl_service_t *service,
                                         const struct rcl_node_t *node,
                                         const struct rclc_service_type_t *type_info,
                                         const char *service_name,
                                         const struct rclc_qos_t *qos,
                                         const struct rcl_service_options_t *options);
 
NROS_PUBLIC rcl_ret_t rcl_service_fini(struct rcl_service_t *service, struct rcl_node_t *node);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_service_init(struct rclc_polling_service_t *service,
                                    const struct rcl_node_t *node,
                                    const struct rclc_service_type_t *type_info,
                                    const char *service_name);
 
NROS_PUBLIC rcl_ret_t rclc_polling_service_fini(struct rclc_polling_service_t *service);
 
NROS_PUBLIC struct rclc_wake_state_t rclc_wake_state_get_zero_initialized(void);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_service_set_wake_callback(struct rclc_polling_service_t *service,
                                                 struct rclc_wake_state_t *state,
                                                 void (*cb)(void*),
                                                 void *ctx);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_client_set_wake_callback(struct rclc_polling_client_t *client,
                                                struct rclc_wake_state_t *state,
                                                void (*cb)(void*),
                                                void *ctx);
 
NROS_PUBLIC
int32_t rclc_polling_service_take_request_raw(struct rclc_polling_service_t *service,
                                              uint8_t *buf,
                                              size_t buf_len,
                                              int64_t *sequence_number);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_service_send_response_raw(struct rclc_polling_service_t *service,
                                                 int64_t sequence_number,
                                                 const uint8_t *data,
                                                 size_t len);
 
NROS_PUBLIC void rclc_service_typed_report_error(int32_t error, const char *type_name);
 
NROS_PUBLIC const char *rcl_service_get_service_name(const struct rcl_service_t *service);
 
NROS_PUBLIC bool rcl_service_is_valid(const struct rcl_service_t *service);
 
NROS_PUBLIC struct rclc_polling_client_t rclc_get_zero_initialized_polling_client(void);
 
NROS_PUBLIC struct rcl_client_t rcl_get_zero_initialized_client(void);
 
NROS_PUBLIC
rcl_ret_t rclc_client_init_default(struct rcl_client_t *client,
                                   const struct rcl_node_t *node,
                                   const struct rclc_service_type_t *type_info,
                                   const char *service_name);
 
NROS_PUBLIC
rcl_ret_t rclc_client_init_with_qos(struct rcl_client_t *client,
                                    const struct rcl_node_t *node,
                                    const struct rclc_service_type_t *type_info,
                                    const char *service_name,
                                    const struct rclc_qos_t *qos);
 
NROS_PUBLIC struct rcl_client_options_t rcl_client_get_default_options(void);
 
NROS_PUBLIC
rcl_ret_t rclc_client_init_with_options(struct rcl_client_t *client,
                                        const struct rcl_node_t *node,
                                        const struct rclc_service_type_t *type_info,
                                        const char *service_name,
                                        const struct rclc_qos_t *qos,
                                        const struct rcl_client_options_t *options);
 
NROS_PUBLIC rcl_ret_t rcl_client_fini(struct rcl_client_t *client, struct rcl_node_t *node);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_client_init(struct rclc_polling_client_t *client,
                                   const struct rcl_node_t *node,
                                   const struct rclc_service_type_t *type_info,
                                   const char *service_name);
 
NROS_PUBLIC rcl_ret_t rclc_polling_client_fini(struct rclc_polling_client_t *client);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_client_send_request_raw(struct rclc_polling_client_t *client,
                                               const uint8_t *data,
                                               size_t len);
 
NROS_PUBLIC
int32_t rclc_polling_client_take_response_raw(struct rclc_polling_client_t *client,
                                              uint8_t *buf,
                                              size_t buf_len);
 
NROS_PUBLIC
rcl_ret_t rclc_client_set_response_callback(struct rcl_client_t *client,
                                            rclc_response_callback_t callback,
                                            void *context);
 
NROS_PUBLIC rcl_ret_t rclc_client_set_timeout(struct rcl_client_t *client, uint32_t timeout_ms);
 
NROS_PUBLIC rcl_ret_t rclc_client_server_available(struct rcl_client_t *client, int32_t *out);
 
NROS_PUBLIC
rcl_ret_t rclc_client_wait_for_service(struct rcl_client_t *client,
                                       uint32_t timeout_ms);
 
NROS_PUBLIC bool rclc_client_service_is_ready(const struct rcl_client_t *client);
 
NROS_PUBLIC
rcl_ret_t rclc_client_send_request_async(struct rcl_client_t *client,
                                         const uint8_t *request_data,
                                         size_t request_len);
 
NROS_PUBLIC
rcl_ret_t rclc_client_take_response(struct rcl_client_t *client,
                                    uint8_t *response_data,
                                    size_t response_capacity,
                                    size_t *response_len);
 
NROS_PUBLIC
rcl_ret_t rclc_client_call(struct rcl_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 *rcl_client_get_service_name(const struct rcl_client_t *client);
 
NROS_PUBLIC bool rcl_client_is_valid(const struct rcl_client_t *client);
 
NROS_PUBLIC
rcl_ret_t rclc_service_request_subscription_get_actual_qos(const struct rcl_service_t *handle,
                                                           struct rclc_qos_t *out_qos);
 
NROS_PUBLIC
rcl_ret_t rclc_service_response_publisher_get_actual_qos(const struct rcl_service_t *handle,
                                                         struct rclc_qos_t *out_qos);
 
NROS_PUBLIC
rcl_ret_t rclc_client_request_publisher_get_actual_qos(const struct rcl_client_t *handle,
                                                       struct rclc_qos_t *out_qos);
 
NROS_PUBLIC
rcl_ret_t rclc_client_response_subscription_get_actual_qos(const struct rcl_client_t *handle,
                                                           struct rclc_qos_t *out_qos);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_service_request_subscription_get_actual_qos(struct rclc_polling_service_t *handle,
                                                                   struct rclc_qos_t *out_qos);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_service_response_publisher_get_actual_qos(struct rclc_polling_service_t *handle,
                                                                 struct rclc_qos_t *out_qos);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_client_request_publisher_get_actual_qos(struct rclc_polling_client_t *handle,
                                                               struct rclc_qos_t *out_qos);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_client_response_subscription_get_actual_qos(struct rclc_polling_client_t *handle,
                                                                   struct rclc_qos_t *out_qos);
 
NROS_PUBLIC struct rclc_polling_subscription_t rclc_get_zero_initialized_polling_subscription(void);
 
NROS_PUBLIC struct rcl_subscription_t rcl_get_zero_initialized_subscription(void);
 
NROS_PUBLIC struct rcl_subscription_options_t rcl_subscription_get_default_options(void);
 
NROS_PUBLIC
rcl_ret_t rclc_subscription_init_default(struct rcl_subscription_t *subscription,
                                         const struct rcl_node_t *node,
                                         const struct rclc_message_type_t *type_info,
                                         const char *topic_name);
 
NROS_PUBLIC
rcl_ret_t rclc_subscription_init_with_qos(struct rcl_subscription_t *subscription,
                                          const struct rcl_node_t *node,
                                          const struct rclc_message_type_t *type_info,
                                          const char *topic_name,
                                          const struct rclc_qos_t *qos);
 
NROS_PUBLIC
rcl_ret_t rclc_subscription_init_with_options(struct rcl_subscription_t *subscription,
                                              const struct rcl_node_t *node,
                                              const struct rclc_message_type_t *type_info,
                                              const char *topic_name,
                                              const struct rclc_qos_t *qos,
                                              const struct rcl_subscription_options_t *options);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_init(struct rclc_polling_subscription_t *subscription,
                                         const struct rcl_node_t *node,
                                         const struct rclc_message_type_t *type_info,
                                         const char *topic_name);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_init_with_qos(struct rclc_polling_subscription_t *subscription,
                                                  const struct rcl_node_t *node,
                                                  const struct rclc_message_type_t *type_info,
                                                  const char *topic_name,
                                                  const struct rclc_qos_t *qos);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_set_wake_callback(struct rclc_polling_subscription_t *subscription,
                                                      struct rclc_wake_state_t *state,
                                                      void (*cb)(void*),
                                                      void *ctx);
 
NROS_PUBLIC
int32_t rclc_polling_subscription_take_serialized(struct rclc_polling_subscription_t *subscription,
                                                  uint8_t *buf,
                                                  size_t buf_len);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_take(struct rclc_polling_subscription_t *subscription,
                                         void *ros_message,
                                         struct rmw_subscription_allocation_t *allocation);
 
NROS_PUBLIC
int32_t rclc_polling_subscription_take_validated(struct rclc_polling_subscription_t *subscription,
                                                 uint8_t *buf,
                                                 size_t buf_len,
                                                 struct rclc_integrity_status_t *out_status);
 
NROS_PUBLIC
int32_t rclc_polling_subscription_borrow(struct rclc_polling_subscription_t *subscription,
                                         const uint8_t **out_buf,
                                         size_t *out_len,
                                         void **out_token);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_release(struct rclc_polling_subscription_t *subscription,
                                            void *token);
 
NROS_PUBLIC
int32_t rclc_polling_subscription_take_sequence(struct rclc_polling_subscription_t *subscription,
                                                uint8_t *buf,
                                                size_t per_msg_cap,
                                                size_t max_msgs,
                                                size_t *out_lens);
 
NROS_PUBLIC
rcl_ret_t rclc_subscription_get_actual_qos(const struct rcl_subscription_t *subscription,
                                           struct rclc_qos_t *out_qos);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_get_actual_qos(struct rclc_polling_subscription_t *subscription,
                                                   struct rclc_qos_t *out_qos);
 
NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_fini(struct rclc_polling_subscription_t *subscription);
 
NROS_PUBLIC
rcl_ret_t rcl_subscription_fini(struct rcl_subscription_t *subscription,
                                struct rcl_node_t *node);
 
NROS_PUBLIC
const char *rcl_subscription_get_topic_name(const struct rcl_subscription_t *subscription);
 
NROS_PUBLIC
rcl_ret_t rclc_subscription_get_publisher_count(const struct rcl_subscription_t *subscription,
                                                struct rclc_executor_t *executor,
                                                size_t *out_count);
 
NROS_PUBLIC bool rcl_subscription_is_valid(const struct rcl_subscription_t *subscription);
 
NROS_PUBLIC struct rclc_support_t rclc_support_get_zero_initialized(void);
 
NROS_PUBLIC
rcl_ret_t rclc_support_init(struct rclc_support_t *support,
                            int argc,
                            const char *const *argv,
                            const struct rcl_allocator_t *allocator);
 
NROS_PUBLIC
rcl_ret_t nros_c_support_init_baked(struct rclc_support_t *support,
                                    int argc,
                                    const char *const *argv,
                                    const struct rcl_allocator_t *allocator,
                                    const char *rmw,
                                    const char *locator,
                                    uint8_t domain_id);
 
NROS_PUBLIC
rcl_ret_t rclc_support_init_with_locator(struct rclc_support_t *support,
                                         const char *locator,
                                         uint8_t domain_id);
 
NROS_PUBLIC
rcl_ret_t rclc_support_init_named(struct rclc_support_t *support,
                                  const char *locator,
                                  uint8_t domain_id,
                                  const char *session_name);
 
NROS_PUBLIC
rcl_ret_t rclc_support_init_rmw(struct rclc_support_t *support,
                                const char *locator,
                                uint8_t domain_id,
                                const char *session_name,
                                const char *rmw);
 
NROS_PUBLIC rcl_ret_t rclc_support_fini(struct rclc_support_t *support);
 
NROS_PUBLIC bool rclc_support_is_valid(const struct rclc_support_t *support);
 
NROS_PUBLIC struct rcl_timer_t rcl_get_zero_initialized_timer(void);
 
NROS_PUBLIC
rcl_ret_t rclc_timer_init_with_context(struct rcl_timer_t *timer,
                                       uint64_t period_ns,
                                       rclc_timer_callback_with_context_t callback,
                                       void *context);
 
NROS_PUBLIC
rcl_ret_t rclc_timer_init_on_clock(struct rcl_timer_t *timer,
                                   const struct rcl_clock_t *clock,
                                   uint64_t period_ns,
                                   rclc_timer_callback_with_context_t callback,
                                   void *context);
 
NROS_PUBLIC rcl_ret_t rcl_timer_cancel(struct rcl_timer_t *timer);
 
NROS_PUBLIC rcl_ret_t rcl_timer_reset(struct rcl_timer_t *timer);
 
NROS_PUBLIC rcl_ret_t rcl_timer_fini(struct rcl_timer_t *timer);
 
NROS_PUBLIC bool rclc_timer_is_valid(const struct rcl_timer_t *timer);
 
NROS_PUBLIC uint64_t rclc_timer_get_period(const struct rcl_timer_t *timer);
 
NROS_PUBLIC
rcl_ret_t rcl_timer_get_time_until_next_call(const struct rcl_timer_t *timer,
                                             int64_t *time_until_next_call_ns);
 
NROS_PUBLIC rcl_ret_t rcl_timer_is_canceled(const struct rcl_timer_t *timer, bool *is_canceled);
 
NROS_PUBLIC rcl_ret_t rcl_timer_is_ready(const struct rcl_timer_t *timer, bool *is_ready);
 
NROS_PUBLIC
rcl_ret_t rcl_timer_get_time_since_last_call(const struct rcl_timer_t *timer,
                                             int64_t *time_since_last_call_ns);
 
NROS_PUBLIC
rcl_ret_t rcl_timer_exchange_period(const struct rcl_timer_t *timer,
                                    int64_t new_period,
                                    int64_t *old_period);
 
NROS_PUBLIC
rcl_ret_t rcl_timer_get_next_call_time(const struct rcl_timer_t *timer,
                                       int64_t *next_call_time);
 
#ifdef __cplusplus
}  // extern "C"
#endif  // __cplusplus
 
#endif  /* NROS_GENERATED_H */