KubernetesNetworkConfigResponse.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/eks/EKS_EXPORTS.h>
#include <aws/eks/model/ElasticLoadBalancing.h>
#include <aws/eks/model/IpFamily.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace EKS {
namespace Model {
 
class KubernetesNetworkConfigResponse {
 public:
  AWS_EKS_API KubernetesNetworkConfigResponse() = default;
  AWS_EKS_API KubernetesNetworkConfigResponse(Aws::Utils::Json::JsonView jsonValue);
  AWS_EKS_API KubernetesNetworkConfigResponse& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_EKS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetServiceIpv4Cidr() const { return m_serviceIpv4Cidr; }
  inline bool ServiceIpv4CidrHasBeenSet() const { return m_serviceIpv4CidrHasBeenSet; }
  template <typename ServiceIpv4CidrT = Aws::String>
  void SetServiceIpv4Cidr(ServiceIpv4CidrT&& value) {
    m_serviceIpv4CidrHasBeenSet = true;
    m_serviceIpv4Cidr = std::forward<ServiceIpv4CidrT>(value);
  }
  template <typename ServiceIpv4CidrT = Aws::String>
  KubernetesNetworkConfigResponse& WithServiceIpv4Cidr(ServiceIpv4CidrT&& value) {
    SetServiceIpv4Cidr(std::forward<ServiceIpv4CidrT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetServiceIpv6Cidr() const { return m_serviceIpv6Cidr; }
  inline bool ServiceIpv6CidrHasBeenSet() const { return m_serviceIpv6CidrHasBeenSet; }
  template <typename ServiceIpv6CidrT = Aws::String>
  void SetServiceIpv6Cidr(ServiceIpv6CidrT&& value) {
    m_serviceIpv6CidrHasBeenSet = true;
    m_serviceIpv6Cidr = std::forward<ServiceIpv6CidrT>(value);
  }
  template <typename ServiceIpv6CidrT = Aws::String>
  KubernetesNetworkConfigResponse& WithServiceIpv6Cidr(ServiceIpv6CidrT&& value) {
    SetServiceIpv6Cidr(std::forward<ServiceIpv6CidrT>(value));
    return *this;
  }
 
 
  inline IpFamily GetIpFamily() const { return m_ipFamily; }
  inline bool IpFamilyHasBeenSet() const { return m_ipFamilyHasBeenSet; }
  inline void SetIpFamily(IpFamily value) {
    m_ipFamilyHasBeenSet = true;
    m_ipFamily = value;
  }
  inline KubernetesNetworkConfigResponse& WithIpFamily(IpFamily value) {
    SetIpFamily(value);
    return *this;
  }
 
 
  inline const ElasticLoadBalancing& GetElasticLoadBalancing() const { return m_elasticLoadBalancing; }
  inline bool ElasticLoadBalancingHasBeenSet() const { return m_elasticLoadBalancingHasBeenSet; }
  template <typename ElasticLoadBalancingT = ElasticLoadBalancing>
  void SetElasticLoadBalancing(ElasticLoadBalancingT&& value) {
    m_elasticLoadBalancingHasBeenSet = true;
    m_elasticLoadBalancing = std::forward<ElasticLoadBalancingT>(value);
  }
  template <typename ElasticLoadBalancingT = ElasticLoadBalancing>
  KubernetesNetworkConfigResponse& WithElasticLoadBalancing(ElasticLoadBalancingT&& value) {
    SetElasticLoadBalancing(std::forward<ElasticLoadBalancingT>(value));
    return *this;
  }
 private:
  Aws::String m_serviceIpv4Cidr;
 
  Aws::String m_serviceIpv6Cidr;
 
  IpFamily m_ipFamily{IpFamily::NOT_SET};
 
  ElasticLoadBalancing m_elasticLoadBalancing;
  bool m_serviceIpv4CidrHasBeenSet = false;
  bool m_serviceIpv6CidrHasBeenSet = false;
  bool m_ipFamilyHasBeenSet = false;
  bool m_elasticLoadBalancingHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EKS
}  // namespace Aws