ActiveVpnTunnelStatus.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSStreamFwd.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/ec2/EC2_EXPORTS.h>
#include <aws/ec2/model/VpnTunnelProvisioningStatus.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace EC2 {
namespace Model {
 
class ActiveVpnTunnelStatus {
 public:
  AWS_EC2_API ActiveVpnTunnelStatus() = default;
  AWS_EC2_API ActiveVpnTunnelStatus(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_EC2_API ActiveVpnTunnelStatus& operator=(const Aws::Utils::Xml::XmlNode& xmlNode);
 
  AWS_EC2_API void OutputToStream(Aws::OStream& ostream, const char* location, unsigned index, const char* locationValue) const;
  AWS_EC2_API void OutputToStream(Aws::OStream& oStream, const char* location) const;
 
 
  inline const Aws::String& GetPhase1EncryptionAlgorithm() const { return m_phase1EncryptionAlgorithm; }
  inline bool Phase1EncryptionAlgorithmHasBeenSet() const { return m_phase1EncryptionAlgorithmHasBeenSet; }
  template <typename Phase1EncryptionAlgorithmT = Aws::String>
  void SetPhase1EncryptionAlgorithm(Phase1EncryptionAlgorithmT&& value) {
    m_phase1EncryptionAlgorithmHasBeenSet = true;
    m_phase1EncryptionAlgorithm = std::forward<Phase1EncryptionAlgorithmT>(value);
  }
  template <typename Phase1EncryptionAlgorithmT = Aws::String>
  ActiveVpnTunnelStatus& WithPhase1EncryptionAlgorithm(Phase1EncryptionAlgorithmT&& value) {
    SetPhase1EncryptionAlgorithm(std::forward<Phase1EncryptionAlgorithmT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPhase2EncryptionAlgorithm() const { return m_phase2EncryptionAlgorithm; }
  inline bool Phase2EncryptionAlgorithmHasBeenSet() const { return m_phase2EncryptionAlgorithmHasBeenSet; }
  template <typename Phase2EncryptionAlgorithmT = Aws::String>
  void SetPhase2EncryptionAlgorithm(Phase2EncryptionAlgorithmT&& value) {
    m_phase2EncryptionAlgorithmHasBeenSet = true;
    m_phase2EncryptionAlgorithm = std::forward<Phase2EncryptionAlgorithmT>(value);
  }
  template <typename Phase2EncryptionAlgorithmT = Aws::String>
  ActiveVpnTunnelStatus& WithPhase2EncryptionAlgorithm(Phase2EncryptionAlgorithmT&& value) {
    SetPhase2EncryptionAlgorithm(std::forward<Phase2EncryptionAlgorithmT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPhase1IntegrityAlgorithm() const { return m_phase1IntegrityAlgorithm; }
  inline bool Phase1IntegrityAlgorithmHasBeenSet() const { return m_phase1IntegrityAlgorithmHasBeenSet; }
  template <typename Phase1IntegrityAlgorithmT = Aws::String>
  void SetPhase1IntegrityAlgorithm(Phase1IntegrityAlgorithmT&& value) {
    m_phase1IntegrityAlgorithmHasBeenSet = true;
    m_phase1IntegrityAlgorithm = std::forward<Phase1IntegrityAlgorithmT>(value);
  }
  template <typename Phase1IntegrityAlgorithmT = Aws::String>
  ActiveVpnTunnelStatus& WithPhase1IntegrityAlgorithm(Phase1IntegrityAlgorithmT&& value) {
    SetPhase1IntegrityAlgorithm(std::forward<Phase1IntegrityAlgorithmT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPhase2IntegrityAlgorithm() const { return m_phase2IntegrityAlgorithm; }
  inline bool Phase2IntegrityAlgorithmHasBeenSet() const { return m_phase2IntegrityAlgorithmHasBeenSet; }
  template <typename Phase2IntegrityAlgorithmT = Aws::String>
  void SetPhase2IntegrityAlgorithm(Phase2IntegrityAlgorithmT&& value) {
    m_phase2IntegrityAlgorithmHasBeenSet = true;
    m_phase2IntegrityAlgorithm = std::forward<Phase2IntegrityAlgorithmT>(value);
  }
  template <typename Phase2IntegrityAlgorithmT = Aws::String>
  ActiveVpnTunnelStatus& WithPhase2IntegrityAlgorithm(Phase2IntegrityAlgorithmT&& value) {
    SetPhase2IntegrityAlgorithm(std::forward<Phase2IntegrityAlgorithmT>(value));
    return *this;
  }
 
 
  inline int GetPhase1DHGroup() const { return m_phase1DHGroup; }
  inline bool Phase1DHGroupHasBeenSet() const { return m_phase1DHGroupHasBeenSet; }
  inline void SetPhase1DHGroup(int value) {
    m_phase1DHGroupHasBeenSet = true;
    m_phase1DHGroup = value;
  }
  inline ActiveVpnTunnelStatus& WithPhase1DHGroup(int value) {
    SetPhase1DHGroup(value);
    return *this;
  }
 
 
  inline int GetPhase2DHGroup() const { return m_phase2DHGroup; }
  inline bool Phase2DHGroupHasBeenSet() const { return m_phase2DHGroupHasBeenSet; }
  inline void SetPhase2DHGroup(int value) {
    m_phase2DHGroupHasBeenSet = true;
    m_phase2DHGroup = value;
  }
  inline ActiveVpnTunnelStatus& WithPhase2DHGroup(int value) {
    SetPhase2DHGroup(value);
    return *this;
  }
 
 
  inline const Aws::String& GetIkeVersion() const { return m_ikeVersion; }
  inline bool IkeVersionHasBeenSet() const { return m_ikeVersionHasBeenSet; }
  template <typename IkeVersionT = Aws::String>
  void SetIkeVersion(IkeVersionT&& value) {
    m_ikeVersionHasBeenSet = true;
    m_ikeVersion = std::forward<IkeVersionT>(value);
  }
  template <typename IkeVersionT = Aws::String>
  ActiveVpnTunnelStatus& WithIkeVersion(IkeVersionT&& value) {
    SetIkeVersion(std::forward<IkeVersionT>(value));
    return *this;
  }
 
 
  inline VpnTunnelProvisioningStatus GetProvisioningStatus() const { return m_provisioningStatus; }
  inline bool ProvisioningStatusHasBeenSet() const { return m_provisioningStatusHasBeenSet; }
  inline void SetProvisioningStatus(VpnTunnelProvisioningStatus value) {
    m_provisioningStatusHasBeenSet = true;
    m_provisioningStatus = value;
  }
  inline ActiveVpnTunnelStatus& WithProvisioningStatus(VpnTunnelProvisioningStatus value) {
    SetProvisioningStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetProvisioningStatusReason() const { return m_provisioningStatusReason; }
  inline bool ProvisioningStatusReasonHasBeenSet() const { return m_provisioningStatusReasonHasBeenSet; }
  template <typename ProvisioningStatusReasonT = Aws::String>
  void SetProvisioningStatusReason(ProvisioningStatusReasonT&& value) {
    m_provisioningStatusReasonHasBeenSet = true;
    m_provisioningStatusReason = std::forward<ProvisioningStatusReasonT>(value);
  }
  template <typename ProvisioningStatusReasonT = Aws::String>
  ActiveVpnTunnelStatus& WithProvisioningStatusReason(ProvisioningStatusReasonT&& value) {
    SetProvisioningStatusReason(std::forward<ProvisioningStatusReasonT>(value));
    return *this;
  }
 private:
  Aws::String m_phase1EncryptionAlgorithm;
 
  Aws::String m_phase2EncryptionAlgorithm;
 
  Aws::String m_phase1IntegrityAlgorithm;
 
  Aws::String m_phase2IntegrityAlgorithm;
 
  int m_phase1DHGroup{0};
 
  int m_phase2DHGroup{0};
 
  Aws::String m_ikeVersion;
 
  VpnTunnelProvisioningStatus m_provisioningStatus{VpnTunnelProvisioningStatus::NOT_SET};
 
  Aws::String m_provisioningStatusReason;
  bool m_phase1EncryptionAlgorithmHasBeenSet = false;
  bool m_phase2EncryptionAlgorithmHasBeenSet = false;
  bool m_phase1IntegrityAlgorithmHasBeenSet = false;
  bool m_phase2IntegrityAlgorithmHasBeenSet = false;
  bool m_phase1DHGroupHasBeenSet = false;
  bool m_phase2DHGroupHasBeenSet = false;
  bool m_ikeVersionHasBeenSet = false;
  bool m_provisioningStatusHasBeenSet = false;
  bool m_provisioningStatusReasonHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EC2
}  // namespace Aws