fix: clang-tidy draft

Signed-off-by: Berkay Karaman <brkay54@gmail.com>

Author: brkay54

tools/reaction_analyzer/include/reaction_analyzer_node.hpp

@@ -66,8 +66,7 @@ struct NodeParams
 class ReactionAnalyzerNode : public rclcpp::Node
 {
 public:
-  explicit ReactionAnalyzerNode(rclcpp::NodeOptions options);
-  ~ReactionAnalyzerNode() = default;
+  explicit ReactionAnalyzerNode(rclcpp::NodeOptions node_options);
 
   Odometry::ConstSharedPtr odometry_ptr_;
 

tools/reaction_analyzer/include/subscriber.hpp

@@ -141,13 +141,7 @@ class SubscriberBase
     rclcpp::Node * node, Odometry::ConstSharedPtr & odometry, std::atomic<bool> & spawn_object_cmd,
     const EntityParams & entity_params);
 
-  // Instances of SubscriberBase cannot be copied
-  SubscriberBase(const SubscriberBase &) = delete;
-  SubscriberBase & operator=(const SubscriberBase &) = delete;
-
-  ~SubscriberBase() = default;
-
-  std::optional<std::unordered_map<std::string, MessageBufferVariant>> getMessageBuffersMap();
+  std::optional<std::unordered_map<std::string, MessageBufferVariant>> get_message_buffers_map();
   void reset();
 
 private:
