Add std::future async overloads (Phase 1) and C++20 coroutine support…

examples/SelectObjectContent.cc

@@ -32,10 +32,12 @@ int main() {
   std::string expression = "select * from S3Object";
   minio::s3::CsvInputSerialization csv_input;
   minio::s3::FileHeaderInfo file_header_info = minio::s3::FileHeaderInfo::kUse;
-  csv_input.file_header_info = &file_header_info;
+  csv_input.file_header_info =
+      std::make_shared<minio::s3::FileHeaderInfo>(file_header_info);
   minio::s3::CsvOutputSerialization csv_output;
   minio::s3::QuoteFields quote_fields = minio::s3::QuoteFields::kAsNeeded;
-  csv_output.quote_fields = &quote_fields;
+  csv_output.quote_fields =
+      std::make_shared<minio::s3::QuoteFields>(quote_fields);
   minio::s3::SelectRequest request(expression, &csv_input, &csv_output);
 
   std::string records;

include/miniocpp/args.h

@@ -337,6 +337,9 @@ struct PutObjectArgs : public PutObjectBaseArgs {
   // Exactly one of (stream, buf) must be set; Validate() enforces.
   // When buf is set, the call attempts RDMA and falls back to a
   // streaming HTTP upload from the same buffer on RDMA decline.
+  //
+  // For async callers (PutObjectAsync): *stream must outlive the
+  // returned std::future, exactly as it must for sync PutObject.
   std::istream* stream = nullptr;
   char* buf = nullptr;
   std::optional<size_t> size;
@@ -425,7 +428,7 @@ struct RemoveObjectsArgs : public BucketArgs {
 };  // struct RemoveObjectsArgs
 
 struct SelectObjectContentArgs : public ObjectReadArgs {
-  SelectRequest& request;
+  SelectRequest request;
   SelectResultFunction resultfunc = nullptr;
 
   SelectObjectContentArgs(SelectRequest& req, SelectResultFunction func)
@@ -466,7 +469,7 @@ using DeleteBucketNotificationArgs = BucketArgs;
 using GetBucketNotificationArgs = BucketArgs;
 
 struct SetBucketNotificationArgs : public BucketArgs {
-  NotificationConfig& config;
+  NotificationConfig config;
 
   explicit SetBucketNotificationArgs(NotificationConfig& configvalue)
       : config(configvalue) {}
@@ -479,7 +482,7 @@ using DeleteBucketEncryptionArgs = BucketArgs;
 using GetBucketEncryptionArgs = BucketArgs;
 
 struct SetBucketEncryptionArgs : public BucketArgs {
-  SseConfig& config;
+  SseConfig config;
 
   explicit SetBucketEncryptionArgs(SseConfig& sseconfig) : config(sseconfig) {}
 
@@ -505,7 +508,7 @@ using DeleteBucketReplicationArgs = BucketArgs;
 using GetBucketReplicationArgs = BucketArgs;
 
 struct SetBucketReplicationArgs : public BucketArgs {
-  ReplicationConfig& config;
+  ReplicationConfig config;
 
   explicit SetBucketReplicationArgs(ReplicationConfig& value) : config(value) {}
 
@@ -517,7 +520,7 @@ using DeleteBucketLifecycleArgs = BucketArgs;
 using GetBucketLifecycleArgs = BucketArgs;
 
 struct SetBucketLifecycleArgs : public BucketArgs {
-  LifecycleConfig& config;
+  LifecycleConfig config;
 
   explicit SetBucketLifecycleArgs(LifecycleConfig& value) : config(value) {}
 

include/miniocpp/baseclient.h

@@ -18,6 +18,7 @@
 #ifndef MINIO_CPP_BASECLIENT_H_INCLUDED
 #define MINIO_CPP_BASECLIENT_H_INCLUDED
 
+#include <future>
 #include <map>
 #include <shared_mutex>
 #include <string>
@@ -171,6 +172,99 @@ class BaseClient {
   UploadPartResponse UploadPart(UploadPartArgs args);
   UploadPartCopyResponse UploadPartCopy(UploadPartCopyArgs args);
 
+  // Async overloads — return std::future<T> backed by std::async.
+  // These are additive and non-breaking; sync methods remain unchanged.
+  std::future<AbortMultipartUploadResponse> AbortMultipartUploadAsync(
+      AbortMultipartUploadArgs args);
+  std::future<BucketExistsResponse> BucketExistsAsync(BucketExistsArgs args);
+  std::future<CompleteMultipartUploadResponse> CompleteMultipartUploadAsync(
+      CompleteMultipartUploadArgs args);
+  std::future<CreateMultipartUploadResponse> CreateMultipartUploadAsync(
+      CreateMultipartUploadArgs args);
+  std::future<DeleteBucketEncryptionResponse> DeleteBucketEncryptionAsync(
+      DeleteBucketEncryptionArgs args);
+  std::future<DeleteBucketLifecycleResponse> DeleteBucketLifecycleAsync(
+      DeleteBucketLifecycleArgs args);
+  std::future<DeleteBucketNotificationResponse> DeleteBucketNotificationAsync(
+      DeleteBucketNotificationArgs args);
+  std::future<DeleteBucketPolicyResponse> DeleteBucketPolicyAsync(
+      DeleteBucketPolicyArgs args);
+  std::future<DeleteBucketReplicationResponse> DeleteBucketReplicationAsync(
+      DeleteBucketReplicationArgs args);
+  std::future<DeleteBucketTagsResponse> DeleteBucketTagsAsync(
+      DeleteBucketTagsArgs args);
+  std::future<DeleteObjectLockConfigResponse> DeleteObjectLockConfigAsync(
+      DeleteObjectLockConfigArgs args);
+  std::future<DeleteObjectTagsResponse> DeleteObjectTagsAsync(
+      DeleteObjectTagsArgs args);
+  std::future<DisableObjectLegalHoldResponse> DisableObjectLegalHoldAsync(
+      DisableObjectLegalHoldArgs args);
+  std::future<EnableObjectLegalHoldResponse> EnableObjectLegalHoldAsync(
+      EnableObjectLegalHoldArgs args);
+  std::future<GetBucketEncryptionResponse> GetBucketEncryptionAsync(
+      GetBucketEncryptionArgs args);
+  std::future<GetBucketLifecycleResponse> GetBucketLifecycleAsync(
+      GetBucketLifecycleArgs args);
+  std::future<GetBucketNotificationResponse> GetBucketNotificationAsync(
+      GetBucketNotificationArgs args);
+  std::future<GetBucketPolicyResponse> GetBucketPolicyAsync(
+      GetBucketPolicyArgs args);
+  std::future<GetBucketReplicationResponse> GetBucketReplicationAsync(
+      GetBucketReplicationArgs args);
+  std::future<GetBucketTagsResponse> GetBucketTagsAsync(GetBucketTagsArgs args);
+  std::future<GetBucketVersioningResponse> GetBucketVersioningAsync(
+      GetBucketVersioningArgs args);
+  std::future<GetObjectResponse> GetObjectAsync(GetObjectArgs args);
+  std::future<GetObjectLockConfigResponse> GetObjectLockConfigAsync(
+      GetObjectLockConfigArgs args);
+  std::future<GetObjectRetentionResponse> GetObjectRetentionAsync(
+      GetObjectRetentionArgs args);
+  std::future<GetObjectTagsResponse> GetObjectTagsAsync(GetObjectTagsArgs args);
+  std::future<GetPresignedObjectUrlResponse> GetPresignedObjectUrlAsync(
+      GetPresignedObjectUrlArgs args);
+  std::future<GetPresignedPostFormDataResponse> GetPresignedPostFormDataAsync(
+      PostPolicy policy);
+  std::future<IsObjectLegalHoldEnabledResponse> IsObjectLegalHoldEnabledAsync(
+      IsObjectLegalHoldEnabledArgs args);
+  std::future<ListBucketsResponse> ListBucketsAsync(ListBucketsArgs args);
+  std::future<ListBucketsResponse> ListBucketsAsync();
+  std::future<ListenBucketNotificationResponse> ListenBucketNotificationAsync(
+      ListenBucketNotificationArgs args);
+  std::future<ListObjectsResponse> ListObjectsV1Async(ListObjectsV1Args args);
+  std::future<ListObjectsResponse> ListObjectsV2Async(ListObjectsV2Args args);
+  std::future<ListObjectsResponse> ListObjectVersionsAsync(
+      ListObjectVersionsArgs args);
+  std::future<MakeBucketResponse> MakeBucketAsync(MakeBucketArgs args);
+  std::future<PutObjectResponse> PutObjectAsync(PutObjectApiArgs args);
+  std::future<RemoveBucketResponse> RemoveBucketAsync(RemoveBucketArgs args);
+  std::future<RemoveObjectResponse> RemoveObjectAsync(RemoveObjectArgs args);
+  std::future<RemoveObjectsResponse> RemoveObjectsAsync(
+      RemoveObjectsApiArgs args);
+  std::future<SelectObjectContentResponse> SelectObjectContentAsync(
+      SelectObjectContentArgs args);
+  std::future<SetBucketEncryptionResponse> SetBucketEncryptionAsync(
+      SetBucketEncryptionArgs args);
+  std::future<SetBucketLifecycleResponse> SetBucketLifecycleAsync(
+      SetBucketLifecycleArgs args);
+  std::future<SetBucketNotificationResponse> SetBucketNotificationAsync(
+      SetBucketNotificationArgs args);
+  std::future<SetBucketPolicyResponse> SetBucketPolicyAsync(
+      SetBucketPolicyArgs args);
+  std::future<SetBucketReplicationResponse> SetBucketReplicationAsync(
+      SetBucketReplicationArgs args);
+  std::future<SetBucketTagsResponse> SetBucketTagsAsync(SetBucketTagsArgs args);
+  std::future<SetBucketVersioningResponse> SetBucketVersioningAsync(
+      SetBucketVersioningArgs args);
+  std::future<SetObjectLockConfigResponse> SetObjectLockConfigAsync(
+      SetObjectLockConfigArgs args);
+  std::future<SetObjectRetentionResponse> SetObjectRetentionAsync(
+      SetObjectRetentionArgs args);
+  std::future<SetObjectTagsResponse> SetObjectTagsAsync(SetObjectTagsArgs args);
+  std::future<StatObjectResponse> StatObjectAsync(StatObjectArgs args);
+  std::future<UploadPartResponse> UploadPartAsync(UploadPartArgs args);
+  std::future<UploadPartCopyResponse> UploadPartCopyAsync(
+      UploadPartCopyArgs args);
+
   // Windows API fix:
   //
   // Windows API headers define `GetObject()` as a macro that expands to either

include/miniocpp/client.h

@@ -18,6 +18,7 @@
 #ifndef MINIO_CPP_CLIENT_H_INCLUDED
 #define MINIO_CPP_CLIENT_H_INCLUDED
 
+#include <future>
 #include <list>
 #include <string>
 
@@ -138,6 +139,20 @@ class Client : public BaseClient {
   GetObjectResponse GetObject(GetObjectArgs args);
   UploadObjectResponse UploadObject(UploadObjectArgs args);
   RemoveObjectsResult RemoveObjects(RemoveObjectsArgs args);
+
+  // Async overloads — return std::future<T> backed by std::async.
+  //
+  // Lifetime note for PutObjectAsync: the caller must ensure
+  // args.stream (if set) outlives the returned std::future<T>,
+  // exactly as it must for the synchronous PutObject call.
+  std::future<ComposeObjectResponse> ComposeObjectAsync(ComposeObjectArgs args);
+  std::future<CopyObjectResponse> CopyObjectAsync(CopyObjectArgs args);
+  std::future<DownloadObjectResponse> DownloadObjectAsync(
+      DownloadObjectArgs args);
+  std::future<GetObjectResponse> GetObjectAsync(GetObjectArgs args);
+  std::future<ListObjectsResult> ListObjectsAsync(ListObjectsArgs args);
+  std::future<PutObjectResponse> PutObjectAsync(PutObjectArgs args);
+  std::future<UploadObjectResponse> UploadObjectAsync(UploadObjectArgs args);
 };  // class Client
 
 }  // namespace minio::s3

include/miniocpp/types.h

@@ -23,6 +23,7 @@
 #include <iostream>
 #include <list>
 #include <map>
+#include <memory>
 #include <nlohmann/json_fwd.hpp>
 #include <ostream>
 #include <string>
@@ -191,11 +192,11 @@ constexpr const char* QuoteFieldsToString(QuoteFields qtype) noexcept {
 }
 
 struct CsvInputSerialization {
-  CompressionType* compression_type = nullptr;
+  std::shared_ptr<CompressionType> compression_type;
   bool allow_quoted_record_delimiter = false;
   char comments = 0;
   char field_delimiter = 0;
-  FileHeaderInfo* file_header_info = nullptr;
+  std::shared_ptr<FileHeaderInfo> file_header_info;
   char quote_character = 0;
   char quote_escape_character = 0;
   char record_delimiter = 0;
@@ -205,8 +206,8 @@ struct CsvInputSerialization {
 };  // struct CsvInputSerialization
 
 struct JsonInputSerialization {
-  CompressionType* compression_type = nullptr;
-  JsonType* json_type = nullptr;
+  std::shared_ptr<CompressionType> compression_type;
+  std::shared_ptr<JsonType> json_type;
 
   JsonInputSerialization() = default;
   ~JsonInputSerialization() = default;
@@ -221,7 +222,7 @@ struct CsvOutputSerialization {
   char field_delimiter = 0;
   char quote_character = 0;
   char quote_escape_character = 0;
-  QuoteFields* quote_fields = nullptr;
+  std::shared_ptr<QuoteFields> quote_fields;
   char record_delimiter = 0;
 
   CsvOutputSerialization() = default;

src/args.cc

@@ -466,8 +466,8 @@ error::Error SelectObjectContentArgs::Validate() const {
     return error::Error("SQL expression must not be empty");
   }
 
-  if (!((request.csv_input != nullptr) ^ (request.json_input != nullptr) ^
-        (request.parquet_input != nullptr))) {
+  if (((request.csv_input != nullptr) + (request.json_input != nullptr) +
+       (request.parquet_input != nullptr)) != 1) {
     return error::Error(
         "One of CSV, JSON or Parquet input serialization must be set");
   }