RCL
===
rcl_get_zero_initialized_node () [NODE]
rcl_node_init (node, name, namespace, context, options) [RET]
rcl_node_fini (node) [RET]
rcl_node_is_valid (node) [BOOL]
rcl_node_is_valid_except_context (node) [BOOL]
rcl_node_get_name (node) [NAME]
rcl_node_get_namespace (node) [NAMESPACE]
rcl_node_get_fully_qualified_name (node) [FQN]
rcl_node_get_options (node) [OPTIONS]
rcl_node_get_domain_id (node, domain_id) [RET]
rcl_node_get_rmw_handle (node) [RMW NODE]
rcl_node_get_rcl_instance_id (node) [INSTANCE ID]
rcl_node_get_graph_guard_condition (node) [GUARD CONDITION]
rcl_node_get_logger_name (node) [LOGGER NAME]

rcl_get_zero_initialized_publisher () [PUBLISHER]
rcl_publisher_init (publisher, node, type_support, topic_name, options) [RET]
rcl_publisher_fini (publisher, node) [RET]
rcl_publisher_get_default_options () [options]
rcl_borrow_loaned_message (publisher, type_support, ros_message) [RET]
rcl_return_loaned_message_from_publisher (publisher, loaned_message) [RET]
rcl_publish (publisher, ros_message, allocation) [RET]
rcl_publish_serialized_message (publisher, serialized_message, allocation) [RET]
rcl_publish_loaned_message (publisher, ros_message, allocation) [RET]
rcl_publisher_assert_liveliness (publisher) [RET]
rcl_publisher_get_topic_name (publisher) [TOPIC NAME]
rcl_publisher_get_options (publisher) [OPTIONS]
rcl_publisher_get_rmw_handle (publisher) [RMW PUBLISHER]
rcl_publisher_get_context (publisher) [CONTEXT]
rcl_publisher_is_valid (publisher) [BOOL]
rcl_publisher_is_valid_except_context (publisher) [BOOL]
rcl_publisher_get_subscription_count (publisher, subscription_count) [RET]
rcl_publisher_get_actual_qos (publisher) [RMW QOS PROFILE]
rcl_publisher_can_loan_messages (publisher) [BOOL]

rcl_get_zero_initialized_subscription () [SUBSCRIBER]
rcl_subscription_init (subscriber, node, type_support, topic_name, options) [RET]
rcl_subscription_fini (subscriber, node) [RET]
rcl_subscription_get_default_options() [OPTIONS]
rcl_take (subscriber, ros_message, message_info, allocation) [RET]
rcl_take_sequence (subscriber, message_sequence, message_info_sequence, allocation) [RET]
rcl_take_serialized_message (subscriber, serialized_message, message_info, allocation) [RET]
rcl_take_loaned_message (subscriber, loaned_message, message_info, allocation) [RET]
rcl_return_loaned_message_from_subscription (subscriber, loaned_message) [RET]
rcl_subscription_get_topic_name (subscriber) [TOPIC NAME]
rcl_subscription_get_options (subscriber) [OPTIONS]
rcl_subscription_get_rmw_handle (subscriber) [RMW SUBSCRIBER]
rcl_subscription_is_valid (subscriber) [BOOL]
rcl_subscription_get_publisher_count (subscriber, publisher_count) [RET]
rcl_subscription_get_actual_qos (subscriber) [QOS PROFILE]
rcl_subscription_can_loan_messages (subscriber) [BOOL]

rcl_get_zero_initialized_client () [CLIENT]
rcl_client_init (client, node, type_support, service_name, options) [RET]
rcl_client_fini (client, node) [RET]
rcl_client_get_default_options () [OPTIONS]
rcl_send_request (client, ros_request, sequence_number) [RET]
rcl_take_response_with_info (client, request_header, ros_response)
rcl_take_response (client, request_header, ros_response)
rcl_client_get_service_name (client) [SERVICE NAME]
rcl_client_get_options (client) [OPTIONS]
rcl_client_get_rmw_handle (client) [RMW HANDLE]
rcl_client_is_valid (client) [BOOL]

