CancelExportTaskResult.h

 
#pragma once
#include <aws/rds/RDS_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/core/utils/DateTime.h>
#include <aws/rds/model/ExportSourceType.h>
#include <aws/rds/model/ResponseMetadata.h>
#include <utility>
 
namespace Aws
{
template<typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils
{
namespace Xml
{
  class XmlDocument;
} // namespace Xml
} // namespace Utils
namespace RDS
{
namespace Model
{
  class CancelExportTaskResult
  {
  public:
    AWS_RDS_API CancelExportTaskResult() = default;
    AWS_RDS_API CancelExportTaskResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
    AWS_RDS_API CancelExportTaskResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
 
 
 
    inline const Aws::String& GetExportTaskIdentifier() const { return m_exportTaskIdentifier; }
    template<typename ExportTaskIdentifierT = Aws::String>
    void SetExportTaskIdentifier(ExportTaskIdentifierT&& value) { m_exportTaskIdentifierHasBeenSet = true; m_exportTaskIdentifier = std::forward<ExportTaskIdentifierT>(value); }
    template<typename ExportTaskIdentifierT = Aws::String>
    CancelExportTaskResult& WithExportTaskIdentifier(ExportTaskIdentifierT&& value) { SetExportTaskIdentifier(std::forward<ExportTaskIdentifierT>(value)); return *this;}
 
 
    inline const Aws::String& GetSourceArn() const { return m_sourceArn; }
    template<typename SourceArnT = Aws::String>
    void SetSourceArn(SourceArnT&& value) { m_sourceArnHasBeenSet = true; m_sourceArn = std::forward<SourceArnT>(value); }
    template<typename SourceArnT = Aws::String>
    CancelExportTaskResult& WithSourceArn(SourceArnT&& value) { SetSourceArn(std::forward<SourceArnT>(value)); return *this;}
 
 
    inline const Aws::Vector<Aws::String>& GetExportOnly() const { return m_exportOnly; }
    template<typename ExportOnlyT = Aws::Vector<Aws::String>>
    void SetExportOnly(ExportOnlyT&& value) { m_exportOnlyHasBeenSet = true; m_exportOnly = std::forward<ExportOnlyT>(value); }
    template<typename ExportOnlyT = Aws::Vector<Aws::String>>
    CancelExportTaskResult& WithExportOnly(ExportOnlyT&& value) { SetExportOnly(std::forward<ExportOnlyT>(value)); return *this;}
    template<typename ExportOnlyT = Aws::String>
    CancelExportTaskResult& AddExportOnly(ExportOnlyT&& value) { m_exportOnlyHasBeenSet = true; m_exportOnly.emplace_back(std::forward<ExportOnlyT>(value)); return *this; }
 
 
    inline const Aws::Utils::DateTime& GetSnapshotTime() const { return m_snapshotTime; }
    template<typename SnapshotTimeT = Aws::Utils::DateTime>
    void SetSnapshotTime(SnapshotTimeT&& value) { m_snapshotTimeHasBeenSet = true; m_snapshotTime = std::forward<SnapshotTimeT>(value); }
    template<typename SnapshotTimeT = Aws::Utils::DateTime>
    CancelExportTaskResult& WithSnapshotTime(SnapshotTimeT&& value) { SetSnapshotTime(std::forward<SnapshotTimeT>(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetTaskStartTime() const { return m_taskStartTime; }
    template<typename TaskStartTimeT = Aws::Utils::DateTime>
    void SetTaskStartTime(TaskStartTimeT&& value) { m_taskStartTimeHasBeenSet = true; m_taskStartTime = std::forward<TaskStartTimeT>(value); }
    template<typename TaskStartTimeT = Aws::Utils::DateTime>
    CancelExportTaskResult& WithTaskStartTime(TaskStartTimeT&& value) { SetTaskStartTime(std::forward<TaskStartTimeT>(value)); return *this;}
 
 
    inline const Aws::Utils::DateTime& GetTaskEndTime() const { return m_taskEndTime; }
    template<typename TaskEndTimeT = Aws::Utils::DateTime>
    void SetTaskEndTime(TaskEndTimeT&& value) { m_taskEndTimeHasBeenSet = true; m_taskEndTime = std::forward<TaskEndTimeT>(value); }
    template<typename TaskEndTimeT = Aws::Utils::DateTime>
    CancelExportTaskResult& WithTaskEndTime(TaskEndTimeT&& value) { SetTaskEndTime(std::forward<TaskEndTimeT>(value)); return *this;}
 
 
    inline const Aws::String& GetS3Bucket() const { return m_s3Bucket; }
    template<typename S3BucketT = Aws::String>
    void SetS3Bucket(S3BucketT&& value) { m_s3BucketHasBeenSet = true; m_s3Bucket = std::forward<S3BucketT>(value); }
    template<typename S3BucketT = Aws::String>
    CancelExportTaskResult& WithS3Bucket(S3BucketT&& value) { SetS3Bucket(std::forward<S3BucketT>(value)); return *this;}
 
 
    inline const Aws::String& GetS3Prefix() const { return m_s3Prefix; }
    template<typename S3PrefixT = Aws::String>
    void SetS3Prefix(S3PrefixT&& value) { m_s3PrefixHasBeenSet = true; m_s3Prefix = std::forward<S3PrefixT>(value); }
    template<typename S3PrefixT = Aws::String>
    CancelExportTaskResult& WithS3Prefix(S3PrefixT&& value) { SetS3Prefix(std::forward<S3PrefixT>(value)); return *this;}
 
 
    inline const Aws::String& GetIamRoleArn() const { return m_iamRoleArn; }
    template<typename IamRoleArnT = Aws::String>
    void SetIamRoleArn(IamRoleArnT&& value) { m_iamRoleArnHasBeenSet = true; m_iamRoleArn = std::forward<IamRoleArnT>(value); }
    template<typename IamRoleArnT = Aws::String>
    CancelExportTaskResult& WithIamRoleArn(IamRoleArnT&& value) { SetIamRoleArn(std::forward<IamRoleArnT>(value)); return *this;}
 
 
    inline const Aws::String& GetKmsKeyId() const { return m_kmsKeyId; }
    template<typename KmsKeyIdT = Aws::String>
    void SetKmsKeyId(KmsKeyIdT&& value) { m_kmsKeyIdHasBeenSet = true; m_kmsKeyId = std::forward<KmsKeyIdT>(value); }
    template<typename KmsKeyIdT = Aws::String>
    CancelExportTaskResult& WithKmsKeyId(KmsKeyIdT&& value) { SetKmsKeyId(std::forward<KmsKeyIdT>(value)); return *this;}
 
 
    inline const Aws::String& GetStatus() const { return m_status; }
    template<typename StatusT = Aws::String>
    void SetStatus(StatusT&& value) { m_statusHasBeenSet = true; m_status = std::forward<StatusT>(value); }
    template<typename StatusT = Aws::String>
    CancelExportTaskResult& WithStatus(StatusT&& value) { SetStatus(std::forward<StatusT>(value)); return *this;}
 
 
    inline int GetPercentProgress() const { return m_percentProgress; }
    inline void SetPercentProgress(int value) { m_percentProgressHasBeenSet = true; m_percentProgress = value; }
    inline CancelExportTaskResult& WithPercentProgress(int value) { SetPercentProgress(value); return *this;}
 
 
    inline int GetTotalExtractedDataInGB() const { return m_totalExtractedDataInGB; }
    inline void SetTotalExtractedDataInGB(int value) { m_totalExtractedDataInGBHasBeenSet = true; m_totalExtractedDataInGB = value; }
    inline CancelExportTaskResult& WithTotalExtractedDataInGB(int value) { SetTotalExtractedDataInGB(value); return *this;}
 
 
    inline const Aws::String& GetFailureCause() const { return m_failureCause; }
    template<typename FailureCauseT = Aws::String>
    void SetFailureCause(FailureCauseT&& value) { m_failureCauseHasBeenSet = true; m_failureCause = std::forward<FailureCauseT>(value); }
    template<typename FailureCauseT = Aws::String>
    CancelExportTaskResult& WithFailureCause(FailureCauseT&& value) { SetFailureCause(std::forward<FailureCauseT>(value)); return *this;}
 
 
    inline const Aws::String& GetWarningMessage() const { return m_warningMessage; }
    template<typename WarningMessageT = Aws::String>
    void SetWarningMessage(WarningMessageT&& value) { m_warningMessageHasBeenSet = true; m_warningMessage = std::forward<WarningMessageT>(value); }
    template<typename WarningMessageT = Aws::String>
    CancelExportTaskResult& WithWarningMessage(WarningMessageT&& value) { SetWarningMessage(std::forward<WarningMessageT>(value)); return *this;}
 
 
    inline ExportSourceType GetSourceType() const { return m_sourceType; }
    inline void SetSourceType(ExportSourceType value) { m_sourceTypeHasBeenSet = true; m_sourceType = value; }
    inline CancelExportTaskResult& WithSourceType(ExportSourceType value) { SetSourceType(value); return *this;}
 
    
    inline const ResponseMetadata& GetResponseMetadata() const { return m_responseMetadata; }
    template<typename ResponseMetadataT = ResponseMetadata>
    void SetResponseMetadata(ResponseMetadataT&& value) { m_responseMetadataHasBeenSet = true; m_responseMetadata = std::forward<ResponseMetadataT>(value); }
    template<typename ResponseMetadataT = ResponseMetadata>
    CancelExportTaskResult& WithResponseMetadata(ResponseMetadataT&& value) { SetResponseMetadata(std::forward<ResponseMetadataT>(value)); return *this;}
  private:
 
    Aws::String m_exportTaskIdentifier;
    bool m_exportTaskIdentifierHasBeenSet = false;
 
    Aws::String m_sourceArn;
    bool m_sourceArnHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_exportOnly;
    bool m_exportOnlyHasBeenSet = false;
 
    Aws::Utils::DateTime m_snapshotTime{};
    bool m_snapshotTimeHasBeenSet = false;
 
    Aws::Utils::DateTime m_taskStartTime{};
    bool m_taskStartTimeHasBeenSet = false;
 
    Aws::Utils::DateTime m_taskEndTime{};
    bool m_taskEndTimeHasBeenSet = false;
 
    Aws::String m_s3Bucket;
    bool m_s3BucketHasBeenSet = false;
 
    Aws::String m_s3Prefix;
    bool m_s3PrefixHasBeenSet = false;
 
    Aws::String m_iamRoleArn;
    bool m_iamRoleArnHasBeenSet = false;
 
    Aws::String m_kmsKeyId;
    bool m_kmsKeyIdHasBeenSet = false;
 
    Aws::String m_status;
    bool m_statusHasBeenSet = false;
 
    int m_percentProgress{0};
    bool m_percentProgressHasBeenSet = false;
 
    int m_totalExtractedDataInGB{0};
    bool m_totalExtractedDataInGBHasBeenSet = false;
 
    Aws::String m_failureCause;
    bool m_failureCauseHasBeenSet = false;
 
    Aws::String m_warningMessage;
    bool m_warningMessageHasBeenSet = false;
 
    ExportSourceType m_sourceType{ExportSourceType::NOT_SET};
    bool m_sourceTypeHasBeenSet = false;
 
    ResponseMetadata m_responseMetadata;
    bool m_responseMetadataHasBeenSet = false;
  };
 
} // namespace Model
} // namespace RDS
} // namespace Aws