Struct aws_sdk_ec2::model::InstanceTypeInfo

#[non_exhaustive]
pub struct InstanceTypeInfo { /* private fields */ }

Describes the instance type.

Implementations

impl InstanceTypeInfo

pub fn instance_type(&self) -> Option<&InstanceType>

The instance type. For more information, see Instance types in the Amazon EC2 User Guide.

pub fn current_generation(&self) -> Option<bool>

Indicates whether the instance type is current generation.

pub fn free_tier_eligible(&self) -> Option<bool>

Indicates whether the instance type is eligible for the free tier.

pub fn supported_usage_classes(&self) -> Option<&[UsageClassType]>

Indicates whether the instance type is offered for spot or On-Demand.

pub fn supported_root_device_types(&self) -> Option<&[RootDeviceType]>

The supported root device types.

pub fn supported_virtualization_types(&self) -> Option<&[VirtualizationType]>

The supported virtualization types.

pub fn bare_metal(&self) -> Option<bool>

Indicates whether the instance is a bare metal instance type.

pub fn hypervisor(&self) -> Option<&InstanceTypeHypervisor>

The hypervisor for the instance type.

pub fn processor_info(&self) -> Option<&ProcessorInfo>

Describes the processor.

pub fn v_cpu_info(&self) -> Option<&VCpuInfo>

Describes the vCPU configurations for the instance type.

pub fn memory_info(&self) -> Option<&MemoryInfo>

Describes the memory for the instance type.

pub fn instance_storage_supported(&self) -> Option<bool>

Indicates whether instance storage is supported.

pub fn instance_storage_info(&self) -> Option<&InstanceStorageInfo>

Describes the instance storage for the instance type.

pub fn ebs_info(&self) -> Option<&EbsInfo>

Describes the Amazon EBS settings for the instance type.

pub fn network_info(&self) -> Option<&NetworkInfo>

Describes the network settings for the instance type.

pub fn gpu_info(&self) -> Option<&GpuInfo>

Describes the GPU accelerator settings for the instance type.

pub fn fpga_info(&self) -> Option<&FpgaInfo>

Describes the FPGA accelerator settings for the instance type.

pub fn placement_group_info(&self) -> Option<&PlacementGroupInfo>

Describes the placement group settings for the instance type.

pub fn inference_accelerator_info(&self) -> Option<&InferenceAcceleratorInfo>

Describes the Inference accelerator settings for the instance type.

pub fn hibernation_supported(&self) -> Option<bool>

Indicates whether On-Demand hibernation is supported.

pub fn burstable_performance_supported(&self) -> Option<bool>

Indicates whether the instance type is a burstable performance instance type.

pub fn dedicated_hosts_supported(&self) -> Option<bool>

Indicates whether Dedicated Hosts are supported on the instance type.

pub fn auto_recovery_supported(&self) -> Option<bool>

Indicates whether auto recovery is supported.

pub fn supported_boot_modes(&self) -> Option<&[BootModeType]>

The supported boot modes. For more information, see Boot modes in the Amazon EC2 User Guide.

impl InstanceTypeInfo

pub fn builder() -> Builder

Creates a new builder-style object to manufacture InstanceTypeInfo.

Examples found in repository

src/xml_deser.rs (line 47287)

