CreateBlueGreenDeploymentRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/rds/RDSRequest.h>
#include <aws/rds/RDS_EXPORTS.h>
#include <aws/rds/model/Tag.h>
 
#include <utility>
 
namespace Aws {
namespace RDS {
namespace Model {
 
class CreateBlueGreenDeploymentRequest : public RDSRequest {
 public:
  AWS_RDS_API CreateBlueGreenDeploymentRequest() = default;
 
  // Service request name is the Operation name which will send this request out,
  // each operation should has unique request name, so that we can get operation's name from this request.
  // Note: this is not true for response, multiple operations may have the same response name,
  // so we can not get operation's name from response.
  inline virtual const char* GetServiceRequestName() const override { return "CreateBlueGreenDeployment"; }
 
  AWS_RDS_API Aws::String SerializePayload() const override;
 
 protected:
  AWS_RDS_API void DumpBodyToUrl(Aws::Http::URI& uri) const override;
 
 public:
 
  inline const Aws::String& GetBlueGreenDeploymentName() const { return m_blueGreenDeploymentName; }
  inline bool BlueGreenDeploymentNameHasBeenSet() const { return m_blueGreenDeploymentNameHasBeenSet; }
  template <typename BlueGreenDeploymentNameT = Aws::String>
  void SetBlueGreenDeploymentName(BlueGreenDeploymentNameT&& value) {
    m_blueGreenDeploymentNameHasBeenSet = true;
    m_blueGreenDeploymentName = std::forward<BlueGreenDeploymentNameT>(value);
  }
  template <typename BlueGreenDeploymentNameT = Aws::String>
  CreateBlueGreenDeploymentRequest& WithBlueGreenDeploymentName(BlueGreenDeploymentNameT&& value) {
    SetBlueGreenDeploymentName(std::forward<BlueGreenDeploymentNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSource() const { return m_source; }
  inline bool SourceHasBeenSet() const { return m_sourceHasBeenSet; }
  template <typename SourceT = Aws::String>
  void SetSource(SourceT&& value) {
    m_sourceHasBeenSet = true;
    m_source = std::forward<SourceT>(value);
  }
  template <typename SourceT = Aws::String>
  CreateBlueGreenDeploymentRequest& WithSource(SourceT&& value) {
    SetSource(std::forward<SourceT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetEngineVersion() const { return m_targetEngineVersion; }
  inline bool TargetEngineVersionHasBeenSet() const { return m_targetEngineVersionHasBeenSet; }
  template <typename TargetEngineVersionT = Aws::String>
  void SetTargetEngineVersion(TargetEngineVersionT&& value) {
    m_targetEngineVersionHasBeenSet = true;
    m_targetEngineVersion = std::forward<TargetEngineVersionT>(value);
  }
  template <typename TargetEngineVersionT = Aws::String>
  CreateBlueGreenDeploymentRequest& WithTargetEngineVersion(TargetEngineVersionT&& value) {
    SetTargetEngineVersion(std::forward<TargetEngineVersionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetDBParameterGroupName() const { return m_targetDBParameterGroupName; }
  inline bool TargetDBParameterGroupNameHasBeenSet() const { return m_targetDBParameterGroupNameHasBeenSet; }
  template <typename TargetDBParameterGroupNameT = Aws::String>
  void SetTargetDBParameterGroupName(TargetDBParameterGroupNameT&& value) {
    m_targetDBParameterGroupNameHasBeenSet = true;
    m_targetDBParameterGroupName = std::forward<TargetDBParameterGroupNameT>(value);
  }
  template <typename TargetDBParameterGroupNameT = Aws::String>
  CreateBlueGreenDeploymentRequest& WithTargetDBParameterGroupName(TargetDBParameterGroupNameT&& value) {
    SetTargetDBParameterGroupName(std::forward<TargetDBParameterGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetDBClusterParameterGroupName() const { return m_targetDBClusterParameterGroupName; }
  inline bool TargetDBClusterParameterGroupNameHasBeenSet() const { return m_targetDBClusterParameterGroupNameHasBeenSet; }
  template <typename TargetDBClusterParameterGroupNameT = Aws::String>
  void SetTargetDBClusterParameterGroupName(TargetDBClusterParameterGroupNameT&& value) {
    m_targetDBClusterParameterGroupNameHasBeenSet = true;
    m_targetDBClusterParameterGroupName = std::forward<TargetDBClusterParameterGroupNameT>(value);
  }
  template <typename TargetDBClusterParameterGroupNameT = Aws::String>
  CreateBlueGreenDeploymentRequest& WithTargetDBClusterParameterGroupName(TargetDBClusterParameterGroupNameT&& value) {
    SetTargetDBClusterParameterGroupName(std::forward<TargetDBClusterParameterGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Tag>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Vector<Tag>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Vector<Tag>>
  CreateBlueGreenDeploymentRequest& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsT = Tag>
  CreateBlueGreenDeploymentRequest& AddTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace_back(std::forward<TagsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTargetDBInstanceClass() const { return m_targetDBInstanceClass; }
  inline bool TargetDBInstanceClassHasBeenSet() const { return m_targetDBInstanceClassHasBeenSet; }
  template <typename TargetDBInstanceClassT = Aws::String>
  void SetTargetDBInstanceClass(TargetDBInstanceClassT&& value) {
    m_targetDBInstanceClassHasBeenSet = true;
    m_targetDBInstanceClass = std::forward<TargetDBInstanceClassT>(value);
  }
  template <typename TargetDBInstanceClassT = Aws::String>
  CreateBlueGreenDeploymentRequest& WithTargetDBInstanceClass(TargetDBInstanceClassT&& value) {
    SetTargetDBInstanceClass(std::forward<TargetDBInstanceClassT>(value));
    return *this;
  }
 
 
  inline bool GetUpgradeTargetStorageConfig() const { return m_upgradeTargetStorageConfig; }
  inline bool UpgradeTargetStorageConfigHasBeenSet() const { return m_upgradeTargetStorageConfigHasBeenSet; }
  inline void SetUpgradeTargetStorageConfig(bool value) {
    m_upgradeTargetStorageConfigHasBeenSet = true;
    m_upgradeTargetStorageConfig = value;
  }
  inline CreateBlueGreenDeploymentRequest& WithUpgradeTargetStorageConfig(bool value) {
    SetUpgradeTargetStorageConfig(value);
    return *this;
  }
 
 
  inline int GetTargetIops() const { return m_targetIops; }
  inline bool TargetIopsHasBeenSet() const { return m_targetIopsHasBeenSet; }
  inline void SetTargetIops(int value) {
    m_targetIopsHasBeenSet = true;
    m_targetIops = value;
  }
  inline CreateBlueGreenDeploymentRequest& WithTargetIops(int value) {
    SetTargetIops(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTargetStorageType() const { return m_targetStorageType; }
  inline bool TargetStorageTypeHasBeenSet() const { return m_targetStorageTypeHasBeenSet; }
  template <typename TargetStorageTypeT = Aws::String>
  void SetTargetStorageType(TargetStorageTypeT&& value) {
    m_targetStorageTypeHasBeenSet = true;
    m_targetStorageType = std::forward<TargetStorageTypeT>(value);
  }
  template <typename TargetStorageTypeT = Aws::String>
  CreateBlueGreenDeploymentRequest& WithTargetStorageType(TargetStorageTypeT&& value) {
    SetTargetStorageType(std::forward<TargetStorageTypeT>(value));
    return *this;
  }
 
 
  inline int GetTargetAllocatedStorage() const { return m_targetAllocatedStorage; }
  inline bool TargetAllocatedStorageHasBeenSet() const { return m_targetAllocatedStorageHasBeenSet; }
  inline void SetTargetAllocatedStorage(int value) {
    m_targetAllocatedStorageHasBeenSet = true;
    m_targetAllocatedStorage = value;
  }
  inline CreateBlueGreenDeploymentRequest& WithTargetAllocatedStorage(int value) {
    SetTargetAllocatedStorage(value);
    return *this;
  }
 
 
  inline int GetTargetStorageThroughput() const { return m_targetStorageThroughput; }
  inline bool TargetStorageThroughputHasBeenSet() const { return m_targetStorageThroughputHasBeenSet; }
  inline void SetTargetStorageThroughput(int value) {
    m_targetStorageThroughputHasBeenSet = true;
    m_targetStorageThroughput = value;
  }
  inline CreateBlueGreenDeploymentRequest& WithTargetStorageThroughput(int value) {
    SetTargetStorageThroughput(value);
    return *this;
  }
 private:
  Aws::String m_blueGreenDeploymentName;
 
  Aws::String m_source;
 
  Aws::String m_targetEngineVersion;
 
  Aws::String m_targetDBParameterGroupName;
 
  Aws::String m_targetDBClusterParameterGroupName;
 
  Aws::Vector<Tag> m_tags;
 
  Aws::String m_targetDBInstanceClass;
 
  bool m_upgradeTargetStorageConfig{false};
 
  int m_targetIops{0};
 
  Aws::String m_targetStorageType;
 
  int m_targetAllocatedStorage{0};
 
  int m_targetStorageThroughput{0};
  bool m_blueGreenDeploymentNameHasBeenSet = false;
  bool m_sourceHasBeenSet = false;
  bool m_targetEngineVersionHasBeenSet = false;
  bool m_targetDBParameterGroupNameHasBeenSet = false;
  bool m_targetDBClusterParameterGroupNameHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_targetDBInstanceClassHasBeenSet = false;
  bool m_upgradeTargetStorageConfigHasBeenSet = false;
  bool m_targetIopsHasBeenSet = false;
  bool m_targetStorageTypeHasBeenSet = false;
  bool m_targetAllocatedStorageHasBeenSet = false;
  bool m_targetStorageThroughputHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace RDS
}  // namespace Aws