[pull] main from autowarefoundation:main

.clang-format

@@ -4,6 +4,7 @@ BasedOnStyle: Google
 
 AccessModifierOffset: -2
 AlignAfterOpenBracket: AlwaysBreak
+AllowShortFunctionsOnASingleLine: InlineOnly
 BraceWrapping:
   AfterClass: true
   AfterFunction: true

.github/PULL_REQUEST_TEMPLATE/small-change.md

@@ -2,6 +2,13 @@
 
 <!-- Write a brief description of this PR. -->
 
+## Tests performed
+
+<!-- Describe how you have tested this PR. -->
+<!-- Although the default value is set to "Not Applicable.", please update this section if the type is either [feat, fix, perf], or if requested by the reviewers. -->
+
+Not applicable.
+
 ## Pre-review checklist for the PR author
 
 The PR author **must** check the checkboxes below when creating the PR.

.pre-commit-config.yaml

@@ -60,7 +60,7 @@ repos:
       - id: isort
 
   - repo: https://github.com/psf/black
-    rev: 23.1.0
+    rev: 23.3.0
     hooks:
       - id: black
         args: [--line-length=100]

common/autoware_auto_geometry/src/spatial_hash.cpp

@@ -59,7 +59,10 @@ details::Index3 Config2d::index3_(const float32_t x, const float32_t y, const fl
   return {x_index(x), y_index(y), Index{}};  // zero initialization
 }
 ////////////////////////////////////////////////////////////////////////////////
