style(pre-commit): autofix

common/autoware_control_center/include/autoware_control_center/autoware_control_center.hpp

@@ -15,17 +15,18 @@
 #ifndef AUTOWARE_CONTROL_CENTER__AUTOWARE_CONTROL_CENTER_HPP_
 #define AUTOWARE_CONTROL_CENTER__AUTOWARE_CONTROL_CENTER_HPP_
 
-#include <string>
-#include <unordered_map>
-
 #include "autoware_control_center/node_registry.hpp"
 #include "autoware_control_center/visibility_control.hpp"
+#include "rclcpp_lifecycle/lifecycle_node.hpp"
+
 #include "autoware_control_center_msgs/msg/autoware_node_reports.hpp"
 #include "autoware_control_center_msgs/msg/heartbeat.hpp"
 #include "autoware_control_center_msgs/srv/autoware_node_deregister.hpp"
 #include "autoware_control_center_msgs/srv/autoware_node_error.hpp"
 #include "autoware_control_center_msgs/srv/autoware_node_register.hpp"
-#include "rclcpp_lifecycle/lifecycle_node.hpp"
+
+#include <string>
+#include <unordered_map>
 
 namespace autoware_control_center
 {
@@ -57,7 +58,7 @@ class AutowareControlCenter : public rclcpp_lifecycle::LifecycleNode
   NodeRegistry node_registry_;
   std::unordered_map<
     std::string, rclcpp::Subscription<autoware_control_center_msgs::msg::Heartbeat>::SharedPtr>
-  heartbeat_sub_map_;
+    heartbeat_sub_map_;
   std::unordered_map<std::string, AutowareNodeStatus> node_status_map_;
 
   rclcpp::TimerBase::SharedPtr startup_timer_;

common/autoware_control_center/include/autoware_control_center/node_registry.hpp

@@ -15,10 +15,12 @@
 #ifndef AUTOWARE_CONTROL_CENTER__NODE_REGISTRY_HPP_
 #define AUTOWARE_CONTROL_CENTER__NODE_REGISTRY_HPP_
 
-#include <optional>
 #include <rclcpp/rclcpp.hpp>
-#include <string>
+
 #include <unique_identifier_msgs/msg/uuid.hpp>
+
+#include <optional>
+#include <string>
 #include <unordered_map>
 
 namespace autoware_control_center

common/autoware_control_center/src/autoware_control_center.cpp

@@ -14,14 +14,16 @@
 
 #include "autoware_control_center/autoware_control_center.hpp"
 
+#include "autoware_control_center/node_registry.hpp"
+
 #include <autoware_utils/ros/uuid_helper.hpp>
-#include <chrono>
-#include <unique_identifier_msgs/msg/uuid.hpp>
 
-#include "autoware_control_center/node_registry.hpp"
 #include "autoware_control_center_msgs/msg/autoware_node_report.hpp"
 #include "autoware_control_center_msgs/msg/heartbeat.hpp"
 #include "autoware_control_center_msgs/srv/autoware_control_center_deregister.hpp"
+#include <unique_identifier_msgs/msg/uuid.hpp>
+
+#include <chrono>
 
 using std::chrono::operator""ms;
 
@@ -135,31 +137,31 @@ void AutowareControlCenter::startup_callback()
     for (auto const & pair : srv_list) {
       RCLCPP_INFO(get_logger(), pair.first.c_str());  // print service name
       rclcpp::Client<autoware_control_center_msgs::srv::AutowareControlCenterDeregister>::SharedPtr
-      // cspell:ignore dereg
+        // cspell:ignore dereg
         dereg_client_ =
-        create_client<autoware_control_center_msgs::srv::AutowareControlCenterDeregister>(
-        pair.first);
+          create_client<autoware_control_center_msgs::srv::AutowareControlCenterDeregister>(
+            pair.first);
       autoware_control_center_msgs::srv::AutowareControlCenterDeregister::Request::SharedPtr req =
         std::make_shared<
-        autoware_control_center_msgs::srv::AutowareControlCenterDeregister::Request>();
+          autoware_control_center_msgs::srv::AutowareControlCenterDeregister::Request>();
 
       req->uuid_acc = acc_uuid;
 
       using ServiceResponseFuture = rclcpp::Client<
         autoware_control_center_msgs::srv::AutowareControlCenterDeregister>::SharedFuture;
       // lambda for async request
       auto response_received_callback = [this](ServiceResponseFuture future) {
-          auto response = future.get();
-          RCLCPP_INFO(
-            get_logger(), "Deregister response: %d, %s", response->status.status,
-            response->name_node.c_str());
-
-          if (response->status.status == 1) {
-            RCLCPP_INFO(get_logger(), "Node was deregistered");
-          } else {
-            RCLCPP_ERROR(get_logger(), "Failed to deregister node");
-          }
-        };
+        auto response = future.get();
+        RCLCPP_INFO(
+          get_logger(), "Deregister response: %d, %s", response->status.status,
+          response->name_node.c_str());
+
+        if (response->status.status == 1) {
+          RCLCPP_INFO(get_logger(), "Node was deregistered");
+        } else {
+          RCLCPP_ERROR(get_logger(), "Failed to deregister node");
+        }
+      };
 
       if (dereg_client_->service_is_ready()) {
         auto future_result = dereg_client_->async_send_request(req, response_received_callback);
@@ -177,28 +179,28 @@ AutowareControlCenter::create_heartbeat_sub(const std::string & node_name)
   RCLCPP_INFO(get_logger(), "Create heart sub is called.");
   rclcpp::QoS qos_profile_ = rclcpp::QoS(10);
   qos_profile_.liveliness(RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC)
-  .liveliness_lease_duration(lease_duration_);
+    .liveliness_lease_duration(lease_duration_);
 
   rclcpp::SubscriptionOptions heartbeat_sub_options_;
   heartbeat_sub_options_.event_callbacks.liveliness_callback =
-    [ = ](rclcpp::QOSLivelinessChangedInfo & event) -> void {
-      RCLCPP_INFO(get_logger(), "Reader Liveliness changed event:");
-      RCLCPP_INFO(get_logger(), "  alive_count: %d", event.alive_count);
-      RCLCPP_INFO(get_logger(), "  not_alive_count: %d", event.not_alive_count);
-      RCLCPP_INFO(get_logger(), "  alive_count_change: %d", event.alive_count_change);
-      RCLCPP_INFO(get_logger(), "  not_alive_count_change: %d", event.not_alive_count_change);
-      if (event.alive_count == 0) {
-        RCLCPP_ERROR(get_logger(), "Heartbeat was not received");
-        node_status_map_[node_name].alive = false;
-      }
-    };
+    [=](rclcpp::QOSLivelinessChangedInfo & event) -> void {
+    RCLCPP_INFO(get_logger(), "Reader Liveliness changed event:");
+    RCLCPP_INFO(get_logger(), "  alive_count: %d", event.alive_count);
+    RCLCPP_INFO(get_logger(), "  not_alive_count: %d", event.not_alive_count);
+    RCLCPP_INFO(get_logger(), "  alive_count_change: %d", event.alive_count_change);
+    RCLCPP_INFO(get_logger(), "  not_alive_count_change: %d", event.not_alive_count_change);
+    if (event.alive_count == 0) {
+      RCLCPP_ERROR(get_logger(), "Heartbeat was not received");
+      node_status_map_[node_name].alive = false;
+    }
+  };
 
   std::string topic_name = node_name + "/heartbeat";
   RCLCPP_INFO(get_logger(), "Topic to subscribe is %s", topic_name.c_str());
   rclcpp::Subscription<autoware_control_center_msgs::msg::Heartbeat>::SharedPtr heartbeat_sub_;
   heartbeat_sub_ = create_subscription<autoware_control_center_msgs::msg::Heartbeat>(
     topic_name, qos_profile_,
-    [ = ](const typename autoware_control_center_msgs::msg::Heartbeat::SharedPtr msg) -> void {
+    [=](const typename autoware_control_center_msgs::msg::Heartbeat::SharedPtr msg) -> void {
       RCLCPP_INFO(get_logger(), "Watchdog raised, heartbeat sent at [%d.x]", msg->stamp.sec);
       node_status_map_[node_name].alive = true;
       node_status_map_[node_name].last_heartbeat = msg->stamp;

common/autoware_control_center/src/autoware_control_center_node.cpp

@@ -12,10 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <memory>
+#include "autoware_control_center/autoware_control_center.hpp"
+
 #include <rclcpp/rclcpp.hpp>
 
-#include "autoware_control_center/autoware_control_center.hpp"
+#include <memory>
 
 int main(int argc, char * argv[])
 {

common/autoware_control_center/test/test_autoware_control_center.cpp

@@ -14,18 +14,18 @@
 
 #include "test_autoware_control_center.hpp"
 
-#include <chrono>
-#include <iostream>
-#include <memory>
-#include <string>
-
 #include "autoware_control_center/autoware_control_center.hpp"
-#include "autoware_control_center_msgs/srv/autoware_node_register.hpp"
+#include "gtest/gtest.h"
+#include "rclcpp/rclcpp.hpp"
+
 #include <autoware_utils/ros/uuid_helper.hpp>
 
+#include "autoware_control_center_msgs/srv/autoware_node_register.hpp"
 
-#include "gtest/gtest.h"
-#include "rclcpp/rclcpp.hpp"
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <string>
 
 using std::chrono::operator""ms;
 using std::chrono::operator""s;
@@ -40,15 +40,15 @@ class AutowareControlCenterTest : public ::testing::Test
       std::make_shared<autoware_control_center::AutowareControlCenter>(rclcpp::NodeOptions());
   }
 
-  void TearDown() override {rclcpp::shutdown();}
+  void TearDown() override { rclcpp::shutdown(); }
   autoware_control_center::AutowareControlCenter::SharedPtr autoware_control_center_;
 };
 
 TEST_F(AutowareControlCenterTest, RegisterNode)
 {
   auto client = autoware_control_center_
-    ->create_client<autoware_control_center_msgs::srv::AutowareNodeRegister>(
-    "/autoware_control_center/srv/autoware_node_register");
+                  ->create_client<autoware_control_center_msgs::srv::AutowareNodeRegister>(
+                    "/autoware_control_center/srv/autoware_node_register");
   if (!client->wait_for_service(20s)) {
     ASSERT_TRUE(false) << "Node register service not available after waiting";
   }
@@ -70,8 +70,8 @@ TEST_F(AutowareControlCenterTest, DeregisterNode)
 {
   std::string node_name = "test_node";
   auto client_reg = autoware_control_center_
-    ->create_client<autoware_control_center_msgs::srv::AutowareNodeRegister>(
-    "/autoware_control_center/srv/autoware_node_register");
+                      ->create_client<autoware_control_center_msgs::srv::AutowareNodeRegister>(
+                        "/autoware_control_center/srv/autoware_node_register");
 
   if (!client_reg->wait_for_service(20s)) {
     ASSERT_TRUE(false) << "Node register service not available after waiting";
@@ -93,8 +93,8 @@ TEST_F(AutowareControlCenterTest, DeregisterNode)
   // cspell:ignore dereg
   // Deregister node
   auto client_dereg = autoware_control_center_
-    ->create_client<autoware_control_center_msgs::srv::AutowareNodeDeregister>(
-    "/autoware_control_center/srv/autoware_node_deregister");
+                        ->create_client<autoware_control_center_msgs::srv::AutowareNodeDeregister>(
+                          "/autoware_control_center/srv/autoware_node_deregister");
   if (!client_dereg->wait_for_service(20s)) {
     ASSERT_TRUE(false) << "Node deregister service not available after waiting";
   }
@@ -115,9 +115,9 @@ TEST_F(AutowareControlCenterTest, DeregisterNode)
 TEST_F(AutowareControlCenterTest, NodeErrorServiceNotRegistered)
 {
   std::string node_name = "test_node";
-  auto client = autoware_control_center_
-    ->create_client<autoware_control_center_msgs::srv::AutowareNodeError>(
-    "/autoware_control_center/srv/autoware_node_error");
+  auto client =
+    autoware_control_center_->create_client<autoware_control_center_msgs::srv::AutowareNodeError>(
+      "/autoware_control_center/srv/autoware_node_error");
 
   if (!client->wait_for_service(20s)) {
     ASSERT_TRUE(false) << "Node error service not available after waiting";
@@ -139,17 +139,16 @@ TEST_F(AutowareControlCenterTest, NodeErrorServiceNotRegistered)
   EXPECT_EQ(0, result_error_payload->status.status) << "Node error request wrong status";
   std::string log_msg = node_name + " node was not registered.";
   EXPECT_EQ(log_msg, result_error_payload->log_response) << "Received wrong log response";
-  EXPECT_EQ(
-    autoware_utils::generate_default_uuid(),
-    result_error_payload->uuid_node) << "Received wrong uuid";
+  EXPECT_EQ(autoware_utils::generate_default_uuid(), result_error_payload->uuid_node)
+    << "Received wrong uuid";
 }
 
 TEST_F(AutowareControlCenterTest, NodeErrorService)
 {
   std::string node_name = "test_node";
   auto client_reg = autoware_control_center_
-    ->create_client<autoware_control_center_msgs::srv::AutowareNodeRegister>(
-    "/autoware_control_center/srv/autoware_node_register");
+                      ->create_client<autoware_control_center_msgs::srv::AutowareNodeRegister>(
+                        "/autoware_control_center/srv/autoware_node_register");
 
   if (!client_reg->wait_for_service(20s)) {
     ASSERT_TRUE(false) << "Node register service not available after waiting";
@@ -168,9 +167,9 @@ TEST_F(AutowareControlCenterTest, NodeErrorService)
   EXPECT_EQ(1, result_reg_payload->status.status) << "Node register request fail";
   unique_identifier_msgs::msg::UUID uuid_node = result_reg_payload->uuid_node;
 
-  auto error_client = autoware_control_center_
-    ->create_client<autoware_control_center_msgs::srv::AutowareNodeError>(
-    "/autoware_control_center/srv/autoware_node_error");
+  auto error_client =
+    autoware_control_center_->create_client<autoware_control_center_msgs::srv::AutowareNodeError>(
+      "/autoware_control_center/srv/autoware_node_error");
 
   if (!error_client->wait_for_service(20s)) {
     ASSERT_TRUE(false) << "Node error service not available after waiting";

common/autoware_control_center/test/test_node_registry.cpp

@@ -12,11 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <gtest/gtest.h>
+#include "autoware_control_center/node_registry.hpp"
 
 #include <autoware_utils/ros/uuid_helper.hpp>
 
-#include "autoware_control_center/node_registry.hpp"
+#include <gtest/gtest.h>
 
 // Test fixture for NodeRegistry
 class NodeRegistryTest : public ::testing::Test