1#[allow(clippy::unnecessary_wraps)]
3pub fn de_write_get_object_response_http_error(
4 _response_status: u16,
5 _response_headers: &::aws_smithy_runtime_api::http::Headers,
6 _response_body: &[u8],
7) -> std::result::Result<
8 crate::operation::write_get_object_response::WriteGetObjectResponseOutput,
9 crate::operation::write_get_object_response::WriteGetObjectResponseError,
10> {
11 #[allow(unused_mut)]
12 let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
13 .map_err(crate::operation::write_get_object_response::WriteGetObjectResponseError::unhandled)?;
14 generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
15 generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
16 let generic = generic_builder.build();
17 Err(crate::operation::write_get_object_response::WriteGetObjectResponseError::generic(generic))
18}
19
20#[allow(clippy::unnecessary_wraps)]
21pub fn de_write_get_object_response_http_response(
22 _response_status: u16,
23 _response_headers: &::aws_smithy_runtime_api::http::Headers,
24 _response_body: &[u8],
25) -> std::result::Result<
26 crate::operation::write_get_object_response::WriteGetObjectResponseOutput,
27 crate::operation::write_get_object_response::WriteGetObjectResponseError,
28> {
29 Ok({
30 #[allow(unused_mut)]
31 let mut output = crate::operation::write_get_object_response::builders::WriteGetObjectResponseOutputBuilder::default();
32 output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
33 output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
34 output.build()
35 })
36}
37
38pub fn ser_write_get_object_response_headers(
39 input: &crate::operation::write_get_object_response::WriteGetObjectResponseInput,
40 mut builder: ::http::request::Builder,
41) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
42 if let ::std::option::Option::Some(inner_1) = &input.request_route {
43 let formatted_2 = inner_1.as_str();
44 let header_value = formatted_2;
45 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
46 ::aws_smithy_types::error::operation::BuildError::invalid_field(
47 "request_route",
48 format!("`{}` cannot be used as a header value: {}", &header_value, err),
49 )
50 })?;
51 builder = builder.header("x-amz-request-route", header_value);
52 }
53 if let ::std::option::Option::Some(inner_3) = &input.request_token {
54 let formatted_4 = inner_3.as_str();
55 let header_value = formatted_4;
56 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
57 ::aws_smithy_types::error::operation::BuildError::invalid_field(
58 "request_token",
59 format!("`{}` cannot be used as a header value: {}", &header_value, err),
60 )
61 })?;
62 builder = builder.header("x-amz-request-token", header_value);
63 }
64 if let ::std::option::Option::Some(inner_5) = &input.status_code {
65 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
66 let formatted_6 = encoder.encode();
67 let header_value = formatted_6;
68 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
69 ::aws_smithy_types::error::operation::BuildError::invalid_field(
70 "status_code",
71 format!("`{}` cannot be used as a header value: {}", &header_value, err),
72 )
73 })?;
74 builder = builder.header("x-amz-fwd-status", header_value);
75 }
76 if let ::std::option::Option::Some(inner_7) = &input.error_code {
77 let formatted_8 = inner_7.as_str();
78 let header_value = formatted_8;
79 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
80 ::aws_smithy_types::error::operation::BuildError::invalid_field(
81 "error_code",
82 format!("`{}` cannot be used as a header value: {}", &header_value, err),
83 )
84 })?;
85 builder = builder.header("x-amz-fwd-error-code", header_value);
86 }
87 if let ::std::option::Option::Some(inner_9) = &input.error_message {
88 let formatted_10 = inner_9.as_str();
89 let header_value = formatted_10;
90 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
91 ::aws_smithy_types::error::operation::BuildError::invalid_field(
92 "error_message",
93 format!("`{}` cannot be used as a header value: {}", &header_value, err),
94 )
95 })?;
96 builder = builder.header("x-amz-fwd-error-message", header_value);
97 }
98 if let ::std::option::Option::Some(inner_11) = &input.accept_ranges {
99 let formatted_12 = inner_11.as_str();
100 let header_value = formatted_12;
101 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
102 ::aws_smithy_types::error::operation::BuildError::invalid_field(
103 "accept_ranges",
104 format!("`{}` cannot be used as a header value: {}", &header_value, err),
105 )
106 })?;
107 builder = builder.header("x-amz-fwd-header-accept-ranges", header_value);
108 }
109 if let ::std::option::Option::Some(inner_13) = &input.cache_control {
110 let formatted_14 = inner_13.as_str();
111 let header_value = formatted_14;
112 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
113 ::aws_smithy_types::error::operation::BuildError::invalid_field(
114 "cache_control",
115 format!("`{}` cannot be used as a header value: {}", &header_value, err),
116 )
117 })?;
118 builder = builder.header("x-amz-fwd-header-Cache-Control", header_value);
119 }
120 if let ::std::option::Option::Some(inner_15) = &input.content_disposition {
121 let formatted_16 = inner_15.as_str();
122 let header_value = formatted_16;
123 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
124 ::aws_smithy_types::error::operation::BuildError::invalid_field(
125 "content_disposition",
126 format!("`{}` cannot be used as a header value: {}", &header_value, err),
127 )
128 })?;
129 builder = builder.header("x-amz-fwd-header-Content-Disposition", header_value);
130 }
131 if let ::std::option::Option::Some(inner_17) = &input.content_encoding {
132 let formatted_18 = inner_17.as_str();
133 let header_value = formatted_18;
134 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
135 ::aws_smithy_types::error::operation::BuildError::invalid_field(
136 "content_encoding",
137 format!("`{}` cannot be used as a header value: {}", &header_value, err),
138 )
139 })?;
140 builder = builder.header("x-amz-fwd-header-Content-Encoding", header_value);
141 }
142 if let ::std::option::Option::Some(inner_19) = &input.content_language {
143 let formatted_20 = inner_19.as_str();
144 let header_value = formatted_20;
145 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
146 ::aws_smithy_types::error::operation::BuildError::invalid_field(
147 "content_language",
148 format!("`{}` cannot be used as a header value: {}", &header_value, err),
149 )
150 })?;
151 builder = builder.header("x-amz-fwd-header-Content-Language", header_value);
152 }
153 if let ::std::option::Option::Some(inner_21) = &input.content_length {
154 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_21);
155 let formatted_22 = encoder.encode();
156 let header_value = formatted_22;
157 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
158 ::aws_smithy_types::error::operation::BuildError::invalid_field(
159 "content_length",
160 format!("`{}` cannot be used as a header value: {}", &header_value, err),
161 )
162 })?;
163 builder = builder.header("Content-Length", header_value);
164 }
165 if let ::std::option::Option::Some(inner_23) = &input.content_range {
166 let formatted_24 = inner_23.as_str();
167 let header_value = formatted_24;
168 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
169 ::aws_smithy_types::error::operation::BuildError::invalid_field(
170 "content_range",
171 format!("`{}` cannot be used as a header value: {}", &header_value, err),
172 )
173 })?;
174 builder = builder.header("x-amz-fwd-header-Content-Range", header_value);
175 }
176 if let ::std::option::Option::Some(inner_25) = &input.content_type {
177 let formatted_26 = inner_25.as_str();
178 let header_value = formatted_26;
179 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
180 ::aws_smithy_types::error::operation::BuildError::invalid_field(
181 "content_type",
182 format!("`{}` cannot be used as a header value: {}", &header_value, err),
183 )
184 })?;
185 builder = builder.header("x-amz-fwd-header-Content-Type", header_value);
186 }
187 if let ::std::option::Option::Some(inner_27) = &input.checksum_crc32 {
188 let formatted_28 = inner_27.as_str();
189 let header_value = formatted_28;
190 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
191 ::aws_smithy_types::error::operation::BuildError::invalid_field(
192 "checksum_crc32",
193 format!("`{}` cannot be used as a header value: {}", &header_value, err),
194 )
195 })?;
196 builder = builder.header("x-amz-fwd-header-x-amz-checksum-crc32", header_value);
197 }
198 if let ::std::option::Option::Some(inner_29) = &input.checksum_crc32_c {
199 let formatted_30 = inner_29.as_str();
200 let header_value = formatted_30;
201 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
202 ::aws_smithy_types::error::operation::BuildError::invalid_field(
203 "checksum_crc32_c",
204 format!("`{}` cannot be used as a header value: {}", &header_value, err),
205 )
206 })?;
207 builder = builder.header("x-amz-fwd-header-x-amz-checksum-crc32c", header_value);
208 }
209 if let ::std::option::Option::Some(inner_31) = &input.checksum_crc64_nvme {
210 let formatted_32 = inner_31.as_str();
211 let header_value = formatted_32;
212 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
213 ::aws_smithy_types::error::operation::BuildError::invalid_field(
214 "checksum_crc64_nvme",
215 format!("`{}` cannot be used as a header value: {}", &header_value, err),
216 )
217 })?;
218 builder = builder.header("x-amz-fwd-header-x-amz-checksum-crc64nvme", header_value);
219 }
220 if let ::std::option::Option::Some(inner_33) = &input.checksum_sha1 {
221 let formatted_34 = inner_33.as_str();
222 let header_value = formatted_34;
223 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
224 ::aws_smithy_types::error::operation::BuildError::invalid_field(
225 "checksum_sha1",
226 format!("`{}` cannot be used as a header value: {}", &header_value, err),
227 )
228 })?;
229 builder = builder.header("x-amz-fwd-header-x-amz-checksum-sha1", header_value);
230 }
231 if let ::std::option::Option::Some(inner_35) = &input.checksum_sha256 {
232 let formatted_36 = inner_35.as_str();
233 let header_value = formatted_36;
234 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
235 ::aws_smithy_types::error::operation::BuildError::invalid_field(
236 "checksum_sha256",
237 format!("`{}` cannot be used as a header value: {}", &header_value, err),
238 )
239 })?;
240 builder = builder.header("x-amz-fwd-header-x-amz-checksum-sha256", header_value);
241 }
242 if let ::std::option::Option::Some(inner_37) = &input.delete_marker {
243 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_37);
244 let formatted_38 = encoder.encode();
245 let header_value = formatted_38;
246 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
247 ::aws_smithy_types::error::operation::BuildError::invalid_field(
248 "delete_marker",
249 format!("`{}` cannot be used as a header value: {}", &header_value, err),
250 )
251 })?;
252 builder = builder.header("x-amz-fwd-header-x-amz-delete-marker", header_value);
253 }
254 if let ::std::option::Option::Some(inner_39) = &input.e_tag {
255 let formatted_40 = inner_39.as_str();
256 let header_value = formatted_40;
257 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
258 ::aws_smithy_types::error::operation::BuildError::invalid_field(
259 "e_tag",
260 format!("`{}` cannot be used as a header value: {}", &header_value, err),
261 )
262 })?;
263 builder = builder.header("x-amz-fwd-header-ETag", header_value);
264 }
265 if let ::std::option::Option::Some(inner_41) = &input.expires {
266 let formatted_42 = inner_41.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
267 let header_value = formatted_42;
268 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
269 ::aws_smithy_types::error::operation::BuildError::invalid_field(
270 "expires",
271 format!("`{}` cannot be used as a header value: {}", &header_value, err),
272 )
273 })?;
274 builder = builder.header("x-amz-fwd-header-Expires", header_value);
275 }
276 if let ::std::option::Option::Some(inner_43) = &input.expiration {
277 let formatted_44 = inner_43.as_str();
278 let header_value = formatted_44;
279 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
280 ::aws_smithy_types::error::operation::BuildError::invalid_field(
281 "expiration",
282 format!("`{}` cannot be used as a header value: {}", &header_value, err),
283 )
284 })?;
285 builder = builder.header("x-amz-fwd-header-x-amz-expiration", header_value);
286 }
287 if let ::std::option::Option::Some(inner_45) = &input.last_modified {
288 let formatted_46 = inner_45.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
289 let header_value = formatted_46;
290 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
291 ::aws_smithy_types::error::operation::BuildError::invalid_field(
292 "last_modified",
293 format!("`{}` cannot be used as a header value: {}", &header_value, err),
294 )
295 })?;
296 builder = builder.header("x-amz-fwd-header-Last-Modified", header_value);
297 }
298 if let ::std::option::Option::Some(inner_47) = &input.missing_meta {
299 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_47);
300 let formatted_48 = encoder.encode();
301 let header_value = formatted_48;
302 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
303 ::aws_smithy_types::error::operation::BuildError::invalid_field(
304 "missing_meta",
305 format!("`{}` cannot be used as a header value: {}", &header_value, err),
306 )
307 })?;
308 builder = builder.header("x-amz-fwd-header-x-amz-missing-meta", header_value);
309 }
310 if let ::std::option::Option::Some(inner_49) = &input.object_lock_mode {
311 let formatted_50 = inner_49.as_str();
312 let header_value = formatted_50;
313 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
314 ::aws_smithy_types::error::operation::BuildError::invalid_field(
315 "object_lock_mode",
316 format!("`{}` cannot be used as a header value: {}", &header_value, err),
317 )
318 })?;
319 builder = builder.header("x-amz-fwd-header-x-amz-object-lock-mode", header_value);
320 }
321 if let ::std::option::Option::Some(inner_51) = &input.object_lock_legal_hold_status {
322 let formatted_52 = inner_51.as_str();
323 let header_value = formatted_52;
324 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
325 ::aws_smithy_types::error::operation::BuildError::invalid_field(
326 "object_lock_legal_hold_status",
327 format!("`{}` cannot be used as a header value: {}", &header_value, err),
328 )
329 })?;
330 builder = builder.header("x-amz-fwd-header-x-amz-object-lock-legal-hold", header_value);
331 }
332 if let ::std::option::Option::Some(inner_53) = &input.object_lock_retain_until_date {
333 let formatted_54 = inner_53.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
334 let header_value = formatted_54;
335 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
336 ::aws_smithy_types::error::operation::BuildError::invalid_field(
337 "object_lock_retain_until_date",
338 format!("`{}` cannot be used as a header value: {}", &header_value, err),
339 )
340 })?;
341 builder = builder.header("x-amz-fwd-header-x-amz-object-lock-retain-until-date", header_value);
342 }
343 if let ::std::option::Option::Some(inner_55) = &input.parts_count {
344 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_55);
345 let formatted_56 = encoder.encode();
346 let header_value = formatted_56;
347 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
348 ::aws_smithy_types::error::operation::BuildError::invalid_field(
349 "parts_count",
350 format!("`{}` cannot be used as a header value: {}", &header_value, err),
351 )
352 })?;
353 builder = builder.header("x-amz-fwd-header-x-amz-mp-parts-count", header_value);
354 }
355 if let ::std::option::Option::Some(inner_57) = &input.replication_status {
356 let formatted_58 = inner_57.as_str();
357 let header_value = formatted_58;
358 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
359 ::aws_smithy_types::error::operation::BuildError::invalid_field(
360 "replication_status",
361 format!("`{}` cannot be used as a header value: {}", &header_value, err),
362 )
363 })?;
364 builder = builder.header("x-amz-fwd-header-x-amz-replication-status", header_value);
365 }
366 if let ::std::option::Option::Some(inner_59) = &input.request_charged {
367 let formatted_60 = inner_59.as_str();
368 let header_value = formatted_60;
369 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
370 ::aws_smithy_types::error::operation::BuildError::invalid_field(
371 "request_charged",
372 format!("`{}` cannot be used as a header value: {}", &header_value, err),
373 )
374 })?;
375 builder = builder.header("x-amz-fwd-header-x-amz-request-charged", header_value);
376 }
377 if let ::std::option::Option::Some(inner_61) = &input.restore {
378 let formatted_62 = inner_61.as_str();
379 let header_value = formatted_62;
380 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
381 ::aws_smithy_types::error::operation::BuildError::invalid_field(
382 "restore",
383 format!("`{}` cannot be used as a header value: {}", &header_value, err),
384 )
385 })?;
386 builder = builder.header("x-amz-fwd-header-x-amz-restore", header_value);
387 }
388 if let ::std::option::Option::Some(inner_63) = &input.server_side_encryption {
389 let formatted_64 = inner_63.as_str();
390 let header_value = formatted_64;
391 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
392 ::aws_smithy_types::error::operation::BuildError::invalid_field(
393 "server_side_encryption",
394 format!("`{}` cannot be used as a header value: {}", &header_value, err),
395 )
396 })?;
397 builder = builder.header("x-amz-fwd-header-x-amz-server-side-encryption", header_value);
398 }
399 if let ::std::option::Option::Some(inner_65) = &input.sse_customer_algorithm {
400 let formatted_66 = inner_65.as_str();
401 let header_value = formatted_66;
402 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
403 ::aws_smithy_types::error::operation::BuildError::invalid_field(
404 "sse_customer_algorithm",
405 format!("`{}` cannot be used as a header value: {}", &header_value, err),
406 )
407 })?;
408 builder = builder.header("x-amz-fwd-header-x-amz-server-side-encryption-customer-algorithm", header_value);
409 }
410 if let ::std::option::Option::Some(inner_67) = &input.ssekms_key_id {
411 let formatted_68 = inner_67.as_str();
412 let header_value = formatted_68;
413 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
414 ::aws_smithy_types::error::operation::BuildError::invalid_field(
415 "ssekms_key_id",
416 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
417 )
418 })?;
419 builder = builder.header("x-amz-fwd-header-x-amz-server-side-encryption-aws-kms-key-id", header_value);
420 }
421 if let ::std::option::Option::Some(inner_69) = &input.sse_customer_key_md5 {
422 let formatted_70 = inner_69.as_str();
423 let header_value = formatted_70;
424 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
425 ::aws_smithy_types::error::operation::BuildError::invalid_field(
426 "sse_customer_key_md5",
427 format!("`{}` cannot be used as a header value: {}", &header_value, err),
428 )
429 })?;
430 builder = builder.header("x-amz-fwd-header-x-amz-server-side-encryption-customer-key-MD5", header_value);
431 }
432 if let ::std::option::Option::Some(inner_71) = &input.storage_class {
433 let formatted_72 = inner_71.as_str();
434 let header_value = formatted_72;
435 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
436 ::aws_smithy_types::error::operation::BuildError::invalid_field(
437 "storage_class",
438 format!("`{}` cannot be used as a header value: {}", &header_value, err),
439 )
440 })?;
441 builder = builder.header("x-amz-fwd-header-x-amz-storage-class", header_value);
442 }
443 if let ::std::option::Option::Some(inner_73) = &input.tag_count {
444 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_73);
445 let formatted_74 = encoder.encode();
446 let header_value = formatted_74;
447 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
448 ::aws_smithy_types::error::operation::BuildError::invalid_field(
449 "tag_count",
450 format!("`{}` cannot be used as a header value: {}", &header_value, err),
451 )
452 })?;
453 builder = builder.header("x-amz-fwd-header-x-amz-tagging-count", header_value);
454 }
455 if let ::std::option::Option::Some(inner_75) = &input.version_id {
456 let formatted_76 = inner_75.as_str();
457 let header_value = formatted_76;
458 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
459 ::aws_smithy_types::error::operation::BuildError::invalid_field(
460 "version_id",
461 format!("`{}` cannot be used as a header value: {}", &header_value, err),
462 )
463 })?;
464 builder = builder.header("x-amz-fwd-header-x-amz-version-id", header_value);
465 }
466 if let ::std::option::Option::Some(inner_77) = &input.bucket_key_enabled {
467 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_77);
468 let formatted_78 = encoder.encode();
469 let header_value = formatted_78;
470 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
471 ::aws_smithy_types::error::operation::BuildError::invalid_field(
472 "bucket_key_enabled",
473 format!("`{}` cannot be used as a header value: {}", &header_value, err),
474 )
475 })?;
476 builder = builder.header("x-amz-fwd-header-x-amz-server-side-encryption-bucket-key-enabled", header_value);
477 }
478 if let ::std::option::Option::Some(inner_79) = &input.metadata {
479 {
480 for (k, v) in inner_79 {
481 use std::str::FromStr;
482 let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
483 ::aws_smithy_types::error::operation::BuildError::invalid_field(
484 "metadata",
485 format!("`{k}` cannot be used as a header name: {err}"),
486 )
487 })?;
488 let header_value = v.as_str();
489 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
490 ::aws_smithy_types::error::operation::BuildError::invalid_field(
491 "metadata",
492 format!("`{}` cannot be used as a header value: {}", v, err),
493 )
494 })?;
495 builder = builder.header(header_name, header_value);
496 }
497 }
498 }
499 Ok(builder)
500}