Refactor messages by subclasses

merge SelectObjectContentRequest
merge ListVersionsResult
Remove unused CompleteMultipartUploadOutput.java
merge ListMultipartUploadsResult
merge NotificationRecords
merge SseConfiguration
merge DeleteRequest, DeleteResult
merge RestoreRequest
merge NotificationConfiguration
merge LifecycleConfiguration
merge ReplicationConfiguration
merge Filter
merge ObjectLockConfiguration
merge ListAllMyBucketsResult
merge Item
merge ListObjectsResult
Move common fields for ListPartsResult and GetObjectAttributesOutput

Signed-off-by: Bala.FA <[email protected]>

Author: balamurugana

adminapi/src/main/java/io/minio/admin/MinioAdminClient.java

@@ -0,0 +1,64 @@
+/*
+ * MinIO Java SDK for Amazon S3 Compatible Cloud Storage, (C) 2025 MinIO, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.minio;
+
+import java.util.Objects;
+
+/**
+ * Argument class of {@link MinioAsyncClient#abortMultipartUpload} and {@link
+ * MinioClient#abortMultipartUpload}.
+ */
+public class AbortMultipartUploadArgs extends ObjectArgs {
+  private String uploadId;
+
+  public String uploadId() {
+    return uploadId;
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  /** Argument builder of {@link AbortMultipartUploadArgs}. */
+  public static final class Builder extends ObjectArgs.Builder<Builder, AbortMultipartUploadArgs> {
+    @Override
+    protected void validate(AbortMultipartUploadArgs args) {
+      super.validate(args);
+      Utils.validateNotEmptyString(args.uploadId, "upload ID");
+    }
+
+    public Builder uploadId(String uploadId) {
+      Utils.validateNotEmptyString(uploadId, "upload ID");
+      operations.add(args -> args.uploadId = uploadId);
+      return this;
+    }
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (!(o instanceof AbortMultipartUploadArgs)) return false;
+    if (!super.equals(o)) return false;
+    AbortMultipartUploadArgs that = (AbortMultipartUploadArgs) o;
+    return Objects.equals(uploadId, that.uploadId);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(super.hashCode(), uploadId);
+  }
+}

api/src/main/java/io/minio/AbortMultipartUploadArgs.java

@@ -30,11 +30,20 @@
 
 /** Base argument class. */
 public abstract class BaseArgs {
+  private String location;
   protected Multimap<String, String> extraHeaders =
       Multimaps.unmodifiableMultimap(HashMultimap.create());
   protected Multimap<String, String> extraQueryParams =
       Multimaps.unmodifiableMultimap(HashMultimap.create());
 
+  public void setLocation(String location) {
+    this.location = location;
+  }
+
+  public String location() {
+    return location;
+  }
+
   public Multimap<String, String> extraHeaders() {
     return extraHeaders;
   }
@@ -43,12 +52,12 @@ public Multimap<String, String> extraQueryParams() {
     return extraQueryParams;
   }
 
-  protected void checkSse(ServerSideEncryption sse, HttpUrl url) {
+  protected void checkSse(ServerSideEncryption sse, boolean isHttps) {
     if (sse == null) {
       return;
     }
 
-    if (sse.tlsRequired() && !url.isHttps()) {
+    if (sse.tlsRequired() && !isHttps) {
       throw new IllegalArgumentException(
           sse + " operations must be performed over a secure connection.");
     }
@@ -60,75 +69,34 @@ public abstract static class Builder<B extends Builder<B, A>, A extends BaseArgs
 
     protected abstract void validate(A args);
 
-    protected void validateNotNull(Object arg, String argName) {
-      if (arg == null) {
-        throw new IllegalArgumentException(argName + " must not be null.");
-      }
-    }
-
-    protected void validateNotEmptyString(String arg, String argName) {
-      validateNotNull(arg, argName);
-      if (arg.isEmpty()) {
-        throw new IllegalArgumentException(argName + " must be a non-empty string.");
-      }
-    }
-
-    protected void validateNullOrNotEmptyString(String arg, String argName) {
-      if (arg != null && arg.isEmpty()) {
-        throw new IllegalArgumentException(argName + " must be a non-empty string.");
-      }
-    }
-
-    protected void validateNullOrPositive(Number arg, String argName) {
-      if (arg != null && arg.longValue() < 0) {
-        throw new IllegalArgumentException(argName + " cannot be non-negative.");
-      }
-    }
-
     public Builder() {
       this.operations = new ArrayList<>();
     }
 
-    protected Multimap<String, String> copyMultimap(Multimap<String, String> multimap) {
-      Multimap<String, String> multimapCopy = HashMultimap.create();
-      if (multimap != null) {
-        multimapCopy.putAll(multimap);
-      }
-      return Multimaps.unmodifiableMultimap(multimapCopy);
-    }
-
-    protected Multimap<String, String> toMultimap(Map<String, String> map) {
-      Multimap<String, String> multimap = HashMultimap.create();
-      if (map != null) {
-        multimap.putAll(Multimaps.forMap(map));
-      }
-      return Multimaps.unmodifiableMultimap(multimap);
-    }
-
     @SuppressWarnings("unchecked") // Its safe to type cast to B as B extends this class.
     public B extraHeaders(Multimap<String, String> headers) {
-      final Multimap<String, String> extraHeaders = copyMultimap(headers);
+      final Multimap<String, String> extraHeaders = Utils.newMultimap(headers);
       operations.add(args -> args.extraHeaders = extraHeaders);
       return (B) this;
     }
 
     @SuppressWarnings("unchecked") // Its safe to type cast to B as B extends this class.
     public B extraQueryParams(Multimap<String, String> queryParams) {
-      final Multimap<String, String> extraQueryParams = copyMultimap(queryParams);
+      final Multimap<String, String> extraQueryParams = Utils.newMultimap(queryParams);
       operations.add(args -> args.extraQueryParams = extraQueryParams);
       return (B) this;
     }
 
     @SuppressWarnings("unchecked") // Its safe to type cast to B as B extends this class.
     public B extraHeaders(Map<String, String> headers) {
-      final Multimap<String, String> extraHeaders = toMultimap(headers);
+      final Multimap<String, String> extraHeaders = Utils.newMultimap(headers);
       operations.add(args -> args.extraHeaders = extraHeaders);
       return (B) this;
     }
 
     @SuppressWarnings("unchecked") // Its safe to type cast to B as B extends this class.
     public B extraQueryParams(Map<String, String> queryParams) {
-      final Multimap<String, String> extraQueryParams = toMultimap(queryParams);
+      final Multimap<String, String> extraQueryParams = Utils.newMultimap(queryParams);
       operations.add(args -> args.extraQueryParams = extraQueryParams);
       return (B) this;
     }