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

@@ -60,75 +60,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;
     }

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

@@ -16,8 +16,6 @@
 
 package io.minio;
 
-import io.minio.http.HttpUtils;
-import io.minio.org.apache.commons.validator.routines.InetAddressValidator;
 import java.util.Objects;
 import java.util.regex.Pattern;
 
@@ -42,7 +40,7 @@ public abstract static class Builder<B extends Builder<B, A>, A extends BucketAr
     protected boolean skipValidation = false;
 
     protected void validateBucketName(String name) {
-      validateNotNull(name, "bucket name");
+      Utils.validateNotNull(name, "bucket name");
       if (skipValidation) {
         return;
       }
@@ -55,7 +53,7 @@ protected void validateBucketName(String name) {
                 + "https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucketnamingrules.html");
       }
 
-      if (InetAddressValidator.getInstance().isValidInet4Address(name)) {
+      if (Utils.isValidIPv4(name)) {
         throw new IllegalArgumentException(
             "bucket name '" + name + "' must not be formatted as an IP address");
       }
@@ -67,7 +65,7 @@ protected void validateBucketName(String name) {
     }
 
     private void validateRegion(String region) {
-      if (!skipValidation && region != null && !HttpUtils.REGION_REGEX.matcher(region).find()) {
+      if (!skipValidation && region != null && !Utils.REGION_REGEX.matcher(region).find()) {
         throw new IllegalArgumentException("invalid region " + region);
       }
     }

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

@@ -0,0 +1,124 @@
+/*
+ * 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.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.SequenceInputStream;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class ByteBuffer extends OutputStream {
+  private static class Buffer extends ByteArrayOutputStream {
+    public InputStream inputStream() {
+      return (count > 0) ? new ByteArrayInputStream(buf, 0, count) : null;
+    }
+  }
+
+  private static final long MAX_SIZE = 5L * 1024 * 1024 * 1024;
+  private static final int CHUNK_SIZE = Integer.MAX_VALUE;
+  private final long totalSize;
+  private final List<Buffer> buffers = new ArrayList<>();
+  private int index = 0;
+  private long writtenBytes = 0;
+  private boolean isClosed = false;
+
+  public ByteBuffer(long totalSize) {
+    if (totalSize > MAX_SIZE) {
+      throw new IllegalArgumentException("Total size cannot exceed 5GiB");
+    }
+    this.totalSize = totalSize;
+  }
+
+  private void updateIndex() {
+    if (buffers.isEmpty()) {
+      index = 0;
+      buffers.add(new Buffer());
+    } else if (writtenBytes >= (long) (index + 1) * CHUNK_SIZE) {
+      index++;
+      if (index > buffers.size() - 1) buffers.add(new Buffer());
+    }
+  }
+
+  @Override
+  public void write(int b) throws IOException {
+    if (isClosed) throw new IOException("Stream is closed");
+    if (writtenBytes >= totalSize) throw new IOException("Exceeded total size limit");
+    updateIndex();
+    buffers.get(index).write(b);
+    writtenBytes++;
+  }
+
+  @Override
+  public void write(byte[] b, int off, int len) throws IOException {
+    if (isClosed) throw new IOException("Stream is closed");
+    if (len > (totalSize - writtenBytes)) throw new IOException("Exceeded total size limit");
+    int remaining = len;
+    while (remaining > 0) {
+      updateIndex();
+      Buffer currentBuffer = buffers.get(index);
+      int bytesToWrite = Math.min(remaining, CHUNK_SIZE - currentBuffer.size());
+      currentBuffer.write(b, off + (len - remaining), bytesToWrite);
+      writtenBytes += bytesToWrite;
+      remaining -= bytesToWrite;
+    }
+  }
+
+  @Override
+  public void write(byte[] b) throws IOException {
+    write(b, 0, b.length);
+  }
+
+  public long length() {
+    return writtenBytes;
+  }
+
+  public void reset() throws IOException {
+    if (isClosed) throw new IOException("Cannot reset a closed stream");
+    writtenBytes = 0;
+    index = 0;
+    for (Buffer buffer : buffers) buffer.reset();
+  }
+
+  public void close() throws IOException {
+    if (!isClosed) {
+      isClosed = true;
+      buffers.clear();
+    }
+  }
+
+  public InputStream inputStream() throws IOException {
+    List<InputStream> streams = new ArrayList<>();
+    for (Buffer buffer : buffers) {
+      InputStream stream = buffer.inputStream();
+      if (stream != null) streams.add(stream);
+    }
+    switch (streams.size()) {
+      case 0:
+        return new ByteArrayInputStream(Utils.EMPTY_BODY);
+      case 1:
+        return streams.get(0);
+      default:
+        return new SequenceInputStream(Collections.enumeration(streams));
+    }
+  }
+}