CancelResizeResult.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/redshift/Redshift_EXPORTS.h>
#include <aws/redshift/model/ResponseMetadata.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Xml {
class XmlDocument;
}  // namespace Xml
}  // namespace Utils
namespace Redshift {
namespace Model {
class CancelResizeResult {
 public:
  AWS_REDSHIFT_API CancelResizeResult() = default;
  AWS_REDSHIFT_API CancelResizeResult(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
  AWS_REDSHIFT_API CancelResizeResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
 
 
  inline const Aws::String& GetTargetNodeType() const { return m_targetNodeType; }
  template <typename TargetNodeTypeT = Aws::String>
  void SetTargetNodeType(TargetNodeTypeT&& value) {
    m_targetNodeTypeHasBeenSet = true;
    m_targetNodeType = std::forward<TargetNodeTypeT>(value);
  }
  template <typename TargetNodeTypeT = Aws::String>
  CancelResizeResult& WithTargetNodeType(TargetNodeTypeT&& value) {
    SetTargetNodeType(std::forward<TargetNodeTypeT>(value));
    return *this;
  }
 
 
  inline int GetTargetNumberOfNodes() const { return m_targetNumberOfNodes; }
  inline void SetTargetNumberOfNodes(int value) {
    m_targetNumberOfNodesHasBeenSet = true;
    m_targetNumberOfNodes = value;
  }
  inline CancelResizeResult& WithTargetNumberOfNodes(int value) {
    SetTargetNumberOfNodes(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTargetClusterType() const { return m_targetClusterType; }
  template <typename TargetClusterTypeT = Aws::String>
  void SetTargetClusterType(TargetClusterTypeT&& value) {
    m_targetClusterTypeHasBeenSet = true;
    m_targetClusterType = std::forward<TargetClusterTypeT>(value);
  }
  template <typename TargetClusterTypeT = Aws::String>
  CancelResizeResult& WithTargetClusterType(TargetClusterTypeT&& value) {
    SetTargetClusterType(std::forward<TargetClusterTypeT>(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>
  CancelResizeResult& WithStatus(StatusT&& value) {
    SetStatus(std::forward<StatusT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetImportTablesCompleted() const { return m_importTablesCompleted; }
  template <typename ImportTablesCompletedT = Aws::Vector<Aws::String>>
  void SetImportTablesCompleted(ImportTablesCompletedT&& value) {
    m_importTablesCompletedHasBeenSet = true;
    m_importTablesCompleted = std::forward<ImportTablesCompletedT>(value);
  }
  template <typename ImportTablesCompletedT = Aws::Vector<Aws::String>>
  CancelResizeResult& WithImportTablesCompleted(ImportTablesCompletedT&& value) {
    SetImportTablesCompleted(std::forward<ImportTablesCompletedT>(value));
    return *this;
  }
  template <typename ImportTablesCompletedT = Aws::String>
  CancelResizeResult& AddImportTablesCompleted(ImportTablesCompletedT&& value) {
    m_importTablesCompletedHasBeenSet = true;
    m_importTablesCompleted.emplace_back(std::forward<ImportTablesCompletedT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetImportTablesInProgress() const { return m_importTablesInProgress; }
  template <typename ImportTablesInProgressT = Aws::Vector<Aws::String>>
  void SetImportTablesInProgress(ImportTablesInProgressT&& value) {
    m_importTablesInProgressHasBeenSet = true;
    m_importTablesInProgress = std::forward<ImportTablesInProgressT>(value);
  }
  template <typename ImportTablesInProgressT = Aws::Vector<Aws::String>>
  CancelResizeResult& WithImportTablesInProgress(ImportTablesInProgressT&& value) {
    SetImportTablesInProgress(std::forward<ImportTablesInProgressT>(value));
    return *this;
  }
  template <typename ImportTablesInProgressT = Aws::String>
  CancelResizeResult& AddImportTablesInProgress(ImportTablesInProgressT&& value) {
    m_importTablesInProgressHasBeenSet = true;
    m_importTablesInProgress.emplace_back(std::forward<ImportTablesInProgressT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetImportTablesNotStarted() const { return m_importTablesNotStarted; }
  template <typename ImportTablesNotStartedT = Aws::Vector<Aws::String>>
  void SetImportTablesNotStarted(ImportTablesNotStartedT&& value) {
    m_importTablesNotStartedHasBeenSet = true;
    m_importTablesNotStarted = std::forward<ImportTablesNotStartedT>(value);
  }
  template <typename ImportTablesNotStartedT = Aws::Vector<Aws::String>>
  CancelResizeResult& WithImportTablesNotStarted(ImportTablesNotStartedT&& value) {
    SetImportTablesNotStarted(std::forward<ImportTablesNotStartedT>(value));
    return *this;
  }
  template <typename ImportTablesNotStartedT = Aws::String>
  CancelResizeResult& AddImportTablesNotStarted(ImportTablesNotStartedT&& value) {
    m_importTablesNotStartedHasBeenSet = true;
    m_importTablesNotStarted.emplace_back(std::forward<ImportTablesNotStartedT>(value));
    return *this;
  }
 
 
  inline double GetAvgResizeRateInMegaBytesPerSecond() const { return m_avgResizeRateInMegaBytesPerSecond; }
  inline void SetAvgResizeRateInMegaBytesPerSecond(double value) {
    m_avgResizeRateInMegaBytesPerSecondHasBeenSet = true;
    m_avgResizeRateInMegaBytesPerSecond = value;
  }
  inline CancelResizeResult& WithAvgResizeRateInMegaBytesPerSecond(double value) {
    SetAvgResizeRateInMegaBytesPerSecond(value);
    return *this;
  }
 
 
  inline long long GetTotalResizeDataInMegaBytes() const { return m_totalResizeDataInMegaBytes; }
  inline void SetTotalResizeDataInMegaBytes(long long value) {
    m_totalResizeDataInMegaBytesHasBeenSet = true;
    m_totalResizeDataInMegaBytes = value;
  }
  inline CancelResizeResult& WithTotalResizeDataInMegaBytes(long long value) {
    SetTotalResizeDataInMegaBytes(value);
    return *this;
  }
 
 
  inline long long GetProgressInMegaBytes() const { return m_progressInMegaBytes; }
  inline void SetProgressInMegaBytes(long long value) {
    m_progressInMegaBytesHasBeenSet = true;
    m_progressInMegaBytes = value;
  }
  inline CancelResizeResult& WithProgressInMegaBytes(long long value) {
    SetProgressInMegaBytes(value);
    return *this;
  }
 
 
  inline long long GetElapsedTimeInSeconds() const { return m_elapsedTimeInSeconds; }
  inline void SetElapsedTimeInSeconds(long long value) {
    m_elapsedTimeInSecondsHasBeenSet = true;
    m_elapsedTimeInSeconds = value;
  }
  inline CancelResizeResult& WithElapsedTimeInSeconds(long long value) {
    SetElapsedTimeInSeconds(value);
    return *this;
  }
 
 
  inline long long GetEstimatedTimeToCompletionInSeconds() const { return m_estimatedTimeToCompletionInSeconds; }
  inline void SetEstimatedTimeToCompletionInSeconds(long long value) {
    m_estimatedTimeToCompletionInSecondsHasBeenSet = true;
    m_estimatedTimeToCompletionInSeconds = value;
  }
  inline CancelResizeResult& WithEstimatedTimeToCompletionInSeconds(long long value) {
    SetEstimatedTimeToCompletionInSeconds(value);
    return *this;
  }
 
 
  inline const Aws::String& GetResizeType() const { return m_resizeType; }
  template <typename ResizeTypeT = Aws::String>
  void SetResizeType(ResizeTypeT&& value) {
    m_resizeTypeHasBeenSet = true;
    m_resizeType = std::forward<ResizeTypeT>(value);
  }
  template <typename ResizeTypeT = Aws::String>
  CancelResizeResult& WithResizeType(ResizeTypeT&& value) {
    SetResizeType(std::forward<ResizeTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMessage() const { return m_message; }
  template <typename MessageT = Aws::String>
  void SetMessage(MessageT&& value) {
    m_messageHasBeenSet = true;
    m_message = std::forward<MessageT>(value);
  }
  template <typename MessageT = Aws::String>
  CancelResizeResult& WithMessage(MessageT&& value) {
    SetMessage(std::forward<MessageT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetEncryptionType() const { return m_targetEncryptionType; }
  template <typename TargetEncryptionTypeT = Aws::String>
  void SetTargetEncryptionType(TargetEncryptionTypeT&& value) {
    m_targetEncryptionTypeHasBeenSet = true;
    m_targetEncryptionType = std::forward<TargetEncryptionTypeT>(value);
  }
  template <typename TargetEncryptionTypeT = Aws::String>
  CancelResizeResult& WithTargetEncryptionType(TargetEncryptionTypeT&& value) {
    SetTargetEncryptionType(std::forward<TargetEncryptionTypeT>(value));
    return *this;
  }
 
 
  inline double GetDataTransferProgressPercent() const { return m_dataTransferProgressPercent; }
  inline void SetDataTransferProgressPercent(double value) {
    m_dataTransferProgressPercentHasBeenSet = true;
    m_dataTransferProgressPercent = value;
  }
  inline CancelResizeResult& WithDataTransferProgressPercent(double value) {
    SetDataTransferProgressPercent(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>
  CancelResizeResult& WithResponseMetadata(ResponseMetadataT&& value) {
    SetResponseMetadata(std::forward<ResponseMetadataT>(value));
    return *this;
  }
 private:
  Aws::String m_targetNodeType;
 
  int m_targetNumberOfNodes{0};
 
  Aws::String m_targetClusterType;
 
  Aws::String m_status;
 
  Aws::Vector<Aws::String> m_importTablesCompleted;
 
  Aws::Vector<Aws::String> m_importTablesInProgress;
 
  Aws::Vector<Aws::String> m_importTablesNotStarted;
 
  double m_avgResizeRateInMegaBytesPerSecond{0.0};
 
  long long m_totalResizeDataInMegaBytes{0};
 
  long long m_progressInMegaBytes{0};
 
  long long m_elapsedTimeInSeconds{0};
 
  long long m_estimatedTimeToCompletionInSeconds{0};
 
  Aws::String m_resizeType;
 
  Aws::String m_message;
 
  Aws::String m_targetEncryptionType;
 
  double m_dataTransferProgressPercent{0.0};
 
  ResponseMetadata m_responseMetadata;
  bool m_targetNodeTypeHasBeenSet = false;
  bool m_targetNumberOfNodesHasBeenSet = false;
  bool m_targetClusterTypeHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_importTablesCompletedHasBeenSet = false;
  bool m_importTablesInProgressHasBeenSet = false;
  bool m_importTablesNotStartedHasBeenSet = false;
  bool m_avgResizeRateInMegaBytesPerSecondHasBeenSet = false;
  bool m_totalResizeDataInMegaBytesHasBeenSet = false;
  bool m_progressInMegaBytesHasBeenSet = false;
  bool m_elapsedTimeInSecondsHasBeenSet = false;
  bool m_estimatedTimeToCompletionInSecondsHasBeenSet = false;
  bool m_resizeTypeHasBeenSet = false;
  bool m_messageHasBeenSet = false;
  bool m_targetEncryptionTypeHasBeenSet = false;
  bool m_dataTransferProgressPercentHasBeenSet = false;
  bool m_responseMetadataHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Redshift
}  // namespace Aws