aws_sdk_ecs/protocol_serde/
shape_instance_requirements_request.rs1pub fn ser_instance_requirements_request(
3 object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
4 input: &crate::types::InstanceRequirementsRequest,
5) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
6 if let Some(var_1) = &input.v_cpu_count {
7 #[allow(unused_mut)]
8 let mut object_2 = object.key("vCpuCount").start_object();
9 crate::protocol_serde::shape_v_cpu_count_range_request::ser_v_cpu_count_range_request(&mut object_2, var_1)?;
10 object_2.finish();
11 }
12 if let Some(var_3) = &input.memory_mib {
13 #[allow(unused_mut)]
14 let mut object_4 = object.key("memoryMiB").start_object();
15 crate::protocol_serde::shape_memory_mib_request::ser_memory_mib_request(&mut object_4, var_3)?;
16 object_4.finish();
17 }
18 if let Some(var_5) = &input.cpu_manufacturers {
19 let mut array_6 = object.key("cpuManufacturers").start_array();
20 for item_7 in var_5 {
21 {
22 array_6.value().string(item_7.as_str());
23 }
24 }
25 array_6.finish();
26 }
27 if let Some(var_8) = &input.memory_gib_per_v_cpu {
28 #[allow(unused_mut)]
29 let mut object_9 = object.key("memoryGiBPerVCpu").start_object();
30 crate::protocol_serde::shape_memory_gib_per_v_cpu_request::ser_memory_gib_per_v_cpu_request(&mut object_9, var_8)?;
31 object_9.finish();
32 }
33 if let Some(var_10) = &input.excluded_instance_types {
34 let mut array_11 = object.key("excludedInstanceTypes").start_array();
35 for item_12 in var_10 {
36 {
37 array_11.value().string(item_12.as_str());
38 }
39 }
40 array_11.finish();
41 }
42 if let Some(var_13) = &input.instance_generations {
43 let mut array_14 = object.key("instanceGenerations").start_array();
44 for item_15 in var_13 {
45 {
46 array_14.value().string(item_15.as_str());
47 }
48 }
49 array_14.finish();
50 }
51 if let Some(var_16) = &input.spot_max_price_percentage_over_lowest_price {
52 object.key("spotMaxPricePercentageOverLowestPrice").number(
53 #[allow(clippy::useless_conversion)]
54 ::aws_smithy_types::Number::NegInt((*var_16).into()),
55 );
56 }
57 if let Some(var_17) = &input.on_demand_max_price_percentage_over_lowest_price {
58 object.key("onDemandMaxPricePercentageOverLowestPrice").number(
59 #[allow(clippy::useless_conversion)]
60 ::aws_smithy_types::Number::NegInt((*var_17).into()),
61 );
62 }
63 if let Some(var_18) = &input.bare_metal {
64 object.key("bareMetal").string(var_18.as_str());
65 }
66 if let Some(var_19) = &input.burstable_performance {
67 object.key("burstablePerformance").string(var_19.as_str());
68 }
69 if let Some(var_20) = &input.require_hibernate_support {
70 object.key("requireHibernateSupport").boolean(*var_20);
71 }
72 if let Some(var_21) = &input.network_interface_count {
73 #[allow(unused_mut)]
74 let mut object_22 = object.key("networkInterfaceCount").start_object();
75 crate::protocol_serde::shape_network_interface_count_request::ser_network_interface_count_request(&mut object_22, var_21)?;
76 object_22.finish();
77 }
78 if let Some(var_23) = &input.local_storage {
79 object.key("localStorage").string(var_23.as_str());
80 }
81 if let Some(var_24) = &input.local_storage_types {
82 let mut array_25 = object.key("localStorageTypes").start_array();
83 for item_26 in var_24 {
84 {
85 array_25.value().string(item_26.as_str());
86 }
87 }
88 array_25.finish();
89 }
90 if let Some(var_27) = &input.total_local_storage_gb {
91 #[allow(unused_mut)]
92 let mut object_28 = object.key("totalLocalStorageGB").start_object();
93 crate::protocol_serde::shape_total_local_storage_gb_request::ser_total_local_storage_gb_request(&mut object_28, var_27)?;
94 object_28.finish();
95 }
96 if let Some(var_29) = &input.baseline_ebs_bandwidth_mbps {
97 #[allow(unused_mut)]
98 let mut object_30 = object.key("baselineEbsBandwidthMbps").start_object();
99 crate::protocol_serde::shape_baseline_ebs_bandwidth_mbps_request::ser_baseline_ebs_bandwidth_mbps_request(&mut object_30, var_29)?;
100 object_30.finish();
101 }
102 if let Some(var_31) = &input.accelerator_types {
103 let mut array_32 = object.key("acceleratorTypes").start_array();
104 for item_33 in var_31 {
105 {
106 array_32.value().string(item_33.as_str());
107 }
108 }
109 array_32.finish();
110 }
111 if let Some(var_34) = &input.accelerator_count {
112 #[allow(unused_mut)]
113 let mut object_35 = object.key("acceleratorCount").start_object();
114 crate::protocol_serde::shape_accelerator_count_request::ser_accelerator_count_request(&mut object_35, var_34)?;
115 object_35.finish();
116 }
117 if let Some(var_36) = &input.accelerator_manufacturers {
118 let mut array_37 = object.key("acceleratorManufacturers").start_array();
119 for item_38 in var_36 {
120 {
121 array_37.value().string(item_38.as_str());
122 }
123 }
124 array_37.finish();
125 }
126 if let Some(var_39) = &input.accelerator_names {
127 let mut array_40 = object.key("acceleratorNames").start_array();
128 for item_41 in var_39 {
129 {
130 array_40.value().string(item_41.as_str());
131 }
132 }
133 array_40.finish();
134 }
135 if let Some(var_42) = &input.accelerator_total_memory_mib {
136 #[allow(unused_mut)]
137 let mut object_43 = object.key("acceleratorTotalMemoryMiB").start_object();
138 crate::protocol_serde::shape_accelerator_total_memory_mib_request::ser_accelerator_total_memory_mib_request(&mut object_43, var_42)?;
139 object_43.finish();
140 }
141 if let Some(var_44) = &input.network_bandwidth_gbps {
142 #[allow(unused_mut)]
143 let mut object_45 = object.key("networkBandwidthGbps").start_object();
144 crate::protocol_serde::shape_network_bandwidth_gbps_request::ser_network_bandwidth_gbps_request(&mut object_45, var_44)?;
145 object_45.finish();
146 }
147 if let Some(var_46) = &input.allowed_instance_types {
148 let mut array_47 = object.key("allowedInstanceTypes").start_array();
149 for item_48 in var_46 {
150 {
151 array_47.value().string(item_48.as_str());
152 }
153 }
154 array_47.finish();
155 }
156 if let Some(var_49) = &input.max_spot_price_as_percentage_of_optimal_on_demand_price {
157 object.key("maxSpotPriceAsPercentageOfOptimalOnDemandPrice").number(
158 #[allow(clippy::useless_conversion)]
159 ::aws_smithy_types::Number::NegInt((*var_49).into()),
160 );
161 }
162 Ok(())
163}
164
165pub(crate) fn de_instance_requirements_request<'a, I>(
166 tokens: &mut ::std::iter::Peekable<I>,
167) -> ::std::result::Result<Option<crate::types::InstanceRequirementsRequest>, ::aws_smithy_json::deserialize::error::DeserializeError>
168where
169 I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
170{
171 match tokens.next().transpose()? {
172 Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
173 Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
174 #[allow(unused_mut)]
175 let mut builder = crate::types::builders::InstanceRequirementsRequestBuilder::default();
176 loop {
177 match tokens.next().transpose()? {
178 Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
179 Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
180 "vCpuCount" => {
181 builder = builder.set_v_cpu_count(crate::protocol_serde::shape_v_cpu_count_range_request::de_v_cpu_count_range_request(
182 tokens,
183 )?);
184 }
185 "memoryMiB" => {
186 builder = builder.set_memory_mib(crate::protocol_serde::shape_memory_mib_request::de_memory_mib_request(tokens)?);
187 }
188 "cpuManufacturers" => {
189 builder =
190 builder.set_cpu_manufacturers(crate::protocol_serde::shape_cpu_manufacturer_set::de_cpu_manufacturer_set(tokens)?);
191 }
192 "memoryGiBPerVCpu" => {
193 builder = builder.set_memory_gib_per_v_cpu(
194 crate::protocol_serde::shape_memory_gib_per_v_cpu_request::de_memory_gib_per_v_cpu_request(tokens)?,
195 );
196 }
197 "excludedInstanceTypes" => {
198 builder = builder.set_excluded_instance_types(
199 crate::protocol_serde::shape_excluded_instance_type_set::de_excluded_instance_type_set(tokens)?,
200 );
201 }
202 "instanceGenerations" => {
203 builder = builder
204 .set_instance_generations(crate::protocol_serde::shape_instance_generation_set::de_instance_generation_set(tokens)?);
205 }
206 "spotMaxPricePercentageOverLowestPrice" => {
207 builder = builder.set_spot_max_price_percentage_over_lowest_price(
208 ::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
209 .map(i32::try_from)
210 .transpose()?,
211 );
212 }
213 "onDemandMaxPricePercentageOverLowestPrice" => {
214 builder = builder.set_on_demand_max_price_percentage_over_lowest_price(
215 ::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
216 .map(i32::try_from)
217 .transpose()?,
218 );
219 }
220 "bareMetal" => {
221 builder = builder.set_bare_metal(
222 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
223 .map(|s| s.to_unescaped().map(|u| crate::types::BareMetal::from(u.as_ref())))
224 .transpose()?,
225 );
226 }
227 "burstablePerformance" => {
228 builder = builder.set_burstable_performance(
229 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
230 .map(|s| s.to_unescaped().map(|u| crate::types::BurstablePerformance::from(u.as_ref())))
231 .transpose()?,
232 );
233 }
234 "requireHibernateSupport" => {
235 builder =
236 builder.set_require_hibernate_support(::aws_smithy_json::deserialize::token::expect_bool_or_null(tokens.next())?);
237 }
238 "networkInterfaceCount" => {
239 builder = builder.set_network_interface_count(
240 crate::protocol_serde::shape_network_interface_count_request::de_network_interface_count_request(tokens)?,
241 );
242 }
243 "localStorage" => {
244 builder = builder.set_local_storage(
245 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
246 .map(|s| s.to_unescaped().map(|u| crate::types::LocalStorage::from(u.as_ref())))
247 .transpose()?,
248 );
249 }
250 "localStorageTypes" => {
251 builder = builder
252 .set_local_storage_types(crate::protocol_serde::shape_local_storage_type_set::de_local_storage_type_set(tokens)?);
253 }
254 "totalLocalStorageGB" => {
255 builder = builder.set_total_local_storage_gb(
256 crate::protocol_serde::shape_total_local_storage_gb_request::de_total_local_storage_gb_request(tokens)?,
257 );
258 }
259 "baselineEbsBandwidthMbps" => {
260 builder = builder.set_baseline_ebs_bandwidth_mbps(
261 crate::protocol_serde::shape_baseline_ebs_bandwidth_mbps_request::de_baseline_ebs_bandwidth_mbps_request(tokens)?,
262 );
263 }
264 "acceleratorTypes" => {
265 builder =
266 builder.set_accelerator_types(crate::protocol_serde::shape_accelerator_type_set::de_accelerator_type_set(tokens)?);
267 }
268 "acceleratorCount" => {
269 builder = builder.set_accelerator_count(
270 crate::protocol_serde::shape_accelerator_count_request::de_accelerator_count_request(tokens)?,
271 );
272 }
273 "acceleratorManufacturers" => {
274 builder = builder.set_accelerator_manufacturers(
275 crate::protocol_serde::shape_accelerator_manufacturer_set::de_accelerator_manufacturer_set(tokens)?,
276 );
277 }
278 "acceleratorNames" => {
279 builder =
280 builder.set_accelerator_names(crate::protocol_serde::shape_accelerator_name_set::de_accelerator_name_set(tokens)?);
281 }
282 "acceleratorTotalMemoryMiB" => {
283 builder = builder.set_accelerator_total_memory_mib(
284 crate::protocol_serde::shape_accelerator_total_memory_mib_request::de_accelerator_total_memory_mib_request(tokens)?,
285 );
286 }
287 "networkBandwidthGbps" => {
288 builder = builder.set_network_bandwidth_gbps(
289 crate::protocol_serde::shape_network_bandwidth_gbps_request::de_network_bandwidth_gbps_request(tokens)?,
290 );
291 }
292 "allowedInstanceTypes" => {
293 builder = builder.set_allowed_instance_types(
294 crate::protocol_serde::shape_allowed_instance_type_set::de_allowed_instance_type_set(tokens)?,
295 );
296 }
297 "maxSpotPriceAsPercentageOfOptimalOnDemandPrice" => {
298 builder = builder.set_max_spot_price_as_percentage_of_optimal_on_demand_price(
299 ::aws_smithy_json::deserialize::token::expect_number_or_null(tokens.next())?
300 .map(i32::try_from)
301 .transpose()?,
302 );
303 }
304 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
305 },
306 other => {
307 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
308 "expected object key or end object, found: {:?}",
309 other
310 )))
311 }
312 }
313 }
314 Ok(Some(crate::serde_util::instance_requirements_request_correct_errors(builder).build()))
315 }
316 _ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
317 "expected start object or null",
318 )),
319 }
320}