rcl_get_zero_initialized_service () [SERVICE]
rcl_service_init (service, node, type_support, service_name, options) [RET]
rcl_service_fini (service, node) [RET]
rcl_service_get_default_options () [OPTIONS]
rcl_take_request_with_info (service, request_header, ros_request) [RET]
rcl_take_request (service, request_header, ros_request) [RET]
rcl_send_response (service, response_header, ros_response) [RET]
rcl_service_get_service_name (service) [SERVICE NAME]
rcl_service_get_options (service) [OPTIONS]
rcl_service_get_rmw_handle (service) [RMW SERVICE]
rcl_service_is_valid (service) [BOOL]

rcl_get_zero_initialized_timer () [TIMER]
rcl_timer_init (timer, clock, context, period, callback, allocator) [RET]
rcl_timer_fini (timer) [RET]
rcl_timer_call (timer) [RET]
rcl_timer_clock (timer, clock) [RET]
rcl_timer_is_ready (timer, is_ready) [RET]
rcl_timer_get_time_until_next_call (timer, time_until_next_call) [RET]
rcl_timer_get_time_since_last_call (timer, time_since_last_call) [RET]
rcl_timer_get_period (timer, period) [RET]
rcl_timer_exchange_period (timer, new_period, old_period) [RET]
rcl_timer_get_callback (timer) [TIMER CALLBACK]
rcl_timer_exchange_callback (TIMER, NEW_CALLBACK) [TIMER CALLBACK]
rcl_timer_cancel (timer) [RET]
rcl_timer_is_canceled (timer, is_canceled) [RET]
rcl_timer_reset (timer) [RET]
rcl_timer_get_allocator (timer) [ALLOCATOR]
rcl_timer_get_guard_condition (timer) [GUARD CONDITION]

rcl_action_get_zero_initialized_client() [ACTION_CLIENT]
rcl_action_client_init(action_client, node, type_support, action_name, action_client_options) [RET]
    * After calling this function on a rcl_action_client_t, it can be used to send
    * goals of the given type to the given topic using rcl_action_send_goal_request().
    * If a goal request is sent to a (possibly remote) server and if the server
    * sends a response, the client can access the response with
    * rcl_take_goal_response() once the response is available.
    *
    * After a goal request has been accepted, the rcl_action_client_t associated with the
    * goal can perform the following operations:
    *
    * - Send a request for the result with rcl_action_send_result_request().
    * If the server sends a response when the goal terminates, the result can be accessed
    * with rcl_action_take_result_response(), once the response is available.
    * - Send a cancel request for the goal with rcl_action_send_cancel_request().
    * If the server sends a response to a cancel request, the client can access the
    * response with rcl_action_take_cancel_response() once the response is available.
    * - Take feedback about the goal with rcl_action_take_feedback().
    *
    * A rcl_action_client_t can be used to access the current status of all accepted goals
    * communicated by the action server with rcl_action_take_status().
rcl_action_client_fini(action_client, node) [RET]
rcl_action_client_get_default_options() [ACTION_CLIENT_OPTIONS] 
    {rmw_qos_profile_services_default, rmw_qos_profile_services_default, rmw_qos_profile_services_default, rmw_qos_profile_default, rcl_action_qos_profile_status_default, rcl_get_default_allocator()}
rcl_action_server_is_available(node, action_client, is_available^) [RET]
rcl_action_send_goal_request(action_client, ros_goal_request, sequence_number^) [RET]
rcl_action_take_goal_response(action_client, response_header^, ros_goal_response^) [RET]
rcl_action_take_feedback(action_client, ros_feedback^) [RET]
rcl_action_take_status(action_client, ros_status_array^) [RET]
rcl_action_send_result_request(action_client, ros_result_request, sequence_number^) [RET]
rcl_action_take_result_response(action_client, response_header^, ros_result^) [RET]
rcl_action_send_cancel_request(action_client, ros_cancel_request, sequence_number^) [RET]
    * The following cancel policy applies based on the goal ID and the timestamp provided
    * by the `ros_cancel_request` message:
    *
    * - If the goal ID is zero and timestamp is zero, cancel all goals.
    * - If the goal ID is zero and timestamp is not zero, cancel all goals accepted
    *   at or before the timestamp.
    * - If the goal ID is not zero and timestamp is zero, cancel the goal with the
    *   given ID regardless of the time it was accepted.
    * - If the goal ID is not zero and timestamp is not zero, cancel the goal with the
    *   given ID and all goals accepted at or before the timestamp.
