waitset -> wait_set (#408)

* waitset -> wait_set

* cpplint

* use wait set in doc

* doc fixup

rclcpp/include/rclcpp/executor.hpp

@@ -344,8 +344,8 @@ protected:
   /// Guard condition for signaling the rmw layer to wake up for special events.
   rcl_guard_condition_t interrupt_guard_condition_ = rcl_get_zero_initialized_guard_condition();
 
-  /// Waitset for managing entities that the rmw layer waits on.
+  /// Wait set for managing entities that the rmw layer waits on.
-  rcl_wait_set_t waitset_ = rcl_get_zero_initialized_wait_set();
+  rcl_wait_set_t wait_set_ = rcl_get_zero_initialized_wait_set();
 
   /// The memory strategy: an interface for handling user-defined memory allocation strategies.
   memory_strategy::MemoryStrategy::SharedPtr memory_strategy_;

rclcpp/include/rclcpp/memory_strategy.hpp

@@ -51,7 +51,7 @@ public:
   virtual size_t number_of_ready_timers() const = 0;
   virtual size_t number_of_guard_conditions() const = 0;
 
-  virtual bool add_handles_to_waitset(rcl_wait_set_t * wait_set) = 0;
+  virtual bool add_handles_to_wait_set(rcl_wait_set_t * wait_set) = 0;
   virtual void clear_handles() = 0;
   virtual void remove_null_handles(rcl_wait_set_t * wait_set) = 0;
 

rclcpp/include/rclcpp/strategies/allocator_memory_strategy.hpp

@@ -183,39 +183,39 @@ public:
     return has_invalid_weak_nodes;
   }
 
