add override attribute to some ipc methods

Signed-off-by: Alberto Soragna <[email protected]>

Author: alsora

rclcpp/include/rclcpp/experimental/action_client_intra_process_base.hpp

@@ -65,25 +65,23 @@ class ActionClientIntraProcessBase : public rclcpp::Waitable
 
   RCLCPP_PUBLIC
   size_t
-  get_number_of_ready_guard_conditions() {return 1;}
+  get_number_of_ready_guard_conditions() override {return 1;}
 
   RCLCPP_PUBLIC
   void
-  add_to_wait_set(rcl_wait_set_t & wait_set);
+  add_to_wait_set(rcl_wait_set_t & wait_set) override;
 
-  virtual bool
-  is_ready(const rcl_wait_set_t & wait_set) = 0;
+  bool
+  is_ready(const rcl_wait_set_t & wait_set) override = 0;
 
-  virtual
   std::shared_ptr<void>
-  take_data() = 0;
+  take_data() override = 0;
 
-  virtual
   std::shared_ptr<void>
-  take_data_by_entity_id(size_t id) = 0;
+  take_data_by_entity_id(size_t id) override = 0;
 
-  virtual void
-  execute(const std::shared_ptr<void> & data) = 0;
+  void
+  execute(const std::shared_ptr<void> & data) override = 0;
 
   RCLCPP_PUBLIC
   const char *

rclcpp/include/rclcpp/experimental/action_server_intra_process_base.hpp

@@ -64,25 +64,23 @@ class ActionServerIntraProcessBase : public rclcpp::Waitable
 
   RCLCPP_PUBLIC
   size_t
-  get_number_of_ready_guard_conditions() {return 1;}
+  get_number_of_ready_guard_conditions() override {return 1;}
 
   RCLCPP_PUBLIC
   void
-  add_to_wait_set(rcl_wait_set_t & wait_set);
+  add_to_wait_set(rcl_wait_set_t & wait_set) override;
 
-  virtual bool
-  is_ready(const rcl_wait_set_t & wait_set) = 0;
+  bool
+  is_ready(const rcl_wait_set_t & wait_set) override = 0;
 
-  virtual
   std::shared_ptr<void>
-  take_data() = 0;
+  take_data() override = 0;
 
-  virtual
   std::shared_ptr<void>
-  take_data_by_entity_id(size_t id) = 0;
+  take_data_by_entity_id(size_t id) override = 0;
 
-  virtual void
-  execute(const std::shared_ptr<void> & data) = 0;
+  void
+  execute(const std::shared_ptr<void> & data) override = 0;
 
   RCLCPP_PUBLIC
   const char *

rclcpp/include/rclcpp/experimental/client_intra_process_base.hpp

@@ -56,18 +56,17 @@ class ClientIntraProcessBase : public rclcpp::Waitable
 
   RCLCPP_PUBLIC
   size_t
-  get_number_of_ready_guard_conditions() {return 1;}
+  get_number_of_ready_guard_conditions() override {return 1;}
 
   RCLCPP_PUBLIC
   void
-  add_to_wait_set(rcl_wait_set_t & wait_set);
+  add_to_wait_set(rcl_wait_set_t & wait_set) override;
 
-  virtual bool
-  is_ready(const rcl_wait_set_t & wait_set) = 0;
+  bool
+  is_ready(const rcl_wait_set_t & wait_set) override = 0;
 
-  virtual
   std::shared_ptr<void>
-  take_data() = 0;
+  take_data() override = 0;
 
   std::shared_ptr<void>
   take_data_by_entity_id(size_t id) override
@@ -76,8 +75,8 @@ class ClientIntraProcessBase : public rclcpp::Waitable
     return take_data();
   }
 
-  virtual void
-  execute(const std::shared_ptr<void> & data) = 0;
+  void
+  execute(const std::shared_ptr<void> & data) override = 0;
 
   RCLCPP_PUBLIC
   const char *

rclcpp/include/rclcpp/experimental/service_intra_process_base.hpp

@@ -60,18 +60,17 @@ class ServiceIntraProcessBase : public rclcpp::Waitable
 
   RCLCPP_PUBLIC
   size_t
-  get_number_of_ready_guard_conditions() {return 1;}
+  get_number_of_ready_guard_conditions() override {return 1;}
 
   RCLCPP_PUBLIC
   void
-  add_to_wait_set(rcl_wait_set_t & wait_set);
+  add_to_wait_set(rcl_wait_set_t & wait_set) override;
 
-  virtual bool
-  is_ready(const rcl_wait_set_t & wait_set) = 0;
+  bool
+  is_ready(const rcl_wait_set_t & wait_set) override = 0;
 
-  virtual
   std::shared_ptr<void>
-  take_data() = 0;
+  take_data() override = 0;
 
   std::shared_ptr<void>
   take_data_by_entity_id(size_t id) override
