Updates to TM headers

Author: narahavi

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/DownloadHandle.h

@@ -19,14 +19,16 @@ class DownloadHandleImpl;
  * Returned from S3TransferManager::Download to represent a single in-flight download. The
  * handle is freely copyable; all copies share the same underlying transfer state.
  */
-class AWS_S3_TRANSFER_API DownloadHandle {
+class AWS_S3_TRANSFER_API DownloadHandle final {
 public:
   ~DownloadHandle();
+  DownloadHandle(DownloadHandle&&) noexcept;
+  DownloadHandle& operator=(DownloadHandle&&) noexcept;
 
   /**
    * Returns a future that resolves once the transfer finishes, succeeds, or fails.
    */
-  std::shared_future<DownloadOutcome> CompletionFuture() const;
+  std::future<DownloadOutcome> CompletionFuture();
 
   /**
    * Requests cancellation of the in-flight download. Returns immediately; the future
@@ -35,7 +37,7 @@ class AWS_S3_TRANSFER_API DownloadHandle {
   void Cancel();
 
 private:
-  std::shared_ptr<DownloadHandleImpl> m_impl;
+  std::unique_ptr<DownloadHandleImpl> m_impl;
 };
 
 

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/DownloadProgressListener.h

@@ -24,23 +24,23 @@ class AWS_S3_TRANSFER_API DownloadProgressListener {
   /**
    * Invoked exactly once when the download begins, before any bytes have been transferred.
    */
-  virtual void OnTransferInitiated(const DownloadRequest&, const DownloadProgressSnapshot&) {}
+  virtual void OnTransferInitiated(const DownloadRequest& /*request*/, const DownloadProgressSnapshot& /*snapshot*/) {}
 
   /**
    * Invoked as bytes are received from S3. Called at least once for a successful transfer
    * and may be called many times depending on object size and I/O buffer sizes.
    */
-  virtual void OnBytesTransferred(const DownloadRequest&, const DownloadProgressSnapshot&) {}
+  virtual void OnBytesTransferred(const DownloadRequest& /*request*/, const DownloadProgressSnapshot& /*snapshot*/) {}
 
   /**
    * Invoked exactly once when the download completes successfully.
    */
-  virtual void OnTransferComplete(const DownloadRequest&, const DownloadProgressSnapshot&) {}
+  virtual void OnTransferComplete(const DownloadRequest& /*request*/, const DownloadProgressSnapshot& /*snapshot*/) {}
 
   /**
    * Invoked exactly once when the download fails or is cancelled.
    */
-  virtual void OnTransferFailed(const DownloadRequest&, const DownloadProgressSnapshot&) {}
+  virtual void OnTransferFailed(const DownloadRequest& /*request*/, const DownloadProgressSnapshot& /*snapshot*/) {}
 };
 
 }

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/DownloadProgressSnapshot.h