-  bool add_handles_to_waitset(rcl_wait_set_t * wait_set)
+  bool add_handles_to_wait_set(rcl_wait_set_t * wait_set)
   {
     for (auto subscription : subscription_handles_) {
       if (rcl_wait_set_add_subscription(wait_set, subscription) != RCL_RET_OK) {
-        fprintf(stderr, "Couldn't add subscription to waitset: %s\n", rcl_get_error_string_safe());
+        fprintf(stderr, "Couldn't add subscription to wait set: %s\n", rcl_get_error_string_safe());
         return false;
       }
     }
 
     for (auto client : client_handles_) {
       if (rcl_wait_set_add_client(wait_set, client) != RCL_RET_OK) {
-        fprintf(stderr, "Couldn't add client to waitset: %s\n", rcl_get_error_string_safe());
+        fprintf(stderr, "Couldn't add client to wait set: %s\n", rcl_get_error_string_safe());
         return false;
       }
     }
 
     for (auto service : service_handles_) {
       if (rcl_wait_set_add_service(wait_set, service) != RCL_RET_OK) {
-        fprintf(stderr, "Couldn't add service to waitset: %s\n", rcl_get_error_string_safe());
+        fprintf(stderr, "Couldn't add service to wait set: %s\n", rcl_get_error_string_safe());
         return false;
       }
     }
 
     for (auto timer : timer_handles_) {
       if (rcl_wait_set_add_timer(wait_set, timer) != RCL_RET_OK) {
-        fprintf(stderr, "Couldn't add timer to waitset: %s\n", rcl_get_error_string_safe());
+        fprintf(stderr, "Couldn't add timer to wait set: %s\n", rcl_get_error_string_safe());
         return false;
       }
     }
 
     for (auto guard_condition : guard_conditions_) {
       if (rcl_wait_set_add_guard_condition(wait_set, guard_condition) != RCL_RET_OK) {
-        fprintf(stderr, "Couldn't add guard_condition to waitset: %s\n",
+        fprintf(stderr, "Couldn't add guard_condition to wait set: %s\n",
           rcl_get_error_string_safe());
         return false;
       }

rclcpp/include/rclcpp/utilities.hpp

@@ -75,32 +75,32 @@ on_shutdown(std::function<void(void)> callback);
 
 /// Get a handle to the rmw guard condition that manages the signal handler.
 /**
- * The first time that this function is called for a given waitset a new guard
+ * The first time that this function is called for a given wait set a new guard
  * condition will be created and returned; thereafter the same guard condition
- * will be returned for the same waitset. This mechanism is designed to ensure
+ * will be returned for the same wait set. This mechanism is designed to ensure
- * that the same guard condition is not reused across waitsets (e.g., when
+ * that the same guard condition is not reused across wait sets (e.g., when
  * using multiple executors in the same process). Will throw an exception if
  * initialization of the guard condition fails.
- * \param waitset Pointer to the rcl_wait_set_t that will be using the
+ * \param wait_set Pointer to the rcl_wait_set_t that will be using the
  * resulting guard condition.
  * \return Pointer to the guard condition.
  */
 RCLCPP_PUBLIC
 rcl_guard_condition_t *
-get_sigint_guard_condition(rcl_wait_set_t * waitset);
+get_sigint_guard_condition(rcl_wait_set_t * wait_set);
 
 /// Release the previously allocated guard condition that manages the signal handler.
 /**
- * If you previously called get_sigint_guard_condition() for a given waitset
+ * If you previously called get_sigint_guard_condition() for a given wait set
  * to get a sigint guard condition, then you should call release_sigint_guard_condition()
  * when you're done, to free that condition.  Will throw an exception if
- * get_sigint_guard_condition() wasn't previously called for the given waitset.
+ * get_sigint_guard_condition() wasn't previously called for the given wait set.
- * \param waitset Pointer to the rcl_wait_set_t that was using the
+ * \param wait_set Pointer to the rcl_wait_set_t that was using the
  * resulting guard condition.
  */
 RCLCPP_PUBLIC
 void
-release_sigint_guard_condition(rcl_wait_set_t * waitset);
+release_sigint_guard_condition(rcl_wait_set_t * wait_set);
 
 /// Use the global condition variable to block for the specified amount of time.
 /**

rclcpp/src/rclcpp/executor.cpp

@@ -50,24 +50,24 @@ Executor::Executor(const ExecutorArgs & args)
   // and one for the executor's guard cond (interrupt_guard_condition_)
 
   // Put the global ctrl-c guard condition in
-  memory_strategy_->add_guard_condition(rclcpp::utilities::get_sigint_guard_condition(&waitset_));
+  memory_strategy_->add_guard_condition(rclcpp::utilities::get_sigint_guard_condition(&wait_set_));
 
   // Put the executor's guard condition in
   memory_strategy_->add_guard_condition(&interrupt_guard_condition_);
   rcl_allocator_t allocator = memory_strategy_->get_allocator();
 
   if (rcl_wait_set_init(
-      &waitset_, 0, 2, 0, 0, 0, allocator) != RCL_RET_OK)
+      &wait_set_, 0, 2, 0, 0, 0, allocator) != RCL_RET_OK)
   {
     fprintf(stderr,
-      "[rclcpp::error] failed to create waitset: %s\n", rcl_get_error_string_safe());
+      "[rclcpp::error] failed to create wait set: %s\n", rcl_get_error_string_safe());
     rcl_reset_error();
     if (rcl_guard_condition_fini(&interrupt_guard_condition_) != RCL_RET_OK) {
       fprintf(stderr,
         "[rclcpp::error] failed to destroy guard condition: %s\n", rcl_get_error_string_safe());
       rcl_reset_error();
     }
-    throw std::runtime_error("Failed to create waitset in Executor constructor");
+    throw std::runtime_error("Failed to create wait set in Executor constructor");
   }
 }
 
@@ -83,10 +83,10 @@ Executor::~Executor()
   }
   weak_nodes_.clear();
 
-  // Finalize the waitset.
+  // Finalize the wait set.
-  if (rcl_wait_set_fini(&waitset_) != RCL_RET_OK) {
+  if (rcl_wait_set_fini(&wait_set_) != RCL_RET_OK) {
     fprintf(stderr,
-      "[rclcpp::error] failed to destroy waitset: %s\n", rcl_get_error_string_safe());
+      "[rclcpp::error] failed to destroy wait set: %s\n", rcl_get_error_string_safe());
     rcl_reset_error();
   }
   // Finalize the interrupt guard condition.
@@ -97,8 +97,8 @@ Executor::~Executor()
   }
   // Remove and release the sigint guard condition
   memory_strategy_->remove_guard_condition(
-    rclcpp::utilities::get_sigint_guard_condition(&waitset_));
+    rclcpp::utilities::get_sigint_guard_condition(&wait_set_));
-  rclcpp::utilities::release_sigint_guard_condition(&waitset_);
+  rclcpp::utilities::release_sigint_guard_condition(&wait_set_);
 }
 
 void
@@ -378,74 +378,74 @@ Executor::wait_for_work(std::chrono::nanoseconds timeout)
   }
 
   if (rcl_wait_set_resize_subscriptions(
-      &waitset_, memory_strategy_->number_of_ready_subscriptions()) != RCL_RET_OK)
+      &wait_set_, memory_strategy_->number_of_ready_subscriptions()) != RCL_RET_OK)
   {
     throw std::runtime_error(
-            std::string("Couldn't resize the number of subscriptions in waitset : ") +
+            std::string("Couldn't resize the number of subscriptions in wait set : ") +
             rcl_get_error_string_safe());
   }
 
   if (rcl_wait_set_resize_services(
-      &waitset_, memory_strategy_->number_of_ready_services()) != RCL_RET_OK)
+      &wait_set_, memory_strategy_->number_of_ready_services()) != RCL_RET_OK)
   {
     throw std::runtime_error(
-            std::string("Couldn't resize the number of services in waitset : ") +
+            std::string("Couldn't resize the number of services in wait set : ") +
             rcl_get_error_string_safe());
   }
 
   if (rcl_wait_set_resize_clients(
-      &waitset_, memory_strategy_->number_of_ready_clients()) != RCL_RET_OK)
+      &wait_set_, memory_strategy_->number_of_ready_clients()) != RCL_RET_OK)
   {
     throw std::runtime_error(
-            std::string("Couldn't resize the number of clients in waitset : ") +
+            std::string("Couldn't resize the number of clients in wait set : ") +
             rcl_get_error_string_safe());
   }
 
   if (rcl_wait_set_resize_guard_conditions(
-      &waitset_, memory_strategy_->number_of_guard_conditions()) != RCL_RET_OK)
+      &wait_set_, memory_strategy_->number_of_guard_conditions()) != RCL_RET_OK)
   {
     throw std::runtime_error(
-            std::string("Couldn't resize the number of guard_conditions in waitset : ") +
+            std::string("Couldn't resize the number of guard_conditions in wait set : ") +
             rcl_get_error_string_safe());
   }
 
   if (rcl_wait_set_resize_timers(
-      &waitset_, memory_strategy_->number_of_ready_timers()) != RCL_RET_OK)
+      &wait_set_, memory_strategy_->number_of_ready_timers()) != RCL_RET_OK)
   {
     throw std::runtime_error(
-            std::string("Couldn't resize the number of timers in waitset : ") +
+            std::string("Couldn't resize the number of timers in wait set : ") +
             rcl_get_error_string_safe());
   }
 
-  if (!memory_strategy_->add_handles_to_waitset(&waitset_)) {
+  if (!memory_strategy_->add_handles_to_wait_set(&wait_set_)) {
-    throw std::runtime_error("Couldn't fill waitset");
+    throw std::runtime_error("Couldn't fill wait set");
   }
   rcl_ret_t status =
-    rcl_wait(&waitset_, std::chrono::duration_cast<std::chrono::nanoseconds>(timeout).count());
+    rcl_wait(&wait_set_, std::chrono::duration_cast<std::chrono::nanoseconds>(timeout).count());
   if (status == RCL_RET_WAIT_SET_EMPTY) {
-    fprintf(stderr, "Warning: empty waitset received in rcl_wait(). This should never happen.\n");
+    fprintf(stderr, "Warning: empty wait set received in rcl_wait(). This should never happen.\n");
   } else if (status != RCL_RET_OK && status != RCL_RET_TIMEOUT) {
     using rclcpp::exceptions::throw_from_rcl_error;
     throw_from_rcl_error(status, "rcl_wait() failed");
   }
 
-  // check the null handles in the waitset and remove them from the handles in memory strategy
+  // check the null handles in the wait set and remove them from the handles in memory strategy
   // for callback-based entities
-  memory_strategy_->remove_null_handles(&waitset_);
+  memory_strategy_->remove_null_handles(&wait_set_);
-  if (rcl_wait_set_clear_subscriptions(&waitset_) != RCL_RET_OK) {
+  if (rcl_wait_set_clear_subscriptions(&wait_set_) != RCL_RET_OK) {
-    throw std::runtime_error("Couldn't clear subscriptions from waitset");
+    throw std::runtime_error("Couldn't clear subscriptions from wait set");
   }
-  if (rcl_wait_set_clear_services(&waitset_) != RCL_RET_OK) {
+  if (rcl_wait_set_clear_services(&wait_set_) != RCL_RET_OK) {
-    throw std::runtime_error("Couldn't clear servicess from waitset");
+    throw std::runtime_error("Couldn't clear servicess from wait set");
   }
-  if (rcl_wait_set_clear_clients(&waitset_) != RCL_RET_OK) {
+  if (rcl_wait_set_clear_clients(&wait_set_) != RCL_RET_OK) {
-    throw std::runtime_error("Couldn't clear clients from waitset");
+    throw std::runtime_error("Couldn't clear clients from wait set");
   }
-  if (rcl_wait_set_clear_guard_conditions(&waitset_) != RCL_RET_OK) {
+  if (rcl_wait_set_clear_guard_conditions(&wait_set_) != RCL_RET_OK) {
-    throw std::runtime_error("Couldn't clear guard conditions from waitset");
+    throw std::runtime_error("Couldn't clear guard conditions from wait set");
   }
-  if (rcl_wait_set_clear_timers(&waitset_) != RCL_RET_OK) {
+  if (rcl_wait_set_clear_timers(&wait_set_) != RCL_RET_OK) {
-    throw std::runtime_error("Couldn't clear timers from waitset");
+    throw std::runtime_error("Couldn't clear timers from wait set");
   }
 }
 

rclcpp/src/rclcpp/node_interfaces/node_services.cpp

@@ -45,7 +45,8 @@ NodeServices::add_service(
     auto notify_guard_condition_lock = node_base_->acquire_notify_guard_condition_lock();
     if (rcl_trigger_guard_condition(node_base_->get_notify_guard_condition()) != RCL_RET_OK) {
       throw std::runtime_error(
-              std::string("Failed to notify waitset on service creation: ") + rmw_get_error_string()
+              std::string(
+                "Failed to notify wait set on service creation: ") + rmw_get_error_string()
       );
     }
   }
@@ -71,7 +72,7 @@ NodeServices::add_client(
     auto notify_guard_condition_lock = node_base_->acquire_notify_guard_condition_lock();
     if (rcl_trigger_guard_condition(node_base_->get_notify_guard_condition()) != RCL_RET_OK) {
       throw std::runtime_error(
-              std::string("Failed to notify waitset on client creation: ") + rmw_get_error_string()
+              std::string("Failed to notify wait set on client creation: ") + rmw_get_error_string()
       );
     }
   }

rclcpp/src/rclcpp/node_interfaces/node_timers.cpp

@@ -42,6 +42,6 @@ NodeTimers::add_timer(
   if (rcl_trigger_guard_condition(node_base_->get_notify_guard_condition()) != RCL_RET_OK) {
     throw std::runtime_error(
             std::string(
-              "Failed to notify waitset on timer creation: ") + rmw_get_error_string());
+              "Failed to notify wait set on timer creation: ") + rmw_get_error_string());
   }
 }

rclcpp/src/rclcpp/node_interfaces/node_topics.cpp

@@ -74,7 +74,7 @@ NodeTopics::add_publisher(
     if (rcl_trigger_guard_condition(node_base_->get_notify_guard_condition()) != RCL_RET_OK) {
       throw std::runtime_error(
               std::string(
-                "Failed to notify waitset on publisher creation: ") + rmw_get_error_string());
+                "Failed to notify wait set on publisher creation: ") + rmw_get_error_string());
     }
   }
 }
@@ -124,7 +124,7 @@ NodeTopics::add_subscription(
     if (rcl_trigger_guard_condition(node_base_->get_notify_guard_condition()) != RCL_RET_OK) {
       throw std::runtime_error(
               std::string(
-                "Failed to notify waitset on subscription creation: ") + rmw_get_error_string()
+                "Failed to notify wait set on subscription creation: ") + rmw_get_error_string()
       );
     }
   }

rclcpp/src/rclcpp/utilities.cpp

@@ -218,10 +218,10 @@ rclcpp::utilities::on_shutdown(std::function<void(void)> callback)
 }
 
 rcl_guard_condition_t *
-rclcpp::utilities::get_sigint_guard_condition(rcl_wait_set_t * waitset)
+rclcpp::utilities::get_sigint_guard_condition(rcl_wait_set_t * wait_set)
 {
   std::lock_guard<std::mutex> lock(g_sigint_guard_cond_handles_mutex);
-  auto kv = g_sigint_guard_cond_handles.find(waitset);
+  auto kv = g_sigint_guard_cond_handles.find(wait_set);
   if (kv != g_sigint_guard_cond_handles.end()) {
     return &kv->second;
   } else {
@@ -234,16 +234,16 @@ rclcpp::utilities::get_sigint_guard_condition(rcl_wait_set_t * waitset)
         "Couldn't initialize guard condition: ") + rcl_get_error_string_safe());
       // *INDENT-ON*
     }
-    g_sigint_guard_cond_handles[waitset] = handle;
+    g_sigint_guard_cond_handles[wait_set] = handle;
-    return &g_sigint_guard_cond_handles[waitset];
+    return &g_sigint_guard_cond_handles[wait_set];
   }
 }
 
 void
-rclcpp::utilities::release_sigint_guard_condition(rcl_wait_set_t * waitset)
+rclcpp::utilities::release_sigint_guard_condition(rcl_wait_set_t * wait_set)
 {
   std::lock_guard<std::mutex> lock(g_sigint_guard_cond_handles_mutex);
-  auto kv = g_sigint_guard_cond_handles.find(waitset);
+  auto kv = g_sigint_guard_cond_handles.find(wait_set);
   if (kv != g_sigint_guard_cond_handles.end()) {
     if (rcl_guard_condition_fini(&kv->second) != RCL_RET_OK) {
       // *INDENT-OFF* (prevent uncrustify from making unnecessary indents here)
@@ -256,7 +256,7 @@ rclcpp::utilities::release_sigint_guard_condition(rcl_wait_set_t * waitset)
   } else {
     // *INDENT-OFF* (prevent uncrustify from making unnecessary indents here)
     throw std::runtime_error(std::string(
-      "Tried to release sigint guard condition for nonexistent waitset"));
+      "Tried to release sigint guard condition for nonexistent wait set"));
     // *INDENT-ON*
   }
 }