AwsElbLoadBalancerDetails.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/securityhub/SecurityHub_EXPORTS.h>
#include <aws/securityhub/model/AwsElbLoadBalancerAttributes.h>
#include <aws/securityhub/model/AwsElbLoadBalancerBackendServerDescription.h>
#include <aws/securityhub/model/AwsElbLoadBalancerHealthCheck.h>
#include <aws/securityhub/model/AwsElbLoadBalancerInstance.h>
#include <aws/securityhub/model/AwsElbLoadBalancerListenerDescription.h>
#include <aws/securityhub/model/AwsElbLoadBalancerPolicies.h>
#include <aws/securityhub/model/AwsElbLoadBalancerSourceSecurityGroup.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SecurityHub {
namespace Model {
 
class AwsElbLoadBalancerDetails {
 public:
  AWS_SECURITYHUB_API AwsElbLoadBalancerDetails() = default;
  AWS_SECURITYHUB_API AwsElbLoadBalancerDetails(Aws::Utils::Json::JsonView jsonValue);
  AWS_SECURITYHUB_API AwsElbLoadBalancerDetails& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SECURITYHUB_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<Aws::String>& GetAvailabilityZones() const { return m_availabilityZones; }
  inline bool AvailabilityZonesHasBeenSet() const { return m_availabilityZonesHasBeenSet; }
  template <typename AvailabilityZonesT = Aws::Vector<Aws::String>>
  void SetAvailabilityZones(AvailabilityZonesT&& value) {
    m_availabilityZonesHasBeenSet = true;
    m_availabilityZones = std::forward<AvailabilityZonesT>(value);
  }
  template <typename AvailabilityZonesT = Aws::Vector<Aws::String>>
  AwsElbLoadBalancerDetails& WithAvailabilityZones(AvailabilityZonesT&& value) {
    SetAvailabilityZones(std::forward<AvailabilityZonesT>(value));
    return *this;
  }
  template <typename AvailabilityZonesT = Aws::String>
  AwsElbLoadBalancerDetails& AddAvailabilityZones(AvailabilityZonesT&& value) {
    m_availabilityZonesHasBeenSet = true;
    m_availabilityZones.emplace_back(std::forward<AvailabilityZonesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AwsElbLoadBalancerBackendServerDescription>& GetBackendServerDescriptions() const {
    return m_backendServerDescriptions;
  }
  inline bool BackendServerDescriptionsHasBeenSet() const { return m_backendServerDescriptionsHasBeenSet; }
  template <typename BackendServerDescriptionsT = Aws::Vector<AwsElbLoadBalancerBackendServerDescription>>
  void SetBackendServerDescriptions(BackendServerDescriptionsT&& value) {
    m_backendServerDescriptionsHasBeenSet = true;
    m_backendServerDescriptions = std::forward<BackendServerDescriptionsT>(value);
  }
  template <typename BackendServerDescriptionsT = Aws::Vector<AwsElbLoadBalancerBackendServerDescription>>
  AwsElbLoadBalancerDetails& WithBackendServerDescriptions(BackendServerDescriptionsT&& value) {
    SetBackendServerDescriptions(std::forward<BackendServerDescriptionsT>(value));
    return *this;
  }
  template <typename BackendServerDescriptionsT = AwsElbLoadBalancerBackendServerDescription>
  AwsElbLoadBalancerDetails& AddBackendServerDescriptions(BackendServerDescriptionsT&& value) {
    m_backendServerDescriptionsHasBeenSet = true;
    m_backendServerDescriptions.emplace_back(std::forward<BackendServerDescriptionsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCanonicalHostedZoneName() const { return m_canonicalHostedZoneName; }
  inline bool CanonicalHostedZoneNameHasBeenSet() const { return m_canonicalHostedZoneNameHasBeenSet; }
  template <typename CanonicalHostedZoneNameT = Aws::String>
  void SetCanonicalHostedZoneName(CanonicalHostedZoneNameT&& value) {
    m_canonicalHostedZoneNameHasBeenSet = true;
    m_canonicalHostedZoneName = std::forward<CanonicalHostedZoneNameT>(value);
  }
  template <typename CanonicalHostedZoneNameT = Aws::String>
  AwsElbLoadBalancerDetails& WithCanonicalHostedZoneName(CanonicalHostedZoneNameT&& value) {
    SetCanonicalHostedZoneName(std::forward<CanonicalHostedZoneNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCanonicalHostedZoneNameID() const { return m_canonicalHostedZoneNameID; }
  inline bool CanonicalHostedZoneNameIDHasBeenSet() const { return m_canonicalHostedZoneNameIDHasBeenSet; }
  template <typename CanonicalHostedZoneNameIDT = Aws::String>
  void SetCanonicalHostedZoneNameID(CanonicalHostedZoneNameIDT&& value) {
    m_canonicalHostedZoneNameIDHasBeenSet = true;
    m_canonicalHostedZoneNameID = std::forward<CanonicalHostedZoneNameIDT>(value);
  }
  template <typename CanonicalHostedZoneNameIDT = Aws::String>
  AwsElbLoadBalancerDetails& WithCanonicalHostedZoneNameID(CanonicalHostedZoneNameIDT&& value) {
    SetCanonicalHostedZoneNameID(std::forward<CanonicalHostedZoneNameIDT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCreatedTime() const { return m_createdTime; }
  inline bool CreatedTimeHasBeenSet() const { return m_createdTimeHasBeenSet; }
  template <typename CreatedTimeT = Aws::String>
  void SetCreatedTime(CreatedTimeT&& value) {
    m_createdTimeHasBeenSet = true;
    m_createdTime = std::forward<CreatedTimeT>(value);
  }
  template <typename CreatedTimeT = Aws::String>
  AwsElbLoadBalancerDetails& WithCreatedTime(CreatedTimeT&& value) {
    SetCreatedTime(std::forward<CreatedTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDnsName() const { return m_dnsName; }
  inline bool DnsNameHasBeenSet() const { return m_dnsNameHasBeenSet; }
  template <typename DnsNameT = Aws::String>
  void SetDnsName(DnsNameT&& value) {
    m_dnsNameHasBeenSet = true;
    m_dnsName = std::forward<DnsNameT>(value);
  }
  template <typename DnsNameT = Aws::String>
  AwsElbLoadBalancerDetails& WithDnsName(DnsNameT&& value) {
    SetDnsName(std::forward<DnsNameT>(value));
    return *this;
  }
 
 
  inline const AwsElbLoadBalancerHealthCheck& GetHealthCheck() const { return m_healthCheck; }
  inline bool HealthCheckHasBeenSet() const { return m_healthCheckHasBeenSet; }
  template <typename HealthCheckT = AwsElbLoadBalancerHealthCheck>
  void SetHealthCheck(HealthCheckT&& value) {
    m_healthCheckHasBeenSet = true;
    m_healthCheck = std::forward<HealthCheckT>(value);
  }
  template <typename HealthCheckT = AwsElbLoadBalancerHealthCheck>
  AwsElbLoadBalancerDetails& WithHealthCheck(HealthCheckT&& value) {
    SetHealthCheck(std::forward<HealthCheckT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AwsElbLoadBalancerInstance>& GetInstances() const { return m_instances; }
  inline bool InstancesHasBeenSet() const { return m_instancesHasBeenSet; }
  template <typename InstancesT = Aws::Vector<AwsElbLoadBalancerInstance>>
  void SetInstances(InstancesT&& value) {
    m_instancesHasBeenSet = true;
    m_instances = std::forward<InstancesT>(value);
  }
  template <typename InstancesT = Aws::Vector<AwsElbLoadBalancerInstance>>
  AwsElbLoadBalancerDetails& WithInstances(InstancesT&& value) {
    SetInstances(std::forward<InstancesT>(value));
    return *this;
  }
  template <typename InstancesT = AwsElbLoadBalancerInstance>
  AwsElbLoadBalancerDetails& AddInstances(InstancesT&& value) {
    m_instancesHasBeenSet = true;
    m_instances.emplace_back(std::forward<InstancesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<AwsElbLoadBalancerListenerDescription>& GetListenerDescriptions() const { return m_listenerDescriptions; }
  inline bool ListenerDescriptionsHasBeenSet() const { return m_listenerDescriptionsHasBeenSet; }
  template <typename ListenerDescriptionsT = Aws::Vector<AwsElbLoadBalancerListenerDescription>>
  void SetListenerDescriptions(ListenerDescriptionsT&& value) {
    m_listenerDescriptionsHasBeenSet = true;
    m_listenerDescriptions = std::forward<ListenerDescriptionsT>(value);
  }
  template <typename ListenerDescriptionsT = Aws::Vector<AwsElbLoadBalancerListenerDescription>>
  AwsElbLoadBalancerDetails& WithListenerDescriptions(ListenerDescriptionsT&& value) {
    SetListenerDescriptions(std::forward<ListenerDescriptionsT>(value));
    return *this;
  }
  template <typename ListenerDescriptionsT = AwsElbLoadBalancerListenerDescription>
  AwsElbLoadBalancerDetails& AddListenerDescriptions(ListenerDescriptionsT&& value) {
    m_listenerDescriptionsHasBeenSet = true;
    m_listenerDescriptions.emplace_back(std::forward<ListenerDescriptionsT>(value));
    return *this;
  }
 
 
  inline const AwsElbLoadBalancerAttributes& GetLoadBalancerAttributes() const { return m_loadBalancerAttributes; }
  inline bool LoadBalancerAttributesHasBeenSet() const { return m_loadBalancerAttributesHasBeenSet; }
  template <typename LoadBalancerAttributesT = AwsElbLoadBalancerAttributes>
  void SetLoadBalancerAttributes(LoadBalancerAttributesT&& value) {
    m_loadBalancerAttributesHasBeenSet = true;
    m_loadBalancerAttributes = std::forward<LoadBalancerAttributesT>(value);
  }
  template <typename LoadBalancerAttributesT = AwsElbLoadBalancerAttributes>
  AwsElbLoadBalancerDetails& WithLoadBalancerAttributes(LoadBalancerAttributesT&& value) {
    SetLoadBalancerAttributes(std::forward<LoadBalancerAttributesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLoadBalancerName() const { return m_loadBalancerName; }
  inline bool LoadBalancerNameHasBeenSet() const { return m_loadBalancerNameHasBeenSet; }
  template <typename LoadBalancerNameT = Aws::String>
  void SetLoadBalancerName(LoadBalancerNameT&& value) {
    m_loadBalancerNameHasBeenSet = true;
    m_loadBalancerName = std::forward<LoadBalancerNameT>(value);
  }
  template <typename LoadBalancerNameT = Aws::String>
  AwsElbLoadBalancerDetails& WithLoadBalancerName(LoadBalancerNameT&& value) {
    SetLoadBalancerName(std::forward<LoadBalancerNameT>(value));
    return *this;
  }
 
 
  inline const AwsElbLoadBalancerPolicies& GetPolicies() const { return m_policies; }
  inline bool PoliciesHasBeenSet() const { return m_policiesHasBeenSet; }
  template <typename PoliciesT = AwsElbLoadBalancerPolicies>
  void SetPolicies(PoliciesT&& value) {
    m_policiesHasBeenSet = true;
    m_policies = std::forward<PoliciesT>(value);
  }
  template <typename PoliciesT = AwsElbLoadBalancerPolicies>
  AwsElbLoadBalancerDetails& WithPolicies(PoliciesT&& value) {
    SetPolicies(std::forward<PoliciesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetScheme() const { return m_scheme; }
  inline bool SchemeHasBeenSet() const { return m_schemeHasBeenSet; }
  template <typename SchemeT = Aws::String>
  void SetScheme(SchemeT&& value) {
    m_schemeHasBeenSet = true;
    m_scheme = std::forward<SchemeT>(value);
  }
  template <typename SchemeT = Aws::String>
  AwsElbLoadBalancerDetails& WithScheme(SchemeT&& value) {
    SetScheme(std::forward<SchemeT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSecurityGroups() const { return m_securityGroups; }
  inline bool SecurityGroupsHasBeenSet() const { return m_securityGroupsHasBeenSet; }
  template <typename SecurityGroupsT = Aws::Vector<Aws::String>>
  void SetSecurityGroups(SecurityGroupsT&& value) {
    m_securityGroupsHasBeenSet = true;
    m_securityGroups = std::forward<SecurityGroupsT>(value);
  }
  template <typename SecurityGroupsT = Aws::Vector<Aws::String>>
  AwsElbLoadBalancerDetails& WithSecurityGroups(SecurityGroupsT&& value) {
    SetSecurityGroups(std::forward<SecurityGroupsT>(value));
    return *this;
  }
  template <typename SecurityGroupsT = Aws::String>
  AwsElbLoadBalancerDetails& AddSecurityGroups(SecurityGroupsT&& value) {
    m_securityGroupsHasBeenSet = true;
    m_securityGroups.emplace_back(std::forward<SecurityGroupsT>(value));
    return *this;
  }
 
 
  inline const AwsElbLoadBalancerSourceSecurityGroup& GetSourceSecurityGroup() const { return m_sourceSecurityGroup; }
  inline bool SourceSecurityGroupHasBeenSet() const { return m_sourceSecurityGroupHasBeenSet; }
  template <typename SourceSecurityGroupT = AwsElbLoadBalancerSourceSecurityGroup>
  void SetSourceSecurityGroup(SourceSecurityGroupT&& value) {
    m_sourceSecurityGroupHasBeenSet = true;
    m_sourceSecurityGroup = std::forward<SourceSecurityGroupT>(value);
  }
  template <typename SourceSecurityGroupT = AwsElbLoadBalancerSourceSecurityGroup>
  AwsElbLoadBalancerDetails& WithSourceSecurityGroup(SourceSecurityGroupT&& value) {
    SetSourceSecurityGroup(std::forward<SourceSecurityGroupT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSubnets() const { return m_subnets; }
  inline bool SubnetsHasBeenSet() const { return m_subnetsHasBeenSet; }
  template <typename SubnetsT = Aws::Vector<Aws::String>>
  void SetSubnets(SubnetsT&& value) {
    m_subnetsHasBeenSet = true;
    m_subnets = std::forward<SubnetsT>(value);
  }
  template <typename SubnetsT = Aws::Vector<Aws::String>>
  AwsElbLoadBalancerDetails& WithSubnets(SubnetsT&& value) {
    SetSubnets(std::forward<SubnetsT>(value));
    return *this;
  }
  template <typename SubnetsT = Aws::String>
  AwsElbLoadBalancerDetails& AddSubnets(SubnetsT&& value) {
    m_subnetsHasBeenSet = true;
    m_subnets.emplace_back(std::forward<SubnetsT>(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>
  AwsElbLoadBalancerDetails& WithVpcId(VpcIdT&& value) {
    SetVpcId(std::forward<VpcIdT>(value));
    return *this;
  }
 private:
  Aws::Vector<Aws::String> m_availabilityZones;
 
  Aws::Vector<AwsElbLoadBalancerBackendServerDescription> m_backendServerDescriptions;
 
  Aws::String m_canonicalHostedZoneName;
 
  Aws::String m_canonicalHostedZoneNameID;
 
  Aws::String m_createdTime;
 
  Aws::String m_dnsName;
 
  AwsElbLoadBalancerHealthCheck m_healthCheck;
 
  Aws::Vector<AwsElbLoadBalancerInstance> m_instances;
 
  Aws::Vector<AwsElbLoadBalancerListenerDescription> m_listenerDescriptions;
 
  AwsElbLoadBalancerAttributes m_loadBalancerAttributes;
 
  Aws::String m_loadBalancerName;
 
  AwsElbLoadBalancerPolicies m_policies;
 
  Aws::String m_scheme;
 
  Aws::Vector<Aws::String> m_securityGroups;
 
  AwsElbLoadBalancerSourceSecurityGroup m_sourceSecurityGroup;
 
  Aws::Vector<Aws::String> m_subnets;
 
  Aws::String m_vpcId;
  bool m_availabilityZonesHasBeenSet = false;
  bool m_backendServerDescriptionsHasBeenSet = false;
  bool m_canonicalHostedZoneNameHasBeenSet = false;
  bool m_canonicalHostedZoneNameIDHasBeenSet = false;
  bool m_createdTimeHasBeenSet = false;
  bool m_dnsNameHasBeenSet = false;
  bool m_healthCheckHasBeenSet = false;
  bool m_instancesHasBeenSet = false;
  bool m_listenerDescriptionsHasBeenSet = false;
  bool m_loadBalancerAttributesHasBeenSet = false;
  bool m_loadBalancerNameHasBeenSet = false;
  bool m_policiesHasBeenSet = false;
  bool m_schemeHasBeenSet = false;
  bool m_securityGroupsHasBeenSet = false;
  bool m_sourceSecurityGroupHasBeenSet = false;
  bool m_subnetsHasBeenSet = false;
  bool m_vpcIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SecurityHub
}  // namespace Aws