rcl_action_take_cancel_response(action_client, response_header^, ros_cancel_response^) [RET]
rcl_action_client_get_action_name(action_client) [ACTION_NAME]
rcl_action_client_get_options(action_client) [ACTION_CLIENT_OPTIONS]
rcl_action_client_is_valid (action_client) [IS_VALID]


rcl_action_get_zero_initialized_server() [ACTION_SERVER]
rcl_action_server_init(action_server, node, clock, type_support, action_name, action_server_options) [RET]
    * After calling this function on a rcl_action_server_t, it can be used to take
    * goals of the given type for the given action name using rcl_action_take_goal_request()
    * and take cancel requests with rcl_action_take_cancel_request().
    * It can also send a result for a request using rcl_action_send_result() or
    * rcl_action_send_cancel_response().
    *
    * After accepting a goal with rcl_action_take_goal_request(), the action server can
    * be used to send feedback with rcl_action_publish_feedback() and send status
    * messages with rcl_action_publish_status().
rcl_action_server_fini(action_server, node) [RET]
rcl_action_server_get_default_options() [ACTION_SERVER_OPTIONS]
    * The defaults are:
    *
    * - goal_service_qos = rmw_qos_profile_services_default;
    * - cancel_service_qos = rmw_qos_profile_services_default;
    * - result_service_qos = rmw_qos_profile_services_default;
    * - feedback_topic_qos = rmw_qos_profile_default;
    * - status_topic_qos = rcl_action_qos_profile_status_default;
    * - allocator = rcl_get_default_allocator();
    * - result_timeout = RCUTILS_S_TO_NS(15 * 60);  // 15 minutes
rcl_action_take_goal_request(action_server,  request_header^, ros_goal_request^) [RET]
rcl_action_send_goal_response(action_server, response_header, ros_goal_response) [RET]
rcl_action_accept_new_goal(action_server, goal_info) [ACTION_GOAL_HANDLE]
    * Creates and returns a new goal handle.
    * The action server starts tracking it internally.
    * If a failure occurs, `NULL` is returned and an error message is set.
    * Possible reasons for failure:
    *   - action server is invalid
    *   - goal info is invalid
    *   - goal ID is already being tracked by the action server
    *   - memory allocation failure
rcl_action_publish_feedback(action_server, ros_feedback) [RET]
rcl_action_get_goal_status_array(action_server, action_goal_status_array)
rcl_action_publish_status(action_server, status_message) [RET]
rcl_action_take_result_request(action_server, request_header^, ros_result_request^) [RET]
rcl_action_send_result_response(action_server, response_header, ros_result_response) [RET]
rcl_action_expire_goals(action_server, expired_goals^, expired_goals_capacity, num_expired^) [RET]
    * A goal is 'expired' if it has been in a terminal state (has a result) for longer
    * than some duration.
    * The timeout duration is set as part of the action server options.
    *
    * If a negative timeout value if provided, then goal results never expire (kept forever).
    * If a timeout of zero is set, then goal results are discarded immediately (ie. goal
    * results are discarded whenever this function is called).
    *
    * Expired goals are removed from the internal array of goal handles.
    * rcl_action_server_goal_exists() will return false for any goals that have expired.
    *
    * \attention If one or more goals are expired then a previously returned goal handle
    * array from rcl_action_server_get_goal_handles() becomes invalid.
    *
    * `expired_goals`, `expired_goals_capacity` and `num_expired` are optional arguments.
    * If set to (`NULL`, 0u, `NULL`) then they are not used.
    * To use them allocate an array with size equal to the maximum number of goals that you want to
    * expire.
    * Pass the number of goals the array can hold in as `expired_goals_capacity`.
    * This function will set `num_expired` to the number of goals that were expired.
