chore: fixed typos

Signed-off-by: Janosch Machowinski <J.Machowinski@cellumation.com>

Author: Janosch Machowinski

rclcpp/include/rclcpp/executors/events_cbg_executor/events_cbg_executor.hpp

@@ -222,7 +222,7 @@ class EventsCBGExecutor : public rclcpp::Executor
     return FutureReturnCode::INTERRUPTED;
   }
 
-  /// We need these fuction to be public, as we use them in the callback_group_scheduler
+  /// We need these function to be public, as we use them in the callback_group_scheduler
   using rclcpp::Executor::execute_subscription;
   using rclcpp::Executor::execute_timer;
   using rclcpp::Executor::execute_service;

rclcpp/include/rclcpp/timer.hpp

@@ -190,6 +190,10 @@ class TimerBase
   void
   clear_on_reset_callback();
 
+  /// Returns the clock this timer uses
+  RCLCPP_PUBLIC
+  const Clock::SharedPtr & get_clock() const;
+
 protected:
   std::recursive_mutex callback_mutex_;
   // Declare callback before timer_handle_, so on destruction

rclcpp/src/rclcpp/executors/events_cbg_executor/events_cbg_executor.cpp

@@ -126,12 +126,12 @@ void EventsCBGExecutor::shutdown()
   // we need to shut down the timer manager first, as it might access the Schedulers
   timer_manager->stop();
 
-  bool was_spining = spinning;
+  bool was_spinning = spinning;
 
   // signal all processing threads to shut down
   spinning = false;
 
