Merge branch 'expose_cdr' of https://github.com/ros2/rmw into expose_cdr

rmw/include/rmw/allocators.h

@@ -80,12 +80,12 @@ void
 rmw_service_free(rmw_service_t * service);
 
 RMW_PUBLIC
-rmw_waitset_t *
-rmw_waitset_allocate(void);
+rmw_wait_set_t *
+rmw_wait_set_allocate(void);
 
 RMW_PUBLIC
 void
-rmw_waitset_free(rmw_waitset_t * waitset);
+rmw_wait_set_free(rmw_wait_set_t * wait_set);
 
 #if __cplusplus
 }

rmw/include/rmw/rmw.h

@@ -88,7 +88,7 @@ extern "C"
 #include "rcutils/types.h"
 
 #include "rosidl_generator_c/message_type_support_struct.h"
-#include "rosidl_generator_c/service_type_support.h"
+#include "rosidl_generator_c/service_type_support_struct.h"
 
 #include "rmw/macros.h"
 #include "rmw/qos_profiles.h"
@@ -299,33 +299,33 @@ RMW_WARN_UNUSED
 rmw_ret_t
 rmw_trigger_guard_condition(const rmw_guard_condition_t * guard_condition);
 
-/// Create a waitset to store conditions that the middleware will block on.
+/// Create a wait set to store conditions that the middleware will block on.
 /**
- * If `max_conditions` is `0`, the waitset can store an unbounded number of
+ * If `max_conditions` is `0`, the wait set can store an unbounded number of
  * conditions to wait on.
  * If `max_conditions` is greater than `0`, the number of conditions that can
- * be attached to the waitset is bounded at `max_conditions`.
+ * be attached to the wait set is bounded at `max_conditions`.
  * \param[in] max_conditions
- *   The maximum number of conditions that can be attached to the waitset.
- * \return A pointer to the created waitset, `NULL` if an error occurred.
+ *   The maximum number of conditions that can be attached to the wait set.
+ * \return A pointer to the created wait set, `NULL` if an error occurred.
  */
 RMW_PUBLIC
 RMW_WARN_UNUSED
-rmw_waitset_t *
-rmw_create_waitset(size_t max_conditions);
+rmw_wait_set_t *
+rmw_create_wait_set(size_t max_conditions);
 
 RMW_PUBLIC
 RMW_WARN_UNUSED
 rmw_ret_t
