Clang fmt

Author: Sandeep Gottimukkala

src/iceberg/catalog/rest/endpoint.h

@@ -134,15 +134,18 @@ class ICEBERG_REST_EXPORT Endpoint {
   }
 
   static Endpoint FetchPlanningResult() {
-    return {HttpMethod::kGet, "/v1/{prefix}/namespaces/{namespace}/tables/{table}/plan/{plan-id}"};
+    return {HttpMethod::kGet,
+            "/v1/{prefix}/namespaces/{namespace}/tables/{table}/plan/{plan-id}"};
   }
 
   static Endpoint CancelPlanning() {
-    return {HttpMethod::kDelete, "/v1/{prefix}/namespaces/{namespace}/tables/{table}/plan/{plan-id}"};
+    return {HttpMethod::kDelete,
+            "/v1/{prefix}/namespaces/{namespace}/tables/{table}/plan/{plan-id}"};
   }
 
   static Endpoint FetchScanTasks() {
-    return {HttpMethod::kPost, "/v1/{prefix}/namespaces/{namespace}/tables/{table}/tasks"};
+    return {HttpMethod::kPost,
+            "/v1/{prefix}/namespaces/{namespace}/tables/{table}/tasks"};
   }
 
  private:

src/iceberg/catalog/rest/error_handlers.cc

@@ -187,8 +187,7 @@ Status ViewCommitErrorHandler::Accept(const ErrorResponse& error) const {
 }
 
 const std::shared_ptr<ScanPlanErrorHandler>& ScanPlanErrorHandler::Instance() {
-  static const std::shared_ptr<ScanPlanErrorHandler> instance{
-      new ScanPlanErrorHandler()};
+  static const std::shared_ptr<ScanPlanErrorHandler> instance{new ScanPlanErrorHandler()};
   return instance;
 }
 
@@ -215,5 +214,4 @@ Status ScanPlanErrorHandler::Accept(const ErrorResponse& error) const {
   return DefaultErrorHandler::Accept(error);
 }
 
-
 }  // namespace iceberg::rest

src/iceberg/catalog/rest/json_serde_internal.h

@@ -68,17 +68,21 @@ ICEBERG_DECLARE_JSON_SERDE(OAuthTokenResponse)
 
 ICEBERG_REST_EXPORT Result<PlanTableScanResponse> PlanTableScanResponseFromJson(
     const nlohmann::json& json,
-    const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>& partition_specs_by_id,
+    const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>&
+        partition_specs_by_id,
     const Schema& schema);
 
-ICEBERG_REST_EXPORT Result<FetchPlanningResultResponse> FetchPlanningResultResponseFromJson(
+ICEBERG_REST_EXPORT Result<FetchPlanningResultResponse>
+FetchPlanningResultResponseFromJson(
     const nlohmann::json& json,
-    const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>& partition_specs_by_id,
+    const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>&
+        partition_specs_by_id,
     const Schema& schema);
 
 ICEBERG_REST_EXPORT Result<FetchScanTasksResponse> FetchScanTasksResponseFromJson(
     const nlohmann::json& json,
-    const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>& partition_specs_by_id,
+    const std::unordered_map<int32_t, std::shared_ptr<PartitionSpec>>&
+        partition_specs_by_id,
     const Schema& schema);
 
 ICEBERG_REST_EXPORT Result<nlohmann::json> ToJson(const PlanTableScanRequest& request);

src/iceberg/catalog/rest/resource_paths.cc

@@ -109,7 +109,8 @@ Result<std::string> ResourcePaths::ScanPlan(const TableIdentifier& ident) const
                      encoded_namespace, encoded_table_name);
 }
 