-  if(was_spining) {
+  if(was_spinning) {
     scheduler->release_all_worker_threads();
   }
 
@@ -193,15 +193,15 @@ bool EventsCBGExecutor::execute_previous_ready_executables_until(
 
   while(true) {
     auto ready_entity = scheduler->get_next_ready_entity(last_ready_id);
-    if(!ready_entity.entitiy) {
+    if(!ready_entity.entity) {
       break;
     }
 
     found_work = true;
 
-    ready_entity.entitiy->execute_function();
+    ready_entity.entity->execute_function();
 
-    scheduler->mark_entity_as_executed(*ready_entity.entitiy);
+    scheduler->mark_entity_as_executed(*ready_entity.entity);
 
     if(std::chrono::steady_clock::now() >= stop_time) {
       break;
@@ -335,7 +335,7 @@ EventsCBGExecutor::run(size_t this_thread_number, bool block_initially)
     sync_callback_groups();
 
     auto ready_entity = scheduler->get_next_ready_entity();
-    if(!ready_entity.entitiy) {
+    if(!ready_entity.entity) {
       scheduler->block_worker_thread();
       continue;
     }
@@ -344,9 +344,9 @@ EventsCBGExecutor::run(size_t this_thread_number, bool block_initially)
       scheduler->unblock_one_worker_thread();
     }
 
-    ready_entity.entitiy->execute_function();
+    ready_entity.entity->execute_function();
 
-    scheduler->mark_entity_as_executed(*ready_entity.entitiy);
+    scheduler->mark_entity_as_executed(*ready_entity.entity);
   }
 }
 
@@ -361,18 +361,18 @@ EventsCBGExecutor::run(
     sync_callback_groups();
 
     auto ready_entity = scheduler->get_next_ready_entity();
-    if(!ready_entity.entitiy) {
+    if(!ready_entity.entity) {
       scheduler->block_worker_thread();
       continue;
     }
 
     try {
-      ready_entity.entitiy->execute_function();
+      ready_entity.entity->execute_function();
     } catch (const std::exception & e) {
       exception_handler(e);
     }
 
-    scheduler->mark_entity_as_executed(*ready_entity.entitiy);
+    scheduler->mark_entity_as_executed(*ready_entity.entity);
   }
 }
 
@@ -384,7 +384,7 @@ void EventsCBGExecutor::spin_once_internal(std::chrono::nanoseconds timeout)
   }
 
   auto ready_entity = scheduler->get_next_ready_entity();
-  if(!ready_entity.entitiy) {
+  if(!ready_entity.entity) {
     if (timeout < std::chrono::nanoseconds::zero()) {
       // can't use std::chrono::nanoseconds::max, as wait_for
       // internally computes end time by using ::now() + timeout
@@ -396,14 +396,14 @@ void EventsCBGExecutor::spin_once_internal(std::chrono::nanoseconds timeout)
 
     ready_entity = scheduler->get_next_ready_entity();
 
-    if (!ready_entity.entitiy) {
+    if (!ready_entity.entity) {
       return;
     }
   }
 
-  ready_entity.entitiy->execute_function();
+  ready_entity.entity->execute_function();
 
-  scheduler->mark_entity_as_executed(*ready_entity.entitiy);
+  scheduler->mark_entity_as_executed(*ready_entity.entity);
 }
 
 void

rclcpp/src/rclcpp/executors/events_cbg_executor/first_in_first_out_scheduler.cpp

@@ -163,12 +163,12 @@ CBGScheduler::ExecutableEntityWithInfo FirstInFirstOutScheduler::get_next_ready_
     std::optional<FirstInFirstOutScheduler::ExecutableEntity> ret =
       ready_cbg->get_next_ready_entity();
     if(ret) {
-      return CBGScheduler::ExecutableEntityWithInfo{.entitiy = std::move(ret),
+      return CBGScheduler::ExecutableEntityWithInfo{.entity = std::move(ret),
         .moreEntitiesReady = !ready_callback_groups.empty()};
     }
   }
 
-  return CBGScheduler::ExecutableEntityWithInfo{.entitiy = std::nullopt,
+  return CBGScheduler::ExecutableEntityWithInfo{.entity = std::nullopt,
     .moreEntitiesReady = false};
 }
 
@@ -187,12 +187,12 @@ CBGScheduler::ExecutableEntityWithInfo FirstInFirstOutScheduler::get_next_ready_
       ready_cbg->get_next_ready_entity(max_id);
     if(ret) {
       ready_callback_groups.erase(it);
-      return CBGScheduler::ExecutableEntityWithInfo{.entitiy = std::move(ret),
+      return CBGScheduler::ExecutableEntityWithInfo{.entity = std::move(ret),
         .moreEntitiesReady = !ready_callback_groups.empty()};
     }
   }
 
-  return CBGScheduler::ExecutableEntityWithInfo{.entitiy = std::nullopt,
+  return CBGScheduler::ExecutableEntityWithInfo{.entity = std::nullopt,
     .moreEntitiesReady = false};
 }
 }  // namespace cbg_executor

rclcpp/src/rclcpp/executors/events_cbg_executor/scheduler.hpp

@@ -230,7 +230,7 @@ class CBGScheduler
 
   struct ExecutableEntityWithInfo
   {
-    std::optional<ExecutableEntity> entitiy;
+    std::optional<ExecutableEntity> entity;
     bool moreEntitiesReady{};
   };
 

rclcpp/test/benchmark/benchmark_executor.cpp

@@ -64,10 +64,10 @@ class PerformanceTestExecutor : public PerformanceTest
     rclcpp::shutdown();
   }
 
-  template<class Executer>
+  template<class Executor>
   void executor_spin_some(benchmark::State & st)
   {
-    Executer executor;
+    Executor executor;
     for (unsigned int i = 0u; i < kNumberOfNodes; i++) {
       executor.add_node(nodes[i]);
     }
@@ -106,19 +106,19 @@ class PerformanceTestExecutor : public PerformanceTest
     }
   }
 
-  template<class Executer>
+  template<class Executor>
   void benchmark_wait_for_work(benchmark::State & st)
   {
-    class ExecuterDerived : public Executer
+    class ExecutorDerived : public Executor
     {
 public:
       void call_wait_for_work(std::chrono::nanoseconds timeout)
       {
-        Executer::wait_for_work(timeout);
+        Executor::wait_for_work(timeout);
       }
     };
 
-    ExecuterDerived executor;
+    ExecutorDerived executor;
     for (unsigned int i = 0u; i < kNumberOfNodes; i++) {
       executor.add_node(nodes[i]);
     }
@@ -344,7 +344,7 @@ class CallbackWaitable : public rclcpp::Waitable
 
 class CascadedPerformanceTestExecutor : public PerformanceTest
 {
-  std::condition_variable cascase_done;
+  std::condition_variable cascade_done;
   std::vector<std::shared_ptr<CallbackWaitable>> waitables;
   std::atomic<bool> last_cb_triggered;
 
@@ -365,7 +365,7 @@ class CascadedPerformanceTestExecutor : public PerformanceTest
         auto callback = [this, i](test_msgs::msg::Empty::ConstSharedPtr) {
             if (i == kNumberOfNodes - 1) {
               this->callback_count++;
-              cascase_done.notify_all();
+              cascade_done.notify_all();
             } else {
               publishers[i + 1]->publish(empty_msgs);
             }
@@ -387,7 +387,7 @@ class CascadedPerformanceTestExecutor : public PerformanceTest
         waitables[i]->set_execute_callback_function(
           [this]() {
             last_cb_triggered = true;
-            cascase_done.notify_all();
+            cascade_done.notify_all();
           });
       } else {
         waitables[i]->set_execute_callback_function(
@@ -441,7 +441,7 @@ class CascadedPerformanceTestExecutor : public PerformanceTest
       // start the cascasde
       waitables[0]->trigger();
 
-      cascase_done.wait_for(lk, 500ms);
+      cascade_done.wait_for(lk, 500ms);
 
       if (!last_cb_triggered) {
         st.SkipWithError("No message was received");