Snapshot.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/elasticache/ElastiCache_EXPORTS.h>
#include <aws/elasticache/model/AutomaticFailoverStatus.h>
#include <aws/elasticache/model/DataTieringStatus.h>
#include <aws/elasticache/model/Durability.h>
#include <aws/elasticache/model/NodeSnapshot.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace ElastiCache {
namespace Model {
 
class Snapshot {
 public:
  AWS_ELASTICACHE_API Snapshot() = default;
  AWS_ELASTICACHE_API Snapshot(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_ELASTICACHE_API Snapshot& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_ELASTICACHE_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
  AWS_ELASTICACHE_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
  inline const Aws::String& GetSnapshotName() const { return m_snapshotName; }
  inline bool SnapshotNameHasBeenSet() const { return m_snapshotNameHasBeenSet; }
  template <typename SnapshotNameT = Aws::String>
  void SetSnapshotName(SnapshotNameT&& value) {
    m_snapshotNameHasBeenSet = true;
    m_snapshotName = std::forward<SnapshotNameT>(value);
  }
  template <typename SnapshotNameT = Aws::String>
  Snapshot& WithSnapshotName(SnapshotNameT&& value) {
    SetSnapshotName(std::forward<SnapshotNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetReplicationGroupId() const { return m_replicationGroupId; }
  inline bool ReplicationGroupIdHasBeenSet() const { return m_replicationGroupIdHasBeenSet; }
  template <typename ReplicationGroupIdT = Aws::String>
  void SetReplicationGroupId(ReplicationGroupIdT&& value) {
    m_replicationGroupIdHasBeenSet = true;
    m_replicationGroupId = std::forward<ReplicationGroupIdT>(value);
  }
  template <typename ReplicationGroupIdT = Aws::String>
  Snapshot& WithReplicationGroupId(ReplicationGroupIdT&& value) {
    SetReplicationGroupId(std::forward<ReplicationGroupIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetReplicationGroupDescription() const { return m_replicationGroupDescription; }
  inline bool ReplicationGroupDescriptionHasBeenSet() const { return m_replicationGroupDescriptionHasBeenSet; }
  template <typename ReplicationGroupDescriptionT = Aws::String>
  void SetReplicationGroupDescription(ReplicationGroupDescriptionT&& value) {
    m_replicationGroupDescriptionHasBeenSet = true;
    m_replicationGroupDescription = std::forward<ReplicationGroupDescriptionT>(value);
  }
  template <typename ReplicationGroupDescriptionT = Aws::String>
  Snapshot& WithReplicationGroupDescription(ReplicationGroupDescriptionT&& value) {
    SetReplicationGroupDescription(std::forward<ReplicationGroupDescriptionT>(value));
    return *this;
  }
 
 
  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>
  Snapshot& WithCacheClusterId(CacheClusterIdT&& value) {
    SetCacheClusterId(std::forward<CacheClusterIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSnapshotStatus() const { return m_snapshotStatus; }
  inline bool SnapshotStatusHasBeenSet() const { return m_snapshotStatusHasBeenSet; }
  template <typename SnapshotStatusT = Aws::String>
  void SetSnapshotStatus(SnapshotStatusT&& value) {
    m_snapshotStatusHasBeenSet = true;
    m_snapshotStatus = std::forward<SnapshotStatusT>(value);
  }
  template <typename SnapshotStatusT = Aws::String>
  Snapshot& WithSnapshotStatus(SnapshotStatusT&& value) {
    SetSnapshotStatus(std::forward<SnapshotStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSnapshotSource() const { return m_snapshotSource; }
  inline bool SnapshotSourceHasBeenSet() const { return m_snapshotSourceHasBeenSet; }
  template <typename SnapshotSourceT = Aws::String>
  void SetSnapshotSource(SnapshotSourceT&& value) {
    m_snapshotSourceHasBeenSet = true;
    m_snapshotSource = std::forward<SnapshotSourceT>(value);
  }
  template <typename SnapshotSourceT = Aws::String>
  Snapshot& WithSnapshotSource(SnapshotSourceT&& value) {
    SetSnapshotSource(std::forward<SnapshotSourceT>(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>
  Snapshot& WithCacheNodeType(CacheNodeTypeT&& value) {
    SetCacheNodeType(std::forward<CacheNodeTypeT>(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>
  Snapshot& 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>
  Snapshot& WithEngineVersion(EngineVersionT&& value) {
    SetEngineVersion(std::forward<EngineVersionT>(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 Snapshot& WithNumCacheNodes(int value) {
    SetNumCacheNodes(value);
    return *this;
  }
 
 
  inline const Aws::String& GetPreferredAvailabilityZone() const { return m_preferredAvailabilityZone; }
  inline bool PreferredAvailabilityZoneHasBeenSet() const { return m_preferredAvailabilityZoneHasBeenSet; }
  template <typename PreferredAvailabilityZoneT = Aws::String>
  void SetPreferredAvailabilityZone(PreferredAvailabilityZoneT&& value) {
    m_preferredAvailabilityZoneHasBeenSet = true;
    m_preferredAvailabilityZone = std::forward<PreferredAvailabilityZoneT>(value);
  }
  template <typename PreferredAvailabilityZoneT = Aws::String>
  Snapshot& WithPreferredAvailabilityZone(PreferredAvailabilityZoneT&& value) {
    SetPreferredAvailabilityZone(std::forward<PreferredAvailabilityZoneT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPreferredOutpostArn() const { return m_preferredOutpostArn; }
  inline bool PreferredOutpostArnHasBeenSet() const { return m_preferredOutpostArnHasBeenSet; }
  template <typename PreferredOutpostArnT = Aws::String>
  void SetPreferredOutpostArn(PreferredOutpostArnT&& value) {
    m_preferredOutpostArnHasBeenSet = true;
    m_preferredOutpostArn = std::forward<PreferredOutpostArnT>(value);
  }
  template <typename PreferredOutpostArnT = Aws::String>
  Snapshot& WithPreferredOutpostArn(PreferredOutpostArnT&& value) {
    SetPreferredOutpostArn(std::forward<PreferredOutpostArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCacheClusterCreateTime() const { return m_cacheClusterCreateTime; }
  inline bool CacheClusterCreateTimeHasBeenSet() const { return m_cacheClusterCreateTimeHasBeenSet; }
  template <typename CacheClusterCreateTimeT = Aws::Utils::DateTime>
  void SetCacheClusterCreateTime(CacheClusterCreateTimeT&& value) {
    m_cacheClusterCreateTimeHasBeenSet = true;
    m_cacheClusterCreateTime = std::forward<CacheClusterCreateTimeT>(value);
  }
  template <typename CacheClusterCreateTimeT = Aws::Utils::DateTime>
  Snapshot& WithCacheClusterCreateTime(CacheClusterCreateTimeT&& value) {
    SetCacheClusterCreateTime(std::forward<CacheClusterCreateTimeT>(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>
  Snapshot& WithPreferredMaintenanceWindow(PreferredMaintenanceWindowT&& value) {
    SetPreferredMaintenanceWindow(std::forward<PreferredMaintenanceWindowT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTopicArn() const { return m_topicArn; }
  inline bool TopicArnHasBeenSet() const { return m_topicArnHasBeenSet; }
  template <typename TopicArnT = Aws::String>
  void SetTopicArn(TopicArnT&& value) {
    m_topicArnHasBeenSet = true;
    m_topicArn = std::forward<TopicArnT>(value);
  }
  template <typename TopicArnT = Aws::String>
  Snapshot& WithTopicArn(TopicArnT&& value) {
    SetTopicArn(std::forward<TopicArnT>(value));
    return *this;
  }
 
 
  inline int GetPort() const { return m_port; }
  inline bool PortHasBeenSet() const { return m_portHasBeenSet; }
  inline void SetPort(int value) {
    m_portHasBeenSet = true;
    m_port = value;
  }
  inline Snapshot& WithPort(int value) {
    SetPort(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>
  Snapshot& WithCacheParameterGroupName(CacheParameterGroupNameT&& value) {
    SetCacheParameterGroupName(std::forward<CacheParameterGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCacheSubnetGroupName() const { return m_cacheSubnetGroupName; }
  inline bool CacheSubnetGroupNameHasBeenSet() const { return m_cacheSubnetGroupNameHasBeenSet; }
  template <typename CacheSubnetGroupNameT = Aws::String>
  void SetCacheSubnetGroupName(CacheSubnetGroupNameT&& value) {
    m_cacheSubnetGroupNameHasBeenSet = true;
    m_cacheSubnetGroupName = std::forward<CacheSubnetGroupNameT>(value);
  }
  template <typename CacheSubnetGroupNameT = Aws::String>
  Snapshot& WithCacheSubnetGroupName(CacheSubnetGroupNameT&& value) {
    SetCacheSubnetGroupName(std::forward<CacheSubnetGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVpcId() const { return m_vpcId; }
  inline bool VpcIdHasBeenSet() const { return m_vpcIdHasBeenSet; }
  template <typename VpcIdT = Aws::String>
  void SetVpcId(VpcIdT&& value) {
    m_vpcIdHasBeenSet = true;
    m_vpcId = std::forward<VpcIdT>(value);
  }
  template <typename VpcIdT = Aws::String>
  Snapshot& WithVpcId(VpcIdT&& value) {
    SetVpcId(std::forward<VpcIdT>(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 Snapshot& 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 Snapshot& 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>
  Snapshot& WithSnapshotWindow(SnapshotWindowT&& value) {
    SetSnapshotWindow(std::forward<SnapshotWindowT>(value));
    return *this;
  }
 
 
  inline int GetNumNodeGroups() const { return m_numNodeGroups; }
  inline bool NumNodeGroupsHasBeenSet() const { return m_numNodeGroupsHasBeenSet; }
  inline void SetNumNodeGroups(int value) {
    m_numNodeGroupsHasBeenSet = true;
    m_numNodeGroups = value;
  }
  inline Snapshot& WithNumNodeGroups(int value) {
    SetNumNodeGroups(value);
    return *this;
  }
 
 
  inline AutomaticFailoverStatus GetAutomaticFailover() const { return m_automaticFailover; }
  inline bool AutomaticFailoverHasBeenSet() const { return m_automaticFailoverHasBeenSet; }
  inline void SetAutomaticFailover(AutomaticFailoverStatus value) {
    m_automaticFailoverHasBeenSet = true;
    m_automaticFailover = value;
  }
  inline Snapshot& WithAutomaticFailover(AutomaticFailoverStatus value) {
    SetAutomaticFailover(value);
    return *this;
  }
 
 
  inline const Aws::Vector<NodeSnapshot>& GetNodeSnapshots() const { return m_nodeSnapshots; }
  inline bool NodeSnapshotsHasBeenSet() const { return m_nodeSnapshotsHasBeenSet; }
  template <typename NodeSnapshotsT = Aws::Vector<NodeSnapshot>>
  void SetNodeSnapshots(NodeSnapshotsT&& value) {
    m_nodeSnapshotsHasBeenSet = true;
    m_nodeSnapshots = std::forward<NodeSnapshotsT>(value);
  }
  template <typename NodeSnapshotsT = Aws::Vector<NodeSnapshot>>
  Snapshot& WithNodeSnapshots(NodeSnapshotsT&& value) {
    SetNodeSnapshots(std::forward<NodeSnapshotsT>(value));
    return *this;
  }
  template <typename NodeSnapshotsT = NodeSnapshot>
  Snapshot& AddNodeSnapshots(NodeSnapshotsT&& value) {
    m_nodeSnapshotsHasBeenSet = true;
    m_nodeSnapshots.emplace_back(std::forward<NodeSnapshotsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKmsKeyId() const { return m_kmsKeyId; }
  inline bool KmsKeyIdHasBeenSet() const { return m_kmsKeyIdHasBeenSet; }
  template <typename KmsKeyIdT = Aws::String>
  void SetKmsKeyId(KmsKeyIdT&& value) {
    m_kmsKeyIdHasBeenSet = true;
    m_kmsKeyId = std::forward<KmsKeyIdT>(value);
  }
  template <typename KmsKeyIdT = Aws::String>
  Snapshot& WithKmsKeyId(KmsKeyIdT&& value) {
    SetKmsKeyId(std::forward<KmsKeyIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetARN() const { return m_aRN; }
  inline bool ARNHasBeenSet() const { return m_aRNHasBeenSet; }
  template <typename ARNT = Aws::String>
  void SetARN(ARNT&& value) {
    m_aRNHasBeenSet = true;
    m_aRN = std::forward<ARNT>(value);
  }
  template <typename ARNT = Aws::String>
  Snapshot& WithARN(ARNT&& value) {
    SetARN(std::forward<ARNT>(value));
    return *this;
  }
 
 
  inline DataTieringStatus GetDataTiering() const { return m_dataTiering; }
  inline bool DataTieringHasBeenSet() const { return m_dataTieringHasBeenSet; }
  inline void SetDataTiering(DataTieringStatus value) {
    m_dataTieringHasBeenSet = true;
    m_dataTiering = value;
  }
  inline Snapshot& WithDataTiering(DataTieringStatus value) {
    SetDataTiering(value);
    return *this;
  }
 
 
  inline Durability GetDurability() const { return m_durability; }
  inline bool DurabilityHasBeenSet() const { return m_durabilityHasBeenSet; }
  inline void SetDurability(Durability value) {
    m_durabilityHasBeenSet = true;
    m_durability = value;
  }
  inline Snapshot& WithDurability(Durability value) {
    SetDurability(value);
    return *this;
  }
 private:
  Aws::String m_snapshotName;
 
  Aws::String m_replicationGroupId;
 
  Aws::String m_replicationGroupDescription;
 
  Aws::String m_cacheClusterId;
 
  Aws::String m_snapshotStatus;
 
  Aws::String m_snapshotSource;
 
  Aws::String m_cacheNodeType;
 
  Aws::String m_engine;
 
  Aws::String m_engineVersion;
 
  int m_numCacheNodes{0};
 
  Aws::String m_preferredAvailabilityZone;
 
  Aws::String m_preferredOutpostArn;
 
  Aws::Utils::DateTime m_cacheClusterCreateTime{};
 
  Aws::String m_preferredMaintenanceWindow;
 
  Aws::String m_topicArn;
 
  int m_port{0};
 
  Aws::String m_cacheParameterGroupName;
 
  Aws::String m_cacheSubnetGroupName;
 
  Aws::String m_vpcId;
 
  bool m_autoMinorVersionUpgrade{false};
 
  int m_snapshotRetentionLimit{0};
 
  Aws::String m_snapshotWindow;
 
  int m_numNodeGroups{0};
 
  AutomaticFailoverStatus m_automaticFailover{AutomaticFailoverStatus::NOT_SET};
 
  Aws::Vector<NodeSnapshot> m_nodeSnapshots;
 
  Aws::String m_kmsKeyId;
 
  Aws::String m_aRN;
 
  DataTieringStatus m_dataTiering{DataTieringStatus::NOT_SET};
 
  Durability m_durability{Durability::NOT_SET};
  bool m_snapshotNameHasBeenSet = false;
  bool m_replicationGroupIdHasBeenSet = false;
  bool m_replicationGroupDescriptionHasBeenSet = false;
  bool m_cacheClusterIdHasBeenSet = false;
  bool m_snapshotStatusHasBeenSet = false;
  bool m_snapshotSourceHasBeenSet = false;
  bool m_cacheNodeTypeHasBeenSet = false;
  bool m_engineHasBeenSet = false;
  bool m_engineVersionHasBeenSet = false;
  bool m_numCacheNodesHasBeenSet = false;
  bool m_preferredAvailabilityZoneHasBeenSet = false;
  bool m_preferredOutpostArnHasBeenSet = false;
  bool m_cacheClusterCreateTimeHasBeenSet = false;
  bool m_preferredMaintenanceWindowHasBeenSet = false;
  bool m_topicArnHasBeenSet = false;
  bool m_portHasBeenSet = false;
  bool m_cacheParameterGroupNameHasBeenSet = false;
  bool m_cacheSubnetGroupNameHasBeenSet = false;
  bool m_vpcIdHasBeenSet = false;
  bool m_autoMinorVersionUpgradeHasBeenSet = false;
  bool m_snapshotRetentionLimitHasBeenSet = false;
  bool m_snapshotWindowHasBeenSet = false;
  bool m_numNodeGroupsHasBeenSet = false;
  bool m_automaticFailoverHasBeenSet = false;
  bool m_nodeSnapshotsHasBeenSet = false;
  bool m_kmsKeyIdHasBeenSet = false;
  bool m_aRNHasBeenSet = false;
  bool m_dataTieringHasBeenSet = false;
  bool m_durabilityHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ElastiCache
}  // namespace Aws