#[allow(unused_mut)]
pub fn ser_instance_requirements_request(
mut writer: ::aws_smithy_query::QueryValueWriter,
input: &crate::types::InstanceRequirementsRequest,
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
#[allow(unused_mut)]
let mut scope_1 = writer.prefix("VCpuCount");
if let Some(var_2) = &input.v_cpu_count {
crate::protocol_serde::shape_v_cpu_count_range_request::ser_v_cpu_count_range_request(scope_1, var_2)?;
}
#[allow(unused_mut)]
let mut scope_3 = writer.prefix("MemoryMiB");
if let Some(var_4) = &input.memory_mib {
crate::protocol_serde::shape_memory_mib_request::ser_memory_mib_request(scope_3, var_4)?;
}
#[allow(unused_mut)]
let mut scope_5 = writer.prefix("CpuManufacturer");
if let Some(var_6) = &input.cpu_manufacturers {
if !var_6.is_empty() {
let mut list_8 = scope_5.start_list(true, Some("item"));
for item_7 in var_6 {
#[allow(unused_mut)]
let mut entry_9 = list_8.entry();
entry_9.string(item_7.as_str());
}
list_8.finish();
}
}
#[allow(unused_mut)]
let mut scope_10 = writer.prefix("MemoryGiBPerVCpu");
if let Some(var_11) = &input.memory_gib_per_v_cpu {
crate::protocol_serde::shape_memory_gib_per_v_cpu_request::ser_memory_gib_per_v_cpu_request(scope_10, var_11)?;
}
#[allow(unused_mut)]
let mut scope_12 = writer.prefix("ExcludedInstanceType");
if let Some(var_13) = &input.excluded_instance_types {
if !var_13.is_empty() {
let mut list_15 = scope_12.start_list(true, Some("item"));
for item_14 in var_13 {
#[allow(unused_mut)]
let mut entry_16 = list_15.entry();
entry_16.string(item_14);
}
list_15.finish();
}
}
#[allow(unused_mut)]
let mut scope_17 = writer.prefix("InstanceGeneration");
if let Some(var_18) = &input.instance_generations {
if !var_18.is_empty() {
let mut list_20 = scope_17.start_list(true, Some("item"));
for item_19 in var_18 {
#[allow(unused_mut)]
let mut entry_21 = list_20.entry();
entry_21.string(item_19.as_str());
}
list_20.finish();
}
}
#[allow(unused_mut)]
let mut scope_22 = writer.prefix("SpotMaxPricePercentageOverLowestPrice");
if let Some(var_23) = &input.spot_max_price_percentage_over_lowest_price {
scope_22.number(
#[allow(clippy::useless_conversion)]
::aws_smithy_types::Number::NegInt((*var_23).into()),
);
}
#[allow(unused_mut)]
let mut scope_24 = writer.prefix("OnDemandMaxPricePercentageOverLowestPrice");
if let Some(var_25) = &input.on_demand_max_price_percentage_over_lowest_price {
scope_24.number(
#[allow(clippy::useless_conversion)]
::aws_smithy_types::Number::NegInt((*var_25).into()),
);
}
#[allow(unused_mut)]
let mut scope_26 = writer.prefix("BareMetal");
if let Some(var_27) = &input.bare_metal {
scope_26.string(var_27.as_str());
}
#[allow(unused_mut)]
let mut scope_28 = writer.prefix("BurstablePerformance");
if let Some(var_29) = &input.burstable_performance {
scope_28.string(var_29.as_str());
}
#[allow(unused_mut)]
let mut scope_30 = writer.prefix("RequireHibernateSupport");
if let Some(var_31) = &input.require_hibernate_support {
scope_30.boolean(*var_31);
}
#[allow(unused_mut)]
let mut scope_32 = writer.prefix("NetworkInterfaceCount");
if let Some(var_33) = &input.network_interface_count {
crate::protocol_serde::shape_network_interface_count_request::ser_network_interface_count_request(scope_32, var_33)?;
}
#[allow(unused_mut)]
let mut scope_34 = writer.prefix("LocalStorage");
if let Some(var_35) = &input.local_storage {
scope_34.string(var_35.as_str());
}
#[allow(unused_mut)]
let mut scope_36 = writer.prefix("LocalStorageType");
if let Some(var_37) = &input.local_storage_types {
if !var_37.is_empty() {
let mut list_39 = scope_36.start_list(true, Some("item"));
for item_38 in var_37 {
#[allow(unused_mut)]
let mut entry_40 = list_39.entry();
entry_40.string(item_38.as_str());
}
list_39.finish();
}
}
#[allow(unused_mut)]
let mut scope_41 = writer.prefix("TotalLocalStorageGB");
if let Some(var_42) = &input.total_local_storage_gb {
crate::protocol_serde::shape_total_local_storage_gb_request::ser_total_local_storage_gb_request(scope_41, var_42)?;
}
#[allow(unused_mut)]
let mut scope_43 = writer.prefix("BaselineEbsBandwidthMbps");
if let Some(var_44) = &input.baseline_ebs_bandwidth_mbps {
crate::protocol_serde::shape_baseline_ebs_bandwidth_mbps_request::ser_baseline_ebs_bandwidth_mbps_request(scope_43, var_44)?;
}
#[allow(unused_mut)]
let mut scope_45 = writer.prefix("AcceleratorType");
if let Some(var_46) = &input.accelerator_types {
if !var_46.is_empty() {
let mut list_48 = scope_45.start_list(true, Some("item"));
for item_47 in var_46 {
#[allow(unused_mut)]
let mut entry_49 = list_48.entry();
entry_49.string(item_47.as_str());
}
list_48.finish();
}
}
#[allow(unused_mut)]
let mut scope_50 = writer.prefix("AcceleratorCount");
if let Some(var_51) = &input.accelerator_count {
crate::protocol_serde::shape_accelerator_count_request::ser_accelerator_count_request(scope_50, var_51)?;
}
#[allow(unused_mut)]
let mut scope_52 = writer.prefix("AcceleratorManufacturer");
if let Some(var_53) = &input.accelerator_manufacturers {
if !var_53.is_empty() {
let mut list_55 = scope_52.start_list(true, Some("item"));
for item_54 in var_53 {
#[allow(unused_mut)]
let mut entry_56 = list_55.entry();
entry_56.string(item_54.as_str());
}
list_55.finish();
}
}
#[allow(unused_mut)]
let mut scope_57 = writer.prefix("AcceleratorName");
if let Some(var_58) = &input.accelerator_names {
if !var_58.is_empty() {
let mut list_60 = scope_57.start_list(true, Some("item"));
for item_59 in var_58 {
#[allow(unused_mut)]
let mut entry_61 = list_60.entry();
entry_61.string(item_59.as_str());
}
list_60.finish();
}
}
#[allow(unused_mut)]
let mut scope_62 = writer.prefix("AcceleratorTotalMemoryMiB");
if let Some(var_63) = &input.accelerator_total_memory_mib {
crate::protocol_serde::shape_accelerator_total_memory_mib_request::ser_accelerator_total_memory_mib_request(scope_62, var_63)?;
}
#[allow(unused_mut)]
let mut scope_64 = writer.prefix("NetworkBandwidthGbps");
if let Some(var_65) = &input.network_bandwidth_gbps {
crate::protocol_serde::shape_network_bandwidth_gbps_request::ser_network_bandwidth_gbps_request(scope_64, var_65)?;
}
#[allow(unused_mut)]
let mut scope_66 = writer.prefix("AllowedInstanceType");
if let Some(var_67) = &input.allowed_instance_types {
if !var_67.is_empty() {
let mut list_69 = scope_66.start_list(true, Some("item"));
for item_68 in var_67 {
#[allow(unused_mut)]
let mut entry_70 = list_69.entry();
entry_70.string(item_68);
}
list_69.finish();
}
}
#[allow(unused_mut)]
let mut scope_71 = writer.prefix("MaxSpotPriceAsPercentageOfOptimalOnDemandPrice");
if let Some(var_72) = &input.max_spot_price_as_percentage_of_optimal_on_demand_price {
scope_71.number(
#[allow(clippy::useless_conversion)]
::aws_smithy_types::Number::NegInt((*var_72).into()),
);
}
#[allow(unused_mut)]
let mut scope_73 = writer.prefix("BaselinePerformanceFactors");
if let Some(var_74) = &input.baseline_performance_factors {
crate::protocol_serde::shape_baseline_performance_factors_request::ser_baseline_performance_factors_request(scope_73, var_74)?;
}
#[allow(unused_mut)]
let mut scope_75 = writer.prefix("RequireEncryptionInTransit");
if let Some(var_76) = &input.require_encryption_in_transit {
scope_75.boolean(*var_76);
}
Ok(())
}