NodeGroupMemberUpdateStatus.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/elasticache/ElastiCache_EXPORTS.h>
#include <aws/elasticache/model/NodeUpdateInitiatedBy.h>
#include <aws/elasticache/model/NodeUpdateStatus.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace ElastiCache {
namespace Model {
 
class NodeGroupMemberUpdateStatus {
 public:
  AWS_ELASTICACHE_API NodeGroupMemberUpdateStatus() = default;
  AWS_ELASTICACHE_API NodeGroupMemberUpdateStatus(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_ELASTICACHE_API NodeGroupMemberUpdateStatus& 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& 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>
  NodeGroupMemberUpdateStatus& WithCacheClusterId(CacheClusterIdT&& value) {
    SetCacheClusterId(std::forward<CacheClusterIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCacheNodeId() const { return m_cacheNodeId; }
  inline bool CacheNodeIdHasBeenSet() const { return m_cacheNodeIdHasBeenSet; }
  template <typename CacheNodeIdT = Aws::String>
  void SetCacheNodeId(CacheNodeIdT&& value) {
    m_cacheNodeIdHasBeenSet = true;
    m_cacheNodeId = std::forward<CacheNodeIdT>(value);
  }
  template <typename CacheNodeIdT = Aws::String>
  NodeGroupMemberUpdateStatus& WithCacheNodeId(CacheNodeIdT&& value) {
    SetCacheNodeId(std::forward<CacheNodeIdT>(value));
    return *this;
  }
 
 
  inline NodeUpdateStatus GetNodeUpdateStatus() const { return m_nodeUpdateStatus; }
  inline bool NodeUpdateStatusHasBeenSet() const { return m_nodeUpdateStatusHasBeenSet; }
  inline void SetNodeUpdateStatus(NodeUpdateStatus value) {
    m_nodeUpdateStatusHasBeenSet = true;
    m_nodeUpdateStatus = value;
  }
  inline NodeGroupMemberUpdateStatus& WithNodeUpdateStatus(NodeUpdateStatus value) {
    SetNodeUpdateStatus(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetNodeDeletionDate() const { return m_nodeDeletionDate; }
  inline bool NodeDeletionDateHasBeenSet() const { return m_nodeDeletionDateHasBeenSet; }
  template <typename NodeDeletionDateT = Aws::Utils::DateTime>
  void SetNodeDeletionDate(NodeDeletionDateT&& value) {
    m_nodeDeletionDateHasBeenSet = true;
    m_nodeDeletionDate = std::forward<NodeDeletionDateT>(value);
  }
  template <typename NodeDeletionDateT = Aws::Utils::DateTime>
  NodeGroupMemberUpdateStatus& WithNodeDeletionDate(NodeDeletionDateT&& value) {
    SetNodeDeletionDate(std::forward<NodeDeletionDateT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetNodeUpdateStartDate() const { return m_nodeUpdateStartDate; }
  inline bool NodeUpdateStartDateHasBeenSet() const { return m_nodeUpdateStartDateHasBeenSet; }
  template <typename NodeUpdateStartDateT = Aws::Utils::DateTime>
  void SetNodeUpdateStartDate(NodeUpdateStartDateT&& value) {
    m_nodeUpdateStartDateHasBeenSet = true;
    m_nodeUpdateStartDate = std::forward<NodeUpdateStartDateT>(value);
  }
  template <typename NodeUpdateStartDateT = Aws::Utils::DateTime>
  NodeGroupMemberUpdateStatus& WithNodeUpdateStartDate(NodeUpdateStartDateT&& value) {
    SetNodeUpdateStartDate(std::forward<NodeUpdateStartDateT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetNodeUpdateEndDate() const { return m_nodeUpdateEndDate; }
  inline bool NodeUpdateEndDateHasBeenSet() const { return m_nodeUpdateEndDateHasBeenSet; }
  template <typename NodeUpdateEndDateT = Aws::Utils::DateTime>
  void SetNodeUpdateEndDate(NodeUpdateEndDateT&& value) {
    m_nodeUpdateEndDateHasBeenSet = true;
    m_nodeUpdateEndDate = std::forward<NodeUpdateEndDateT>(value);
  }
  template <typename NodeUpdateEndDateT = Aws::Utils::DateTime>
  NodeGroupMemberUpdateStatus& WithNodeUpdateEndDate(NodeUpdateEndDateT&& value) {
    SetNodeUpdateEndDate(std::forward<NodeUpdateEndDateT>(value));
    return *this;
  }
 
 
  inline NodeUpdateInitiatedBy GetNodeUpdateInitiatedBy() const { return m_nodeUpdateInitiatedBy; }
  inline bool NodeUpdateInitiatedByHasBeenSet() const { return m_nodeUpdateInitiatedByHasBeenSet; }
  inline void SetNodeUpdateInitiatedBy(NodeUpdateInitiatedBy value) {
    m_nodeUpdateInitiatedByHasBeenSet = true;
    m_nodeUpdateInitiatedBy = value;
  }
  inline NodeGroupMemberUpdateStatus& WithNodeUpdateInitiatedBy(NodeUpdateInitiatedBy value) {
    SetNodeUpdateInitiatedBy(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetNodeUpdateInitiatedDate() const { return m_nodeUpdateInitiatedDate; }
  inline bool NodeUpdateInitiatedDateHasBeenSet() const { return m_nodeUpdateInitiatedDateHasBeenSet; }
  template <typename NodeUpdateInitiatedDateT = Aws::Utils::DateTime>
  void SetNodeUpdateInitiatedDate(NodeUpdateInitiatedDateT&& value) {
    m_nodeUpdateInitiatedDateHasBeenSet = true;
    m_nodeUpdateInitiatedDate = std::forward<NodeUpdateInitiatedDateT>(value);
  }
  template <typename NodeUpdateInitiatedDateT = Aws::Utils::DateTime>
  NodeGroupMemberUpdateStatus& WithNodeUpdateInitiatedDate(NodeUpdateInitiatedDateT&& value) {
    SetNodeUpdateInitiatedDate(std::forward<NodeUpdateInitiatedDateT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetNodeUpdateStatusModifiedDate() const { return m_nodeUpdateStatusModifiedDate; }
  inline bool NodeUpdateStatusModifiedDateHasBeenSet() const { return m_nodeUpdateStatusModifiedDateHasBeenSet; }
  template <typename NodeUpdateStatusModifiedDateT = Aws::Utils::DateTime>
  void SetNodeUpdateStatusModifiedDate(NodeUpdateStatusModifiedDateT&& value) {
    m_nodeUpdateStatusModifiedDateHasBeenSet = true;
    m_nodeUpdateStatusModifiedDate = std::forward<NodeUpdateStatusModifiedDateT>(value);
  }
  template <typename NodeUpdateStatusModifiedDateT = Aws::Utils::DateTime>
  NodeGroupMemberUpdateStatus& WithNodeUpdateStatusModifiedDate(NodeUpdateStatusModifiedDateT&& value) {
    SetNodeUpdateStatusModifiedDate(std::forward<NodeUpdateStatusModifiedDateT>(value));
    return *this;
  }
 private:
  Aws::String m_cacheClusterId;
 
  Aws::String m_cacheNodeId;
 
  NodeUpdateStatus m_nodeUpdateStatus{NodeUpdateStatus::NOT_SET};
 
  Aws::Utils::DateTime m_nodeDeletionDate{};
 
  Aws::Utils::DateTime m_nodeUpdateStartDate{};
 
  Aws::Utils::DateTime m_nodeUpdateEndDate{};
 
  NodeUpdateInitiatedBy m_nodeUpdateInitiatedBy{NodeUpdateInitiatedBy::NOT_SET};
 
  Aws::Utils::DateTime m_nodeUpdateInitiatedDate{};
 
  Aws::Utils::DateTime m_nodeUpdateStatusModifiedDate{};
  bool m_cacheClusterIdHasBeenSet = false;
  bool m_cacheNodeIdHasBeenSet = false;
  bool m_nodeUpdateStatusHasBeenSet = false;
  bool m_nodeDeletionDateHasBeenSet = false;
  bool m_nodeUpdateStartDateHasBeenSet = false;
  bool m_nodeUpdateEndDateHasBeenSet = false;
  bool m_nodeUpdateInitiatedByHasBeenSet = false;
  bool m_nodeUpdateInitiatedDateHasBeenSet = false;
  bool m_nodeUpdateStatusModifiedDateHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace ElastiCache
}  // namespace Aws