@@ -18,7 +18,8 @@ namespace Transfer {
  * Captures bytes transferred, total bytes (known after the GetObject response is received),
  * and the response once available.
  */
-class AWS_S3_TRANSFER_API DownloadProgressSnapshot {
+
+class AWS_S3_TRANSFER_API DownloadProgressSnapshot final {
  public:
   DownloadProgressSnapshot(uint64_t transferredBytes,
                            uint64_t totalBytes,

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/DownloadRequest.h

@@ -21,72 +21,31 @@ namespace Transfer {
  * with the local destination (file path or stream factory) and any request-level progress
  * listeners. The transfer manager parallelizes large objects via ranged GETs internally.
  */
-class AWS_S3_TRANSFER_API DownloadRequest {
+class AWS_S3_TRANSFER_API DownloadRequest final {
  public:
-  inline const Aws::S3::Model::GetObjectRequest& GetS3Request() const { return m_s3Request; }
-  inline bool S3RequestHasBeenSet() const { return m_s3RequestHasBeenSet; }
-  template <typename S3RequestT = Aws::S3::Model::GetObjectRequest>
-  void SetS3Request(S3RequestT&& val) {
-    m_s3RequestHasBeenSet = true;
-    m_s3Request = std::forward<S3RequestT>(val);
-  }
-  template <typename S3RequestT = Aws::S3::Model::GetObjectRequest>
-  DownloadRequest& WithS3Request(S3RequestT&& value) {
-    SetS3Request(std::forward<S3RequestT>(value));
-    return *this;
-  }
+  explicit DownloadRequest(
+    Aws::S3::Model::GetObjectRequest s3Request,
+    Aws::String destinationFilePath,
+    Aws::IOStreamFactory responseStreamFactory,
+    Aws::Vector<std::shared_ptr<DownloadProgressListener>> transferListeners = {})
+  : m_s3Request(std::move(s3Request)),
+    m_destinationFilePath(std::move(destinationFilePath)),
+    m_responseStreamFactory(std::move(responseStreamFactory)),
+    m_transferListeners(std::move(transferListeners)) {}
 
+  inline const Aws::S3::Model::GetObjectRequest& GetS3Request() const { return m_s3Request; }
   inline const Aws::String& GetDestinationFilePath() const { return m_destinationFilePath; }
-  inline bool DestinationFilePathHasBeenSet() const { return m_destinationFilePathHasBeenSet; }
-  template <typename DestinationFilePathT = Aws::String>
-  void SetDestinationFilePath(DestinationFilePathT&& value) {
-    m_destinationFilePathHasBeenSet = true;
-    m_destinationFilePath = std::forward<DestinationFilePathT>(value);
-  }
-  template <typename DestinationFilePathT = Aws::String>
-  DownloadRequest& WithDestinationFilePath(DestinationFilePathT&& value) {
-    SetDestinationFilePath(std::forward<DestinationFilePathT>(value));
-    return *this;
-  }
-
-  inline const Aws::IOStreamFactory& GetBody() const { return m_body; }
-  inline bool BodyHasBeenSet() const { return m_bodyHasBeenSet; }
-  inline void SetBody(const Aws::IOStreamFactory& val) {
-    m_bodyHasBeenSet = true;
-    m_body = val;
-  }
-  inline DownloadRequest& WithBody(const Aws::IOStreamFactory& val) {
-    SetBody(val);
-    return *this;
-  }
-
+  inline const Aws::IOStreamFactory& GetResponseStreamFactory() const { return m_responseStreamFactory; }
   inline const Aws::Vector<std::shared_ptr<DownloadProgressListener>>& GetTransferListeners() const {
     return m_transferListeners;
   }
-  inline bool TransferListenersHasBeenSet() const { return m_transferListenersHasBeenSet; }
-  inline void SetTransferListeners(const Aws::Vector<std::shared_ptr<DownloadProgressListener>>& val) {
-    m_transferListenersHasBeenSet = true;
-    m_transferListeners = val;
-  }
-  inline DownloadRequest& WithTransferListeners(const Aws::Vector<std::shared_ptr<DownloadProgressListener>>& val) {
-    SetTransferListeners(val);
-    return *this;
-  }
-  inline DownloadRequest& AddTransferListener(const std::shared_ptr<DownloadProgressListener>& listener) {
-    m_transferListenersHasBeenSet = true;
-    m_transferListeners.push_back(listener);
-    return *this;
-  }
+
 
  private:
   Aws::S3::Model::GetObjectRequest m_s3Request;
   Aws::String m_destinationFilePath;
-  Aws::IOStreamFactory m_body;
+  Aws::IOStreamFactory m_responseStreamFactory;
   Aws::Vector<std::shared_ptr<DownloadProgressListener>> m_transferListeners;
-  bool m_s3RequestHasBeenSet = false;
-  bool m_destinationFilePathHasBeenSet = false;
-  bool m_bodyHasBeenSet = false;
-  bool m_transferListenersHasBeenSet = false;
 };
 
 }

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/DownloadResponse.h

@@ -19,7 +19,7 @@ namespace Transfer {
  * the underlying S3 GetObjectResult with whole-object content length and range, regardless
  * of how many ranged GETs were issued internally.
  */
-class AWS_S3_TRANSFER_API DownloadResponse {
+class AWS_S3_TRANSFER_API DownloadResponse final {
  public:
   inline const Aws::S3::Model::GetObjectResult& GetS3Result() const { return m_s3Result; }
   inline bool S3ResultHasBeenSet() const { return m_s3ResultHasBeenSet; }

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/S3TransferManager.h

@@ -16,21 +16,17 @@ namespace Aws {
   class S3TransferManagerImpl;
 
   /**
-   * High-level S3 transfer client backed by the AWS Common Runtime. Performs single-file
-   * uploads and downloads, automatically using multipart transfers for objects larger than
-   * the configured threshold. Customers hold an instance via shared_ptr; the manager owns
-   * the underlying CRT client and is not copyable or movable.
+   * Customers construct an instance directly. The manager owns the underlying CRT
+   * client; it is movable but not copyable.
    */
-  class AWS_S3_TRANSFER_API S3TransferManager: public std::enable_shared_from_this<S3TransferManager> {
+  class AWS_S3_TRANSFER_API S3TransferManager final {
   public:
-    static std::shared_ptr<S3TransferManager> Create(const S3TransferManagerConfiguration& config);
-
+    explicit S3TransferManager(const S3TransferManagerConfiguration& config);
     ~S3TransferManager();
 
     S3TransferManager(const S3TransferManager&) = delete;
     S3TransferManager& operator=(const S3TransferManager&) = delete;
-    S3TransferManager(S3TransferManager&&) = delete;
-    S3TransferManager& operator=(S3TransferManager&&) = delete;
+
 
     /**
      * Begin uploading the object described by request. Returns immediately with a handle
@@ -45,7 +41,6 @@ namespace Aws {
     DownloadHandle Download(const DownloadRequest& request);
 
   private:
-    explicit S3TransferManager(const S3TransferManagerConfiguration& config);
     Aws::UniquePtr<S3TransferManagerImpl> m_impl;
   };
   }

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/UploadHandle.h

@@ -19,14 +19,16 @@ class UploadHandleImpl;
  * Returned from S3TransferManager::Upload to represent a single in-flight upload. The
  * handle is freely copyable; all copies share the same underlying transfer state.
  */
-class AWS_S3_TRANSFER_API UploadHandle {
+class AWS_S3_TRANSFER_API UploadHandle final {
 public:
   ~UploadHandle();
+  UploadHandle(UploadHandle&&) noexcept;
+  UploadHandle& operator=(UploadHandle&&) noexcept;
 
   /**
    * Returns a future that resolves once the transfer finishes, succeeds, or fails.
    */
-  std::shared_future<UploadOutcome> CompletionFuture() const;
+  std::future<UploadOutcome> CompletionFuture();
 
   /**
    * Requests cancellation of the in-flight upload. Returns immediately; the future
@@ -35,7 +37,7 @@ class AWS_S3_TRANSFER_API UploadHandle {
   void Cancel();
 
 private:
-  std::shared_ptr<UploadHandleImpl> m_impl;
+  std::unique_ptr<UploadHandleImpl> m_impl;
 };
 
 

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/UploadProgressListener.h

@@ -24,23 +24,23 @@ class AWS_S3_TRANSFER_API UploadProgressListener {
   /**
    * Invoked exactly once when the upload begins, before any bytes have been transferred.
    */
-  virtual void OnTransferInitiated(const UploadRequest&, const UploadProgressSnapshot&) {}
+  virtual void OnTransferInitiated(const UploadRequest& /*request*/, const UploadProgressSnapshot& /*snapshot*/) {}
 
   /**
    * Invoked as bytes are submitted to S3. Called at least once for a successful transfer
    * and may be called many times depending on object size and I/O buffer sizes.
    */
-  virtual void OnBytesTransferred(const UploadRequest&, const UploadProgressSnapshot&) {}
+  virtual void OnBytesTransferred(const UploadRequest& /*request*/, const UploadProgressSnapshot& /*snapshot*/) {}
 
   /**
    * Invoked exactly once when the upload completes successfully.
    */
-  virtual void OnTransferComplete(const UploadRequest&, const UploadProgressSnapshot&) {}
+  virtual void OnTransferComplete(const UploadRequest& /*request*/, const UploadProgressSnapshot& /*snapshot*/) {}
 
   /**
    * Invoked exactly once when the upload fails or is cancelled.
    */
-  virtual void OnTransferFailed(const UploadRequest&, const UploadProgressSnapshot&) {}
+  virtual void OnTransferFailed(const UploadRequest& /*request*/, const UploadProgressSnapshot& /*snapshot*/) {}
 };
 
 }

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/UploadProgressSnapshot.h

@@ -17,7 +17,7 @@ namespace Transfer {
  * Immutable snapshot of upload progress passed to UploadProgressListener callbacks. Captures
  * bytes transferred, total bytes (known up-front for uploads), and the response once available.
  */
-class AWS_S3_TRANSFER_API UploadProgressSnapshot {
+class AWS_S3_TRANSFER_API UploadProgressSnapshot final {
  public:
   UploadProgressSnapshot(uint64_t transferredBytes,
                          uint64_t totalBytes,

src/aws-cpp-sdk-s3-transfer/include/aws/s3-transfer/UploadRequest.h

@@ -21,72 +21,31 @@ namespace Transfer {
  * The transfer manager chooses between a single PutObject and a multipart upload based on
  * the configured threshold.
  */
-class AWS_S3_TRANSFER_API UploadRequest {
+class AWS_S3_TRANSFER_API UploadRequest final {
  public:
-  inline const Aws::S3::Model::PutObjectRequest& GetS3Request() const { return m_s3Request; }
-  inline bool S3RequestHasBeenSet() const { return m_s3RequestHasBeenSet; }
-  template <typename S3RequestT = Aws::S3::Model::PutObjectRequest>
-  void SetS3Request(S3RequestT&& val) {
-    m_s3RequestHasBeenSet = true;
-    m_s3Request = std::forward<S3RequestT>(val);
-  }
-  template <typename S3RequestT = Aws::S3::Model::PutObjectRequest>
-  UploadRequest& WithS3Request(S3RequestT&& value) {
-    SetS3Request(std::forward<S3RequestT>(value));
-    return *this;
-  }
-
-  inline const Aws::String& GetSourceFilePath() const { return m_sourceFilePath; }
-  inline bool SourceFilePathHasBeenSet() const { return m_sourceFilePathHasBeenSet; }
-  template <typename SourceFilePathT = Aws::String>
-  void SetSourceFilePath(SourceFilePathT&& value) {
-    m_sourceFilePathHasBeenSet = true;
-    m_sourceFilePath = std::forward<SourceFilePathT>(value);
-  }
-  template <typename SourceFilePathT = Aws::String>
-  UploadRequest& WithSourceFilePath(SourceFilePathT&& value) {
-    SetSourceFilePath(std::forward<SourceFilePathT>(value));
-    return *this;
-  }
-
-  inline const std::shared_ptr<Aws::IOStream>& GetBody() const { return m_body; }
-  inline bool BodyHasBeenSet() const { return m_bodyHasBeenSet; }
-  inline void SetBody(const std::shared_ptr<Aws::IOStream>& val) {
-    m_bodyHasBeenSet = true;
-    m_body = val;
-  }
-  inline UploadRequest& WithBody(const std::shared_ptr<Aws::IOStream>& val) {
-    SetBody(val);
-    return *this;
-  }
+  explicit UploadRequest(
+    Aws::S3::Model::PutObjectRequest s3Request,
+    Aws::String sourceFilePath,
+    std::shared_ptr<Aws::IOStream> body,
+    Aws::Vector<std::shared_ptr<UploadProgressListener>> transferListeners = {})
+  : m_s3Request(std::move(s3Request)),
+    m_sourceFilePath(std::move(sourceFilePath)),
+    m_body(std::move(body)),
+    m_transferListeners(std::move(transferListeners)) {}
 
+  inline const Aws::S3::Model::PutObjectRequest& GetS3Request() const {return m_s3Request; }
+  inline const Aws::String& GetSourceFilePath() const {return m_sourceFilePath;}
+  inline const std::shared_ptr<Aws::IOStream>& GetBody() const {return m_body;}
   inline const Aws::Vector<std::shared_ptr<UploadProgressListener>>& GetTransferListeners() const {
     return m_transferListeners;
   }
-  inline bool TransferListenersHasBeenSet() const { return m_transferListenersHasBeenSet; }
-  inline void SetTransferListeners(const Aws::Vector<std::shared_ptr<UploadProgressListener>>& val) {
-    m_transferListenersHasBeenSet = true;
-    m_transferListeners = val;
-  }
-  inline UploadRequest& WithTransferListeners(const Aws::Vector<std::shared_ptr<UploadProgressListener>>& val) {
-    SetTransferListeners(val);
-    return *this;
-  }
-  inline UploadRequest& AddTransferListener(const std::shared_ptr<UploadProgressListener>& listener) {
-    m_transferListenersHasBeenSet = true;
-    m_transferListeners.push_back(listener);
-    return *this;
-  }
+
 
  private:
   Aws::S3::Model::PutObjectRequest m_s3Request;
   Aws::String m_sourceFilePath;
   std::shared_ptr<Aws::IOStream> m_body;
   Aws::Vector<std::shared_ptr<UploadProgressListener>> m_transferListeners;
-  bool m_s3RequestHasBeenSet = false;
-  bool m_sourceFilePathHasBeenSet = false;
-  bool m_bodyHasBeenSet = false;
-  bool m_transferListenersHasBeenSet = false;
 };
 
 }