InitialVlans.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/evs/EVS_EXPORTS.h>
#include <aws/evs/model/InitialVlanInfo.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace EVS {
namespace Model {
 
class InitialVlans {
 public:
  AWS_EVS_API InitialVlans() = default;
  AWS_EVS_API InitialVlans(Aws::Utils::Json::JsonView jsonValue);
  AWS_EVS_API InitialVlans& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_EVS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const InitialVlanInfo& GetVmkManagement() const { return m_vmkManagement; }
  inline bool VmkManagementHasBeenSet() const { return m_vmkManagementHasBeenSet; }
  template <typename VmkManagementT = InitialVlanInfo>
  void SetVmkManagement(VmkManagementT&& value) {
    m_vmkManagementHasBeenSet = true;
    m_vmkManagement = std::forward<VmkManagementT>(value);
  }
  template <typename VmkManagementT = InitialVlanInfo>
  InitialVlans& WithVmkManagement(VmkManagementT&& value) {
    SetVmkManagement(std::forward<VmkManagementT>(value));
    return *this;
  }
 
 
  inline const InitialVlanInfo& GetVmManagement() const { return m_vmManagement; }
  inline bool VmManagementHasBeenSet() const { return m_vmManagementHasBeenSet; }
  template <typename VmManagementT = InitialVlanInfo>
  void SetVmManagement(VmManagementT&& value) {
    m_vmManagementHasBeenSet = true;
    m_vmManagement = std::forward<VmManagementT>(value);
  }
  template <typename VmManagementT = InitialVlanInfo>
  InitialVlans& WithVmManagement(VmManagementT&& value) {
    SetVmManagement(std::forward<VmManagementT>(value));
    return *this;
  }
 
 
  inline const InitialVlanInfo& GetVMotion() const { return m_vMotion; }
  inline bool VMotionHasBeenSet() const { return m_vMotionHasBeenSet; }
  template <typename VMotionT = InitialVlanInfo>
  void SetVMotion(VMotionT&& value) {
    m_vMotionHasBeenSet = true;
    m_vMotion = std::forward<VMotionT>(value);
  }
  template <typename VMotionT = InitialVlanInfo>
  InitialVlans& WithVMotion(VMotionT&& value) {
    SetVMotion(std::forward<VMotionT>(value));
    return *this;
  }
 
 
  inline const InitialVlanInfo& GetVSan() const { return m_vSan; }
  inline bool VSanHasBeenSet() const { return m_vSanHasBeenSet; }
  template <typename VSanT = InitialVlanInfo>
  void SetVSan(VSanT&& value) {
    m_vSanHasBeenSet = true;
    m_vSan = std::forward<VSanT>(value);
  }
  template <typename VSanT = InitialVlanInfo>
  InitialVlans& WithVSan(VSanT&& value) {
    SetVSan(std::forward<VSanT>(value));
    return *this;
  }
 
 
  inline const InitialVlanInfo& GetVTep() const { return m_vTep; }
  inline bool VTepHasBeenSet() const { return m_vTepHasBeenSet; }
  template <typename VTepT = InitialVlanInfo>
  void SetVTep(VTepT&& value) {
    m_vTepHasBeenSet = true;
    m_vTep = std::forward<VTepT>(value);
  }
  template <typename VTepT = InitialVlanInfo>
  InitialVlans& WithVTep(VTepT&& value) {
    SetVTep(std::forward<VTepT>(value));
    return *this;
  }
 
 
  inline const InitialVlanInfo& GetEdgeVTep() const { return m_edgeVTep; }
  inline bool EdgeVTepHasBeenSet() const { return m_edgeVTepHasBeenSet; }
  template <typename EdgeVTepT = InitialVlanInfo>
  void SetEdgeVTep(EdgeVTepT&& value) {
    m_edgeVTepHasBeenSet = true;
    m_edgeVTep = std::forward<EdgeVTepT>(value);
  }
  template <typename EdgeVTepT = InitialVlanInfo>
  InitialVlans& WithEdgeVTep(EdgeVTepT&& value) {
    SetEdgeVTep(std::forward<EdgeVTepT>(value));
    return *this;
  }
 
 
  inline const InitialVlanInfo& GetNsxUplink() const { return m_nsxUplink; }
  inline bool NsxUplinkHasBeenSet() const { return m_nsxUplinkHasBeenSet; }
  template <typename NsxUplinkT = InitialVlanInfo>
  void SetNsxUplink(NsxUplinkT&& value) {
    m_nsxUplinkHasBeenSet = true;
    m_nsxUplink = std::forward<NsxUplinkT>(value);
  }
  template <typename NsxUplinkT = InitialVlanInfo>
  InitialVlans& WithNsxUplink(NsxUplinkT&& value) {
    SetNsxUplink(std::forward<NsxUplinkT>(value));
    return *this;
  }
 
 
  inline const InitialVlanInfo& GetHcx() const { return m_hcx; }
  inline bool HcxHasBeenSet() const { return m_hcxHasBeenSet; }
  template <typename HcxT = InitialVlanInfo>
  void SetHcx(HcxT&& value) {
    m_hcxHasBeenSet = true;
    m_hcx = std::forward<HcxT>(value);
  }
  template <typename HcxT = InitialVlanInfo>
  InitialVlans& WithHcx(HcxT&& value) {
    SetHcx(std::forward<HcxT>(value));
    return *this;
  }
 
 
  inline const InitialVlanInfo& GetExpansionVlan1() const { return m_expansionVlan1; }
  inline bool ExpansionVlan1HasBeenSet() const { return m_expansionVlan1HasBeenSet; }
  template <typename ExpansionVlan1T = InitialVlanInfo>
  void SetExpansionVlan1(ExpansionVlan1T&& value) {
    m_expansionVlan1HasBeenSet = true;
    m_expansionVlan1 = std::forward<ExpansionVlan1T>(value);
  }
  template <typename ExpansionVlan1T = InitialVlanInfo>
  InitialVlans& WithExpansionVlan1(ExpansionVlan1T&& value) {
    SetExpansionVlan1(std::forward<ExpansionVlan1T>(value));
    return *this;
  }
 
 
  inline const InitialVlanInfo& GetExpansionVlan2() const { return m_expansionVlan2; }
  inline bool ExpansionVlan2HasBeenSet() const { return m_expansionVlan2HasBeenSet; }
  template <typename ExpansionVlan2T = InitialVlanInfo>
  void SetExpansionVlan2(ExpansionVlan2T&& value) {
    m_expansionVlan2HasBeenSet = true;
    m_expansionVlan2 = std::forward<ExpansionVlan2T>(value);
  }
  template <typename ExpansionVlan2T = InitialVlanInfo>
  InitialVlans& WithExpansionVlan2(ExpansionVlan2T&& value) {
    SetExpansionVlan2(std::forward<ExpansionVlan2T>(value));
    return *this;
  }
 
 
  inline bool GetIsHcxPublic() const { return m_isHcxPublic; }
  inline bool IsHcxPublicHasBeenSet() const { return m_isHcxPublicHasBeenSet; }
  inline void SetIsHcxPublic(bool value) {
    m_isHcxPublicHasBeenSet = true;
    m_isHcxPublic = value;
  }
  inline InitialVlans& WithIsHcxPublic(bool value) {
    SetIsHcxPublic(value);
    return *this;
  }
 
 
  inline const Aws::String& GetHcxNetworkAclId() const { return m_hcxNetworkAclId; }
  inline bool HcxNetworkAclIdHasBeenSet() const { return m_hcxNetworkAclIdHasBeenSet; }
  template <typename HcxNetworkAclIdT = Aws::String>
  void SetHcxNetworkAclId(HcxNetworkAclIdT&& value) {
    m_hcxNetworkAclIdHasBeenSet = true;
    m_hcxNetworkAclId = std::forward<HcxNetworkAclIdT>(value);
  }
  template <typename HcxNetworkAclIdT = Aws::String>
  InitialVlans& WithHcxNetworkAclId(HcxNetworkAclIdT&& value) {
    SetHcxNetworkAclId(std::forward<HcxNetworkAclIdT>(value));
    return *this;
  }
 private:
  InitialVlanInfo m_vmkManagement;
 
  InitialVlanInfo m_vmManagement;
 
  InitialVlanInfo m_vMotion;
 
  InitialVlanInfo m_vSan;
 
  InitialVlanInfo m_vTep;
 
  InitialVlanInfo m_edgeVTep;
 
  InitialVlanInfo m_nsxUplink;
 
  InitialVlanInfo m_hcx;
 
  InitialVlanInfo m_expansionVlan1;
 
  InitialVlanInfo m_expansionVlan2;
 
  bool m_isHcxPublic{false};
 
  Aws::String m_hcxNetworkAclId;
  bool m_vmkManagementHasBeenSet = false;
  bool m_vmManagementHasBeenSet = false;
  bool m_vMotionHasBeenSet = false;
  bool m_vSanHasBeenSet = false;
  bool m_vTepHasBeenSet = false;
  bool m_edgeVTepHasBeenSet = false;
  bool m_nsxUplinkHasBeenSet = false;
  bool m_hcxHasBeenSet = false;
  bool m_expansionVlan1HasBeenSet = false;
  bool m_expansionVlan2HasBeenSet = false;
  bool m_isHcxPublicHasBeenSet = false;
  bool m_hcxNetworkAclIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EVS
}  // namespace Aws