InputDeviceNetworkSettings.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/medialive/MediaLive_EXPORTS.h>
#include <aws/medialive/model/InputDeviceIpScheme.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace MediaLive {
namespace Model {
 
class InputDeviceNetworkSettings {
 public:
  AWS_MEDIALIVE_API InputDeviceNetworkSettings() = default;
  AWS_MEDIALIVE_API InputDeviceNetworkSettings(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIALIVE_API InputDeviceNetworkSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_MEDIALIVE_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::Vector<Aws::String>& GetDnsAddresses() const { return m_dnsAddresses; }
  inline bool DnsAddressesHasBeenSet() const { return m_dnsAddressesHasBeenSet; }
  template <typename DnsAddressesT = Aws::Vector<Aws::String>>
  void SetDnsAddresses(DnsAddressesT&& value) {
    m_dnsAddressesHasBeenSet = true;
    m_dnsAddresses = std::forward<DnsAddressesT>(value);
  }
  template <typename DnsAddressesT = Aws::Vector<Aws::String>>
  InputDeviceNetworkSettings& WithDnsAddresses(DnsAddressesT&& value) {
    SetDnsAddresses(std::forward<DnsAddressesT>(value));
    return *this;
  }
  template <typename DnsAddressesT = Aws::String>
  InputDeviceNetworkSettings& AddDnsAddresses(DnsAddressesT&& value) {
    m_dnsAddressesHasBeenSet = true;
    m_dnsAddresses.emplace_back(std::forward<DnsAddressesT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetGateway() const { return m_gateway; }
  inline bool GatewayHasBeenSet() const { return m_gatewayHasBeenSet; }
  template <typename GatewayT = Aws::String>
  void SetGateway(GatewayT&& value) {
    m_gatewayHasBeenSet = true;
    m_gateway = std::forward<GatewayT>(value);
  }
  template <typename GatewayT = Aws::String>
  InputDeviceNetworkSettings& WithGateway(GatewayT&& value) {
    SetGateway(std::forward<GatewayT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetIpAddress() const { return m_ipAddress; }
  inline bool IpAddressHasBeenSet() const { return m_ipAddressHasBeenSet; }
  template <typename IpAddressT = Aws::String>
  void SetIpAddress(IpAddressT&& value) {
    m_ipAddressHasBeenSet = true;
    m_ipAddress = std::forward<IpAddressT>(value);
  }
  template <typename IpAddressT = Aws::String>
  InputDeviceNetworkSettings& WithIpAddress(IpAddressT&& value) {
    SetIpAddress(std::forward<IpAddressT>(value));
    return *this;
  }
 
 
  inline InputDeviceIpScheme GetIpScheme() const { return m_ipScheme; }
  inline bool IpSchemeHasBeenSet() const { return m_ipSchemeHasBeenSet; }
  inline void SetIpScheme(InputDeviceIpScheme value) {
    m_ipSchemeHasBeenSet = true;
    m_ipScheme = value;
  }
  inline InputDeviceNetworkSettings& WithIpScheme(InputDeviceIpScheme value) {
    SetIpScheme(value);
    return *this;
  }
 
 
  inline const Aws::String& GetSubnetMask() const { return m_subnetMask; }
  inline bool SubnetMaskHasBeenSet() const { return m_subnetMaskHasBeenSet; }
  template <typename SubnetMaskT = Aws::String>
  void SetSubnetMask(SubnetMaskT&& value) {
    m_subnetMaskHasBeenSet = true;
    m_subnetMask = std::forward<SubnetMaskT>(value);
  }
  template <typename SubnetMaskT = Aws::String>
  InputDeviceNetworkSettings& WithSubnetMask(SubnetMaskT&& value) {
    SetSubnetMask(std::forward<SubnetMaskT>(value));
    return *this;
  }
 private:
  Aws::Vector<Aws::String> m_dnsAddresses;
 
  Aws::String m_gateway;
 
  Aws::String m_ipAddress;
 
  InputDeviceIpScheme m_ipScheme{InputDeviceIpScheme::NOT_SET};
 
  Aws::String m_subnetMask;
  bool m_dnsAddressesHasBeenSet = false;
  bool m_gatewayHasBeenSet = false;
  bool m_ipAddressHasBeenSet = false;
  bool m_ipSchemeHasBeenSet = false;
  bool m_subnetMaskHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace MediaLive
}  // namespace Aws