pub fn deser_structure_crate_model_instance_type_info(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::InstanceTypeInfo, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::InstanceTypeInfo::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("instanceType") /* InstanceType com.amazonaws.ec2#InstanceTypeInfo$InstanceType */ =>  {
                let var_2151 =
                    Some(
                        Result::<crate::model::InstanceType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::InstanceType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_instance_type(var_2151);
            }
            ,
            s if s.matches("currentGeneration") /* CurrentGeneration com.amazonaws.ec2#InstanceTypeInfo$CurrentGeneration */ =>  {
                let var_2152 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#CurrentGenerationFlag`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_current_generation(var_2152);
            }
            ,
            s if s.matches("freeTierEligible") /* FreeTierEligible com.amazonaws.ec2#InstanceTypeInfo$FreeTierEligible */ =>  {
                let var_2153 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#FreeTierEligibleFlag`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_free_tier_eligible(var_2153);
            }
            ,
            s if s.matches("supportedUsageClasses") /* SupportedUsageClasses com.amazonaws.ec2#InstanceTypeInfo$SupportedUsageClasses */ =>  {
                let var_2154 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_usage_class_type_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_supported_usage_classes(var_2154);
            }
            ,
            s if s.matches("supportedRootDeviceTypes") /* SupportedRootDeviceTypes com.amazonaws.ec2#InstanceTypeInfo$SupportedRootDeviceTypes */ =>  {
                let var_2155 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_root_device_type_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_supported_root_device_types(var_2155);
            }
            ,
            s if s.matches("supportedVirtualizationTypes") /* SupportedVirtualizationTypes com.amazonaws.ec2#InstanceTypeInfo$SupportedVirtualizationTypes */ =>  {
                let var_2156 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_virtualization_type_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_supported_virtualization_types(var_2156);
            }
            ,
            s if s.matches("bareMetal") /* BareMetal com.amazonaws.ec2#InstanceTypeInfo$BareMetal */ =>  {
                let var_2157 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#BareMetalFlag`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_bare_metal(var_2157);
            }
            ,
            s if s.matches("hypervisor") /* Hypervisor com.amazonaws.ec2#InstanceTypeInfo$Hypervisor */ =>  {
                let var_2158 =
                    Some(
                        Result::<crate::model::InstanceTypeHypervisor, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::InstanceTypeHypervisor::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_hypervisor(var_2158);
            }
            ,
            s if s.matches("processorInfo") /* ProcessorInfo com.amazonaws.ec2#InstanceTypeInfo$ProcessorInfo */ =>  {
                let var_2159 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_processor_info(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_processor_info(var_2159);
            }
            ,
            s if s.matches("vCpuInfo") /* VCpuInfo com.amazonaws.ec2#InstanceTypeInfo$VCpuInfo */ =>  {
                let var_2160 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_v_cpu_info(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_v_cpu_info(var_2160);
            }
            ,
            s if s.matches("memoryInfo") /* MemoryInfo com.amazonaws.ec2#InstanceTypeInfo$MemoryInfo */ =>  {
                let var_2161 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_memory_info(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_memory_info(var_2161);
            }
            ,
            s if s.matches("instanceStorageSupported") /* InstanceStorageSupported com.amazonaws.ec2#InstanceTypeInfo$InstanceStorageSupported */ =>  {
                let var_2162 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#InstanceStorageFlag`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_instance_storage_supported(var_2162);
            }
            ,
            s if s.matches("instanceStorageInfo") /* InstanceStorageInfo com.amazonaws.ec2#InstanceTypeInfo$InstanceStorageInfo */ =>  {
                let var_2163 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_instance_storage_info(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_instance_storage_info(var_2163);
            }
            ,
            s if s.matches("ebsInfo") /* EbsInfo com.amazonaws.ec2#InstanceTypeInfo$EbsInfo */ =>  {
                let var_2164 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_ebs_info(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_ebs_info(var_2164);
            }
            ,
            s if s.matches("networkInfo") /* NetworkInfo com.amazonaws.ec2#InstanceTypeInfo$NetworkInfo */ =>  {
                let var_2165 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_network_info(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_network_info(var_2165);
            }
            ,
            s if s.matches("gpuInfo") /* GpuInfo com.amazonaws.ec2#InstanceTypeInfo$GpuInfo */ =>  {
                let var_2166 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_gpu_info(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_gpu_info(var_2166);
            }
            ,
            s if s.matches("fpgaInfo") /* FpgaInfo com.amazonaws.ec2#InstanceTypeInfo$FpgaInfo */ =>  {
                let var_2167 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_fpga_info(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_fpga_info(var_2167);
            }
            ,
            s if s.matches("placementGroupInfo") /* PlacementGroupInfo com.amazonaws.ec2#InstanceTypeInfo$PlacementGroupInfo */ =>  {
                let var_2168 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_placement_group_info(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_placement_group_info(var_2168);
            }
            ,
            s if s.matches("inferenceAcceleratorInfo") /* InferenceAcceleratorInfo com.amazonaws.ec2#InstanceTypeInfo$InferenceAcceleratorInfo */ =>  {
                let var_2169 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_inference_accelerator_info(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_inference_accelerator_info(var_2169);
            }
            ,
            s if s.matches("hibernationSupported") /* HibernationSupported com.amazonaws.ec2#InstanceTypeInfo$HibernationSupported */ =>  {
                let var_2170 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#HibernationFlag`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_hibernation_supported(var_2170);
            }
            ,
            s if s.matches("burstablePerformanceSupported") /* BurstablePerformanceSupported com.amazonaws.ec2#InstanceTypeInfo$BurstablePerformanceSupported */ =>  {
                let var_2171 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#BurstablePerformanceFlag`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_burstable_performance_supported(var_2171);
            }
            ,
            s if s.matches("dedicatedHostsSupported") /* DedicatedHostsSupported com.amazonaws.ec2#InstanceTypeInfo$DedicatedHostsSupported */ =>  {
                let var_2172 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#DedicatedHostFlag`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_dedicated_hosts_supported(var_2172);
            }
            ,
            s if s.matches("autoRecoverySupported") /* AutoRecoverySupported com.amazonaws.ec2#InstanceTypeInfo$AutoRecoverySupported */ =>  {
                let var_2173 =
                    Some(
                         {
                            <bool as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.ec2#AutoRecoveryFlag`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_auto_recovery_supported(var_2173);
            }
            ,
            s if s.matches("supportedBootModes") /* SupportedBootModes com.amazonaws.ec2#InstanceTypeInfo$SupportedBootModes */ =>  {
                let var_2174 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_boot_mode_type_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_supported_boot_modes(var_2174);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for InstanceTypeInfo

fn clone(&self) -> InstanceTypeInfo

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InstanceTypeInfo

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<InstanceTypeInfo> for InstanceTypeInfo

fn eq(&self, other: &InstanceTypeInfo) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for InstanceTypeInfo