@@ -179,7 +173,7 @@ class SubscriberBase
   std::optional<size_t> find_first_brake_idx(
     const std::vector<AckermannControlCommand> & cmd_array);
   void set_control_command_to_buffer(
-    std::vector<AckermannControlCommand> & buffer, const AckermannControlCommand & cmd);
+    std::vector<AckermannControlCommand> & buffer, const AckermannControlCommand & cmd) const;
 
   // Callbacks for modules are subscribed
   void on_control_command(

tools/reaction_analyzer/include/topic_publisher.hpp

@@ -110,23 +110,23 @@ struct PublisherVarAccessor
 {
   // Template struct to check if a type has a header member.
   template <typename T, typename = std::void_t<>>
-  struct has_header : std::false_type
+  struct HasHeader : std::false_type
   {
   };
 
   template <typename T>
-  struct has_header<T, std::void_t<decltype(T::header)>> : std::true_type
+  struct HasHeader<T, std::void_t<decltype(T::header)>> : std::true_type
   {
   };
 
   // Template struct to check if a type has a stamp member.
   template <typename T, typename = std::void_t<>>
-  struct has_stamp : std::false_type
+  struct HasStamp : std::false_type
   {
   };
 
   template <typename T>
-  struct has_stamp<T, std::void_t<decltype(T::stamp)>> : std::true_type
+  struct HasStamp<T, std::void_t<decltype(T::stamp)>> : std::true_type
   {
   };
 
@@ -142,9 +142,9 @@ struct PublisherVarAccessor
     } else {
       *msg_to_be_published = *publisherVar.empty_area_message;
     }
-    if constexpr (has_header<MessageType>::value) {
+    if constexpr (HasHeader<MessageType>::value) {
       msg_to_be_published->header.stamp = current_time;
-    } else if constexpr (has_stamp<MessageType>::value) {
+    } else if constexpr (HasStamp<MessageType>::value) {
       msg_to_be_published->stamp = current_time;
     }
     publisherVar.publisher->publish(std::move(msg_to_be_published));
@@ -200,7 +200,6 @@ class TopicPublisher
     std::optional<rclcpp::Time> & spawn_cmd_time, const RunningMode & node_running_mode,
     const EntityParams & entity_params);
 
-  ~TopicPublisher() = default;
   void reset();
 
 private:

tools/reaction_analyzer/src/reaction_analyzer_node.cpp

@@ -51,8 +51,8 @@ void ReactionAnalyzerNode::on_ground_truth_pose(PoseStamped::ConstSharedPtr msg_
   ground_truth_pose_ptr_ = std::move(msg_ptr);
 }
 
-ReactionAnalyzerNode::ReactionAnalyzerNode(rclcpp::NodeOptions options)
-: Node("reaction_analyzer_node", options.automatically_declare_parameters_from_overrides(true))
+ReactionAnalyzerNode::ReactionAnalyzerNode(rclcpp::NodeOptions node_options)
+: Node("reaction_analyzer_node", node_options.automatically_declare_parameters_from_overrides(true))
 {
   using std::placeholders::_1;
 
@@ -173,7 +173,7 @@ void ReactionAnalyzerNode::on_timer()
   if (!spawn_cmd_time) return;
 
   // Get the reacted messages, if all modules reacted
-  const auto message_buffers = subscriber_ptr_->getMessageBuffersMap();
+  const auto message_buffers = subscriber_ptr_->get_message_buffers_map();
 
   if (message_buffers) {
     // if reacted, calculate the results

tools/reaction_analyzer/src/subscriber.cpp

@@ -40,7 +40,7 @@ SubscriberBase::SubscriberBase(
 
 void SubscriberBase::init_reaction_chains_and_params()
 {
-  auto stringToMessageType = [](const std::string & input) {
+  auto string_to_message_type = [](const std::string & input) {
     if (input == "autoware_auto_control_msgs/msg/AckermannControlCommand") {
       return SubscriberMessageType::ACKERMANN_CONTROL_COMMAND;
     } else if (input == "autoware_auto_planning_msgs/msg/Trajectory") {
@@ -58,7 +58,7 @@ void SubscriberBase::init_reaction_chains_and_params()
     }
   };
 
-  auto stringToReactionType = [](const std::string & input) {
+  auto string_to_reaction_type = [](const std::string & input) {
     if (input == "first_brake_params") {
       return ReactionType::FIRST_BRAKE;
     } else if (input == "search_zero_vel_params") {
@@ -82,7 +82,7 @@ void SubscriberBase::init_reaction_chains_and_params()
       tmp.time_debug_topic_address =
         node_->get_parameter_or(module_name + ".time_debug_topic_name", std::string(""));
       tmp.message_type =
-        stringToMessageType(node_->get_parameter(module_name + ".message_type").as_string());
+        string_to_message_type(node_->get_parameter(module_name + ".message_type").as_string());
       if (tmp.message_type != SubscriberMessageType::UNKNOWN) {
         chain_modules_.emplace_back(tmp);
       } else {
@@ -99,7 +99,7 @@ void SubscriberBase::init_reaction_chains_and_params()
     const auto module_names = node_->list_parameters({param_key}, 3).prefixes;
     for (const auto & module_name : module_names) {
       const auto splitted_name = split(module_name, '.');
-      const auto type = stringToReactionType(splitted_name.back());
+      const auto type = string_to_reaction_type(splitted_name.back());
       switch (type) {
         case ReactionType::FIRST_BRAKE: {
           reaction_params_.first_brake_params.debug_control_commands =
@@ -460,7 +460,7 @@ bool SubscriberBase::init_subscribers()
 }
 
 std::optional<std::unordered_map<std::string, MessageBufferVariant>>
-SubscriberBase::getMessageBuffersMap()
+SubscriberBase::get_message_buffers_map()
 {
   std::lock_guard<std::mutex> lock(mutex_);
   if (message_buffers_.empty()) {
@@ -997,7 +997,7 @@ std::optional<size_t> SubscriberBase::find_first_brake_idx(
 }
 
 void SubscriberBase::set_control_command_to_buffer(
-  std::vector<AckermannControlCommand> & buffer, const AckermannControlCommand & cmd)
+  std::vector<AckermannControlCommand> & buffer, const AckermannControlCommand & cmd) const
 {
   const auto last_cmd_time = cmd.stamp;
   if (!buffer.empty()) {

tools/reaction_analyzer/src/topic_publisher.cpp

@@ -304,9 +304,8 @@ void TopicPublisher::init_rosbag_publishers()
       if (it != topics.end()) {
         return string_to_publisher_message_type(
           it->topic_metadata.type);  // Return the message type if found
-      } else {
-        return PublisherMessageType::UNKNOWN;  //
       }
+      return PublisherMessageType::UNKNOWN;
     };
 
     // Collect timestamps for each topic to set the frequency of the publishers
@@ -349,25 +348,24 @@ void TopicPublisher::init_rosbag_publishers()
 
     const auto & topics = reader.get_metadata().topics_with_message_count;
 
-    auto getMessageTypeForTopic = [&topics, &string_to_publisher_message_type](
-                                    const std::string & topicName) -> PublisherMessageType {
+    auto get_message_type_for_topic = [&topics, &string_to_publisher_message_type](
+                                        const std::string & topicName) -> PublisherMessageType {
       auto it = std::find_if(topics.begin(), topics.end(), [&topicName](const auto & topic) {
         return topic.topic_metadata.name == topicName;
       });
 
       if (it != topics.end()) {
         return string_to_publisher_message_type(
           it->topic_metadata.type);  // Return the message type if found
-      } else {
-        return PublisherMessageType::UNKNOWN;
       }
+      return PublisherMessageType::UNKNOWN;
     };
 
     while (reader.has_next()) {
       auto bag_message = reader.read_next();
       const auto current_topic = bag_message->topic_name;
 
-      const auto message_type = getMessageTypeForTopic(current_topic);
+      const auto message_type = get_message_type_for_topic(current_topic);
 
       if (message_type == PublisherMessageType::UNKNOWN) {
         continue;
@@ -869,10 +867,10 @@ void TopicPublisher::set_period_to_variable_map(
       auto period_ms = std::chrono::duration_cast<std::chrono::milliseconds>(total_duration_ns) /
                        (timestamps_tmp.size() - 1);
 
-      PublisherVariablesVariant & publisherVar = topic_publisher_map_[topic_name];
+      PublisherVariablesVariant & publisher_variant = topic_publisher_map_[topic_name];
       PublisherVarAccessor accessor;
 
-      std::visit([&](auto & var) { accessor.set_period(var, period_ms); }, publisherVar);
+      std::visit([&](auto & var) { accessor.set_period(var, period_ms); }, publisher_variant);
     }
   }
 }
@@ -973,24 +971,21 @@ bool TopicPublisher::set_publishers_and_timers_to_variable_map()
     // Create a timer to create phase difference bw timers which will be created for each lidar
     // topics
     auto one_shot_timer = node_->create_wall_timer(phase_dif, [this, period_pointcloud_ns]() {
-      for (const auto & [lidar_name, publisher_var_pair] : lidar_pub_variable_pair_map_) {
+      for (const auto & publisher_var_pair : lidar_pub_variable_pair_map_) {
+        const auto & lidar_name = publisher_var_pair.first;
+        const auto & publisher_var = publisher_var_pair.second;
         if (
           pointcloud_publish_timers_map_.find(lidar_name) == pointcloud_publish_timers_map_.end()) {
-          // Create the periodic timer
-          auto periodic_timer =
-            node_->create_wall_timer(period_pointcloud_ns, [this, publisher_var_pair]() {
-              this->pointcloud_messages_async_publisher(publisher_var_pair);
-            });
-          // Store the periodic timer to keep it alive
+          auto periodic_timer = node_->create_wall_timer(
+            period_pointcloud_ns,
+            [this, publisher_var]() { this->pointcloud_messages_async_publisher(publisher_var); });
           pointcloud_publish_timers_map_[lidar_name] = periodic_timer;
           return;
         }
       }
-      // close the timer
       one_shot_timer_shared_ptr_->cancel();
     });
-
-    one_shot_timer_shared_ptr_ = one_shot_timer;  // Store a weak pointer to the timer
+    one_shot_timer_shared_ptr_ = one_shot_timer;
   }
   return true;
 }
@@ -1010,7 +1005,8 @@ bool TopicPublisher::check_publishers_initialized_correctly()
         node_->get_logger(),
         "Empty area message couldn't found in the topic named: " << topic_name);
       return false;
-    } else if (!object_spawned_message) {
+    }
+    if (!object_spawned_message) {
       RCLCPP_ERROR_STREAM(
         node_->get_logger(),
         "Object spawned message couldn't found in the topic named: " << topic_name);

tools/reaction_analyzer/src/utils.cpp

@@ -66,27 +66,27 @@ double calculate_time_diff_ms(const rclcpp::Time & start, const rclcpp::Time & e
 TimestampedReactionPairsVector convert_pipeline_map_to_sorted_vector(
   const PipelineMap & pipelineMap)
 {
-  std::vector<std::tuple<rclcpp::Time, std::vector<ReactionPair>>> sortedVector;
+  std::vector<std::tuple<rclcpp::Time, std::vector<ReactionPair>>> sorted_vector;
 
   for (const auto & entry : pipelineMap) {
-    auto sortedReactions = entry.second;
+    auto sorted_reactions = entry.second;
     // Sort the vector of ReactionPair based on the published stamp
     std::sort(
-      sortedReactions.begin(), sortedReactions.end(),
+      sorted_reactions.begin(), sorted_reactions.end(),
       [](const ReactionPair & a, const ReactionPair & b) {
         return rclcpp::Time(a.second.published_stamp) < rclcpp::Time(b.second.published_stamp);
       });
 
     // Add to the vector as a tuple
-    sortedVector.push_back(std::make_tuple(entry.first, sortedReactions));
+    sorted_vector.emplace_back(std::make_tuple(entry.first, sorted_reactions));
   }
 
   // Sort the vector of tuples by rclcpp::Time
-  std::sort(sortedVector.begin(), sortedVector.end(), [](const auto & a, const auto & b) {
+  std::sort(sorted_vector.begin(), sorted_vector.end(), [](const auto & a, const auto & b) {
     return std::get<0>(a) < std::get<0>(b);
   });
 
-  return sortedVector;
+  return sorted_vector;
 }
 
 unique_identifier_msgs::msg::UUID generate_uuid_msg(const std::string & input)
@@ -212,70 +212,51 @@ bool search_pointcloud_near_pose(
   const pcl::PointCloud<pcl::PointXYZ> & pcl_pointcloud, const geometry_msgs::msg::Pose & pose,
   const double search_radius)
 {
-  bool isAnyPointWithinRadius = std::any_of(
+  return std::any_of(
     pcl_pointcloud.points.begin(), pcl_pointcloud.points.end(),
     [pose, search_radius](const auto & point) {
       return tier4_autoware_utils::calcDistance3d(pose.position, point) <= search_radius;
     });
-
-  if (isAnyPointWithinRadius) {
-    return true;
-  }
-  return false;
 }
 
 bool search_predicted_objects_near_pose(
   const PredictedObjects & predicted_objects, const geometry_msgs::msg::Pose & pose,
   const double search_radius)
 {
-  bool isAnyObjectWithinRadius = std::any_of(
+  return std::any_of(
     predicted_objects.objects.begin(), predicted_objects.objects.end(),
     [pose, search_radius](const PredictedObject & object) {
       return tier4_autoware_utils::calcDistance3d(
                pose.position, object.kinematics.initial_pose_with_covariance.pose.position) <=
              search_radius;
     });
-
-  if (isAnyObjectWithinRadius) {
-    return true;
-  }
-  return false;
+  ;
 }
 
 bool search_detected_objects_near_pose(
   const DetectedObjects & detected_objects, const geometry_msgs::msg::Pose & pose,
   const double search_radius)
 {
-  bool isAnyObjectWithinRadius = std::any_of(
+  return std::any_of(
     detected_objects.objects.begin(), detected_objects.objects.end(),
     [pose, search_radius](const DetectedObject & object) {
       return tier4_autoware_utils::calcDistance3d(
                pose.position, object.kinematics.pose_with_covariance.pose.position) <=
              search_radius;
     });
-
-  if (isAnyObjectWithinRadius) {
-    return true;
-  }
-  return false;
 }
 
 bool search_tracked_objects_near_pose(
   const TrackedObjects & tracked_objects, const geometry_msgs::msg::Pose & pose,
   const double search_radius)
 {
-  bool isAnyObjectWithinRadius = std::any_of(
+  return std::any_of(
     tracked_objects.objects.begin(), tracked_objects.objects.end(),
     [pose, search_radius](const TrackedObject & object) {
       return tier4_autoware_utils::calcDistance3d(
                pose.position, object.kinematics.pose_with_covariance.pose.position) <=
              search_radius;
     });
-
-  if (isAnyObjectWithinRadius) {
-    return true;
-  }
-  return false;
 }
 
 LatencyStats calculate_statistics(const std::vector<double> & latency_vec)