rcl_action_notify_goal_done(action_server) [RET]
    * Notifies action server that a goal handle reached a terminal state.
rcl_action_take_cancel_request(action_server, request_header^, ros_cancel_request^) [RET]
rcl_action_process_cancel_request(action_server, cancel_request, cancel_response^) [RET]
    * This function will compute a list of goals that a cancelation request is attempting to cancel.
    * It does not change the state of any goal.
    * The following cancel policy applies based on the goal ID and the timestamp
    * contained in the cancel request:
    *
    * - If the goal ID is zero and timestamp is zero, cancel all goals.
    * - If the goal ID is zero and timestamp is not zero, cancel all goals accepted
    *   at or before the timestamp.
    * - If the goal ID is not zero and timestamp is zero, cancel the goal with the
    *   given ID regardless of the time it was accepted.
    * - If the goal ID is not zero and timestamp is not zero, cancel the goal with the
    *   given ID and all goals accepted at or before the timestamp.
rcl_action_send_cancel_response(action_server, response_header, ros_cancel_response) [RET]
rcl_action_server_get_action_name(action_server) [ACTION_NAME]
rcl_action_server_get_options(action_server) [ACTION_SERVER_OPTIONS]
rcl_action_server_get_goal_handles(action_server, goal_handles^, num_goals^) [RET]
    * A pointer to the internally held array of pointers to goal handle structs is returned
    * along with the number of items in the array.
    *
    * The returned handle is made invalid if the action server is finalized, if
    * rcl_shutdown() is called, or if rcl_action_expire_goals() is called and one or more
    * goals are expired.
    * The returned handle is not guaranteed to be valid for the life time of the
    * action server as it may be finalized and recreated itself.
    * Therefore, it is recommended to get the handle from the action server using
    * this function each time it is needed and avoid use of the handle
    * concurrently with functions that might change it.
rcl_action_server_goal_exists(action_server, goal_info) [BOOL]
    * Checks whether or not a goal is being tracked in the internal goal array.
    * The goal state has no effect on the return value.
rcl_action_server_is_valid(action_server) [BOOL]
    * In the case where `false` is returned (ie. the action server is invalid),
    * an error message is set.
rcl_action_server_is_valid_except_context(action_server) [BOOL]

rcl_action_get_zero_initialized_goal_handle() [GOAL_HANDLE]
rcl_action_goal_handle_init(goal_handle^, goal_info, allocator) [RET]
    * After calling this function on a rcl_action_goal_handle_t, it can be used to update the
    * goals state with rcl_action_update_goal_state().
    * It can also be used to query the state of the goal with
    * rcl_action_goal_handle_get_message() and rcl_action_goal_handle_is_active().
    * Goal information can be accessed with rcl_action_goal_handle_get_message() and
    * rcl_action_goal_handle_get_info().
    *
    * Goal handles are typically initialized and finalized by action servers.
    * I.e. The allocator should be provided by the action server.
    * Goal handles are created with rcl_action_accept_new_goal() and destroyed with
    * rcl_action_clear_expired_goals() or rcl_action_server_fini().
rcl_action_goal_handle_fini(goal_handle) [RET]
rcl_action_update_goal_state(goal_handle, goal_event) [RET]
    * Update a goal state with a rcl_action_goal_handle_t and an event.
rcl_action_goal_handle_get_info(goal_handle, goal_info^) [RET]
rcl_action_goal_handle_get_status(goal_handle, goal_state^) [RET]
rcl_action_goal_handle_is_active(goal_handle) [BOOL]
    * \return `true` if the goal is in one of the following states: ACCEPTED, EXECUTING, or CANCELING, or
    * \return `false` if the goal handle pointer is invalid, or
    * \return `false` otherwise