@@ -80,8 +79,8 @@ class ServiceIntraProcessBase : public rclcpp::Waitable
     return take_data();
   }
 
-  virtual void
-  execute(const std::shared_ptr<void> & data) = 0;
+  void
+  execute(const std::shared_ptr<void> & data) override = 0;
 
   RCLCPP_PUBLIC
   const char *

rclcpp_action/include/rclcpp_action/client.hpp

@@ -195,7 +195,7 @@ class ClientBase : public rclcpp::Waitable
   rclcpp::Waitable::SharedPtr
   get_intra_process_waitable();
 
-  protected:
+protected:
   RCLCPP_ACTION_PUBLIC
   ClientBase(
     rclcpp::node_interfaces::NodeBaseInterface::SharedPtr node_base,
@@ -316,7 +316,7 @@ class ClientBase : public rclcpp::Waitable
   setup_intra_process(
     uint64_t ipc_action_client_id,
     IntraProcessManagerWeakPtr weak_ipm);
- 
+
   // End API for communication between ClientBase and Client<>
   // ---------------------------------------------------------
 
@@ -508,36 +508,36 @@ class Client : public ClientBase
         }
       };
 
-      bool intra_process_send_done = false;
-  
-      std::lock_guard<std::recursive_mutex> lock(ipc_mutex_);
-  
-      if (use_intra_process_) {
-        auto ipm = weak_ipm_.lock();
-        if (!ipm) {
-          throw std::runtime_error(
+    bool intra_process_send_done = false;
+
+    std::lock_guard<std::recursive_mutex> lock(ipc_mutex_);
+
+    if (use_intra_process_) {
+      auto ipm = weak_ipm_.lock();
+      if (!ipm) {
+        throw std::runtime_error(
                   "intra process send goal called after destruction of intra process manager");
-        }
-        bool intra_process_server_available = ipm->action_server_is_available(ipc_action_client_id_);
-  
+      }
+      bool intra_process_server_available = ipm->action_server_is_available(ipc_action_client_id_);
+
         // Check if there's an intra-process action server available matching this client.
         // If there's not, we fall back into inter-process communication, since
         // the server might be available in another process or was configured to not use IPC.
-        if (intra_process_server_available) {
-          ipm->intra_process_action_send_goal_request<ActionT>(
+      if (intra_process_server_available) {
+        ipm->intra_process_action_send_goal_request<ActionT>(
             ipc_action_client_id_,
             std::move(goal_request),
             callback);
-          intra_process_send_done = true;
-        }
+        intra_process_send_done = true;
       }
-  
-      if (!intra_process_send_done) {
+    }
+
+    if (!intra_process_send_done) {
         // Send inter-process goal request
-        this->send_goal_request(
+      this->send_goal_request(
           std::static_pointer_cast<void>(goal_request),
           callback);
-      }
+    }
 
     // TODO(jacobperron): Encapsulate into it's own function and
     //                    consider exposing an option to disable this cleanup
@@ -848,53 +848,53 @@ class Client : public ClientBase
     // The client callback to be called when server calculates the result, using the server
     // response as argument.
     auto callback =
-        [goal_handle, this](std::shared_ptr<void> response) mutable
-        {
+      [goal_handle, this](std::shared_ptr<void> response) mutable
+      {
           // Wrap the response in a struct with the fields a user cares about
-          WrappedResult wrapped_result;
-          using GoalResultResponse = typename ActionT::Impl::GetResultService::Response;
-          auto result_response = std::static_pointer_cast<GoalResultResponse>(response);
-          wrapped_result.result = std::make_shared<typename ActionT::Result>();
-          *wrapped_result.result = result_response->result;
-          wrapped_result.goal_id = goal_handle->get_goal_id();
-          wrapped_result.code = static_cast<ResultCode>(result_response->status);
-          goal_handle->set_result(wrapped_result);
-          std::lock_guard<std::recursive_mutex> lock(goal_handles_mutex_);
-          goal_handles_.erase(goal_handle->get_goal_id());
-        };
-
-        try {
-          bool intra_process_send_done = false;
-    
-          std::lock_guard<std::recursive_mutex> lock(ipc_mutex_);
-    
-          if (use_intra_process_) {
-            auto ipm = weak_ipm_.lock();
-            if (!ipm) {
-              throw std::runtime_error(
+        WrappedResult wrapped_result;
+        using GoalResultResponse = typename ActionT::Impl::GetResultService::Response;
+        auto result_response = std::static_pointer_cast<GoalResultResponse>(response);
+        wrapped_result.result = std::make_shared<typename ActionT::Result>();
+        *wrapped_result.result = result_response->result;
+        wrapped_result.goal_id = goal_handle->get_goal_id();
+        wrapped_result.code = static_cast<ResultCode>(result_response->status);
+        goal_handle->set_result(wrapped_result);
+        std::lock_guard<std::recursive_mutex> lock(goal_handles_mutex_);
+        goal_handles_.erase(goal_handle->get_goal_id());
+      };
+
+    try {
+      bool intra_process_send_done = false;
+
+      std::lock_guard<std::recursive_mutex> lock(ipc_mutex_);
+
+      if (use_intra_process_) {
+        auto ipm = weak_ipm_.lock();
+        if (!ipm) {
+          throw std::runtime_error(
                       "intra process send result called after destruction of intra process manager");
-            }
-            bool intra_process_server_available =
-              ipm->action_server_is_available(ipc_action_client_id_);
-    
+        }
+        bool intra_process_server_available =
+          ipm->action_server_is_available(ipc_action_client_id_);
+
             // Check if there's an intra-process action server available matching this client.
             // If there's not, we fall back into inter-process communication, since
             // the server might be available in another process or was configured to not use IPC.
-            if (intra_process_server_available) {
-              ipm->intra_process_action_send_result_request<ActionT>(
+        if (intra_process_server_available) {
+          ipm->intra_process_action_send_result_request<ActionT>(
                 ipc_action_client_id_,
                 std::move(goal_result_request),
                 callback);
-              intra_process_send_done = true;
-            }
-          }
-    
-          if (!intra_process_send_done) {
+          intra_process_send_done = true;
+        }
+      }
+
+      if (!intra_process_send_done) {
             // Send inter-process result request
-            this->send_result_request(
+        this->send_result_request(
               std::static_pointer_cast<void>(goal_result_request),
               callback);
-          }
+      }
     } catch (rclcpp::exceptions::RCLError & ex) {
       // This will cause an exception when the user tries to access the result
       goal_handle->invalidate(exceptions::UnawareGoalHandleError(ex.message));
@@ -921,35 +921,35 @@ class Client : public ClientBase
         }
       };
 
-      bool intra_process_send_done = false;
-  
-      std::lock_guard<std::recursive_mutex> lock(ipc_mutex_);
-  
-      if (use_intra_process_) {
-        auto ipm = weak_ipm_.lock();
-        if (!ipm) {
-          throw std::runtime_error(
+    bool intra_process_send_done = false;
+
+    std::lock_guard<std::recursive_mutex> lock(ipc_mutex_);
+
+    if (use_intra_process_) {
+      auto ipm = weak_ipm_.lock();
+      if (!ipm) {
+        throw std::runtime_error(
                   "intra process send goal called after destruction of intra process manager");
-        }
-        bool intra_process_server_available = ipm->action_server_is_available(ipc_action_client_id_);
-  
+      }
+      bool intra_process_server_available = ipm->action_server_is_available(ipc_action_client_id_);
+
         // Check if there's an intra-process action server available matching this client.
         // If there's not, we fall back into inter-process communication, since
         // the server might be available in another process or was configured to not use IPC.
-        if (intra_process_server_available) {
-          ipm->intra_process_action_send_cancel_request<ActionT>(
+      if (intra_process_server_available) {
+        ipm->intra_process_action_send_cancel_request<ActionT>(
             ipc_action_client_id_,
             std::move(cancel_request),
             callback);
-          intra_process_send_done = true;
-        }
+        intra_process_send_done = true;
       }
-  
-      if (!intra_process_send_done) {
-        this->send_cancel_request(
+    }
+
+    if (!intra_process_send_done) {
+      this->send_cancel_request(
           std::static_pointer_cast<void>(cancel_request),
           callback);
-      }
+    }
     return future;
   }
 

rclcpp_action/include/rclcpp_action/server.hpp

@@ -304,7 +304,7 @@ class ServerBase : public rclcpp::Waitable
   RCLCPP_ACTION_PUBLIC
   std::shared_ptr<void>
   get_result_response(GoalUUID uuid);
-  
+
   // End API for communication between ServerBase and Server<>
   // ---------------------------------------------------------
 
@@ -701,9 +701,9 @@ class Server : public ServerBase, public std::enable_shared_from_this<Server<Act
           ipm->remove_intra_process_action_client_goal_uuid(hashed_uuid);
         } else {
         // Send result message to anyone that asked
-        shared_this->publish_result(goal_uuid, result_message);
+          shared_this->publish_result(goal_uuid, result_message);
         // Publish a status message any time a goal handle changes state
-        shared_this->publish_status();
+          shared_this->publish_status();
         }
 
         // notify base so it can recalculate the expired goal timer
@@ -746,7 +746,7 @@ class Server : public ServerBase, public std::enable_shared_from_this<Server<Act
             std::move(status_msg));
 
         } else {
-        shared_this->publish_status();
+          shared_this->publish_status();
         }
       };
 
@@ -780,7 +780,7 @@ class Server : public ServerBase, public std::enable_shared_from_this<Server<Act
             ipc_action_client_id,
             std::move(feedback_msg));
         } else {
-        shared_this->publish_feedback(std::static_pointer_cast<void>(feedback_msg));
+          shared_this->publish_feedback(std::static_pointer_cast<void>(feedback_msg));
         }
       };