CreateBlueGreenDeploymentRequest.h

 
#pragma once
#include <aws/rds/RDS_EXPORTS.h>
#include <aws/rds/RDSRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.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;
    bool m_blueGreenDeploymentNameHasBeenSet = false;
 
    Aws::String m_source;
    bool m_sourceHasBeenSet = false;
 
    Aws::String m_targetEngineVersion;
    bool m_targetEngineVersionHasBeenSet = false;
 
    Aws::String m_targetDBParameterGroupName;
    bool m_targetDBParameterGroupNameHasBeenSet = false;
 
    Aws::String m_targetDBClusterParameterGroupName;
    bool m_targetDBClusterParameterGroupNameHasBeenSet = false;
 
    Aws::Vector<Tag> m_tags;
    bool m_tagsHasBeenSet = false;
 
    Aws::String m_targetDBInstanceClass;
    bool m_targetDBInstanceClassHasBeenSet = false;
 
    bool m_upgradeTargetStorageConfig{false};
    bool m_upgradeTargetStorageConfigHasBeenSet = false;
 
    int m_targetIops{0};
    bool m_targetIopsHasBeenSet = false;
 
    Aws::String m_targetStorageType;
    bool m_targetStorageTypeHasBeenSet = false;
 
    int m_targetAllocatedStorage{0};
    bool m_targetAllocatedStorageHasBeenSet = false;
 
    int m_targetStorageThroughput{0};
    bool m_targetStorageThroughputHasBeenSet = false;
  };
 
} // namespace Model
} // namespace RDS
} // namespace Aws