bazel: Reformat for clang-format-22

Author: StephanDollberg

src/transform-sdk/cpp/examples/schema_registry.cc

@@ -41,11 +41,12 @@ constexpr std::string_view schema_def = R"({
 
 int main() {
     sr_client = sr::new_client();
-    if (auto res = sr_client->create_schema(
-          "avro-value",
-          sr::schema::new_avro(
-            std::string{schema_def.data(), schema_def.size()}));
-        !res.has_value()) {
+    if (
+      auto res = sr_client->create_schema(
+        "avro-value",
+        sr::schema::new_avro(
+          std::string{schema_def.data(), schema_def.size()}));
+      !res.has_value()) {
         return 0;
     }
     redpanda::on_record_written(do_transform);
@@ -67,8 +68,9 @@ do_transform(redpanda::write_event event, redpanda::record_writer* writer) {
         return id_e.error();
     }
     std::optional<sr::schema> raw_schema;
-    if (auto rs_e = sr_client->lookup_schema_by_id(id.value());
-        rs_e.has_value()) {
+    if (
+      auto rs_e = sr_client->lookup_schema_by_id(id.value());
+      rs_e.has_value()) {
         raw_schema.emplace(std::move(rs_e).value());
     } else {
         return rs_e.error();
@@ -77,17 +79,19 @@ do_transform(redpanda::write_event event, redpanda::record_writer* writer) {
     // auto schema = avro::schema::parse_str(raw_schema.value().schema());
 
     std::optional<sr::subject_schema> latest_schema;
-    if (auto latest_e = sr_client->lookup_latest_schema("avro-value");
-        latest_e.has_value()) {
+    if (
+      auto latest_e = sr_client->lookup_latest_schema("avro-value");
+      latest_e.has_value()) {
         latest_schema.emplace(std::move(latest_e).value());
     } else {
         return latest_e.error();
     }
 
     std::optional<sr::subject_schema> latest_direct;
-    if (auto latest_e = sr_client->lookup_schema_by_version(
-          "avro-value", latest_schema->version);
-        latest_e.has_value()) {
+    if (
+      auto latest_e = sr_client->lookup_schema_by_version(
+        "avro-value", latest_schema->version);
+      latest_e.has_value()) {
         latest_direct.emplace(std::move(latest_e).value());
     } else {
         return latest_e.error();

src/transform-sdk/cpp/include/redpanda/transform_sdk.h

@@ -39,8 +39,8 @@ struct simple_named_type {
 
 private:
     friend bool operator==(
-      const simple_named_type<type, Tag>&, const simple_named_type<type, Tag>&)
-      = default;
+      const simple_named_type<type, Tag>&,
+      const simple_named_type<type, Tag>&) = default;
     type _val;
 };
 
@@ -319,8 +319,8 @@ struct subject_schema {
     schema_version version;
     schema_id id;
 
-    friend bool operator==(const subject_schema&, const subject_schema&)
-      = default;
+    friend bool
+    operator==(const subject_schema&, const subject_schema&) = default;
 };
 
 /**
@@ -332,8 +332,8 @@ class schema_registry_client {
     schema_registry_client(const schema_registry_client&) = delete;
     schema_registry_client& operator=(const schema_registry_client&) = delete;
     schema_registry_client(schema_registry_client&&) noexcept = delete;
-    schema_registry_client& operator=(schema_registry_client&&) noexcept
-      = delete;
+    schema_registry_client&
+    operator=(schema_registry_client&&) noexcept = delete;
     virtual ~schema_registry_client() = default;
 
     /**
@@ -347,8 +347,7 @@ class schema_registry_client {
      */
     [[nodiscard]] virtual std::expected<subject_schema, std::error_code>
     lookup_schema_by_version(
-      std::string_view subject, schema_version version) const
-      = 0;
+      std::string_view subject, schema_version version) const = 0;
 
     /**
      * Look up the latest version of a schema (by subject)

src/v/cloud_io/basic_cache_service_api.h

@@ -96,8 +96,8 @@ class basic_cache_service_api {
 public:
     basic_cache_service_api() = default;
     basic_cache_service_api(const basic_cache_service_api&) = default;
-    basic_cache_service_api& operator=(const basic_cache_service_api&)
-      = default;
+    basic_cache_service_api&
+    operator=(const basic_cache_service_api&) = default;
     basic_cache_service_api(basic_cache_service_api&&) = default;
     basic_cache_service_api& operator=(basic_cache_service_api&&) = default;
     virtual ~basic_cache_service_api() = default;
@@ -110,8 +110,7 @@ class basic_cache_service_api {
     virtual ss::future<std::optional<cache_item_stream>> get_stream(
       std::filesystem::path key,
       size_t read_buffer_size = default_read_buffer_size,
-      unsigned int read_ahead = default_read_ahead)
-      = 0;
+      unsigned int read_ahead = default_read_ahead) = 0;
 
     /// Get a range of a cached value as a stream if it exists
     ///
@@ -125,8 +124,7 @@ class basic_cache_service_api {
       uint64_t offset,
       uint64_t length,
       size_t read_buffer_size = default_read_buffer_size,
-      unsigned int read_ahead = default_read_ahead)
-      = 0;
+      unsigned int read_ahead = default_read_ahead) = 0;
 
     /// Add new value to the cache, overwrite if it's already exist
     ///
@@ -142,8 +140,7 @@ class basic_cache_service_api {
       ss::input_stream<char>& data,
       basic_space_reservation_guard<Clock>& reservation,
       size_t write_buffer_size = default_write_buffer_size,
-      unsigned int write_behind = default_write_behind)
-      = 0;
+      unsigned int write_behind = default_write_behind) = 0;
 
     /// \brief Checks if the value is cached
     ///

src/v/cloud_io/cache_service.cc

@@ -207,8 +207,9 @@ ss::future<> cache::clean_up_at_start() {
         auto filepath_to_remove = file_item.path;
 
         // delete only tmp files that are left from previous RedPanda run
-        if (std::string_view(filepath_to_remove)
-              .ends_with(cache_tmp_file_extension)) {
+        if (
+          std::string_view(filepath_to_remove)
+            .ends_with(cache_tmp_file_extension)) {
             try {
                 co_await delete_file_and_empty_parents(filepath_to_remove);
                 deleted_bytes += file_item.size;
@@ -574,8 +575,9 @@ ss::future<> cache::trim(
           exhaustive_result.deleted_size, size_to_delete);
         objects_to_delete -= std::min(
           exhaustive_result.deleted_count, objects_to_delete);
-        if ((size_to_delete > undeletable_bytes
-             || objects_to_delete > undeletable_objects)) {
+        if (
+          (size_to_delete > undeletable_bytes
+           || objects_to_delete > undeletable_objects)) {
             const auto msg = fmt::format(
               "trim: failed to free sufficient space in exhaustive trim, {} "
               "bytes, {} objects still require deletion",
@@ -720,8 +722,9 @@ ss::future<cache::trim_result> cache::do_trim(
         }
 
         // skip tmp files since someone may be writing to it
-        if (std::string_view(file_stat.path)
-              .ends_with(cache_tmp_file_extension)) {
+        if (
+          std::string_view(file_stat.path)
+            .ends_with(cache_tmp_file_extension)) {
             return true;
         }
 
@@ -1226,8 +1229,8 @@ ss::future<> cache::put(
         probe.put_ended();
     });
     auto filename = normal_key_path.filename();
-    if (std::string_view(filename.native())
-          .ends_with(cache_tmp_file_extension)) {
+    if (
+      std::string_view(filename.native()).ends_with(cache_tmp_file_extension)) {
         throw std::invalid_argument(
           fmt::format(
             "Cache file key {} is ending with tmp extension {}.",
@@ -1601,9 +1604,10 @@ cache::trim_carryover(uint64_t delete_bytes, uint64_t delete_objects) {
                         / std::filesystem::relative(
                           std::filesystem::path(file_stat.path), _cache_dir);
 
-        if (auto estimate = _access_time_tracker.get(rel_path.native());
-            estimate.has_value()
-            && estimate->time_point() != file_stat.access_time) {
+        if (
+          auto estimate = _access_time_tracker.get(rel_path.native());
+          estimate.has_value()
+          && estimate->time_point() != file_stat.access_time) {
             vlog(
               log.trace,
               "carryover file {} was accessed ({}) since the last trim ({}), "

src/v/cloud_io/recursive_directory_walker.cc

@@ -45,8 +45,9 @@ struct walk_accumulator {
         if (entry.type && entry.type == ss::directory_entry_type::regular) {
             size_t file_size{0};
             std::chrono::system_clock::time_point atime;
-            if (const auto tracker_entry = tracker.get(entry_path);
-                tracker_entry.has_value()) {
+            if (
+              const auto tracker_entry = tracker.get(entry_path);
+              tracker_entry.has_value()) {
                 file_size = tracker_entry->size;
                 atime = tracker_entry->time_point();
             } else {

src/v/cloud_io/remote_api.h

@@ -80,8 +80,7 @@ class remote_api {
       const cloud_storage_clients::bucket_name& bucket,
       const cloud_storage_clients::object_key& path,
       retry_chain_node& parent,
-      std::string_view object_type)
-      = 0;
+      std::string_view object_type) = 0;
 
     /// \brief Upload small objects to bucket. Suitable for uploading simple
     /// strings, does not check for leadership before upload like the segment
@@ -95,8 +94,7 @@ class remote_api {
       const reset_input_stream& reset_str,
       lazy_abort_source& lazy_abort_source,
       const std::string_view stream_label,
-      std::optional<size_t> max_retries)
-      = 0;
+      std::optional<size_t> max_retries) = 0;
 
     virtual ss::future<download_result> download_stream(
       transfer_details transfer_details,
@@ -105,8 +103,7 @@ class remote_api {
       bool acquire_hydration_units,
       std::optional<cloud_storage_clients::http_byte_range> byte_range
       = std::nullopt,
-      std::function<void(size_t)> throttle_metric_ms_cb = {})
-      = 0;
+      std::function<void(size_t)> throttle_metric_ms_cb = {}) = 0;
 };
 
 } // namespace cloud_io

src/v/cloud_io/tests/s3_imposter.cc

@@ -225,8 +225,9 @@ struct s3_imposter_fixture::content_handler {
           request.content_length,
           request._method);
 
-        if (auto maybe_resp = fixture.should_fail_request(ri);
-            maybe_resp.has_value()) {
+        if (
+          auto maybe_resp = fixture.should_fail_request(ri);
+          maybe_resp.has_value()) {
             vlog(
               fixt_log.debug,
               "S3 imposter request {} - {} - {} marked as failed, response {}",

src/v/cloud_roles/apply_aws_credentials.cc

@@ -60,7 +60,11 @@ static std::string_view sha_for_verb(boost::beast::http::verb verb) {
 }
 
 apply_aws_credentials::apply_aws_credentials(aws_credentials credentials)
-  : _signature{credentials.service, credentials.region, credentials.access_key_id, credentials.secret_access_key}
+  : _signature{
+      credentials.service,
+      credentials.region,
+      credentials.access_key_id,
+      credentials.secret_access_key}
   , _session_token{credentials.session_token} {}
 
 std::error_code

src/v/cloud_roles/apply_credentials.h

@@ -26,8 +26,7 @@ class apply_credentials {
         /// token added as an authorization header, to multiple headers added
         /// along with signing of the request payload.
         virtual std::error_code
-        add_auth(http::client::request_header& header) const
-          = 0;
+        add_auth(http::client::request_header& header) const = 0;
 
         /// Changes the authentication key and secret or the oauth token
         /// associated with the credentials. The concept of temporary

src/v/cloud_roles/auth_refresh_bg_op.cc

@@ -124,8 +124,9 @@ uint64_t auth_refresh_bg_op::token_refresh_count() const noexcept {
 }
 
 cloud_roles::credentials auth_refresh_bg_op::build_static_credentials() const {
-    if (auto creds = std::get_if<cloud_roles::credentials>(&_source_config);
-        creds) {
+    if (
+      auto creds = std::get_if<cloud_roles::credentials>(&_source_config);
+      creds) {
         return *creds;
     } else {
         throw std::runtime_error(