FargateProfile.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/eks/EKS_EXPORTS.h>
#include <aws/eks/model/FargateProfileHealth.h>
#include <aws/eks/model/FargateProfileSelector.h>
#include <aws/eks/model/FargateProfileStatus.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace EKS {
namespace Model {
 
class FargateProfile {
 public:
  AWS_EKS_API FargateProfile() = default;
  AWS_EKS_API FargateProfile(Aws::Utils::Json::JsonView jsonValue);
  AWS_EKS_API FargateProfile& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_EKS_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetFargateProfileName() const { return m_fargateProfileName; }
  inline bool FargateProfileNameHasBeenSet() const { return m_fargateProfileNameHasBeenSet; }
  template <typename FargateProfileNameT = Aws::String>
  void SetFargateProfileName(FargateProfileNameT&& value) {
    m_fargateProfileNameHasBeenSet = true;
    m_fargateProfileName = std::forward<FargateProfileNameT>(value);
  }
  template <typename FargateProfileNameT = Aws::String>
  FargateProfile& WithFargateProfileName(FargateProfileNameT&& value) {
    SetFargateProfileName(std::forward<FargateProfileNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFargateProfileArn() const { return m_fargateProfileArn; }
  inline bool FargateProfileArnHasBeenSet() const { return m_fargateProfileArnHasBeenSet; }
  template <typename FargateProfileArnT = Aws::String>
  void SetFargateProfileArn(FargateProfileArnT&& value) {
    m_fargateProfileArnHasBeenSet = true;
    m_fargateProfileArn = std::forward<FargateProfileArnT>(value);
  }
  template <typename FargateProfileArnT = Aws::String>
  FargateProfile& WithFargateProfileArn(FargateProfileArnT&& value) {
    SetFargateProfileArn(std::forward<FargateProfileArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetClusterName() const { return m_clusterName; }
  inline bool ClusterNameHasBeenSet() const { return m_clusterNameHasBeenSet; }
  template <typename ClusterNameT = Aws::String>
  void SetClusterName(ClusterNameT&& value) {
    m_clusterNameHasBeenSet = true;
    m_clusterName = std::forward<ClusterNameT>(value);
  }
  template <typename ClusterNameT = Aws::String>
  FargateProfile& WithClusterName(ClusterNameT&& value) {
    SetClusterName(std::forward<ClusterNameT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreatedAt() const { return m_createdAt; }
  inline bool CreatedAtHasBeenSet() const { return m_createdAtHasBeenSet; }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  void SetCreatedAt(CreatedAtT&& value) {
    m_createdAtHasBeenSet = true;
    m_createdAt = std::forward<CreatedAtT>(value);
  }
  template <typename CreatedAtT = Aws::Utils::DateTime>
  FargateProfile& WithCreatedAt(CreatedAtT&& value) {
    SetCreatedAt(std::forward<CreatedAtT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPodExecutionRoleArn() const { return m_podExecutionRoleArn; }
  inline bool PodExecutionRoleArnHasBeenSet() const { return m_podExecutionRoleArnHasBeenSet; }
  template <typename PodExecutionRoleArnT = Aws::String>
  void SetPodExecutionRoleArn(PodExecutionRoleArnT&& value) {
    m_podExecutionRoleArnHasBeenSet = true;
    m_podExecutionRoleArn = std::forward<PodExecutionRoleArnT>(value);
  }
  template <typename PodExecutionRoleArnT = Aws::String>
  FargateProfile& WithPodExecutionRoleArn(PodExecutionRoleArnT&& value) {
    SetPodExecutionRoleArn(std::forward<PodExecutionRoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Aws::String>& GetSubnets() const { return m_subnets; }
  inline bool SubnetsHasBeenSet() const { return m_subnetsHasBeenSet; }
  template <typename SubnetsT = Aws::Vector<Aws::String>>
  void SetSubnets(SubnetsT&& value) {
    m_subnetsHasBeenSet = true;
    m_subnets = std::forward<SubnetsT>(value);
  }
  template <typename SubnetsT = Aws::Vector<Aws::String>>
  FargateProfile& WithSubnets(SubnetsT&& value) {
    SetSubnets(std::forward<SubnetsT>(value));
    return *this;
  }
  template <typename SubnetsT = Aws::String>
  FargateProfile& AddSubnets(SubnetsT&& value) {
    m_subnetsHasBeenSet = true;
    m_subnets.emplace_back(std::forward<SubnetsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<FargateProfileSelector>& GetSelectors() const { return m_selectors; }
  inline bool SelectorsHasBeenSet() const { return m_selectorsHasBeenSet; }
  template <typename SelectorsT = Aws::Vector<FargateProfileSelector>>
  void SetSelectors(SelectorsT&& value) {
    m_selectorsHasBeenSet = true;
    m_selectors = std::forward<SelectorsT>(value);
  }
  template <typename SelectorsT = Aws::Vector<FargateProfileSelector>>
  FargateProfile& WithSelectors(SelectorsT&& value) {
    SetSelectors(std::forward<SelectorsT>(value));
    return *this;
  }
  template <typename SelectorsT = FargateProfileSelector>
  FargateProfile& AddSelectors(SelectorsT&& value) {
    m_selectorsHasBeenSet = true;
    m_selectors.emplace_back(std::forward<SelectorsT>(value));
    return *this;
  }
 
 
  inline FargateProfileStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(FargateProfileStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline FargateProfile& WithStatus(FargateProfileStatus value) {
    SetStatus(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>>
  FargateProfile& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  FargateProfile& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const FargateProfileHealth& GetHealth() const { return m_health; }
  inline bool HealthHasBeenSet() const { return m_healthHasBeenSet; }
  template <typename HealthT = FargateProfileHealth>
  void SetHealth(HealthT&& value) {
    m_healthHasBeenSet = true;
    m_health = std::forward<HealthT>(value);
  }
  template <typename HealthT = FargateProfileHealth>
  FargateProfile& WithHealth(HealthT&& value) {
    SetHealth(std::forward<HealthT>(value));
    return *this;
  }
 private:
  Aws::String m_fargateProfileName;
 
  Aws::String m_fargateProfileArn;
 
  Aws::String m_clusterName;
 
  Aws::Utils::DateTime m_createdAt{};
 
  Aws::String m_podExecutionRoleArn;
 
  Aws::Vector<Aws::String> m_subnets;
 
  Aws::Vector<FargateProfileSelector> m_selectors;
 
  FargateProfileStatus m_status{FargateProfileStatus::NOT_SET};
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  FargateProfileHealth m_health;
  bool m_fargateProfileNameHasBeenSet = false;
  bool m_fargateProfileArnHasBeenSet = false;
  bool m_clusterNameHasBeenSet = false;
  bool m_createdAtHasBeenSet = false;
  bool m_podExecutionRoleArnHasBeenSet = false;
  bool m_subnetsHasBeenSet = false;
  bool m_selectorsHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_healthHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EKS
}  // namespace Aws