TransferState.h

 
#pragma once
 
#include <aws/s3-transfer/S3Transfer_EXPORTS.h>
#include <aws/s3-transfer/UploadRequest.h>
#include <aws/s3-transfer/UploadResponse.h>
#include <aws/s3-transfer/DownloadRequest.h>
#include <aws/s3-transfer/DownloadResponse.h>
#include <aws/core/Core_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/http/HttpTypes.h>
#include <aws/crt/Optional.h>
#include <atomic>
#include <cstdint>
#include <future>
#include <memory>
 
namespace Aws {
namespace S3 {
namespace Transfer {
 
// Per-transfer state shared by the CRT callbacks and the customer's handle. The promise is
// fulfilled exactly once, inside the finish callback. The meta request deliberately lives on the
// handle instead (see HandleImpls.h): with nothing here pointing back at it, the callbacks can hold
// this state by shared_ptr, and a transfer outlives a handle the customer dropped.
template <typename RequestT, typename OutcomeT>
struct AWS_CORE_LOCAL TransferStateBase {
  std::promise<OutcomeT> promise;
  RequestT request;
  Aws::Crt::Optional<uint64_t> totalBytes;
  std::atomic<uint64_t> transferredBytes{0};
  Aws::Http::HeaderValueCollection responseHeaders;
  int responseStatus = 0;
 
  explicit TransferStateBase(RequestT req) : request(std::move(req)) {}
  virtual ~TransferStateBase() = default;
 
  TransferStateBase(const TransferStateBase&) = delete;
  TransferStateBase& operator=(const TransferStateBase&) = delete;
  TransferStateBase(TransferStateBase&&) = delete;
  TransferStateBase& operator=(TransferStateBase&&) = delete;
};
 
struct AWS_CORE_LOCAL UploadTransferState final : TransferStateBase<UploadRequest, UploadOutcome> {
  using TransferStateBase::TransferStateBase;
};
 
struct AWS_CORE_LOCAL DownloadTransferState final : TransferStateBase<DownloadRequest, DownloadOutcome> {
  using TransferStateBase::TransferStateBase;
};
 
}  // namespace Transfer
}  // namespace S3
}  // namespace Aws