ModifyCacheClusterRequest.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/elasticache/ElastiCacheRequest.h>
#include <aws/elasticache/ElastiCache_EXPORTS.h>
#include <aws/elasticache/model/AZMode.h>
#include <aws/elasticache/model/AuthTokenUpdateStrategyType.h>
#include <aws/elasticache/model/IpDiscovery.h>
#include <aws/elasticache/model/LogDeliveryConfigurationRequest.h>
#include <aws/elasticache/model/ScaleConfig.h>
 
#include <utility>
 
namespace Aws {
namespace ElastiCache {
namespace Model {
 
class ModifyCacheClusterRequest : public ElastiCacheRequest {
 public:
  AWS_ELASTICACHE_API ModifyCacheClusterRequest() = 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 "ModifyCacheCluster"; }
 
  AWS_ELASTICACHE_API Aws::String SerializePayload() const override;
 
 protected:
  AWS_ELASTICACHE_API void DumpBodyToUrl(Aws::Http::URI& uri) const override;
 
 public:
 
  inline const Aws::String& GetCacheClusterId() const { return m_cacheClusterId; }
  inline bool CacheClusterIdHasBeenSet() const { return m_cacheClusterIdHasBeenSet; }
  template <typename CacheClusterIdT = Aws::String>
  void SetCacheClusterId(CacheClusterIdT&& value) {
    m_cacheClusterIdHasBeenSet = true;
    m_cacheClusterId = std::forward<CacheClusterIdT>(value);
  }
  template <typename CacheClusterIdT = Aws::String>
  ModifyCacheClusterRequest& WithCacheClusterId(CacheClusterIdT&& value) {
    SetCacheClusterId(std::forward<CacheClusterIdT>(value));
    return *this;
  }
 
 
  inline int GetNumCacheNodes() const { return m_numCacheNodes; }
  inline bool NumCacheNodesHasBeenSet() const { return m_numCacheNodesHasBeenSet; }
  inline void SetNumCacheNodes(int value) {
    m_numCacheNodesHasBeenSet = true;
    m_numCacheNodes = value;
  }
  inline ModifyCacheClusterRequest& WithNumCacheNodes(int value) {
    SetNumCacheNodes(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetCacheNodeIdsToRemove() const { return m_cacheNodeIdsToRemove; }
  inline bool CacheNodeIdsToRemoveHasBeenSet() const { return m_cacheNodeIdsToRemoveHasBeenSet; }
  template <typename CacheNodeIdsToRemoveT = Aws::Vector<Aws::String>>
  void SetCacheNodeIdsToRemove(CacheNodeIdsToRemoveT&& value) {
    m_cacheNodeIdsToRemoveHasBeenSet = true;
    m_cacheNodeIdsToRemove = std::forward<CacheNodeIdsToRemoveT>(value);
  }
  template <typename CacheNodeIdsToRemoveT = Aws::Vector<Aws::String>>
  ModifyCacheClusterRequest& WithCacheNodeIdsToRemove(CacheNodeIdsToRemoveT&& value) {
    SetCacheNodeIdsToRemove(std::forward<CacheNodeIdsToRemoveT>(value));
    return *this;
  }
  template <typename CacheNodeIdsToRemoveT = Aws::String>
  ModifyCacheClusterRequest& AddCacheNodeIdsToRemove(CacheNodeIdsToRemoveT&& value) {
    m_cacheNodeIdsToRemoveHasBeenSet = true;
    m_cacheNodeIdsToRemove.emplace_back(std::forward<CacheNodeIdsToRemoveT>(value));
    return *this;
  }
 
 
  inline AZMode GetAZMode() const { return m_aZMode; }
  inline bool AZModeHasBeenSet() const { return m_aZModeHasBeenSet; }
  inline void SetAZMode(AZMode value) {
    m_aZModeHasBeenSet = true;
    m_aZMode = value;
  }
  inline ModifyCacheClusterRequest& WithAZMode(AZMode value) {
    SetAZMode(value);
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetNewAvailabilityZones() const { return m_newAvailabilityZones; }
  inline bool NewAvailabilityZonesHasBeenSet() const { return m_newAvailabilityZonesHasBeenSet; }
  template <typename NewAvailabilityZonesT = Aws::Vector<Aws::String>>
  void SetNewAvailabilityZones(NewAvailabilityZonesT&& value) {
    m_newAvailabilityZonesHasBeenSet = true;
    m_newAvailabilityZones = std::forward<NewAvailabilityZonesT>(value);
  }
  template <typename NewAvailabilityZonesT = Aws::Vector<Aws::String>>
  ModifyCacheClusterRequest& WithNewAvailabilityZones(NewAvailabilityZonesT&& value) {
    SetNewAvailabilityZones(std::forward<NewAvailabilityZonesT>(value));
    return *this;
  }
  template <typename NewAvailabilityZonesT = Aws::String>
  ModifyCacheClusterRequest& AddNewAvailabilityZones(NewAvailabilityZonesT&& value) {
    m_newAvailabilityZonesHasBeenSet = true;
    m_newAvailabilityZones.emplace_back(std::forward<NewAvailabilityZonesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetCacheSecurityGroupNames() const { return m_cacheSecurityGroupNames; }
  inline bool CacheSecurityGroupNamesHasBeenSet() const { return m_cacheSecurityGroupNamesHasBeenSet; }
  template <typename CacheSecurityGroupNamesT = Aws::Vector<Aws::String>>
  void SetCacheSecurityGroupNames(CacheSecurityGroupNamesT&& value) {
    m_cacheSecurityGroupNamesHasBeenSet = true;
    m_cacheSecurityGroupNames = std::forward<CacheSecurityGroupNamesT>(value);
  }
  template <typename CacheSecurityGroupNamesT = Aws::Vector<Aws::String>>
  ModifyCacheClusterRequest& WithCacheSecurityGroupNames(CacheSecurityGroupNamesT&& value) {
    SetCacheSecurityGroupNames(std::forward<CacheSecurityGroupNamesT>(value));
    return *this;
  }
  template <typename CacheSecurityGroupNamesT = Aws::String>
  ModifyCacheClusterRequest& AddCacheSecurityGroupNames(CacheSecurityGroupNamesT&& value) {
    m_cacheSecurityGroupNamesHasBeenSet = true;
    m_cacheSecurityGroupNames.emplace_back(std::forward<CacheSecurityGroupNamesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSecurityGroupIds() const { return m_securityGroupIds; }
  inline bool SecurityGroupIdsHasBeenSet() const { return m_securityGroupIdsHasBeenSet; }
  template <typename SecurityGroupIdsT = Aws::Vector<Aws::String>>
  void SetSecurityGroupIds(SecurityGroupIdsT&& value) {
    m_securityGroupIdsHasBeenSet = true;
    m_securityGroupIds = std::forward<SecurityGroupIdsT>(value);
  }
  template <typename SecurityGroupIdsT = Aws::Vector<Aws::String>>
  ModifyCacheClusterRequest& WithSecurityGroupIds(SecurityGroupIdsT&& value) {
    SetSecurityGroupIds(std::forward<SecurityGroupIdsT>(value));
    return *this;
  }
  template <typename SecurityGroupIdsT = Aws::String>
  ModifyCacheClusterRequest& AddSecurityGroupIds(SecurityGroupIdsT&& value) {
    m_securityGroupIdsHasBeenSet = true;
    m_securityGroupIds.emplace_back(std::forward<SecurityGroupIdsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPreferredMaintenanceWindow() const { return m_preferredMaintenanceWindow; }
  inline bool PreferredMaintenanceWindowHasBeenSet() const { return m_preferredMaintenanceWindowHasBeenSet; }
  template <typename PreferredMaintenanceWindowT = Aws::String>
  void SetPreferredMaintenanceWindow(PreferredMaintenanceWindowT&& value) {
    m_preferredMaintenanceWindowHasBeenSet = true;
    m_preferredMaintenanceWindow = std::forward<PreferredMaintenanceWindowT>(value);
  }
  template <typename PreferredMaintenanceWindowT = Aws::String>
  ModifyCacheClusterRequest& WithPreferredMaintenanceWindow(PreferredMaintenanceWindowT&& value) {
    SetPreferredMaintenanceWindow(std::forward<PreferredMaintenanceWindowT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNotificationTopicArn() const { return m_notificationTopicArn; }
  inline bool NotificationTopicArnHasBeenSet() const { return m_notificationTopicArnHasBeenSet; }
  template <typename NotificationTopicArnT = Aws::String>
  void SetNotificationTopicArn(NotificationTopicArnT&& value) {
    m_notificationTopicArnHasBeenSet = true;
    m_notificationTopicArn = std::forward<NotificationTopicArnT>(value);
  }
  template <typename NotificationTopicArnT = Aws::String>
  ModifyCacheClusterRequest& WithNotificationTopicArn(NotificationTopicArnT&& value) {
    SetNotificationTopicArn(std::forward<NotificationTopicArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCacheParameterGroupName() const { return m_cacheParameterGroupName; }
  inline bool CacheParameterGroupNameHasBeenSet() const { return m_cacheParameterGroupNameHasBeenSet; }
  template <typename CacheParameterGroupNameT = Aws::String>
  void SetCacheParameterGroupName(CacheParameterGroupNameT&& value) {
    m_cacheParameterGroupNameHasBeenSet = true;
    m_cacheParameterGroupName = std::forward<CacheParameterGroupNameT>(value);
  }
  template <typename CacheParameterGroupNameT = Aws::String>
  ModifyCacheClusterRequest& WithCacheParameterGroupName(CacheParameterGroupNameT&& value) {
    SetCacheParameterGroupName(std::forward<CacheParameterGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNotificationTopicStatus() const { return m_notificationTopicStatus; }
  inline bool NotificationTopicStatusHasBeenSet() const { return m_notificationTopicStatusHasBeenSet; }
  template <typename NotificationTopicStatusT = Aws::String>
  void SetNotificationTopicStatus(NotificationTopicStatusT&& value) {
    m_notificationTopicStatusHasBeenSet = true;
    m_notificationTopicStatus = std::forward<NotificationTopicStatusT>(value);
  }
  template <typename NotificationTopicStatusT = Aws::String>
  ModifyCacheClusterRequest& WithNotificationTopicStatus(NotificationTopicStatusT&& value) {
    SetNotificationTopicStatus(std::forward<NotificationTopicStatusT>(value));
    return *this;
  }
 
 
  inline bool GetApplyImmediately() const { return m_applyImmediately; }
  inline bool ApplyImmediatelyHasBeenSet() const { return m_applyImmediatelyHasBeenSet; }
  inline void SetApplyImmediately(bool value) {
    m_applyImmediatelyHasBeenSet = true;
    m_applyImmediately = value;
  }
  inline ModifyCacheClusterRequest& WithApplyImmediately(bool value) {
    SetApplyImmediately(value);
    return *this;
  }
 
 
  inline const Aws::String& GetEngine() const { return m_engine; }
  inline bool EngineHasBeenSet() const { return m_engineHasBeenSet; }
  template <typename EngineT = Aws::String>
  void SetEngine(EngineT&& value) {
    m_engineHasBeenSet = true;
    m_engine = std::forward<EngineT>(value);
  }
  template <typename EngineT = Aws::String>
  ModifyCacheClusterRequest& WithEngine(EngineT&& value) {
    SetEngine(std::forward<EngineT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEngineVersion() const { return m_engineVersion; }
  inline bool EngineVersionHasBeenSet() const { return m_engineVersionHasBeenSet; }
  template <typename EngineVersionT = Aws::String>
  void SetEngineVersion(EngineVersionT&& value) {
    m_engineVersionHasBeenSet = true;
    m_engineVersion = std::forward<EngineVersionT>(value);
  }
  template <typename EngineVersionT = Aws::String>
  ModifyCacheClusterRequest& WithEngineVersion(EngineVersionT&& value) {
    SetEngineVersion(std::forward<EngineVersionT>(value));
    return *this;
  }
 
 
  inline bool GetAutoMinorVersionUpgrade() const { return m_autoMinorVersionUpgrade; }
  inline bool AutoMinorVersionUpgradeHasBeenSet() const { return m_autoMinorVersionUpgradeHasBeenSet; }
  inline void SetAutoMinorVersionUpgrade(bool value) {
    m_autoMinorVersionUpgradeHasBeenSet = true;
    m_autoMinorVersionUpgrade = value;
  }
  inline ModifyCacheClusterRequest& WithAutoMinorVersionUpgrade(bool value) {
    SetAutoMinorVersionUpgrade(value);
    return *this;
  }
 
 
  inline int GetSnapshotRetentionLimit() const { return m_snapshotRetentionLimit; }
  inline bool SnapshotRetentionLimitHasBeenSet() const { return m_snapshotRetentionLimitHasBeenSet; }
  inline void SetSnapshotRetentionLimit(int value) {
    m_snapshotRetentionLimitHasBeenSet = true;
    m_snapshotRetentionLimit = value;
  }
  inline ModifyCacheClusterRequest& WithSnapshotRetentionLimit(int value) {
    SetSnapshotRetentionLimit(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSnapshotWindow() const { return m_snapshotWindow; }
  inline bool SnapshotWindowHasBeenSet() const { return m_snapshotWindowHasBeenSet; }
  template <typename SnapshotWindowT = Aws::String>
  void SetSnapshotWindow(SnapshotWindowT&& value) {
    m_snapshotWindowHasBeenSet = true;
    m_snapshotWindow = std::forward<SnapshotWindowT>(value);
  }
  template <typename SnapshotWindowT = Aws::String>
  ModifyCacheClusterRequest& WithSnapshotWindow(SnapshotWindowT&& value) {
    SetSnapshotWindow(std::forward<SnapshotWindowT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCacheNodeType() const { return m_cacheNodeType; }
  inline bool CacheNodeTypeHasBeenSet() const { return m_cacheNodeTypeHasBeenSet; }
  template <typename CacheNodeTypeT = Aws::String>
  void SetCacheNodeType(CacheNodeTypeT&& value) {
    m_cacheNodeTypeHasBeenSet = true;
    m_cacheNodeType = std::forward<CacheNodeTypeT>(value);
  }
  template <typename CacheNodeTypeT = Aws::String>
  ModifyCacheClusterRequest& WithCacheNodeType(CacheNodeTypeT&& value) {
    SetCacheNodeType(std::forward<CacheNodeTypeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAuthToken() const { return m_authToken; }
  inline bool AuthTokenHasBeenSet() const { return m_authTokenHasBeenSet; }
  template <typename AuthTokenT = Aws::String>
  void SetAuthToken(AuthTokenT&& value) {
    m_authTokenHasBeenSet = true;
    m_authToken = std::forward<AuthTokenT>(value);
  }
  template <typename AuthTokenT = Aws::String>
  ModifyCacheClusterRequest& WithAuthToken(AuthTokenT&& value) {
    SetAuthToken(std::forward<AuthTokenT>(value));
    return *this;
  }
 
 
  inline AuthTokenUpdateStrategyType GetAuthTokenUpdateStrategy() const { return m_authTokenUpdateStrategy; }
  inline bool AuthTokenUpdateStrategyHasBeenSet() const { return m_authTokenUpdateStrategyHasBeenSet; }
  inline void SetAuthTokenUpdateStrategy(AuthTokenUpdateStrategyType value) {
    m_authTokenUpdateStrategyHasBeenSet = true;
    m_authTokenUpdateStrategy = value;
  }
  inline ModifyCacheClusterRequest& WithAuthTokenUpdateStrategy(AuthTokenUpdateStrategyType value) {
    SetAuthTokenUpdateStrategy(value);
    return *this;
  }
 
 
  inline const Aws::Vector<LogDeliveryConfigurationRequest>& GetLogDeliveryConfigurations() const { return m_logDeliveryConfigurations; }
  inline bool LogDeliveryConfigurationsHasBeenSet() const { return m_logDeliveryConfigurationsHasBeenSet; }
  template <typename LogDeliveryConfigurationsT = Aws::Vector<LogDeliveryConfigurationRequest>>
  void SetLogDeliveryConfigurations(LogDeliveryConfigurationsT&& value) {
    m_logDeliveryConfigurationsHasBeenSet = true;
    m_logDeliveryConfigurations = std::forward<LogDeliveryConfigurationsT>(value);
  }
  template <typename LogDeliveryConfigurationsT = Aws::Vector<LogDeliveryConfigurationRequest>>
  ModifyCacheClusterRequest& WithLogDeliveryConfigurations(LogDeliveryConfigurationsT&& value) {
    SetLogDeliveryConfigurations(std::forward<LogDeliveryConfigurationsT>(value));
    return *this;
  }
  template <typename LogDeliveryConfigurationsT = LogDeliveryConfigurationRequest>
  ModifyCacheClusterRequest& AddLogDeliveryConfigurations(LogDeliveryConfigurationsT&& value) {
    m_logDeliveryConfigurationsHasBeenSet = true;
    m_logDeliveryConfigurations.emplace_back(std::forward<LogDeliveryConfigurationsT>(value));
    return *this;
  }
 
 
  inline IpDiscovery GetIpDiscovery() const { return m_ipDiscovery; }
  inline bool IpDiscoveryHasBeenSet() const { return m_ipDiscoveryHasBeenSet; }
  inline void SetIpDiscovery(IpDiscovery value) {
    m_ipDiscoveryHasBeenSet = true;
    m_ipDiscovery = value;
  }
  inline ModifyCacheClusterRequest& WithIpDiscovery(IpDiscovery value) {
    SetIpDiscovery(value);
    return *this;
  }
 
 
  inline const ScaleConfig& GetScaleConfig() const { return m_scaleConfig; }
  inline bool ScaleConfigHasBeenSet() const { return m_scaleConfigHasBeenSet; }
  template <typename ScaleConfigT = ScaleConfig>
  void SetScaleConfig(ScaleConfigT&& value) {
    m_scaleConfigHasBeenSet = true;
    m_scaleConfig = std::forward<ScaleConfigT>(value);
  }
  template <typename ScaleConfigT = ScaleConfig>
  ModifyCacheClusterRequest& WithScaleConfig(ScaleConfigT&& value) {
    SetScaleConfig(std::forward<ScaleConfigT>(value));
    return *this;
  }
 private:
  Aws::String m_cacheClusterId;
 
  int m_numCacheNodes{0};
 
  Aws::Vector<Aws::String> m_cacheNodeIdsToRemove;
 
  AZMode m_aZMode{AZMode::NOT_SET};
 
  Aws::Vector<Aws::String> m_newAvailabilityZones;
 
  Aws::Vector<Aws::String> m_cacheSecurityGroupNames;
 
  Aws::Vector<Aws::String> m_securityGroupIds;
 
  Aws::String m_preferredMaintenanceWindow;
 
  Aws::String m_notificationTopicArn;
 
  Aws::String m_cacheParameterGroupName;
 
  Aws::String m_notificationTopicStatus;
 
  bool m_applyImmediately{false};
 
  Aws::String m_engine;
 
  Aws::String m_engineVersion;
 
  bool m_autoMinorVersionUpgrade{false};
 
  int m_snapshotRetentionLimit{0};
 
  Aws::String m_snapshotWindow;
 
  Aws::String m_cacheNodeType;
 
  Aws::String m_authToken;
 
  AuthTokenUpdateStrategyType m_authTokenUpdateStrategy{AuthTokenUpdateStrategyType::NOT_SET};
 
  Aws::Vector<LogDeliveryConfigurationRequest> m_logDeliveryConfigurations;
 
  IpDiscovery m_ipDiscovery{IpDiscovery::NOT_SET};
 
  ScaleConfig m_scaleConfig;
  bool m_cacheClusterIdHasBeenSet = false;
  bool m_numCacheNodesHasBeenSet = false;
  bool m_cacheNodeIdsToRemoveHasBeenSet = false;
  bool m_aZModeHasBeenSet = false;
  bool m_newAvailabilityZonesHasBeenSet = false;
  bool m_cacheSecurityGroupNamesHasBeenSet = false;
  bool m_securityGroupIdsHasBeenSet = false;
  bool m_preferredMaintenanceWindowHasBeenSet = false;
  bool m_notificationTopicArnHasBeenSet = false;
  bool m_cacheParameterGroupNameHasBeenSet = false;
  bool m_notificationTopicStatusHasBeenSet = false;
  bool m_applyImmediatelyHasBeenSet = false;
  bool m_engineHasBeenSet = false;
  bool m_engineVersionHasBeenSet = false;
  bool m_autoMinorVersionUpgradeHasBeenSet = false;
  bool m_snapshotRetentionLimitHasBeenSet = false;
  bool m_snapshotWindowHasBeenSet = false;
  bool m_cacheNodeTypeHasBeenSet = false;
  bool m_authTokenHasBeenSet = false;
  bool m_authTokenUpdateStrategyHasBeenSet = false;
  bool m_logDeliveryConfigurationsHasBeenSet = false;
  bool m_ipDiscoveryHasBeenSet = false;
  bool m_scaleConfigHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ElastiCache
}  // namespace Aws