aws_sdk_ec2/protocol_serde/
shape_instance_requirements_request.rs1#[allow(unused_mut)]
3pub fn ser_instance_requirements_request(
4 mut writer: ::aws_smithy_query::QueryValueWriter,
5 input: &crate::types::InstanceRequirementsRequest,
6) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
7 #[allow(unused_mut)]
8 let mut scope_1 = writer.prefix("VCpuCount");
9 if let Some(var_2) = &input.v_cpu_count {
10 crate::protocol_serde::shape_v_cpu_count_range_request::ser_v_cpu_count_range_request(scope_1, var_2)?;
11 }
12 #[allow(unused_mut)]
13 let mut scope_3 = writer.prefix("MemoryMiB");
14 if let Some(var_4) = &input.memory_mib {
15 crate::protocol_serde::shape_memory_mib_request::ser_memory_mib_request(scope_3, var_4)?;
16 }
17 #[allow(unused_mut)]
18 let mut scope_5 = writer.prefix("CpuManufacturer");
19 if let Some(var_6) = &input.cpu_manufacturers {
20 if !var_6.is_empty() {
21 let mut list_8 = scope_5.start_list(true, Some("item"));
22 for item_7 in var_6 {
23 #[allow(unused_mut)]
24 let mut entry_9 = list_8.entry();
25 entry_9.string(item_7.as_str());
26 }
27 list_8.finish();
28 }
29 }
30 #[allow(unused_mut)]
31 let mut scope_10 = writer.prefix("MemoryGiBPerVCpu");
32 if let Some(var_11) = &input.memory_gib_per_v_cpu {
33 crate::protocol_serde::shape_memory_gib_per_v_cpu_request::ser_memory_gib_per_v_cpu_request(scope_10, var_11)?;
34 }
35 #[allow(unused_mut)]
36 let mut scope_12 = writer.prefix("ExcludedInstanceType");
37 if let Some(var_13) = &input.excluded_instance_types {
38 if !var_13.is_empty() {
39 let mut list_15 = scope_12.start_list(true, Some("item"));
40 for item_14 in var_13 {
41 #[allow(unused_mut)]
42 let mut entry_16 = list_15.entry();
43 entry_16.string(item_14);
44 }
45 list_15.finish();
46 }
47 }
48 #[allow(unused_mut)]
49 let mut scope_17 = writer.prefix("InstanceGeneration");
50 if let Some(var_18) = &input.instance_generations {
51 if !var_18.is_empty() {
52 let mut list_20 = scope_17.start_list(true, Some("item"));
53 for item_19 in var_18 {
54 #[allow(unused_mut)]
55 let mut entry_21 = list_20.entry();
56 entry_21.string(item_19.as_str());
57 }
58 list_20.finish();
59 }
60 }
61 #[allow(unused_mut)]
62 let mut scope_22 = writer.prefix("SpotMaxPricePercentageOverLowestPrice");
63 if let Some(var_23) = &input.spot_max_price_percentage_over_lowest_price {
64 scope_22.number(
65 #[allow(clippy::useless_conversion)]
66 ::aws_smithy_types::Number::NegInt((*var_23).into()),
67 );
68 }
69 #[allow(unused_mut)]
70 let mut scope_24 = writer.prefix("OnDemandMaxPricePercentageOverLowestPrice");
71 if let Some(var_25) = &input.on_demand_max_price_percentage_over_lowest_price {
72 scope_24.number(
73 #[allow(clippy::useless_conversion)]
74 ::aws_smithy_types::Number::NegInt((*var_25).into()),
75 );
76 }
77 #[allow(unused_mut)]
78 let mut scope_26 = writer.prefix("BareMetal");
79 if let Some(var_27) = &input.bare_metal {
80 scope_26.string(var_27.as_str());
81 }
82 #[allow(unused_mut)]
83 let mut scope_28 = writer.prefix("BurstablePerformance");
84 if let Some(var_29) = &input.burstable_performance {
85 scope_28.string(var_29.as_str());
86 }
87 #[allow(unused_mut)]
88 let mut scope_30 = writer.prefix("RequireHibernateSupport");
89 if let Some(var_31) = &input.require_hibernate_support {
90 scope_30.boolean(*var_31);
91 }
92 #[allow(unused_mut)]
93 let mut scope_32 = writer.prefix("NetworkInterfaceCount");
94 if let Some(var_33) = &input.network_interface_count {
95 crate::protocol_serde::shape_network_interface_count_request::ser_network_interface_count_request(scope_32, var_33)?;
96 }
97 #[allow(unused_mut)]
98 let mut scope_34 = writer.prefix("LocalStorage");
99 if let Some(var_35) = &input.local_storage {
100 scope_34.string(var_35.as_str());
101 }
102 #[allow(unused_mut)]
103 let mut scope_36 = writer.prefix("LocalStorageType");
104 if let Some(var_37) = &input.local_storage_types {
105 if !var_37.is_empty() {
106 let mut list_39 = scope_36.start_list(true, Some("item"));
107 for item_38 in var_37 {
108 #[allow(unused_mut)]
109 let mut entry_40 = list_39.entry();
110 entry_40.string(item_38.as_str());
111 }
112 list_39.finish();
113 }
114 }
115 #[allow(unused_mut)]
116 let mut scope_41 = writer.prefix("TotalLocalStorageGB");
117 if let Some(var_42) = &input.total_local_storage_gb {
118 crate::protocol_serde::shape_total_local_storage_gb_request::ser_total_local_storage_gb_request(scope_41, var_42)?;
119 }
120 #[allow(unused_mut)]
121 let mut scope_43 = writer.prefix("BaselineEbsBandwidthMbps");
122 if let Some(var_44) = &input.baseline_ebs_bandwidth_mbps {
123 crate::protocol_serde::shape_baseline_ebs_bandwidth_mbps_request::ser_baseline_ebs_bandwidth_mbps_request(scope_43, var_44)?;
124 }
125 #[allow(unused_mut)]
126 let mut scope_45 = writer.prefix("AcceleratorType");
127 if let Some(var_46) = &input.accelerator_types {
128 if !var_46.is_empty() {
129 let mut list_48 = scope_45.start_list(true, Some("item"));
130 for item_47 in var_46 {
131 #[allow(unused_mut)]
132 let mut entry_49 = list_48.entry();
133 entry_49.string(item_47.as_str());
134 }
135 list_48.finish();
136 }
137 }
138 #[allow(unused_mut)]
139 let mut scope_50 = writer.prefix("AcceleratorCount");
140 if let Some(var_51) = &input.accelerator_count {
141 crate::protocol_serde::shape_accelerator_count_request::ser_accelerator_count_request(scope_50, var_51)?;
142 }
143 #[allow(unused_mut)]
144 let mut scope_52 = writer.prefix("AcceleratorManufacturer");
145 if let Some(var_53) = &input.accelerator_manufacturers {
146 if !var_53.is_empty() {
147 let mut list_55 = scope_52.start_list(true, Some("item"));
148 for item_54 in var_53 {
149 #[allow(unused_mut)]
150 let mut entry_56 = list_55.entry();
151 entry_56.string(item_54.as_str());
152 }
153 list_55.finish();
154 }
155 }
156 #[allow(unused_mut)]
157 let mut scope_57 = writer.prefix("AcceleratorName");
158 if let Some(var_58) = &input.accelerator_names {
159 if !var_58.is_empty() {
160 let mut list_60 = scope_57.start_list(true, Some("item"));
161 for item_59 in var_58 {
162 #[allow(unused_mut)]
163 let mut entry_61 = list_60.entry();
164 entry_61.string(item_59.as_str());
165 }
166 list_60.finish();
167 }
168 }
169 #[allow(unused_mut)]
170 let mut scope_62 = writer.prefix("AcceleratorTotalMemoryMiB");
171 if let Some(var_63) = &input.accelerator_total_memory_mib {
172 crate::protocol_serde::shape_accelerator_total_memory_mib_request::ser_accelerator_total_memory_mib_request(scope_62, var_63)?;
173 }
174 #[allow(unused_mut)]
175 let mut scope_64 = writer.prefix("NetworkBandwidthGbps");
176 if let Some(var_65) = &input.network_bandwidth_gbps {
177 crate::protocol_serde::shape_network_bandwidth_gbps_request::ser_network_bandwidth_gbps_request(scope_64, var_65)?;
178 }
179 #[allow(unused_mut)]
180 let mut scope_66 = writer.prefix("AllowedInstanceType");
181 if let Some(var_67) = &input.allowed_instance_types {
182 if !var_67.is_empty() {
183 let mut list_69 = scope_66.start_list(true, Some("item"));
184 for item_68 in var_67 {
185 #[allow(unused_mut)]
186 let mut entry_70 = list_69.entry();
187 entry_70.string(item_68);
188 }
189 list_69.finish();
190 }
191 }
192 #[allow(unused_mut)]
193 let mut scope_71 = writer.prefix("MaxSpotPriceAsPercentageOfOptimalOnDemandPrice");
194 if let Some(var_72) = &input.max_spot_price_as_percentage_of_optimal_on_demand_price {
195 scope_71.number(
196 #[allow(clippy::useless_conversion)]
197 ::aws_smithy_types::Number::NegInt((*var_72).into()),
198 );
199 }
200 #[allow(unused_mut)]
201 let mut scope_73 = writer.prefix("BaselinePerformanceFactors");
202 if let Some(var_74) = &input.baseline_performance_factors {
203 crate::protocol_serde::shape_baseline_performance_factors_request::ser_baseline_performance_factors_request(scope_73, var_74)?;
204 }
205 Ok(())
206}