VcfHostnames.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/evs/EVS_EXPORTS.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace EVS {
namespace Model {
 
class VcfHostnames {
 public:
  AWS_EVS_API VcfHostnames() = default;
  AWS_EVS_API VcfHostnames(Aws::Utils::Json::JsonView jsonValue);
  AWS_EVS_API VcfHostnames& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_EVS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetVCenter() const { return m_vCenter; }
  inline bool VCenterHasBeenSet() const { return m_vCenterHasBeenSet; }
  template <typename VCenterT = Aws::String>
  void SetVCenter(VCenterT&& value) {
    m_vCenterHasBeenSet = true;
    m_vCenter = std::forward<VCenterT>(value);
  }
  template <typename VCenterT = Aws::String>
  VcfHostnames& WithVCenter(VCenterT&& value) {
    SetVCenter(std::forward<VCenterT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNsx() const { return m_nsx; }
  inline bool NsxHasBeenSet() const { return m_nsxHasBeenSet; }
  template <typename NsxT = Aws::String>
  void SetNsx(NsxT&& value) {
    m_nsxHasBeenSet = true;
    m_nsx = std::forward<NsxT>(value);
  }
  template <typename NsxT = Aws::String>
  VcfHostnames& WithNsx(NsxT&& value) {
    SetNsx(std::forward<NsxT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNsxManager1() const { return m_nsxManager1; }
  inline bool NsxManager1HasBeenSet() const { return m_nsxManager1HasBeenSet; }
  template <typename NsxManager1T = Aws::String>
  void SetNsxManager1(NsxManager1T&& value) {
    m_nsxManager1HasBeenSet = true;
    m_nsxManager1 = std::forward<NsxManager1T>(value);
  }
  template <typename NsxManager1T = Aws::String>
  VcfHostnames& WithNsxManager1(NsxManager1T&& value) {
    SetNsxManager1(std::forward<NsxManager1T>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNsxManager2() const { return m_nsxManager2; }
  inline bool NsxManager2HasBeenSet() const { return m_nsxManager2HasBeenSet; }
  template <typename NsxManager2T = Aws::String>
  void SetNsxManager2(NsxManager2T&& value) {
    m_nsxManager2HasBeenSet = true;
    m_nsxManager2 = std::forward<NsxManager2T>(value);
  }
  template <typename NsxManager2T = Aws::String>
  VcfHostnames& WithNsxManager2(NsxManager2T&& value) {
    SetNsxManager2(std::forward<NsxManager2T>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNsxManager3() const { return m_nsxManager3; }
  inline bool NsxManager3HasBeenSet() const { return m_nsxManager3HasBeenSet; }
  template <typename NsxManager3T = Aws::String>
  void SetNsxManager3(NsxManager3T&& value) {
    m_nsxManager3HasBeenSet = true;
    m_nsxManager3 = std::forward<NsxManager3T>(value);
  }
  template <typename NsxManager3T = Aws::String>
  VcfHostnames& WithNsxManager3(NsxManager3T&& value) {
    SetNsxManager3(std::forward<NsxManager3T>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNsxEdge1() const { return m_nsxEdge1; }
  inline bool NsxEdge1HasBeenSet() const { return m_nsxEdge1HasBeenSet; }
  template <typename NsxEdge1T = Aws::String>
  void SetNsxEdge1(NsxEdge1T&& value) {
    m_nsxEdge1HasBeenSet = true;
    m_nsxEdge1 = std::forward<NsxEdge1T>(value);
  }
  template <typename NsxEdge1T = Aws::String>
  VcfHostnames& WithNsxEdge1(NsxEdge1T&& value) {
    SetNsxEdge1(std::forward<NsxEdge1T>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNsxEdge2() const { return m_nsxEdge2; }
  inline bool NsxEdge2HasBeenSet() const { return m_nsxEdge2HasBeenSet; }
  template <typename NsxEdge2T = Aws::String>
  void SetNsxEdge2(NsxEdge2T&& value) {
    m_nsxEdge2HasBeenSet = true;
    m_nsxEdge2 = std::forward<NsxEdge2T>(value);
  }
  template <typename NsxEdge2T = Aws::String>
  VcfHostnames& WithNsxEdge2(NsxEdge2T&& value) {
    SetNsxEdge2(std::forward<NsxEdge2T>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSddcManager() const { return m_sddcManager; }
  inline bool SddcManagerHasBeenSet() const { return m_sddcManagerHasBeenSet; }
  template <typename SddcManagerT = Aws::String>
  void SetSddcManager(SddcManagerT&& value) {
    m_sddcManagerHasBeenSet = true;
    m_sddcManager = std::forward<SddcManagerT>(value);
  }
  template <typename SddcManagerT = Aws::String>
  VcfHostnames& WithSddcManager(SddcManagerT&& value) {
    SetSddcManager(std::forward<SddcManagerT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCloudBuilder() const { return m_cloudBuilder; }
  inline bool CloudBuilderHasBeenSet() const { return m_cloudBuilderHasBeenSet; }
  template <typename CloudBuilderT = Aws::String>
  void SetCloudBuilder(CloudBuilderT&& value) {
    m_cloudBuilderHasBeenSet = true;
    m_cloudBuilder = std::forward<CloudBuilderT>(value);
  }
  template <typename CloudBuilderT = Aws::String>
  VcfHostnames& WithCloudBuilder(CloudBuilderT&& value) {
    SetCloudBuilder(std::forward<CloudBuilderT>(value));
    return *this;
  }
 private:
  Aws::String m_vCenter;
 
  Aws::String m_nsx;
 
  Aws::String m_nsxManager1;
 
  Aws::String m_nsxManager2;
 
  Aws::String m_nsxManager3;
 
  Aws::String m_nsxEdge1;
 
  Aws::String m_nsxEdge2;
 
  Aws::String m_sddcManager;
 
  Aws::String m_cloudBuilder;
  bool m_vCenterHasBeenSet = false;
  bool m_nsxHasBeenSet = false;
  bool m_nsxManager1HasBeenSet = false;
  bool m_nsxManager2HasBeenSet = false;
  bool m_nsxManager3HasBeenSet = false;
  bool m_nsxEdge1HasBeenSet = false;
  bool m_nsxEdge2HasBeenSet = false;
  bool m_sddcManagerHasBeenSet = false;
  bool m_cloudBuilderHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EVS
}  // namespace Aws