Resource.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSMap.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/inspector2/Inspector2_EXPORTS.h>
#include <aws/inspector2/model/Provider.h>
#include <aws/inspector2/model/ResourceDetails.h>
#include <aws/inspector2/model/ResourceType.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Inspector2 {
namespace Model {
 
class Resource {
 public:
  AWS_INSPECTOR2_API Resource() = default;
  AWS_INSPECTOR2_API Resource(Aws::Utils::Json::JsonView jsonValue);
  AWS_INSPECTOR2_API Resource& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_INSPECTOR2_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline ResourceType GetType() const { return m_type; }
  inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
  inline void SetType(ResourceType value) {
    m_typeHasBeenSet = true;
    m_type = value;
  }
  inline Resource& WithType(ResourceType value) {
    SetType(value);
    return *this;
  }
 
 
  inline const Aws::String& GetId() const { return m_id; }
  inline bool IdHasBeenSet() const { return m_idHasBeenSet; }
  template <typename IdT = Aws::String>
  void SetId(IdT&& value) {
    m_idHasBeenSet = true;
    m_id = std::forward<IdT>(value);
  }
  template <typename IdT = Aws::String>
  Resource& WithId(IdT&& value) {
    SetId(std::forward<IdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPartition() const { return m_partition; }
  inline bool PartitionHasBeenSet() const { return m_partitionHasBeenSet; }
  template <typename PartitionT = Aws::String>
  void SetPartition(PartitionT&& value) {
    m_partitionHasBeenSet = true;
    m_partition = std::forward<PartitionT>(value);
  }
  template <typename PartitionT = Aws::String>
  Resource& WithPartition(PartitionT&& value) {
    SetPartition(std::forward<PartitionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRegion() const { return m_region; }
  inline bool RegionHasBeenSet() const { return m_regionHasBeenSet; }
  template <typename RegionT = Aws::String>
  void SetRegion(RegionT&& value) {
    m_regionHasBeenSet = true;
    m_region = std::forward<RegionT>(value);
  }
  template <typename RegionT = Aws::String>
  Resource& WithRegion(RegionT&& value) {
    SetRegion(std::forward<RegionT>(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>>
  Resource& WithTags(TagsT&& value) {
    SetTags(std::forward<TagsT>(value));
    return *this;
  }
  template <typename TagsKeyT = Aws::String, typename TagsValueT = Aws::String>
  Resource& AddTags(TagsKeyT&& key, TagsValueT&& value) {
    m_tagsHasBeenSet = true;
    m_tags.emplace(std::forward<TagsKeyT>(key), std::forward<TagsValueT>(value));
    return *this;
  }
 
 
  inline const ResourceDetails& GetDetails() const { return m_details; }
  inline bool DetailsHasBeenSet() const { return m_detailsHasBeenSet; }
  template <typename DetailsT = ResourceDetails>
  void SetDetails(DetailsT&& value) {
    m_detailsHasBeenSet = true;
    m_details = std::forward<DetailsT>(value);
  }
  template <typename DetailsT = ResourceDetails>
  Resource& WithDetails(DetailsT&& value) {
    SetDetails(std::forward<DetailsT>(value));
    return *this;
  }
 
 
  inline Provider GetProvider() const { return m_provider; }
  inline bool ProviderHasBeenSet() const { return m_providerHasBeenSet; }
  inline void SetProvider(Provider value) {
    m_providerHasBeenSet = true;
    m_provider = value;
  }
  inline Resource& WithProvider(Provider value) {
    SetProvider(value);
    return *this;
  }
 
 
  inline const Aws::String& GetProviderAccountId() const { return m_providerAccountId; }
  inline bool ProviderAccountIdHasBeenSet() const { return m_providerAccountIdHasBeenSet; }
  template <typename ProviderAccountIdT = Aws::String>
  void SetProviderAccountId(ProviderAccountIdT&& value) {
    m_providerAccountIdHasBeenSet = true;
    m_providerAccountId = std::forward<ProviderAccountIdT>(value);
  }
  template <typename ProviderAccountIdT = Aws::String>
  Resource& WithProviderAccountId(ProviderAccountIdT&& value) {
    SetProviderAccountId(std::forward<ProviderAccountIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetProviderOrgId() const { return m_providerOrgId; }
  inline bool ProviderOrgIdHasBeenSet() const { return m_providerOrgIdHasBeenSet; }
  template <typename ProviderOrgIdT = Aws::String>
  void SetProviderOrgId(ProviderOrgIdT&& value) {
    m_providerOrgIdHasBeenSet = true;
    m_providerOrgId = std::forward<ProviderOrgIdT>(value);
  }
  template <typename ProviderOrgIdT = Aws::String>
  Resource& WithProviderOrgId(ProviderOrgIdT&& value) {
    SetProviderOrgId(std::forward<ProviderOrgIdT>(value));
    return *this;
  }
 private:
  ResourceType m_type{ResourceType::NOT_SET};
 
  Aws::String m_id;
 
  Aws::String m_partition;
 
  Aws::String m_region;
 
  Aws::Map<Aws::String, Aws::String> m_tags;
 
  ResourceDetails m_details;
 
  Provider m_provider{Provider::NOT_SET};
 
  Aws::String m_providerAccountId;
 
  Aws::String m_providerOrgId;
  bool m_typeHasBeenSet = false;
  bool m_idHasBeenSet = false;
  bool m_partitionHasBeenSet = false;
  bool m_regionHasBeenSet = false;
  bool m_tagsHasBeenSet = false;
  bool m_detailsHasBeenSet = false;
  bool m_providerHasBeenSet = false;
  bool m_providerAccountIdHasBeenSet = false;
  bool m_providerOrgIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Inspector2
}  // namespace Aws