CancelResizeResult.h

 
#pragma once
#include <aws/redshift/Redshift_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.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;
    bool m_targetNodeTypeHasBeenSet = false;
 
    int m_targetNumberOfNodes{0};
    bool m_targetNumberOfNodesHasBeenSet = false;
 
    Aws::String m_targetClusterType;
    bool m_targetClusterTypeHasBeenSet = false;
 
    Aws::String m_status;
    bool m_statusHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_importTablesCompleted;
    bool m_importTablesCompletedHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_importTablesInProgress;
    bool m_importTablesInProgressHasBeenSet = false;
 
    Aws::Vector<Aws::String> m_importTablesNotStarted;
    bool m_importTablesNotStartedHasBeenSet = false;
 
    double m_avgResizeRateInMegaBytesPerSecond{0.0};
    bool m_avgResizeRateInMegaBytesPerSecondHasBeenSet = false;
 
    long long m_totalResizeDataInMegaBytes{0};
    bool m_totalResizeDataInMegaBytesHasBeenSet = false;
 
    long long m_progressInMegaBytes{0};
    bool m_progressInMegaBytesHasBeenSet = false;
 
    long long m_elapsedTimeInSeconds{0};
    bool m_elapsedTimeInSecondsHasBeenSet = false;
 
    long long m_estimatedTimeToCompletionInSeconds{0};
    bool m_estimatedTimeToCompletionInSecondsHasBeenSet = false;
 
    Aws::String m_resizeType;
    bool m_resizeTypeHasBeenSet = false;
 
    Aws::String m_message;
    bool m_messageHasBeenSet = false;
 
    Aws::String m_targetEncryptionType;
    bool m_targetEncryptionTypeHasBeenSet = false;
 
    double m_dataTransferProgressPercent{0.0};
    bool m_dataTransferProgressPercentHasBeenSet = false;
 
    ResponseMetadata m_responseMetadata;
    bool m_responseMetadataHasBeenSet = false;
  };
 
} // namespace Model
} // namespace Redshift
} // namespace Aws