DescribeImageAttributeResponse.h

 
#pragma once
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/ec2/EC2_EXPORTS.h>
#include <aws/ec2/model/AttributeValue.h>
#include <aws/ec2/model/BlockDeviceMapping.h>
#include <aws/ec2/model/LaunchPermission.h>
#include <aws/ec2/model/ProductCode.h>
#include <aws/ec2/model/ResponseMetadata.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Xml {
class XmlDocument;
}  // namespace Xml
}  // namespace Utils
namespace EC2 {
namespace Model {
class DescribeImageAttributeResponse {
 public:
  AWS_EC2_API DescribeImageAttributeResponse() = default;
  AWS_EC2_API DescribeImageAttributeResponse(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
  AWS_EC2_API DescribeImageAttributeResponse& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
 
 
  inline const AttributeValue& GetDescription() const { return m_description; }
  template <typename DescriptionT = AttributeValue>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = AttributeValue>
  DescribeImageAttributeResponse& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetKernelId() const { return m_kernelId; }
  template <typename KernelIdT = AttributeValue>
  void SetKernelId(KernelIdT&& value) {
    m_kernelIdHasBeenSet = true;
    m_kernelId = std::forward<KernelIdT>(value);
  }
  template <typename KernelIdT = AttributeValue>
  DescribeImageAttributeResponse& WithKernelId(KernelIdT&& value) {
    SetKernelId(std::forward<KernelIdT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetRamdiskId() const { return m_ramdiskId; }
  template <typename RamdiskIdT = AttributeValue>
  void SetRamdiskId(RamdiskIdT&& value) {
    m_ramdiskIdHasBeenSet = true;
    m_ramdiskId = std::forward<RamdiskIdT>(value);
  }
  template <typename RamdiskIdT = AttributeValue>
  DescribeImageAttributeResponse& WithRamdiskId(RamdiskIdT&& value) {
    SetRamdiskId(std::forward<RamdiskIdT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetSriovNetSupport() const { return m_sriovNetSupport; }
  template <typename SriovNetSupportT = AttributeValue>
  void SetSriovNetSupport(SriovNetSupportT&& value) {
    m_sriovNetSupportHasBeenSet = true;
    m_sriovNetSupport = std::forward<SriovNetSupportT>(value);
  }
  template <typename SriovNetSupportT = AttributeValue>
  DescribeImageAttributeResponse& WithSriovNetSupport(SriovNetSupportT&& value) {
    SetSriovNetSupport(std::forward<SriovNetSupportT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetBootMode() const { return m_bootMode; }
  template <typename BootModeT = AttributeValue>
  void SetBootMode(BootModeT&& value) {
    m_bootModeHasBeenSet = true;
    m_bootMode = std::forward<BootModeT>(value);
  }
  template <typename BootModeT = AttributeValue>
  DescribeImageAttributeResponse& WithBootMode(BootModeT&& value) {
    SetBootMode(std::forward<BootModeT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetTpmSupport() const { return m_tpmSupport; }
  template <typename TpmSupportT = AttributeValue>
  void SetTpmSupport(TpmSupportT&& value) {
    m_tpmSupportHasBeenSet = true;
    m_tpmSupport = std::forward<TpmSupportT>(value);
  }
  template <typename TpmSupportT = AttributeValue>
  DescribeImageAttributeResponse& WithTpmSupport(TpmSupportT&& value) {
    SetTpmSupport(std::forward<TpmSupportT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetUefiData() const { return m_uefiData; }
  template <typename UefiDataT = AttributeValue>
  void SetUefiData(UefiDataT&& value) {
    m_uefiDataHasBeenSet = true;
    m_uefiData = std::forward<UefiDataT>(value);
  }
  template <typename UefiDataT = AttributeValue>
  DescribeImageAttributeResponse& WithUefiData(UefiDataT&& value) {
    SetUefiData(std::forward<UefiDataT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetLastLaunchedTime() const { return m_lastLaunchedTime; }
  template <typename LastLaunchedTimeT = AttributeValue>
  void SetLastLaunchedTime(LastLaunchedTimeT&& value) {
    m_lastLaunchedTimeHasBeenSet = true;
    m_lastLaunchedTime = std::forward<LastLaunchedTimeT>(value);
  }
  template <typename LastLaunchedTimeT = AttributeValue>
  DescribeImageAttributeResponse& WithLastLaunchedTime(LastLaunchedTimeT&& value) {
    SetLastLaunchedTime(std::forward<LastLaunchedTimeT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetImdsSupport() const { return m_imdsSupport; }
  template <typename ImdsSupportT = AttributeValue>
  void SetImdsSupport(ImdsSupportT&& value) {
    m_imdsSupportHasBeenSet = true;
    m_imdsSupport = std::forward<ImdsSupportT>(value);
  }
  template <typename ImdsSupportT = AttributeValue>
  DescribeImageAttributeResponse& WithImdsSupport(ImdsSupportT&& value) {
    SetImdsSupport(std::forward<ImdsSupportT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetDeregistrationProtection() const { return m_deregistrationProtection; }
  template <typename DeregistrationProtectionT = AttributeValue>
  void SetDeregistrationProtection(DeregistrationProtectionT&& value) {
    m_deregistrationProtectionHasBeenSet = true;
    m_deregistrationProtection = std::forward<DeregistrationProtectionT>(value);
  }
  template <typename DeregistrationProtectionT = AttributeValue>
  DescribeImageAttributeResponse& WithDeregistrationProtection(DeregistrationProtectionT&& value) {
    SetDeregistrationProtection(std::forward<DeregistrationProtectionT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetImageId() const { return m_imageId; }
  template <typename ImageIdT = Aws::String>
  void SetImageId(ImageIdT&& value) {
    m_imageIdHasBeenSet = true;
    m_imageId = std::forward<ImageIdT>(value);
  }
  template <typename ImageIdT = Aws::String>
  DescribeImageAttributeResponse& WithImageId(ImageIdT&& value) {
    SetImageId(std::forward<ImageIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<LaunchPermission>& GetLaunchPermissions() const { return m_launchPermissions; }
  template <typename LaunchPermissionsT = Aws::Vector<LaunchPermission>>
  void SetLaunchPermissions(LaunchPermissionsT&& value) {
    m_launchPermissionsHasBeenSet = true;
    m_launchPermissions = std::forward<LaunchPermissionsT>(value);
  }
  template <typename LaunchPermissionsT = Aws::Vector<LaunchPermission>>
  DescribeImageAttributeResponse& WithLaunchPermissions(LaunchPermissionsT&& value) {
    SetLaunchPermissions(std::forward<LaunchPermissionsT>(value));
    return *this;
  }
  template <typename LaunchPermissionsT = LaunchPermission>
  DescribeImageAttributeResponse& AddLaunchPermissions(LaunchPermissionsT&& value) {
    m_launchPermissionsHasBeenSet = true;
    m_launchPermissions.emplace_back(std::forward<LaunchPermissionsT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<ProductCode>& GetProductCodes() const { return m_productCodes; }
  template <typename ProductCodesT = Aws::Vector<ProductCode>>
  void SetProductCodes(ProductCodesT&& value) {
    m_productCodesHasBeenSet = true;
    m_productCodes = std::forward<ProductCodesT>(value);
  }
  template <typename ProductCodesT = Aws::Vector<ProductCode>>
  DescribeImageAttributeResponse& WithProductCodes(ProductCodesT&& value) {
    SetProductCodes(std::forward<ProductCodesT>(value));
    return *this;
  }
  template <typename ProductCodesT = ProductCode>
  DescribeImageAttributeResponse& AddProductCodes(ProductCodesT&& value) {
    m_productCodesHasBeenSet = true;
    m_productCodes.emplace_back(std::forward<ProductCodesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<BlockDeviceMapping>& GetBlockDeviceMappings() const { return m_blockDeviceMappings; }
  template <typename BlockDeviceMappingsT = Aws::Vector<BlockDeviceMapping>>
  void SetBlockDeviceMappings(BlockDeviceMappingsT&& value) {
    m_blockDeviceMappingsHasBeenSet = true;
    m_blockDeviceMappings = std::forward<BlockDeviceMappingsT>(value);
  }
  template <typename BlockDeviceMappingsT = Aws::Vector<BlockDeviceMapping>>
  DescribeImageAttributeResponse& WithBlockDeviceMappings(BlockDeviceMappingsT&& value) {
    SetBlockDeviceMappings(std::forward<BlockDeviceMappingsT>(value));
    return *this;
  }
  template <typename BlockDeviceMappingsT = BlockDeviceMapping>
  DescribeImageAttributeResponse& AddBlockDeviceMappings(BlockDeviceMappingsT&& value) {
    m_blockDeviceMappingsHasBeenSet = true;
    m_blockDeviceMappings.emplace_back(std::forward<BlockDeviceMappingsT>(value));
    return *this;
  }
 
 
  inline const ResponseMetadata& GetResponseMetadata() const { return m_responseMetadata; }
  template <typename ResponseMetadataT = ResponseMetadata>
  void SetResponseMetadata(ResponseMetadataT&& value) {
    m_responseMetadataHasBeenSet = true;
    m_responseMetadata = std::forward<ResponseMetadataT>(value);
  }
  template <typename ResponseMetadataT = ResponseMetadata>
  DescribeImageAttributeResponse& WithResponseMetadata(ResponseMetadataT&& value) {
    SetResponseMetadata(std::forward<ResponseMetadataT>(value));
    return *this;
  }
 private:
  AttributeValue m_description;
 
  AttributeValue m_kernelId;
 
  AttributeValue m_ramdiskId;
 
  AttributeValue m_sriovNetSupport;
 
  AttributeValue m_bootMode;
 
  AttributeValue m_tpmSupport;
 
  AttributeValue m_uefiData;
 
  AttributeValue m_lastLaunchedTime;
 
  AttributeValue m_imdsSupport;
 
  AttributeValue m_deregistrationProtection;
 
  Aws::String m_imageId;
 
  Aws::Vector<LaunchPermission> m_launchPermissions;
 
  Aws::Vector<ProductCode> m_productCodes;
 
  Aws::Vector<BlockDeviceMapping> m_blockDeviceMappings;
 
  ResponseMetadata m_responseMetadata;
  bool m_descriptionHasBeenSet = false;
  bool m_kernelIdHasBeenSet = false;
  bool m_ramdiskIdHasBeenSet = false;
  bool m_sriovNetSupportHasBeenSet = false;
  bool m_bootModeHasBeenSet = false;
  bool m_tpmSupportHasBeenSet = false;
  bool m_uefiDataHasBeenSet = false;
  bool m_lastLaunchedTimeHasBeenSet = false;
  bool m_imdsSupportHasBeenSet = false;
  bool m_deregistrationProtectionHasBeenSet = false;
  bool m_imageIdHasBeenSet = false;
  bool m_launchPermissionsHasBeenSet = false;
  bool m_productCodesHasBeenSet = false;
  bool m_blockDeviceMappingsHasBeenSet = false;
  bool m_responseMetadataHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EC2
}  // namespace Aws