Fix Code Style On waller-coordinator (#2468)

automated style fixes

Co-authored-by: sanatd33 <sanatd33@users.noreply.github.com>

Author: github-actions[bot]

src/rj_strategy/include/rj_strategy/coordinator/waller.hpp

@@ -1,24 +1,23 @@
 #pragma once
 
-#include <rclcpp/rclcpp.hpp>
-
-#include <array>
 #include <algorithm>
+#include <array>
+
+#include <rclcpp/rclcpp.hpp>
 
-#include <rj_msgs/srv/waller.hpp>
-#include <rj_msgs/msg/waller.hpp>
-#include <rj_msgs/msg/world_state.hpp>
-#include <rj_constants/topic_names.hpp>
 #include <rj_common/world_state.hpp>
 #include <rj_constants/constants.hpp>
+#include <rj_constants/topic_names.hpp>
 #include <rj_convert/ros_convert.hpp>
+#include <rj_msgs/msg/waller.hpp>
+#include <rj_msgs/msg/world_state.hpp>
+#include <rj_msgs/srv/waller.hpp>
 
 #include "rj_strategy/coordinator.hpp"
 
 namespace strategy {
 
-class Waller
-    : public Coordinator<Waller, rj_msgs::srv::Waller, rj_msgs::msg::Waller> {
+class Waller : public Coordinator<Waller, rj_msgs::srv::Waller, rj_msgs::msg::Waller> {
 public:
     Waller();
     ~Waller() override = default;
@@ -28,6 +27,7 @@ class Waller
     Waller& operator=(Waller&&) = delete;
 
     void service_callback(RequestPtr request, ResponsePtr response);
+
 private:
     std::array<u_int8_t, kNumShells> walling_robots_;
     u_int8_t num_wallers_ = 0;

src/rj_strategy/include/rj_strategy/coordinator/waller_client.hpp

@@ -5,9 +5,9 @@
 #include <rclcpp/rclcpp.hpp>
 #include <spdlog/spdlog.h>
 
+#include <rj_common/field_dimensions.hpp>
 #include <rj_msgs/msg/waller.hpp>
 #include <rj_msgs/srv/waller.hpp>
-#include <rj_common/field_dimensions.hpp>
 
 #include "rj_strategy/coordinator/waller.hpp"
 
@@ -51,11 +51,11 @@ class WallerClient {
     [[nodiscard]] bool am_i_member() const;
 
     /**
-     * @brief Get the target walling point 
+     * @brief Get the target walling point
      * @return target walling point of this robot.
      */
-    [[nodiscard]] std::optional<rj_geometry::Point> get_walling_point(const WorldState* world_state,
-                                        FieldDimensions field_dimensions) const;
+    [[nodiscard]] std::optional<rj_geometry::Point> get_walling_point(
+        const WorldState* world_state, FieldDimensions field_dimensions) const;
 
 private:
     rclcpp::Node::SharedPtr node_;

src/rj_strategy/src/agent/position/defense.cpp

@@ -32,8 +32,10 @@ Defense::State Defense::update_state() {
             break;
         case JOINING_WALL:
             client_handles_->waller->join_group([this](WallerClient::Result result) {
-                if (result.success) current_state_ = WALLING;
-                else current_state_ = ENTERING_MARKING;
+                if (result.success)
+                    current_state_ = WALLING;
+                else
+                    current_state_ = ENTERING_MARKING;
             });
             break;
         case WALLING:
@@ -123,12 +125,14 @@ std::optional<RobotIntent> Defense::state_to_task(RobotIntent intent) {
         intent.is_active = true;
         return intent;
     } else if (current_state_ == WALLING) {
-        auto walling_point = client_handles_->waller->get_walling_point(last_world_state_, field_dimensions_);
+        auto walling_point =
+            client_handles_->waller->get_walling_point(last_world_state_, field_dimensions_);
         if (walling_point) {
             planning::LinearMotionInstant target{walling_point.value()};
-            intent.motion_command = planning::MotionCommand{"path_target", target, planning::FaceBall{}};
-        }
-        else intent.motion_command = planning::MotionCommand{};
+            intent.motion_command =
+                planning::MotionCommand{"path_target", target, planning::FaceBall{}};
+        } else
+            intent.motion_command = planning::MotionCommand{};
         return intent;
     } else if (current_state_ == FACING) {
         rj_geometry::Point robot_position =
@@ -177,10 +181,7 @@ void Defense::derived_acknowledge_ball_in_transit() {
     chasing_ball = false;
 }
 
-
-void Defense::die() {
-    client_handles_->waller->leave_group();
-}
+void Defense::die() { client_handles_->waller->leave_group(); }
 
 void Defense::revive() { current_state_ = JOINING_WALL; }
 

src/rj_strategy/src/agent/position/robot_factory_position.cpp

@@ -6,7 +6,7 @@ RobotFactoryPosition::RobotFactoryPosition(int r_id, rclcpp::Node::SharedPtr nod
     : Position(r_id, "RobotFactoryPosition") {
     client_handles_->kicker_picker = std::make_unique<KickerPickerClient>(node, r_id);
     client_handles_->waller = std::make_unique<WallerClient>(node, r_id);
-    
+
     if (robot_id_ == 0) {
         current_position_ = std::make_unique<Goalie>(robot_id_);
     } else if (robot_id_ == 1 || robot_id_ == 2) {

src/rj_strategy/src/coordinator/waller.cpp

@@ -2,17 +2,17 @@
 
 namespace strategy {
 
-Waller::Waller()
-    : Coordinator("waller_srv", "waller_data", "waller_node") {
+Waller::Waller() : Coordinator("waller_srv", "waller_data", "waller_node") {
     walling_robots_.fill(-1);
 }
 
 void Waller::service_callback(RequestPtr request, ResponsePtr response) {
     if (request->joining) {
-        if (num_wallers_ == kMaxWallers) {       
+        if (num_wallers_ == kMaxWallers) {
             response->success = false;
         } else {
-            if (std::find(walling_robots_.begin(), walling_robots_.end(), request->robot_id) == walling_robots_.end()) {
+            if (std::find(walling_robots_.begin(), walling_robots_.end(), request->robot_id) ==
+                walling_robots_.end()) {
                 walling_robots_[num_wallers_] = request->robot_id;
                 num_wallers_++;
                 update_wallers();
@@ -33,7 +33,8 @@ void Waller::service_callback(RequestPtr request, ResponsePtr response) {
 void Waller::update_wallers() {
     auto prev_wallers = walling_robots_;
     std::sort(walling_robots_.begin(), walling_robots_.end());
-    publisher_->publish(rj_msgs::msg::Waller().set__wall_list(walling_robots_).set__wall_size(num_wallers_));
+    publisher_->publish(
+        rj_msgs::msg::Waller().set__wall_list(walling_robots_).set__wall_size(num_wallers_));
 }
 
 }  // namespace strategy

src/rj_strategy/src/coordinator/waller_client.cpp

@@ -1,8 +1,9 @@
 #include "rj_strategy/coordinator/waller_client.hpp"
 
 namespace strategy {
-    
-WallerClient::WallerClient(rclcpp::Node::SharedPtr node, uint8_t robot_id) : node_{std::move(node)}, robot_id_{robot_id} {
+
+WallerClient::WallerClient(rclcpp::Node::SharedPtr node, uint8_t robot_id)
+    : node_{std::move(node)}, robot_id_{robot_id} {
     client_ = node_->create_client<rj_msgs::srv::Waller>("waller_srv");
     walling_robots_.fill(-1);
 }
@@ -25,9 +26,11 @@ void WallerClient::join_group(StatusCallback callback) {
     request->joining = true;
 
     request_pending_ = true;
-    client_->async_send_request(request, [this, callback = std::move(callback)](
-        rclcpp::Client<rj_msgs::srv::Waller>::SharedFuture future) {    // 6 NOLINT(performance-unnecessary-value-param) --
-                                                                        //  ROS2 async callbacks require value capture.
+    client_->async_send_request(
+        request, [this, callback = std::move(callback)](
+                     rclcpp::Client<rj_msgs::srv::Waller>::SharedFuture
+                         future) {  // 6 NOLINT(performance-unnecessary-value-param) --
+                                    //  ROS2 async callbacks require value capture.
             request_pending_ = false;
             if (!future.valid() || !future.get()->success) {
                 if (callback) {
@@ -39,20 +42,18 @@ void WallerClient::join_group(StatusCallback callback) {
 
             subscription_ = node_->create_subscription<rj_msgs::msg::Waller>(
                 "waller_data", rclcpp::QoS(1).transient_local(),
-                [this, callback = std::move(callback)] 
-                    (const rj_msgs::msg::Waller::SharedPtr msg) {
-                        walling_robots_ = msg->wall_list;
-                        num_wallers_ = msg->wall_size;
-                        am_i_member_ = std::find(walling_robots_.begin(), walling_robots_.end(), robot_id_) != walling_robots_.end();
-                        
-                        if (callback) {
-                            callback(Result{am_i_member_});
-                        }
+                [this, callback = std::move(callback)](const rj_msgs::msg::Waller::SharedPtr msg) {
+                    walling_robots_ = msg->wall_list;
+                    num_wallers_ = msg->wall_size;
+                    am_i_member_ = std::find(walling_robots_.begin(), walling_robots_.end(),
+                                             robot_id_) != walling_robots_.end();
+
+                    if (callback) {
+                        callback(Result{am_i_member_});
                     }
-            );
+                });
 
-        }
-    );
+        });
 }
 
 void WallerClient::leave_group(StatusCallback callback) {
@@ -93,10 +94,10 @@ void WallerClient::leave_group(StatusCallback callback) {
 
 bool WallerClient::am_i_member() const { return am_i_member_; }
 
-std::optional<rj_geometry::Point> WallerClient::get_walling_point(const WorldState* world_state,
-                                        FieldDimensions field_dimensions) const {
+std::optional<rj_geometry::Point> WallerClient::get_walling_point(
+    const WorldState* world_state, FieldDimensions field_dimensions) const {
     if (!am_i_member_) return std::nullopt;
-    
+
     // Creates Minimum wall radius is slightly greater than  box bounds
     // Dimension accessors should be edited when we figure out how we are doing dimensions realtime
     // from vision
@@ -122,7 +123,7 @@ std::optional<rj_geometry::Point> WallerClient::get_walling_point(const WorldSta
     auto wall_spacing = kRobotDiameterMultiplier * kRobotDiameter + kBallRadius;
 
     auto it = std::find(walling_robots_.begin(), walling_robots_.end(), robot_id_);
-    auto waller_pos = std::distance(walling_robots_.begin(), it)+1;
+    auto waller_pos = std::distance(walling_robots_.begin(), it) + 1;
 
     rj_geometry::Point target_point{};
     auto angle = (mid_point - goal_pos).angle();
@@ -164,5 +165,4 @@ std::optional<rj_geometry::Point> WallerClient::get_walling_point(const WorldSta
     return target_point;
 }
 
-
-} // namespace strategy
+}  // namespace strategy