-Result<std::string> ResourcePaths::ScanPlan(const TableIdentifier& ident, const std::string& plan_id) const {
+Result<std::string> ResourcePaths::ScanPlan(const TableIdentifier& ident,
+                                            const std::string& plan_id) const {
   ICEBERG_ASSIGN_OR_RAISE(std::string encoded_namespace, EncodeNamespace(ident.ns));
   ICEBERG_ASSIGN_OR_RAISE(std::string encoded_table_name, EncodeString(ident.name));
   return std::format("{}/v1/{}namespaces/{}/tables/{}/plan/{}", base_uri_, prefix_,

src/iceberg/catalog/rest/rest_catalog.h

@@ -109,8 +109,8 @@ class ICEBERG_REST_EXPORT RestCatalog : public Catalog,
   Result<FetchPlanningResultResponse> FetchPlanningResult(
       const Table& table, const std::string& plan_id) override;
   Status CancelPlanning(const Table& table, const std::string& plan_id) override;
-  Result<FetchScanTasksResponse> FetchScanTasks(
-      const Table& table, const std::string& plan_task) override;
+  Result<FetchScanTasksResponse> FetchScanTasks(const Table& table,
+                                                const std::string& plan_task) override;
 
  private:
   RestCatalog(RestCatalogProperties config, std::shared_ptr<FileIO> file_io,

src/iceberg/json_serde_internal.h

@@ -424,8 +424,10 @@ ICEBERG_EXPORT Result<std::unique_ptr<TableRequirement>> TableRequirementFromJso
 /// Binary fields (lower-bounds, upper-bounds, key-metadata) are base64-encoded.
 ///
 /// \param json The JSON object representing a `DataFile`.
-/// \param partitionSpecById Map from spec ID to PartitionSpec for type-aware partition parsing.
-/// \param schema The table schema, used with partitionSpecById to resolve partition types.
+/// \param partitionSpecById Map from spec ID to PartitionSpec for type-aware partition
+/// parsing.
+/// \param schema The table schema, used with partitionSpecById to resolve partition
+/// types.
 /// \return A `DataFile` object or an error if the conversion fails.
 ICEBERG_EXPORT Result<DataFile> DataFileFromJson(const nlohmann::json& json);
 
@@ -440,8 +442,10 @@ ICEBERG_EXPORT Result<DataFile> DataFileFromJson(
 ///
 /// \param json The JSON array of file scan task objects.
 /// \param delete_files Delete files indexed by the tasks' delete-file-references.
-/// \param partitionSpecById Map from spec ID to PartitionSpec for type-aware partition parsing.
-/// \param schema The table schema, used with partitionSpecById to resolve partition types.
+/// \param partitionSpecById Map from spec ID to PartitionSpec for type-aware partition
+/// parsing.
+/// \param schema The table schema, used with partitionSpecById to resolve partition
+/// types.
 /// \return A vector of `FileScanTask` objects or an error if the conversion fails.
 ICEBERG_EXPORT Result<std::vector<FileScanTask>> FileScanTasksFromJson(
     const nlohmann::json& json, const std::vector<DataFile>& delete_files,

src/iceberg/test/endpoint_test.cc

@@ -264,11 +264,11 @@ TEST(EndpointTest, FromStringInvalid) {
 TEST(EndpointTest, StringRoundTrip) {
   // Create various endpoints and verify they survive string round-trip
   std::vector<Endpoint> endpoints = {
-      Endpoint::ListNamespaces(),     Endpoint::GetNamespaceProperties(),
-      Endpoint::CreateNamespace(),    Endpoint::LoadTable(),
-      Endpoint::CreateTable(),        Endpoint::DeleteTable(),
-      Endpoint::PlanTableScan(),      Endpoint::FetchPlanningResult(),
-      Endpoint::CancelPlanning(),     Endpoint::FetchScanTasks(),
+      Endpoint::ListNamespaces(),  Endpoint::GetNamespaceProperties(),
+      Endpoint::CreateNamespace(), Endpoint::LoadTable(),
+      Endpoint::CreateTable(),     Endpoint::DeleteTable(),
+      Endpoint::PlanTableScan(),   Endpoint::FetchPlanningResult(),
+      Endpoint::CancelPlanning(),  Endpoint::FetchScanTasks(),
   };
 
   for (const auto& original : endpoints) {