-Index Config2d::index_(const details::Index3 & idx) const { return bin_impl(idx.x, idx.y); }
+Index Config2d::index_(const details::Index3 & idx) const
+{
+  return bin_impl(idx.x, idx.y);
+}
 ////////////////////////////////////////////////////////////////////////////////
 Config3d::Config3d(
   const float32_t min_x, const float32_t max_x, const float32_t min_y, const float32_t max_y,
@@ -88,7 +91,10 @@ details::Index3 Config3d::index3_(const float32_t x, const float32_t y, const fl
   return {x_index(x), y_index(y), z_index(z)};  // zero initialization
 }
 ////////////////////////////////////////////////////////////////////////////////
-Index Config3d::index_(const details::Index3 & idx) const { return bin_impl(idx.x, idx.y, idx.z); }
+Index Config3d::index_(const details::Index3 & idx) const
+{
+  return bin_impl(idx.x, idx.y, idx.z);
+}
 ////////////////////////////////////////////////////////////////////////////////
 template class SpatialHash<geometry_msgs::msg::Point32, Config2d>;
 template class SpatialHash<geometry_msgs::msg::Point32, Config3d>;

common/autoware_auto_geometry/test/src/test_area.cpp

@@ -53,7 +53,10 @@ using TestTypes = TestTypes_<geometry_msgs::msg::Point32>;
 TYPED_TEST_SUITE(AreaTest, TestTypes, );
 
 // The empty set has zero area
-TYPED_TEST(AreaTest, DegenerateZero) { EXPECT_FLOAT_EQ(0.0, this->area()); }
+TYPED_TEST(AreaTest, DegenerateZero)
+{
+  EXPECT_FLOAT_EQ(0.0, this->area());
+}
 
 // An individual point has zero area
 TYPED_TEST(AreaTest, DegenerateOne)

common/autoware_auto_perception_rviz_plugin/src/object_detection/detected_objects_display.cpp

@@ -24,7 +24,9 @@ namespace rviz_plugins
 {
 namespace object_detection
 {
-DetectedObjectsDisplay::DetectedObjectsDisplay() : ObjectPolygonDisplayBase("detected_objects") {}
+DetectedObjectsDisplay::DetectedObjectsDisplay() : ObjectPolygonDisplayBase("detected_objects")
+{
+}
 
 void DetectedObjectsDisplay::processMessage(DetectedObjects::ConstSharedPtr msg)
 {

common/autoware_auto_perception_rviz_plugin/src/object_detection/tracked_objects_display.cpp

@@ -24,7 +24,9 @@ namespace rviz_plugins
 {
 namespace object_detection
 {
-TrackedObjectsDisplay::TrackedObjectsDisplay() : ObjectPolygonDisplayBase("tracks") {}
+TrackedObjectsDisplay::TrackedObjectsDisplay() : ObjectPolygonDisplayBase("tracks")
+{
+}
 
 void TrackedObjectsDisplay::processMessage(TrackedObjects::ConstSharedPtr msg)
 {

common/fake_test_node/src/fake_test_node.cpp

@@ -53,7 +53,10 @@ void detail::FakeNodeCore::set_up(const std::string & test_name)
     std::make_shared<tf2_ros::TransformListener>(m_tf_buffer, m_fake_node, kSpinThread);
 }
 
-void detail::FakeNodeCore::tear_down() { (void)rclcpp::shutdown(); }
+void detail::FakeNodeCore::tear_down()
+{
+  (void)rclcpp::shutdown();
+}
 
 std::string detail::get_test_name(const ::testing::TestInfo * info)
 {
@@ -68,7 +71,10 @@ void FakeTestNode::SetUp()
   set_up(detail::get_test_name(::testing::UnitTest::GetInstance()->current_test_info()));
 }
 
-void FakeTestNode::TearDown() { tear_down(); }
+void FakeTestNode::TearDown()
+{
+  tear_down();
+}
 
 }  // namespace testing
 }  // namespace tools

common/fake_test_node/test/test_fake_test_node.cpp

@@ -91,12 +91,18 @@ void run_test(int32_t value_in_message, FixtureT * fixture)
 }  // namespace
 
 /// @test Test that we can use a non-parametrized test.
-TEST_F(FakeNodeFixture, Test) { run_test(15, this); }
+TEST_F(FakeNodeFixture, Test)
+{
+  run_test(15, this);
+}
 
 INSTANTIATE_TEST_SUITE_P(
   FakeNodeFixtureTests, FakeNodeFixtureParametrized,
   // cppcheck-suppress syntaxError  // cppcheck doesn't like the trailing comma.
   ::testing::Values(-5, 0, 42));
 
 /// @test Test that we can use a parametrized test.
-TEST_P(FakeNodeFixtureParametrized, Test) { run_test(GetParam(), this); }
+TEST_P(FakeNodeFixtureParametrized, Test)
+{
+  run_test(GetParam(), this);
+}

common/grid_map_utils/src/polygon_iterator.cpp

@@ -153,7 +153,10 @@ bool PolygonIterator::operator!=(const PolygonIterator & other) const
   return current_line_ != other.current_line_ || current_col_ != other.current_col_;
 }
 
-const grid_map::Index & PolygonIterator::operator*() const { return current_index_; }
+const grid_map::Index & PolygonIterator::operator*() const
+{
+  return current_index_;
+}
 
 void PolygonIterator::goToNextLine()
 {

common/kalman_filter/src/kalman_filter.cpp

@@ -14,15 +14,19 @@
 
 #include "kalman_filter/kalman_filter.hpp"
 
-KalmanFilter::KalmanFilter() {}
+KalmanFilter::KalmanFilter()
+{
+}
 KalmanFilter::KalmanFilter(
   const Eigen::MatrixXd & x, const Eigen::MatrixXd & A, const Eigen::MatrixXd & B,
   const Eigen::MatrixXd & C, const Eigen::MatrixXd & Q, const Eigen::MatrixXd & R,
   const Eigen::MatrixXd & P)
 {
   init(x, A, B, C, Q, R, P);
 }
-KalmanFilter::~KalmanFilter() {}
+KalmanFilter::~KalmanFilter()
+{
+}
 bool KalmanFilter::init(
   const Eigen::MatrixXd & x, const Eigen::MatrixXd & A, const Eigen::MatrixXd & B,
   const Eigen::MatrixXd & C, const Eigen::MatrixXd & Q, const Eigen::MatrixXd & R,
@@ -53,14 +57,38 @@ bool KalmanFilter::init(const Eigen::MatrixXd & x, const Eigen::MatrixXd & P0)
   return true;
 }
 
-void KalmanFilter::setA(const Eigen::MatrixXd & A) { A_ = A; }
-void KalmanFilter::setB(const Eigen::MatrixXd & B) { B_ = B; }
-void KalmanFilter::setC(const Eigen::MatrixXd & C) { C_ = C; }
-void KalmanFilter::setQ(const Eigen::MatrixXd & Q) { Q_ = Q; }
-void KalmanFilter::setR(const Eigen::MatrixXd & R) { R_ = R; }
-void KalmanFilter::getX(Eigen::MatrixXd & x) { x = x_; }
-void KalmanFilter::getP(Eigen::MatrixXd & P) { P = P_; }
-double KalmanFilter::getXelement(unsigned int i) { return x_(i); }
+void KalmanFilter::setA(const Eigen::MatrixXd & A)
+{
+  A_ = A;
+}
+void KalmanFilter::setB(const Eigen::MatrixXd & B)
+{
+  B_ = B;
+}
+void KalmanFilter::setC(const Eigen::MatrixXd & C)
+{
+  C_ = C;
+}
+void KalmanFilter::setQ(const Eigen::MatrixXd & Q)
+{
+  Q_ = Q;
+}
+void KalmanFilter::setR(const Eigen::MatrixXd & R)
+{
+  R_ = R;
+}
+void KalmanFilter::getX(Eigen::MatrixXd & x)
+{
+  x = x_;
+}
+void KalmanFilter::getP(Eigen::MatrixXd & P)
+{
+  P = P_;
+}
+double KalmanFilter::getXelement(unsigned int i)
+{
+  return x_(i);
+}
 
 bool KalmanFilter::predict(
   const Eigen::MatrixXd & x_next, const Eigen::MatrixXd & A, const Eigen::MatrixXd & Q)
@@ -89,7 +117,10 @@ bool KalmanFilter::predict(
   const Eigen::MatrixXd x_next = A * x_ + B * u;
   return predict(x_next, A, Q);
 }
-bool KalmanFilter::predict(const Eigen::MatrixXd & u) { return predict(u, A_, B_, Q_); }
+bool KalmanFilter::predict(const Eigen::MatrixXd & u)
+{
+  return predict(u, A_, B_, Q_);
+}
 
 bool KalmanFilter::update(
   const Eigen::MatrixXd & y, const Eigen::MatrixXd & y_pred, const Eigen::MatrixXd & C,
@@ -121,4 +152,7 @@ bool KalmanFilter::update(
   const Eigen::MatrixXd y_pred = C * x_;
   return update(y, y_pred, C, R);
 }
-bool KalmanFilter::update(const Eigen::MatrixXd & y) { return update(y, C_, R_); }
+bool KalmanFilter::update(const Eigen::MatrixXd & y)
+{
+  return update(y, C_, R_);
+}

common/kalman_filter/src/time_delay_kalman_filter.cpp

@@ -14,7 +14,9 @@
 
 #include "kalman_filter/time_delay_kalman_filter.hpp"
 
-TimeDelayKalmanFilter::TimeDelayKalmanFilter() {}
+TimeDelayKalmanFilter::TimeDelayKalmanFilter()
+{
+}
 
 void TimeDelayKalmanFilter::init(
   const Eigen::MatrixXd & x, const Eigen::MatrixXd & P0, const int max_delay_step)
@@ -32,9 +34,15 @@ void TimeDelayKalmanFilter::init(
   }
 }
 
-Eigen::MatrixXd TimeDelayKalmanFilter::getLatestX() const { return x_.block(0, 0, dim_x_, 1); }
+Eigen::MatrixXd TimeDelayKalmanFilter::getLatestX() const
+{
+  return x_.block(0, 0, dim_x_, 1);
+}
 
-Eigen::MatrixXd TimeDelayKalmanFilter::getLatestP() const { return P_.block(0, 0, dim_x_, dim_x_); }
+Eigen::MatrixXd TimeDelayKalmanFilter::getLatestP() const
+{
+  return P_.block(0, 0, dim_x_, dim_x_);
+}
 
 bool TimeDelayKalmanFilter::predictWithDelay(
   const Eigen::MatrixXd & x_next, const Eigen::MatrixXd & A, const Eigen::MatrixXd & Q)

common/motion_utils/src/vehicle/vehicle_state_checker.cpp

@@ -128,5 +128,8 @@ bool VehicleArrivalChecker::isVehicleStoppedAtStopPoint(const double stop_durati
          th_arrived_distance_m;
 }
 
-void VehicleArrivalChecker::onTrajectory(const Trajectory::SharedPtr msg) { trajectory_ptr_ = msg; }
+void VehicleArrivalChecker::onTrajectory(const Trajectory::SharedPtr msg)
+{
+  trajectory_ptr_ = msg;
+}
 }  // namespace motion_utils

common/osqp_interface/src/osqp_interface.cpp

@@ -208,7 +208,10 @@ void OSQPInterface::updateAlpha(const double alpha)
   }
 }
 