rcl_action_goal_handle_is_cancelable(goal_handle) [BOOL]
    * \return `true` if the goal can be transitioned to CANCELING from its current state, or
    * \return `false` if the goal handle pointer is invalid, or
    * \return `false` otherwise
rcl_action_goal_handle_is_valid(goal_handle) [BOOL]
    * A goal handle is invalid if:
    *   - the implementation is `NULL` (rcl_action_goal_handle_init() not called or failed)
    *   - rcl_shutdown() has been called since the goal handle has been initialized
    *   - the goal handle has been finalized with rcl_action_goal_handle_fini()


rcl_action_transition_goal_state(goal_state, goal_event) [GOAL_STATE]
    * Given a goal state and a goal event, return the next state.

rcl_action_get_client_names_and_types_by_node(node, allocator, node_name, node_namespace, action_names_and_types^) [RET]
rcl_action_get_server_names_and_types_by_node(node, allocator, node_name, node_namespace, action_names_and_types^) [RET]
rcl_action_get_names_and_types(node, allocator, action_names_and_types^) [RET]

rcl_action_get_goal_service_name(action_name, allocator, goal_service_name^) [RET]
rcl_action_get_cancel_service_name(action_name, allocator, cancel_service_name^) [RET]
rcl_action_get_result_service_name(action_name, allocator, result_service_name^) [RET]
rcl_action_get_feedback_topic_name(action_name, allocator, feedback_topic_name^) [RET]
rcl_action_get_status_topic_name(action_name, allocator, status_topic_name^) [RET]

rcl_action_wait_set_add_action_client(wait_set, action_client, client_index^, subscription_index^) [RET]
rcl_action_wait_set_add_action_server(wait_set, action_server, service_index^) [RET]
rcl_action_client_wait_set_get_num_entities(action_client, num_subscriptions^, num_guard_conditions^, num_timers^, num_clients^, num_services^) [RET]
rcl_action_server_wait_set_get_num_entities(action_server, num_subscriptions^, num_guard_conditions^, num_timers^, num_clients^, num_services^) [RET]
rcl_action_client_wait_set_get_entities_ready(wait_set, action_client, is_feedback_ready^, is_status_ready^, is_goal_response_ready^, is_cancel_response_ready^, is_result_response_ready^) [RET]
rcl_action_server_wait_set_get_entities_ready(wait_set, action_client, is_goal_request_ready^, is_cancel_request_ready^, is_result_request_ready^, is_goal_expired^) [RET]


ACTION_CLIENT_OPTIONS
---------------------
goal_service_qos, result_service_qos, cancel_service_qos, feedback_topic_qos, status_topic_qos, rcl_allocator

ACTION_SERVER_OPTIONS
---------------------
goal_service_qos, result_service_qos, cancel_service_qos, feedback_topic_qos, status_topic_qos, rcl_allocator, result_timeout

RESPONSE_HEADER
---------------
request_id

REQUEST_HEADER
--------------
request_id

GOAL_EVENT
----------
GOAL_EVENT_EXECUTE = 0,GOAL_EVENT_CANCEL_GOAL,GOAL_EVENT_SUCCEED,GOAL_EVENT_ABORT,GOAL_EVENT_CANCELED,GOAL_EVENT_NUM_EVENTS

GOAL_HANDLE
-----------
goal_info, goal_state, allocator

GOAL_STATE
----------
rcl_interfaces/action_msgs/GoalStatus {UNKNOWN, ACCEPTED, EXECUTING, CANCELING, SUCCEEDED, CANCELED, ABOTED}

RMW
===

rmw_get_zero_initialized_context () [CONTEXT]
rmw_init (options, context) [RET]
rmw_shutdown (context) [RET]
rmw_context_fini (context) [RET]

