Snapshot.h

 
#pragma once
#include <aws/elasticache/ElastiCache_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/DateTime.h>
#include <aws/elasticache/model/AutomaticFailoverStatus.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/elasticache/model/DataTieringStatus.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;}
  private:
 
    Aws::String m_snapshotName;
    bool m_snapshotNameHasBeenSet = false;
 
    Aws::String m_replicationGroupId;
    bool m_replicationGroupIdHasBeenSet = false;
 
    Aws::String m_replicationGroupDescription;
    bool m_replicationGroupDescriptionHasBeenSet = false;
 
    Aws::String m_cacheClusterId;
    bool m_cacheClusterIdHasBeenSet = false;
 
    Aws::String m_snapshotStatus;
    bool m_snapshotStatusHasBeenSet = false;
 
    Aws::String m_snapshotSource;
    bool m_snapshotSourceHasBeenSet = false;
 
    Aws::String m_cacheNodeType;
    bool m_cacheNodeTypeHasBeenSet = false;
 
    Aws::String m_engine;
    bool m_engineHasBeenSet = false;
 
    Aws::String m_engineVersion;
    bool m_engineVersionHasBeenSet = false;
 
    int m_numCacheNodes{0};
    bool m_numCacheNodesHasBeenSet = false;
 
    Aws::String m_preferredAvailabilityZone;
    bool m_preferredAvailabilityZoneHasBeenSet = false;
 
    Aws::String m_preferredOutpostArn;
    bool m_preferredOutpostArnHasBeenSet = false;
 
    Aws::Utils::DateTime m_cacheClusterCreateTime{};
    bool m_cacheClusterCreateTimeHasBeenSet = false;
 
    Aws::String m_preferredMaintenanceWindow;
    bool m_preferredMaintenanceWindowHasBeenSet = false;
 
    Aws::String m_topicArn;
    bool m_topicArnHasBeenSet = false;
 
    int m_port{0};
    bool m_portHasBeenSet = false;
 
    Aws::String m_cacheParameterGroupName;
    bool m_cacheParameterGroupNameHasBeenSet = false;
 
    Aws::String m_cacheSubnetGroupName;
    bool m_cacheSubnetGroupNameHasBeenSet = false;
 
    Aws::String m_vpcId;
    bool m_vpcIdHasBeenSet = false;
 
    bool m_autoMinorVersionUpgrade{false};
    bool m_autoMinorVersionUpgradeHasBeenSet = false;
 
    int m_snapshotRetentionLimit{0};
    bool m_snapshotRetentionLimitHasBeenSet = false;
 
    Aws::String m_snapshotWindow;
    bool m_snapshotWindowHasBeenSet = false;
 
    int m_numNodeGroups{0};
    bool m_numNodeGroupsHasBeenSet = false;
 
    AutomaticFailoverStatus m_automaticFailover{AutomaticFailoverStatus::NOT_SET};
    bool m_automaticFailoverHasBeenSet = false;
 
    Aws::Vector<NodeSnapshot> m_nodeSnapshots;
    bool m_nodeSnapshotsHasBeenSet = false;
 
    Aws::String m_kmsKeyId;
    bool m_kmsKeyIdHasBeenSet = false;
 
    Aws::String m_aRN;
    bool m_aRNHasBeenSet = false;
 
    DataTieringStatus m_dataTiering{DataTieringStatus::NOT_SET};
    bool m_dataTieringHasBeenSet = false;
  };
 
} // namespace Model
} // namespace ElastiCache
} // namespace Aws