ClientVpnConnection.h

 
#pragma once
#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/ec2/EC2_EXPORTS.h>
#include <aws/ec2/model/ClientVpnConnectionStatus.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Xml {
class XmlNode;
}  // namespace Xml
}  // namespace Utils
namespace EC2 {
namespace Model {
 
class ClientVpnConnection {
 public:
  AWS_EC2_API ClientVpnConnection() = default;
  AWS_EC2_API ClientVpnConnection(const Aws::Utils::Xml::XmlNode& xmlNode);
  AWS_EC2_API ClientVpnConnection& 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& GetClientVpnEndpointId() const { return m_clientVpnEndpointId; }
  inline bool ClientVpnEndpointIdHasBeenSet() const { return m_clientVpnEndpointIdHasBeenSet; }
  template <typename ClientVpnEndpointIdT = Aws::String>
  void SetClientVpnEndpointId(ClientVpnEndpointIdT&& value) {
    m_clientVpnEndpointIdHasBeenSet = true;
    m_clientVpnEndpointId = std::forward<ClientVpnEndpointIdT>(value);
  }
  template <typename ClientVpnEndpointIdT = Aws::String>
  ClientVpnConnection& WithClientVpnEndpointId(ClientVpnEndpointIdT&& value) {
    SetClientVpnEndpointId(std::forward<ClientVpnEndpointIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetTimestamp() const { return m_timestamp; }
  inline bool TimestampHasBeenSet() const { return m_timestampHasBeenSet; }
  template <typename TimestampT = Aws::String>
  void SetTimestamp(TimestampT&& value) {
    m_timestampHasBeenSet = true;
    m_timestamp = std::forward<TimestampT>(value);
  }
  template <typename TimestampT = Aws::String>
  ClientVpnConnection& WithTimestamp(TimestampT&& value) {
    SetTimestamp(std::forward<TimestampT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetConnectionId() const { return m_connectionId; }
  inline bool ConnectionIdHasBeenSet() const { return m_connectionIdHasBeenSet; }
  template <typename ConnectionIdT = Aws::String>
  void SetConnectionId(ConnectionIdT&& value) {
    m_connectionIdHasBeenSet = true;
    m_connectionId = std::forward<ConnectionIdT>(value);
  }
  template <typename ConnectionIdT = Aws::String>
  ClientVpnConnection& WithConnectionId(ConnectionIdT&& value) {
    SetConnectionId(std::forward<ConnectionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetUsername() const { return m_username; }
  inline bool UsernameHasBeenSet() const { return m_usernameHasBeenSet; }
  template <typename UsernameT = Aws::String>
  void SetUsername(UsernameT&& value) {
    m_usernameHasBeenSet = true;
    m_username = std::forward<UsernameT>(value);
  }
  template <typename UsernameT = Aws::String>
  ClientVpnConnection& WithUsername(UsernameT&& value) {
    SetUsername(std::forward<UsernameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetConnectionEstablishedTime() const { return m_connectionEstablishedTime; }
  inline bool ConnectionEstablishedTimeHasBeenSet() const { return m_connectionEstablishedTimeHasBeenSet; }
  template <typename ConnectionEstablishedTimeT = Aws::String>
  void SetConnectionEstablishedTime(ConnectionEstablishedTimeT&& value) {
    m_connectionEstablishedTimeHasBeenSet = true;
    m_connectionEstablishedTime = std::forward<ConnectionEstablishedTimeT>(value);
  }
  template <typename ConnectionEstablishedTimeT = Aws::String>
  ClientVpnConnection& WithConnectionEstablishedTime(ConnectionEstablishedTimeT&& value) {
    SetConnectionEstablishedTime(std::forward<ConnectionEstablishedTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIngressBytes() const { return m_ingressBytes; }
  inline bool IngressBytesHasBeenSet() const { return m_ingressBytesHasBeenSet; }
  template <typename IngressBytesT = Aws::String>
  void SetIngressBytes(IngressBytesT&& value) {
    m_ingressBytesHasBeenSet = true;
    m_ingressBytes = std::forward<IngressBytesT>(value);
  }
  template <typename IngressBytesT = Aws::String>
  ClientVpnConnection& WithIngressBytes(IngressBytesT&& value) {
    SetIngressBytes(std::forward<IngressBytesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEgressBytes() const { return m_egressBytes; }
  inline bool EgressBytesHasBeenSet() const { return m_egressBytesHasBeenSet; }
  template <typename EgressBytesT = Aws::String>
  void SetEgressBytes(EgressBytesT&& value) {
    m_egressBytesHasBeenSet = true;
    m_egressBytes = std::forward<EgressBytesT>(value);
  }
  template <typename EgressBytesT = Aws::String>
  ClientVpnConnection& WithEgressBytes(EgressBytesT&& value) {
    SetEgressBytes(std::forward<EgressBytesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIngressPackets() const { return m_ingressPackets; }
  inline bool IngressPacketsHasBeenSet() const { return m_ingressPacketsHasBeenSet; }
  template <typename IngressPacketsT = Aws::String>
  void SetIngressPackets(IngressPacketsT&& value) {
    m_ingressPacketsHasBeenSet = true;
    m_ingressPackets = std::forward<IngressPacketsT>(value);
  }
  template <typename IngressPacketsT = Aws::String>
  ClientVpnConnection& WithIngressPackets(IngressPacketsT&& value) {
    SetIngressPackets(std::forward<IngressPacketsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetEgressPackets() const { return m_egressPackets; }
  inline bool EgressPacketsHasBeenSet() const { return m_egressPacketsHasBeenSet; }
  template <typename EgressPacketsT = Aws::String>
  void SetEgressPackets(EgressPacketsT&& value) {
    m_egressPacketsHasBeenSet = true;
    m_egressPackets = std::forward<EgressPacketsT>(value);
  }
  template <typename EgressPacketsT = Aws::String>
  ClientVpnConnection& WithEgressPackets(EgressPacketsT&& value) {
    SetEgressPackets(std::forward<EgressPacketsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClientIp() const { return m_clientIp; }
  inline bool ClientIpHasBeenSet() const { return m_clientIpHasBeenSet; }
  template <typename ClientIpT = Aws::String>
  void SetClientIp(ClientIpT&& value) {
    m_clientIpHasBeenSet = true;
    m_clientIp = std::forward<ClientIpT>(value);
  }
  template <typename ClientIpT = Aws::String>
  ClientVpnConnection& WithClientIp(ClientIpT&& value) {
    SetClientIp(std::forward<ClientIpT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClientIpv6Address() const { return m_clientIpv6Address; }
  inline bool ClientIpv6AddressHasBeenSet() const { return m_clientIpv6AddressHasBeenSet; }
  template <typename ClientIpv6AddressT = Aws::String>
  void SetClientIpv6Address(ClientIpv6AddressT&& value) {
    m_clientIpv6AddressHasBeenSet = true;
    m_clientIpv6Address = std::forward<ClientIpv6AddressT>(value);
  }
  template <typename ClientIpv6AddressT = Aws::String>
  ClientVpnConnection& WithClientIpv6Address(ClientIpv6AddressT&& value) {
    SetClientIpv6Address(std::forward<ClientIpv6AddressT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCommonName() const { return m_commonName; }
  inline bool CommonNameHasBeenSet() const { return m_commonNameHasBeenSet; }
  template <typename CommonNameT = Aws::String>
  void SetCommonName(CommonNameT&& value) {
    m_commonNameHasBeenSet = true;
    m_commonName = std::forward<CommonNameT>(value);
  }
  template <typename CommonNameT = Aws::String>
  ClientVpnConnection& WithCommonName(CommonNameT&& value) {
    SetCommonName(std::forward<CommonNameT>(value));
    return *this;
  }
 
 
  inline const ClientVpnConnectionStatus& GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  template <typename StatusT = ClientVpnConnectionStatus>
  void SetStatus(StatusT&& value) {
    m_statusHasBeenSet = true;
    m_status = std::forward<StatusT>(value);
  }
  template <typename StatusT = ClientVpnConnectionStatus>
  ClientVpnConnection& WithStatus(StatusT&& value) {
    SetStatus(std::forward<StatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetConnectionEndTime() const { return m_connectionEndTime; }
  inline bool ConnectionEndTimeHasBeenSet() const { return m_connectionEndTimeHasBeenSet; }
  template <typename ConnectionEndTimeT = Aws::String>
  void SetConnectionEndTime(ConnectionEndTimeT&& value) {
    m_connectionEndTimeHasBeenSet = true;
    m_connectionEndTime = std::forward<ConnectionEndTimeT>(value);
  }
  template <typename ConnectionEndTimeT = Aws::String>
  ClientVpnConnection& WithConnectionEndTime(ConnectionEndTimeT&& value) {
    SetConnectionEndTime(std::forward<ConnectionEndTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetPostureComplianceStatuses() const { return m_postureComplianceStatuses; }
  inline bool PostureComplianceStatusesHasBeenSet() const { return m_postureComplianceStatusesHasBeenSet; }
  template <typename PostureComplianceStatusesT = Aws::Vector<Aws::String>>
  void SetPostureComplianceStatuses(PostureComplianceStatusesT&& value) {
    m_postureComplianceStatusesHasBeenSet = true;
    m_postureComplianceStatuses = std::forward<PostureComplianceStatusesT>(value);
  }
  template <typename PostureComplianceStatusesT = Aws::Vector<Aws::String>>
  ClientVpnConnection& WithPostureComplianceStatuses(PostureComplianceStatusesT&& value) {
    SetPostureComplianceStatuses(std::forward<PostureComplianceStatusesT>(value));
    return *this;
  }
  template <typename PostureComplianceStatusesT = Aws::String>
  ClientVpnConnection& AddPostureComplianceStatuses(PostureComplianceStatusesT&& value) {
    m_postureComplianceStatusesHasBeenSet = true;
    m_postureComplianceStatuses.emplace_back(std::forward<PostureComplianceStatusesT>(value));
    return *this;
  }
 private:
  Aws::String m_clientVpnEndpointId;
 
  Aws::String m_timestamp;
 
  Aws::String m_connectionId;
 
  Aws::String m_username;
 
  Aws::String m_connectionEstablishedTime;
 
  Aws::String m_ingressBytes;
 
  Aws::String m_egressBytes;
 
  Aws::String m_ingressPackets;
 
  Aws::String m_egressPackets;
 
  Aws::String m_clientIp;
 
  Aws::String m_clientIpv6Address;
 
  Aws::String m_commonName;
 
  ClientVpnConnectionStatus m_status;
 
  Aws::String m_connectionEndTime;
 
  Aws::Vector<Aws::String> m_postureComplianceStatuses;
  bool m_clientVpnEndpointIdHasBeenSet = false;
  bool m_timestampHasBeenSet = false;
  bool m_connectionIdHasBeenSet = false;
  bool m_usernameHasBeenSet = false;
  bool m_connectionEstablishedTimeHasBeenSet = false;
  bool m_ingressBytesHasBeenSet = false;
  bool m_egressBytesHasBeenSet = false;
  bool m_ingressPacketsHasBeenSet = false;
  bool m_egressPacketsHasBeenSet = false;
  bool m_clientIpHasBeenSet = false;
  bool m_clientIpv6AddressHasBeenSet = false;
  bool m_commonNameHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_connectionEndTimeHasBeenSet = false;
  bool m_postureComplianceStatusesHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EC2
}  // namespace Aws