rmw_get_implementation_identifier () [IMPLEMENTATION IDENTIFIER]
rmw_get_serialization_format () [SERIALIZATION FORMAT]
rmw_create_node (context, name, namespace, domain_id, localhost_only) [NODE]
rmw_destroy_node (node) [RET]
rmw_node_get_graph_guard_condition (node) [GUARD CONDITION]
rmw_init_publisher_allocation (type_support, message_bound, allocation) [RET]
rmw_fini_publisher_allocation (allocation) [RET]
rmw_get_default_publisher_options () [PUB OPTIONS]
rmw_create_publisher (node, type_support, topic_name, qos_policies, publisher_options) [PUBLISHER]
rmw_destroy_publisher (node, publisher)
rmw_borrow_loaned_message (publisher, type_support, ros_message) [RET]
rmw_return_loaned_message_from_publisher (publisher, loaned_message [RET]
rmw_publish (publisher, ros_message, allocation) [RET]
rmw_publish_loaned_message (publisher, ros_message, allocation) [RET]
rmw_publisher_count_matched_subscriptions (publisher, subscription_count) [RET]
rmw_publisher_get_actual_qos (publisher, qos) [RET]
rmw_publish_serialized_message (publisher, serialized_message, allocation) [RET]
rmw_get_serialized_message_size (type_support, message_bounds, size) [RET]
rmw_publisher_assert_liveliness (publisher) [RET]
rmw_serialize (ros_message, type_support, serialized_message) [RET]
rmw_deserialize (serialized_message, type_support, ros_message) [RET]
rmw_init_subscription_allocation (type_support, message_bounds, allocation) [RET]
rmw_fini_subscription_allocation (allocation) [RET]
rmw_create_subscription (node, type_support, topic_name, qos_policies, subscriber_options) [SUBSCRIBER]
rmw_destroy_subscription (node, subscriber) [RET]
rmw_subscription_count_matched_publishers (subscriber, publisher_count) [RET]
rmw_subscription_get_actual_qos (subscriber, qos) [RET]
rmw_take (subscriber, ros_message, taken, allocation) [RET]
rmw_take_with_info (subscriber, ros_message, taken, message_info, allocation) [RET]
rmw_take_sequence (subscriber, count, message_sequence, message_info_sequence, taken, allocation) [RET]
rmw_take_serialized_message (subscriber, serialized_message, taken, allocation) [RET]
rmw_take_serialized_message_with_info (subscriber, serialized_message, taken, message_info, allocation) [RET]
rmw_take_loaned_message (subscriber, loaned_message, taken, allocation) [RET]
rmw_take_loaned_message_with_info (subscriber, loaned_message, taken, message_info, allocation) [RET]
rmw_return_loaned_message_from_subscription (subscriber, loaned_message) [RET]
rmw_create_client (node, type_support, service_name, qos_policies) [CLIENT]
rmw_destroy_client (node, client) [RET]
rmw_send_request (client, ros_request, sequence_id) [RET]
rmw_take_response (client, service_info, ros_response, taken) [RET]
rmw_create_service (node, type_support, service_name, qos_policies) [SERVICE]
rmw_destroy_service (node, service) [RET]
rmw_take_request (service, service_info, ros_request, taken) [RET]
rmw_send_response (service, request_id, ros_response) [RET]
rmw_create_guard_condition (context) [GUARD CONDITION]
rmw_destroy_guard_condition (guard_condition) [RET]
rmw_trigger_guard_condition (guard_condition) [RET]
rmw_create_wait_set (context, max_conditions) [WAIT_SET]
rmw_destroy_wait_set (wait_set) [RET]
rmw_wait (subscriber, guard_condition, services, clients, events, wait_set, wait_timeout) [RET]
rmw_get_node_names (node, node_names, node_namespaces) [RET]
rmw_get_node_names_with_enclaves (node, node_names, node_namespaces, enclaves) [RET]
rmw_count_publishers (node, topic_name, count) [RET]
rmw_count_subscribers (node, topic_name, count) [RET]
rmw_get_gid_for_publisher (publisher, gid) [RET]
rmw_compare_gids_equal (gid1, gid2, result) [RET]
rmw_service_server_is_available (node, client, is_available) [RET]
rmw_set_log_severity (severity) [RET]


CONTEXT
-------
instance_id, implementation_identifier, options, impl

OPTIONS
-------
instance_id, implementation_identifier, domain_id, security_options, localhost_only, enclave, allocator, impl

SECURITY_OPTIONS
----------------
enforce_security, security_root_path

GUARD_CONDITION
---------------
implementation_identifier, data, context

SERVICE_INFO
------------
source_timestamp, received_timestamp, request_id

REQUEST_ID
----------
writer_guid, sequence_number


##################################
http://design.ros2.org/articles/legacy_interface_definition.html
http://design.ros2.org/articles/idl_interface_definition.html
http://design.ros2.org/articles/topic_and_service_names.html

http://design.ros2.org/articles/clock_and_time.html
http://design.ros2.org/articles/qos.html
http://design.ros2.org/articles/qos_configurability.html
http://design.ros2.org/articles/qos_deadline_liveliness_lifespan.html

GENERAL
=======
http://design.ros2.org/articles/Node_to_Participant_mapping.html
REF: https://github.com/ros2/rmw_dds_common.git

TOPIC: 'ros_discovery_info' [ParticipantInfo.msg]
QOS: TRANSIENT_LOCAL, KEEP_LAST, DEPTH 1, RELIABLE

Each Participant publishes a message with all the information needed to match an entity to a Node.
When one entity is updated (e.g.: a Publisher is created or destroyed), a new message is sent.

SERVICE
=======
REF: https://github.com/ros2/rmw_cyclonedds.git

TOPIC: 'rq<SERVICE_NAME>Request' [cdds_request_wrapper_t]
TOPIC: 'rr<SERVICE_NAME>Response' [cdds_request_wrapper_t]
QOS: According to caling rmw_function

NOTE: This is Cyclone DDS implementation specific

ACTION
======
http://design.ros2.org/articles/actions.html
REF: https://github.com/ros2/rclcpp.git [/rlcpp_action]
REF: https://github.com/ros2/rosidl.git [rosidl_parser/definition.py]

SERVICE: '<ACTIONNAME>/_action/send_goal' 
    REQUEST: [unique_identifier_msgs/UUID goal_id, 1st section of .action Definition]
    RESPONSE: [boolean accepted, builtin_interfaces/Time stamp]
SERVICE: '<ACTIONNAME>/_action/cancel_goal' 
    rcl_interfaces/action_msgs/CancelGoal.srv
SERVICE: '<ACTIONNAME>/_action/get_result'
    REQUEST: [unique_identifier_msgs/UUID goal_id]
    RESPONSE: [int8 status, 2nd section of .action Definition]
TOPIC: '<ACTIONNAME>/_action/feedback' 
    [unique_identifier_msgs/UUID goal_id, 3rd section of .action Definition]
TOPIC: '<ACTIONNAME>/_action/status'
    rcl_interfaces/action_msgs/GoalStatusArray.msg

action_tutorials_interfaces::action::dds_::Fibonacci_SendGoal_Response_
action_tutorials_interfaces::action::dds_::Fibonacci_GetResult_Response_
action_tutorials_interfaces::action::dds_::Fibonacci_FeedbackMessage_
action_msgs::srv::dds_::CancelGoal_Response_
action_msgs::msg::dds_::GoalStatusArray_

action_tutorials_interfaces::action::dds_::Fibonacci_SendGoal_Request_
action_tutorials_interfaces::action::dds_::Fibonacci_GetResult_Request_
action_msgs::srv::dds_::CancelGoal_Request_

PARAMETER
=========
http://design.ros2.org/articles/ros_parameters.html
REF: https://github.com/ros2/rclcpp.git

SERVICE: 'GetParameters'
SERVICE: 'HasParameters'
SERVICE: 'ListParameters'
SERVICE: 'SetParameters'
TOPIC: 'ParameterEvent'
TOPIC: 'ParameterEventDescriptor'


MANAGED NODE
============
http://design.ros2.org/articles/node_lifecycle.html
REF: https://github.com/ros2/rclcpp.git [/rlcpp_lifecycle]