-rmw_destroy_waitset(rmw_waitset_t * waitset);
+rmw_destroy_wait_set(rmw_wait_set_t * wait_set);
 
 /// Waits on sets of different waitable entities and returns when one is ready.
 /**
  * Add conditions to the wait set and wait until a response comes in, or until
  * the timeout is reached.
  * The arrays contain type-erased representations of waitable entities.
  * This function casts the pointers to middleware-specific conditions and adds
- * them to the waitset.
+ * them to the wait set.
  *
  * The count variables in the arrays represents the number of valid pointers
  * in the array.
@@ -343,12 +343,12 @@ rmw_destroy_waitset(rmw_waitset_t * waitset);
  * \param guard_conditions Array of guard conditions to wait on
  * \param services Array of services to wait on
  * \param clients Array of clients to wait on
- * \param waitset Storage for the waitset
+ * \param wait_set Storage for the wait set
  * \param wait_timeout
- *   If negative, block indefinitely or until a condition is ready.
+ *   If NULL, block until a condition is ready.
  *   If zero, check only for immediately available conditions and don't block.
  *   Else, this represents the maximum time to wait for a response from the
- *   waitset.
+ *   wait set.
  * \return `RMW_RET_OK` if success, or
  * \return `RMW_RET_ERROR` if error, or
  * \return `RMW_RET_TIMEOUT` if wait timed out.
@@ -361,7 +361,7 @@ rmw_wait(
   rmw_guard_conditions_t * guard_conditions,
   rmw_services_t * services,
   rmw_clients_t * clients,
-  rmw_waitset_t * waitset,
+  rmw_wait_set_t * wait_set,
   const rmw_time_t * wait_timeout);
 
 RMW_PUBLIC
@@ -432,6 +432,11 @@ rmw_service_server_is_available(
   const rmw_client_t * client,
   bool * is_available);
 
+RMW_PUBLIC
+RMW_WARN_UNUSED
+rmw_ret_t
+rmw_set_log_severity(rmw_log_severity_t severity);
+
 #if __cplusplus
 }
 #endif

rmw/include/rmw/types.h

@@ -24,6 +24,8 @@ extern "C"
 #include <stddef.h>
 #include <stdint.h>
 
+// map rcutils specific log levels to rmw speicfic type
+#include <rcutils/logging.h>
 #include "rmw/visibility_control.h"
 
 typedef int rmw_ret_t;
@@ -142,12 +144,12 @@ typedef struct RMW_PUBLIC_TYPE rmw_guard_conditions_t
   void ** guard_conditions;
 } rmw_guard_conditions_t;
 
-typedef struct RMW_PUBLIC_TYPE rmw_waitset_t
+typedef struct RMW_PUBLIC_TYPE rmw_wait_set_t
 {
   const char * implementation_identifier;
   rmw_guard_conditions_t * guard_conditions;
   void * data;
-} rmw_waitset_t;
+} rmw_wait_set_t;
 
 typedef struct RMW_PUBLIC_TYPE rmw_request_id_t
 {
@@ -235,6 +237,17 @@ typedef struct RMW_PUBLIC_TYPE rmw_message_raw_t
 
 enum {RMW_QOS_POLICY_DEPTH_SYSTEM_DEFAULT = 0};
 
+// Type mapping of rcutil log severity types to
+// rmw specific types.
+typedef enum RWM_PUBLIC_TYPE
+{
+  RMW_LOG_SEVERITY_DEBUG = RCUTILS_LOG_SEVERITY_DEBUG,
+  RMW_LOG_SEVERITY_INFO = RCUTILS_LOG_SEVERITY_INFO,
+  RMW_LOG_SEVERITY_WARN = RCUTILS_LOG_SEVERITY_WARN,
+  RMW_LOG_SEVERITY_ERROR = RCUTILS_LOG_SEVERITY_ERROR,
+  RMW_LOG_SEVERITY_FATAL = RCUTILS_LOG_SEVERITY_FATAL
+} rmw_log_severity_t;
+
 #if __cplusplus
 }
 #endif

rmw/package.xml

@@ -2,7 +2,7 @@
 <?xml-model href="http://download.ros.org/schema/package_format2.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
 <package format="2">
   <name>rmw</name>
-  <version>0.0.3</version>
+  <version>0.4.0</version>
   <description>Contains the ROS middleware API.</description>
   <maintainer email="dthomas@osrfoundation.org">Dirk Thomas</maintainer>
   <maintainer email="william@osrfoundation.org">William Woodall</maintainer>

rmw/src/allocators.c

@@ -122,16 +122,16 @@ rmw_service_free(rmw_service_t * service)
   rmw_free(service);
 }
 
-rmw_waitset_t *
-rmw_waitset_allocate()
+rmw_wait_set_t *
+rmw_wait_set_allocate()
 {
   // Could be overridden with custom (maybe static) client struct allocator
-  return (rmw_waitset_t *)rmw_allocate(sizeof(rmw_waitset_t));
+  return (rmw_wait_set_t *)rmw_allocate(sizeof(rmw_wait_set_t));
 }
 
 void
-rmw_waitset_free(rmw_waitset_t * waitset)
+rmw_wait_set_free(rmw_wait_set_t * wait_set)
 {
-  // Should have matching overide with rmw_waitset_allocate
-  rmw_free(waitset);
+  // Should have matching overide with rmw_wait_set_allocate
+  rmw_free(wait_set);
 }

rmw/src/validate_full_topic_name.c

@@ -134,6 +134,6 @@ rmw_full_topic_name_validation_result_string(int validation_result)
     case RMW_TOPIC_INVALID_TOO_LONG:
       return "topic length should not exceed '" RMW_STRINGIFY(RMW_TOPIC_MAX_NAME_LENGTH) "'";
     default:
-      return NULL;
+      return "unknown result code for rwm topic name validation";
   }
 }

rmw/src/validate_namespace.c

@@ -80,8 +80,7 @@ rmw_validate_namespace(
           rcutils_snprintf(
             default_err_msg, sizeof(default_err_msg),
             "rmw_validate_namespace(): unknown rmw_validate_full_topic_name() result '%d'",
-            *validation_result
-          );
+            t_validation_result);
           RMW_SET_ERROR_MSG(default_err_msg);
         }
         return RMW_RET_ERROR;
@@ -127,6 +126,6 @@ rmw_namespace_validation_result_string(int validation_result)
     case RMW_NAMESPACE_INVALID_TOO_LONG:
       return "namespace should not exceed '" RMW_STRINGIFY(RMW_NAMESPACE_MAX_NAME_LENGTH) "'";
     default:
-      return NULL;
+      return "unknown result code for rmw namespace validation";
   }
 }

rmw/src/validate_node_name.c

@@ -93,6 +93,6 @@ rmw_node_name_validation_result_string(int validation_result)
       return
         "node name length should not exceed '" RMW_STRINGIFY(RMW_NODE_NAME_MAX_NAME_LENGTH) "'";
     default:
-      return NULL;
+      return "unknown result code for rmw node name validation";
   }
 }

rmw/test/test_validate_full_topic_name.cpp

@@ -47,7 +47,7 @@ TEST(test_validate_topic_name, valid_topic) {
   ASSERT_EQ(RMW_RET_OK, ret);
   ASSERT_EQ(RMW_TOPIC_VALID, validation_result);
 
-  ASSERT_EQ((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_EQ((char *)nullptr, rmw_full_topic_name_validation_result_string(validation_result));
 }
 
 TEST(test_validate_topic_name, empty_topic_name) {
@@ -66,7 +66,7 @@ TEST(test_validate_topic_name, empty_topic_name) {
   ASSERT_EQ(RMW_TOPIC_INVALID_IS_EMPTY_STRING, validation_result);
   ASSERT_EQ(0ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_full_topic_name_validation_result_string(validation_result));
 }
 
 TEST(test_validate_topic_name, not_absolute) {
@@ -90,7 +90,7 @@ TEST(test_validate_topic_name, not_absolute) {
   ASSERT_EQ(RMW_TOPIC_INVALID_NOT_ABSOLUTE, validation_result);
   ASSERT_EQ(0ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_full_topic_name_validation_result_string(validation_result));
 }
 
 TEST(test_validate_topic_name, ends_with_forward_slash) {
@@ -114,7 +114,7 @@ TEST(test_validate_topic_name, ends_with_forward_slash) {
   ASSERT_EQ(RMW_TOPIC_INVALID_ENDS_WITH_FORWARD_SLASH, validation_result);
   ASSERT_EQ(0ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_full_topic_name_validation_result_string(validation_result));
 }
 
 TEST(test_validate_topic_name, unallowed_characters) {
@@ -148,7 +148,7 @@ TEST(test_validate_topic_name, unallowed_characters) {
   ASSERT_EQ(RMW_TOPIC_INVALID_CONTAINS_UNALLOWED_CHARACTERS, validation_result);
   ASSERT_EQ(5ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_full_topic_name_validation_result_string(validation_result));
 }
 
 TEST(test_validate_topic_name, repeated_forward_slashes) {
@@ -167,7 +167,7 @@ TEST(test_validate_topic_name, repeated_forward_slashes) {
   ASSERT_EQ(RMW_TOPIC_INVALID_CONTAINS_REPEATED_FORWARD_SLASH, validation_result);
   ASSERT_EQ(10ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_full_topic_name_validation_result_string(validation_result));
 }
 
 TEST(test_validate_topic_name, starts_with_number) {
@@ -191,7 +191,7 @@ TEST(test_validate_topic_name, starts_with_number) {
   ASSERT_EQ(RMW_TOPIC_INVALID_NAME_TOKEN_STARTS_WITH_NUMBER, validation_result);
   ASSERT_EQ(8ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_full_topic_name_validation_result_string(validation_result));
 }
 
 TEST(test_validate_topic_name, topic_too_long) {
@@ -228,5 +228,5 @@ TEST(test_validate_topic_name, topic_too_long) {
   EXPECT_EQ(RMW_TOPIC_INVALID_TOO_LONG, validation_result);
   EXPECT_EQ(RMW_TOPIC_MAX_NAME_LENGTH - 1, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_full_topic_name_validation_result_string(validation_result));
 }

rmw/test/test_validate_namespace.cpp

@@ -52,7 +52,7 @@ TEST(test_validate_namespace, valid_namespace) {
   ASSERT_EQ(RMW_RET_OK, ret);
   ASSERT_EQ(RMW_NAMESPACE_VALID, validation_result);
 
-  ASSERT_EQ((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_EQ((char *)nullptr, rmw_namespace_validation_result_string(validation_result));
 }
 
 TEST(test_validate_namespace, empty_namespace) {
@@ -71,7 +71,7 @@ TEST(test_validate_namespace, empty_namespace) {
   ASSERT_EQ(RMW_NAMESPACE_INVALID_IS_EMPTY_STRING, validation_result);
   ASSERT_EQ(0ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_namespace_validation_result_string(validation_result));
 }
 
 TEST(test_validate_namespace, not_absolute) {
@@ -95,7 +95,7 @@ TEST(test_validate_namespace, not_absolute) {
   ASSERT_EQ(RMW_NAMESPACE_INVALID_NOT_ABSOLUTE, validation_result);
   ASSERT_EQ(0ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_namespace_validation_result_string(validation_result));
 }
 
 TEST(test_validate_namespace, ends_with_forward_slash) {
@@ -114,7 +114,7 @@ TEST(test_validate_namespace, ends_with_forward_slash) {
   ASSERT_EQ(RMW_NAMESPACE_INVALID_ENDS_WITH_FORWARD_SLASH, validation_result);
   ASSERT_EQ(10ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_namespace_validation_result_string(validation_result));
 }
 
 TEST(test_validate_namespace, unallowed_characters) {
@@ -148,7 +148,7 @@ TEST(test_validate_namespace, unallowed_characters) {
   ASSERT_EQ(RMW_NAMESPACE_INVALID_CONTAINS_UNALLOWED_CHARACTERS, validation_result);
   ASSERT_EQ(5ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_namespace_validation_result_string(validation_result));
 }
 
 TEST(test_validate_namespace, repeated_forward_slashes) {
@@ -167,7 +167,7 @@ TEST(test_validate_namespace, repeated_forward_slashes) {
   ASSERT_EQ(RMW_NAMESPACE_INVALID_CONTAINS_REPEATED_FORWARD_SLASH, validation_result);
   ASSERT_EQ(10ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_namespace_validation_result_string(validation_result));
 }
 
 TEST(test_validate_namespace, starts_with_number) {
@@ -191,7 +191,7 @@ TEST(test_validate_namespace, starts_with_number) {
   ASSERT_EQ(RMW_NAMESPACE_INVALID_NAME_TOKEN_STARTS_WITH_NUMBER, validation_result);
   ASSERT_EQ(8ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_namespace_validation_result_string(validation_result));
 }
 
 TEST(test_validate_namespace, topic_too_long) {
@@ -228,5 +228,5 @@ TEST(test_validate_namespace, topic_too_long) {
   EXPECT_EQ(RMW_NAMESPACE_INVALID_TOO_LONG, validation_result);
   EXPECT_EQ(RMW_NAMESPACE_MAX_LENGTH - 1, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_full_topic_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_namespace_validation_result_string(validation_result));
 }

rmw/test/test_validate_node_name.cpp

@@ -47,7 +47,7 @@ TEST(test_validate_node_name, valid_node_name) {
   ASSERT_EQ(RMW_RET_OK, ret);
   ASSERT_EQ(RMW_NODE_NAME_VALID, validation_result);
 
-  ASSERT_EQ((char *)NULL, rmw_node_name_validation_result_string(validation_result));
+  ASSERT_EQ((char *)nullptr, rmw_node_name_validation_result_string(validation_result));
 }
 
 TEST(test_validate_node_name, empty_node_name) {
@@ -66,7 +66,7 @@ TEST(test_validate_node_name, empty_node_name) {
   ASSERT_EQ(RMW_NODE_NAME_INVALID_IS_EMPTY_STRING, validation_result);
   ASSERT_EQ(0ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_node_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_node_name_validation_result_string(validation_result));
 }
 
 TEST(test_validate_node_name, unallowed_characters) {
@@ -105,7 +105,7 @@ TEST(test_validate_node_name, unallowed_characters) {
   ASSERT_EQ(RMW_NODE_NAME_INVALID_CONTAINS_UNALLOWED_CHARACTERS, validation_result);
   ASSERT_EQ(4ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_node_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_node_name_validation_result_string(validation_result));
 }
 
 TEST(test_validate_node_name, starts_with_number) {
@@ -124,7 +124,7 @@ TEST(test_validate_node_name, starts_with_number) {
   ASSERT_EQ(RMW_NODE_NAME_INVALID_STARTS_WITH_NUMBER, validation_result);
   ASSERT_EQ(0ul, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_node_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_node_name_validation_result_string(validation_result));
 }
 
 TEST(test_validate_node_name, node_name_too_long) {
@@ -162,5 +162,5 @@ TEST(test_validate_node_name, node_name_too_long) {
   EXPECT_EQ(RMW_NODE_NAME_INVALID_TOO_LONG, validation_result);
   EXPECT_EQ(RMW_NODE_NAME_MAX_NAME_LENGTH - 1U, invalid_index);
 
-  ASSERT_NE((char *)NULL, rmw_node_name_validation_result_string(validation_result));
+  ASSERT_NE((char *)nullptr, rmw_node_name_validation_result_string(validation_result));
 }