-void OSQPInterface::updateScaling(const int scaling) { m_settings->scaling = scaling; }
+void OSQPInterface::updateScaling(const int scaling)
+{
+  m_settings->scaling = scaling;
+}
 
 void OSQPInterface::updatePolish(const bool polish)
 {

common/rtc_manager_rviz_plugin/src/rtc_manager_panel.cpp

@@ -25,8 +25,14 @@
 
 namespace rviz_plugins
 {
-inline std::string Bool2String(const bool var) { return var ? "True" : "False"; }
-inline bool uint2bool(uint8_t var) { return var == static_cast<uint8_t>(0) ? false : true; }
+inline std::string Bool2String(const bool var)
+{
+  return var ? "True" : "False";
+}
+inline bool uint2bool(uint8_t var)
+{
+  return var == static_cast<uint8_t>(0) ? false : true;
+}
 using std::placeholders::_1;
 using std::placeholders::_2;
 
@@ -326,12 +332,30 @@ void RTCManagerPanel::onClickCommandRequest(const uint8_t command)
   client_rtc_commands_->async_send_request(executable_cooperate_commands_request);
 }
 
-void RTCManagerPanel::onClickExecuteVelChange() { onClickChangeRequest(false, Command::ACTIVATE); }
-void RTCManagerPanel::onClickWaitVelChange() { onClickChangeRequest(false, Command::DEACTIVATE); }
-void RTCManagerPanel::onClickExecutePathChange() { onClickChangeRequest(true, Command::ACTIVATE); }
-void RTCManagerPanel::onClickWaitPathChange() { onClickChangeRequest(true, Command::DEACTIVATE); }
-void RTCManagerPanel::onClickExecution() { onClickCommandRequest(Command::ACTIVATE); }
-void RTCManagerPanel::onClickWait() { onClickCommandRequest(Command::DEACTIVATE); }
+void RTCManagerPanel::onClickExecuteVelChange()
+{
+  onClickChangeRequest(false, Command::ACTIVATE);
+}
+void RTCManagerPanel::onClickWaitVelChange()
+{
+  onClickChangeRequest(false, Command::DEACTIVATE);
+}
+void RTCManagerPanel::onClickExecutePathChange()
+{
+  onClickChangeRequest(true, Command::ACTIVATE);
+}
+void RTCManagerPanel::onClickWaitPathChange()
+{
+  onClickChangeRequest(true, Command::DEACTIVATE);
+}
+void RTCManagerPanel::onClickExecution()
+{
+  onClickCommandRequest(Command::ACTIVATE);
+}
+void RTCManagerPanel::onClickWait()
+{
+  onClickCommandRequest(Command::DEACTIVATE);
+}
 
 void RTCManagerPanel::onRTCStatus(const CooperateStatusArray::ConstSharedPtr msg)
 {

common/signal_processing/src/butterworth.cpp

@@ -52,9 +52,15 @@ void ButterworthFilter::Buttord(
   setCutOffFrequency(right_lim);
 }
 
-void ButterworthFilter::setOrder(const int & N) { filter_specs_.N = N; }
+void ButterworthFilter::setOrder(const int & N)
+{
+  filter_specs_.N = N;
+}
 
-void ButterworthFilter::setCutOffFrequency(const double & Wc) { filter_specs_.Wc_rad_sec = Wc; }
+void ButterworthFilter::setCutOffFrequency(const double & Wc)
+{
+  filter_specs_.Wc_rad_sec = Wc;
+}
 
 /**
  * @brief Sets the cut-off and sampling frequencies.
@@ -76,7 +82,10 @@ void ButterworthFilter::setCutOffFrequency(const double & fc, const double & fs)
   filter_specs_.fs = fs;
 }
 
-sOrderCutOff ButterworthFilter::getOrderCutOff() const { return filter_specs_; }
+sOrderCutOff ButterworthFilter::getOrderCutOff() const
+{
+  return filter_specs_;
+}
 
 /**
  * @brief Matlab equivalent : [b, a]  = butter(n, Wn, 's')
@@ -306,9 +315,18 @@ void ButterworthFilter::printDiscreteTimeTF() const
 
   RCLCPP_INFO(rclcpp::get_logger("rclcpp"), "[%s]", stream.str().c_str());
 }
-std::vector<double> ButterworthFilter::getAn() const { return AnBn_.An; }
-std::vector<double> ButterworthFilter::getBn() const { return AnBn_.Bn; }
-sDifferenceAnBn ButterworthFilter::getAnBn() const { return AnBn_; }
+std::vector<double> ButterworthFilter::getAn() const
+{
+  return AnBn_.An;
+}
+std::vector<double> ButterworthFilter::getBn() const
+{
+  return AnBn_.Bn;
+}
+sDifferenceAnBn ButterworthFilter::getAnBn() const
+{
+  return AnBn_;
+}
 
 void ButterworthFilter::printFilterSpecs() const
 {