rename local_event_queue->execution_event_queue

Author: Mauro Passerino

rclcpp/include/rclcpp/executors/events_executor.hpp

@@ -223,12 +223,12 @@ class EventsExecutor : public rclcpp::Executor
     // Remove events associated with this entity from the local event queue
     {
       std::unique_lock<std::mutex> lock(execution_mutex_);
-      local_event_queue_.erase(
+      execution_event_queue_.erase(
         std::remove_if(
-          local_event_queue_.begin(), local_event_queue_.end(),
+          execution_event_queue_.begin(), execution_event_queue_.end(),
           [&entity](ExecutorEvent event) {
             return event.entity == entity;
-          }), local_event_queue_.end());
+          }), execution_event_queue_.end());
     }
   }
 
@@ -244,7 +244,7 @@ class EventsExecutor : public rclcpp::Executor
 
   // We use two instances of EventQueue to allow threads to push events while we execute them
   EventQueue event_queue_;
-  EventQueue local_event_queue_;
+  EventQueue execution_event_queue_;
 
   EventsExecutorEntitiesCollector::SharedPtr entities_collector_;
   EventsExecutorNotifyWaitable::SharedPtr executor_notifier_;

rclcpp/src/rclcpp/executors/events_executor.cpp

@@ -67,11 +67,11 @@ EventsExecutor::spin()
     event_queue_cv_.wait(push_lock, has_event_predicate);
     std::unique_lock<std::mutex> execution_lock(execution_mutex_);
     // We got an event! Swap queues while we hold both mutexes
-    std::swap(local_event_queue_, event_queue_);
+    std::swap(execution_event_queue_, event_queue_);
     // After swapping the queues, we don't need the push lock anymore
     push_lock.unlock();
     // Consume events while under the execution lock only
-    this->consume_all_events(local_event_queue_);
+    this->consume_all_events(execution_event_queue_);
   }
   timers_manager_->stop();
 }
@@ -108,9 +108,9 @@ EventsExecutor::spin_some(std::chrono::nanoseconds max_duration)
   std::unique_lock<std::mutex> push_lock(push_mutex_);
   event_queue_cv_.wait_for(push_lock, max_duration, has_event_predicate);
   std::unique_lock<std::mutex> execution_lock(execution_mutex_);
-  std::swap(local_event_queue_, event_queue_);
+  std::swap(execution_event_queue_, event_queue_);
   push_lock.unlock();
-  this->consume_all_events(local_event_queue_);
+  this->consume_all_events(execution_event_queue_);
   execution_lock.unlock();
 
   timers_manager_->execute_ready_timers();
@@ -154,18 +154,18 @@ EventsExecutor::spin_all(std::chrono::nanoseconds max_duration)
   while (rclcpp::ok(context_) && spinning.load() && max_duration_not_elapsed()) {
     std::unique_lock<std::mutex> push_lock(push_mutex_);
     std::unique_lock<std::mutex> execution_lock(execution_mutex_);
-    std::swap(local_event_queue_, event_queue_);
+    std::swap(execution_event_queue_, event_queue_);
     push_lock.unlock();
 
     bool ready_timer = timers_manager_->get_head_timeout() < 0ns;
-    bool has_events = !local_event_queue_.empty();
+    bool has_events = !execution_event_queue_.empty();
     if (!ready_timer && !has_events) {
       // Exit as there is no more work to do
       break;
     }
     // Execute all ready work
 
-    this->consume_all_events(local_event_queue_);
+    this->consume_all_events(execution_event_queue_);
     execution_lock.unlock();
 
     timers_manager_->execute_ready_timers();