DescribeInstanceAttributeResponse.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/AttributeBooleanValue.h>
#include <aws/ec2/model/AttributeValue.h>
#include <aws/ec2/model/EnclaveOptions.h>
#include <aws/ec2/model/GroupIdentifier.h>
#include <aws/ec2/model/InstanceBlockDeviceMapping.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 DescribeInstanceAttributeResponse {
 public:
  AWS_EC2_API DescribeInstanceAttributeResponse() = default;
  AWS_EC2_API DescribeInstanceAttributeResponse(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
  AWS_EC2_API DescribeInstanceAttributeResponse& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Xml::XmlDocument>& result);
 
 
  inline const Aws::Vector<InstanceBlockDeviceMapping>& GetBlockDeviceMappings() const { return m_blockDeviceMappings; }
  template <typename BlockDeviceMappingsT = Aws::Vector<InstanceBlockDeviceMapping>>
  void SetBlockDeviceMappings(BlockDeviceMappingsT&& value) {
    m_blockDeviceMappingsHasBeenSet = true;
    m_blockDeviceMappings = std::forward<BlockDeviceMappingsT>(value);
  }
  template <typename BlockDeviceMappingsT = Aws::Vector<InstanceBlockDeviceMapping>>
  DescribeInstanceAttributeResponse& WithBlockDeviceMappings(BlockDeviceMappingsT&& value) {
    SetBlockDeviceMappings(std::forward<BlockDeviceMappingsT>(value));
    return *this;
  }
  template <typename BlockDeviceMappingsT = InstanceBlockDeviceMapping>
  DescribeInstanceAttributeResponse& AddBlockDeviceMappings(BlockDeviceMappingsT&& value) {
    m_blockDeviceMappingsHasBeenSet = true;
    m_blockDeviceMappings.emplace_back(std::forward<BlockDeviceMappingsT>(value));
    return *this;
  }
 
 
  inline const AttributeBooleanValue& GetDisableApiTermination() const { return m_disableApiTermination; }
  template <typename DisableApiTerminationT = AttributeBooleanValue>
  void SetDisableApiTermination(DisableApiTerminationT&& value) {
    m_disableApiTerminationHasBeenSet = true;
    m_disableApiTermination = std::forward<DisableApiTerminationT>(value);
  }
  template <typename DisableApiTerminationT = AttributeBooleanValue>
  DescribeInstanceAttributeResponse& WithDisableApiTermination(DisableApiTerminationT&& value) {
    SetDisableApiTermination(std::forward<DisableApiTerminationT>(value));
    return *this;
  }
 
 
  inline const AttributeBooleanValue& GetEnaSupport() const { return m_enaSupport; }
  template <typename EnaSupportT = AttributeBooleanValue>
  void SetEnaSupport(EnaSupportT&& value) {
    m_enaSupportHasBeenSet = true;
    m_enaSupport = std::forward<EnaSupportT>(value);
  }
  template <typename EnaSupportT = AttributeBooleanValue>
  DescribeInstanceAttributeResponse& WithEnaSupport(EnaSupportT&& value) {
    SetEnaSupport(std::forward<EnaSupportT>(value));
    return *this;
  }
 
 
  inline const EnclaveOptions& GetEnclaveOptions() const { return m_enclaveOptions; }
  template <typename EnclaveOptionsT = EnclaveOptions>
  void SetEnclaveOptions(EnclaveOptionsT&& value) {
    m_enclaveOptionsHasBeenSet = true;
    m_enclaveOptions = std::forward<EnclaveOptionsT>(value);
  }
  template <typename EnclaveOptionsT = EnclaveOptions>
  DescribeInstanceAttributeResponse& WithEnclaveOptions(EnclaveOptionsT&& value) {
    SetEnclaveOptions(std::forward<EnclaveOptionsT>(value));
    return *this;
  }
 
 
  inline const AttributeBooleanValue& GetEbsOptimized() const { return m_ebsOptimized; }
  template <typename EbsOptimizedT = AttributeBooleanValue>
  void SetEbsOptimized(EbsOptimizedT&& value) {
    m_ebsOptimizedHasBeenSet = true;
    m_ebsOptimized = std::forward<EbsOptimizedT>(value);
  }
  template <typename EbsOptimizedT = AttributeBooleanValue>
  DescribeInstanceAttributeResponse& WithEbsOptimized(EbsOptimizedT&& value) {
    SetEbsOptimized(std::forward<EbsOptimizedT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInstanceId() const { return m_instanceId; }
  template <typename InstanceIdT = Aws::String>
  void SetInstanceId(InstanceIdT&& value) {
    m_instanceIdHasBeenSet = true;
    m_instanceId = std::forward<InstanceIdT>(value);
  }
  template <typename InstanceIdT = Aws::String>
  DescribeInstanceAttributeResponse& WithInstanceId(InstanceIdT&& value) {
    SetInstanceId(std::forward<InstanceIdT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetInstanceInitiatedShutdownBehavior() const { return m_instanceInitiatedShutdownBehavior; }
  template <typename InstanceInitiatedShutdownBehaviorT = AttributeValue>
  void SetInstanceInitiatedShutdownBehavior(InstanceInitiatedShutdownBehaviorT&& value) {
    m_instanceInitiatedShutdownBehaviorHasBeenSet = true;
    m_instanceInitiatedShutdownBehavior = std::forward<InstanceInitiatedShutdownBehaviorT>(value);
  }
  template <typename InstanceInitiatedShutdownBehaviorT = AttributeValue>
  DescribeInstanceAttributeResponse& WithInstanceInitiatedShutdownBehavior(InstanceInitiatedShutdownBehaviorT&& value) {
    SetInstanceInitiatedShutdownBehavior(std::forward<InstanceInitiatedShutdownBehaviorT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetInstanceType() const { return m_instanceType; }
  template <typename InstanceTypeT = AttributeValue>
  void SetInstanceType(InstanceTypeT&& value) {
    m_instanceTypeHasBeenSet = true;
    m_instanceType = std::forward<InstanceTypeT>(value);
  }
  template <typename InstanceTypeT = AttributeValue>
  DescribeInstanceAttributeResponse& WithInstanceType(InstanceTypeT&& value) {
    SetInstanceType(std::forward<InstanceTypeT>(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>
  DescribeInstanceAttributeResponse& WithKernelId(KernelIdT&& value) {
    SetKernelId(std::forward<KernelIdT>(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>>
  DescribeInstanceAttributeResponse& WithProductCodes(ProductCodesT&& value) {
    SetProductCodes(std::forward<ProductCodesT>(value));
    return *this;
  }
  template <typename ProductCodesT = ProductCode>
  DescribeInstanceAttributeResponse& AddProductCodes(ProductCodesT&& value) {
    m_productCodesHasBeenSet = true;
    m_productCodes.emplace_back(std::forward<ProductCodesT>(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>
  DescribeInstanceAttributeResponse& WithRamdiskId(RamdiskIdT&& value) {
    SetRamdiskId(std::forward<RamdiskIdT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetRootDeviceName() const { return m_rootDeviceName; }
  template <typename RootDeviceNameT = AttributeValue>
  void SetRootDeviceName(RootDeviceNameT&& value) {
    m_rootDeviceNameHasBeenSet = true;
    m_rootDeviceName = std::forward<RootDeviceNameT>(value);
  }
  template <typename RootDeviceNameT = AttributeValue>
  DescribeInstanceAttributeResponse& WithRootDeviceName(RootDeviceNameT&& value) {
    SetRootDeviceName(std::forward<RootDeviceNameT>(value));
    return *this;
  }
 
 
  inline const AttributeBooleanValue& GetSourceDestCheck() const { return m_sourceDestCheck; }
  template <typename SourceDestCheckT = AttributeBooleanValue>
  void SetSourceDestCheck(SourceDestCheckT&& value) {
    m_sourceDestCheckHasBeenSet = true;
    m_sourceDestCheck = std::forward<SourceDestCheckT>(value);
  }
  template <typename SourceDestCheckT = AttributeBooleanValue>
  DescribeInstanceAttributeResponse& WithSourceDestCheck(SourceDestCheckT&& value) {
    SetSourceDestCheck(std::forward<SourceDestCheckT>(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>
  DescribeInstanceAttributeResponse& WithSriovNetSupport(SriovNetSupportT&& value) {
    SetSriovNetSupport(std::forward<SriovNetSupportT>(value));
    return *this;
  }
 
 
  inline const AttributeValue& GetUserData() const { return m_userData; }
  template <typename UserDataT = AttributeValue>
  void SetUserData(UserDataT&& value) {
    m_userDataHasBeenSet = true;
    m_userData = std::forward<UserDataT>(value);
  }
  template <typename UserDataT = AttributeValue>
  DescribeInstanceAttributeResponse& WithUserData(UserDataT&& value) {
    SetUserData(std::forward<UserDataT>(value));
    return *this;
  }
 
 
  inline const AttributeBooleanValue& GetDisableApiStop() const { return m_disableApiStop; }
  template <typename DisableApiStopT = AttributeBooleanValue>
  void SetDisableApiStop(DisableApiStopT&& value) {
    m_disableApiStopHasBeenSet = true;
    m_disableApiStop = std::forward<DisableApiStopT>(value);
  }
  template <typename DisableApiStopT = AttributeBooleanValue>
  DescribeInstanceAttributeResponse& WithDisableApiStop(DisableApiStopT&& value) {
    SetDisableApiStop(std::forward<DisableApiStopT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<GroupIdentifier>& GetGroups() const { return m_groups; }
  template <typename GroupsT = Aws::Vector<GroupIdentifier>>
  void SetGroups(GroupsT&& value) {
    m_groupsHasBeenSet = true;
    m_groups = std::forward<GroupsT>(value);
  }
  template <typename GroupsT = Aws::Vector<GroupIdentifier>>
  DescribeInstanceAttributeResponse& WithGroups(GroupsT&& value) {
    SetGroups(std::forward<GroupsT>(value));
    return *this;
  }
  template <typename GroupsT = GroupIdentifier>
  DescribeInstanceAttributeResponse& AddGroups(GroupsT&& value) {
    m_groupsHasBeenSet = true;
    m_groups.emplace_back(std::forward<GroupsT>(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>
  DescribeInstanceAttributeResponse& WithResponseMetadata(ResponseMetadataT&& value) {
    SetResponseMetadata(std::forward<ResponseMetadataT>(value));
    return *this;
  }
 private:
  Aws::Vector<InstanceBlockDeviceMapping> m_blockDeviceMappings;
 
  AttributeBooleanValue m_disableApiTermination;
 
  AttributeBooleanValue m_enaSupport;
 
  EnclaveOptions m_enclaveOptions;
 
  AttributeBooleanValue m_ebsOptimized;
 
  Aws::String m_instanceId;
 
  AttributeValue m_instanceInitiatedShutdownBehavior;
 
  AttributeValue m_instanceType;
 
  AttributeValue m_kernelId;
 
  Aws::Vector<ProductCode> m_productCodes;
 
  AttributeValue m_ramdiskId;
 
  AttributeValue m_rootDeviceName;
 
  AttributeBooleanValue m_sourceDestCheck;
 
  AttributeValue m_sriovNetSupport;
 
  AttributeValue m_userData;
 
  AttributeBooleanValue m_disableApiStop;
 
  Aws::Vector<GroupIdentifier> m_groups;
 
  ResponseMetadata m_responseMetadata;
  bool m_blockDeviceMappingsHasBeenSet = false;
  bool m_disableApiTerminationHasBeenSet = false;
  bool m_enaSupportHasBeenSet = false;
  bool m_enclaveOptionsHasBeenSet = false;
  bool m_ebsOptimizedHasBeenSet = false;
  bool m_instanceIdHasBeenSet = false;
  bool m_instanceInitiatedShutdownBehaviorHasBeenSet = false;
  bool m_instanceTypeHasBeenSet = false;
  bool m_kernelIdHasBeenSet = false;
  bool m_productCodesHasBeenSet = false;
  bool m_ramdiskIdHasBeenSet = false;
  bool m_rootDeviceNameHasBeenSet = false;
  bool m_sourceDestCheckHasBeenSet = false;
  bool m_sriovNetSupportHasBeenSet = false;
  bool m_userDataHasBeenSet = false;
  bool m_disableApiStopHasBeenSet = false;
  bool m_groupsHasBeenSet = false;
  bool m_responseMetadataHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace EC2
}  // namespace Aws