Outpost.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/outposts/Outposts_EXPORTS.h>
#include <aws/outposts/model/SupportedHardwareType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Outposts {
namespace Model {
 
class Outpost {
 public:
  AWS_OUTPOSTS_API Outpost() = default;
  AWS_OUTPOSTS_API Outpost(Aws::Utils::Json::JsonView jsonValue);
  AWS_OUTPOSTS_API Outpost& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_OUTPOSTS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetOutpostId() const { return m_outpostId; }
  inline bool OutpostIdHasBeenSet() const { return m_outpostIdHasBeenSet; }
  template <typename OutpostIdT = Aws::String>
  void SetOutpostId(OutpostIdT&& value) {
    m_outpostIdHasBeenSet = true;
    m_outpostId = std::forward<OutpostIdT>(value);
  }
  template <typename OutpostIdT = Aws::String>
  Outpost& WithOutpostId(OutpostIdT&& value) {
    SetOutpostId(std::forward<OutpostIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOwnerId() const { return m_ownerId; }
  inline bool OwnerIdHasBeenSet() const { return m_ownerIdHasBeenSet; }
  template <typename OwnerIdT = Aws::String>
  void SetOwnerId(OwnerIdT&& value) {
    m_ownerIdHasBeenSet = true;
    m_ownerId = std::forward<OwnerIdT>(value);
  }
  template <typename OwnerIdT = Aws::String>
  Outpost& WithOwnerId(OwnerIdT&& value) {
    SetOwnerId(std::forward<OwnerIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetOutpostArn() const { return m_outpostArn; }
  inline bool OutpostArnHasBeenSet() const { return m_outpostArnHasBeenSet; }
  template <typename OutpostArnT = Aws::String>
  void SetOutpostArn(OutpostArnT&& value) {
    m_outpostArnHasBeenSet = true;
    m_outpostArn = std::forward<OutpostArnT>(value);
  }
  template <typename OutpostArnT = Aws::String>
  Outpost& WithOutpostArn(OutpostArnT&& value) {
    SetOutpostArn(std::forward<OutpostArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSiteId() const { return m_siteId; }
  inline bool SiteIdHasBeenSet() const { return m_siteIdHasBeenSet; }
  template <typename SiteIdT = Aws::String>
  void SetSiteId(SiteIdT&& value) {
    m_siteIdHasBeenSet = true;
    m_siteId = std::forward<SiteIdT>(value);
  }
  template <typename SiteIdT = Aws::String>
  Outpost& WithSiteId(SiteIdT&& value) {
    SetSiteId(std::forward<SiteIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  Outpost& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  Outpost& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLifeCycleStatus() const { return m_lifeCycleStatus; }
  inline bool LifeCycleStatusHasBeenSet() const { return m_lifeCycleStatusHasBeenSet; }
  template <typename LifeCycleStatusT = Aws::String>
  void SetLifeCycleStatus(LifeCycleStatusT&& value) {
    m_lifeCycleStatusHasBeenSet = true;
    m_lifeCycleStatus = std::forward<LifeCycleStatusT>(value);
  }
  template <typename LifeCycleStatusT = Aws::String>
  Outpost& WithLifeCycleStatus(LifeCycleStatusT&& value) {
    SetLifeCycleStatus(std::forward<LifeCycleStatusT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAvailabilityZone() const { return m_availabilityZone; }
  inline bool AvailabilityZoneHasBeenSet() const { return m_availabilityZoneHasBeenSet; }
  template <typename AvailabilityZoneT = Aws::String>
  void SetAvailabilityZone(AvailabilityZoneT&& value) {
    m_availabilityZoneHasBeenSet = true;
    m_availabilityZone = std::forward<AvailabilityZoneT>(value);
  }
  template <typename AvailabilityZoneT = Aws::String>
  Outpost& WithAvailabilityZone(AvailabilityZoneT&& value) {
    SetAvailabilityZone(std::forward<AvailabilityZoneT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetAvailabilityZoneId() const { return m_availabilityZoneId; }
  inline bool AvailabilityZoneIdHasBeenSet() const { return m_availabilityZoneIdHasBeenSet; }
  template <typename AvailabilityZoneIdT = Aws::String>
  void SetAvailabilityZoneId(AvailabilityZoneIdT&& value) {
    m_availabilityZoneIdHasBeenSet = true;
    m_availabilityZoneId = std::forward<AvailabilityZoneIdT>(value);
  }
  template <typename AvailabilityZoneIdT = Aws::String>
  Outpost& WithAvailabilityZoneId(AvailabilityZoneIdT&& value) {
    SetAvailabilityZoneId(std::forward<AvailabilityZoneIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Map<Aws::String, Aws::String>& GetTags() const { return m_tags; }
  inline bool TagsHasBeenSet() const { return m_tagsHasBeenSet; }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  void SetTags(TagsT&& value) {
    m_tagsHasBeenSet = true;
    m_tags = std::forward<TagsT>(value);
  }
  template <typename TagsT = Aws::Map<Aws::String, Aws::String>>
  Outpost& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  Outpost& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSiteArn() const { return m_siteArn; }
  inline bool SiteArnHasBeenSet() const { return m_siteArnHasBeenSet; }
  template <typename SiteArnT = Aws::String>
  void SetSiteArn(SiteArnT&& value) {
    m_siteArnHasBeenSet = true;
    m_siteArn = std::forward<SiteArnT>(value);
  }
  template <typename SiteArnT = Aws::String>
  Outpost& WithSiteArn(SiteArnT&& value) {
    SetSiteArn(std::forward<SiteArnT>(value));
    return *this;
  }
 
 
  inline SupportedHardwareType GetSupportedHardwareType() const { return m_supportedHardwareType; }
  inline bool SupportedHardwareTypeHasBeenSet() const { return m_supportedHardwareTypeHasBeenSet; }
  inline void SetSupportedHardwareType(SupportedHardwareType value) {
    m_supportedHardwareTypeHasBeenSet = true;
    m_supportedHardwareType = value;
  }
  inline Outpost& WithSupportedHardwareType(SupportedHardwareType value) {
    SetSupportedHardwareType(value);
    return *this;
  }
 private:
  Aws::String m_outpostId;
 
  Aws::String m_ownerId;
 
  Aws::String m_outpostArn;
 
  Aws::String m_siteId;
 
  Aws::String m_name;
 
  Aws::String m_description;
 
  Aws::String m_lifeCycleStatus;
 
  Aws::String m_availabilityZone;
 
  Aws::String m_availabilityZoneId;
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  Aws::String m_siteArn;
 
  SupportedHardwareType m_supportedHardwareType{SupportedHardwareType::NOT_SET};
  bool m_outpostIdHasBeenSet = false;
  bool m_ownerIdHasBeenSet = false;
  bool m_outpostArnHasBeenSet = false;
  bool m_siteIdHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_lifeCycleStatusHasBeenSet = false;
  bool m_availabilityZoneHasBeenSet = false;
  bool m_availabilityZoneIdHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_siteArnHasBeenSet = false;
  bool m_supportedHardwareTypeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Outposts
}  // namespace Aws