1#[allow(clippy::unnecessary_wraps)]
3pub fn de_copy_object_http_error(
4 _response_status: u16,
5 _response_headers: &::aws_smithy_runtime_api::http::Headers,
6 _response_body: &[u8],
7) -> std::result::Result<crate::operation::copy_object::CopyObjectOutput, crate::operation::copy_object::CopyObjectError> {
8 #[allow(unused_mut)]
9 let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
10 .map_err(crate::operation::copy_object::CopyObjectError::unhandled)?;
11 generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
12 generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
13 let generic = generic_builder.build();
14 let error_code = match generic.code() {
15 Some(code) => code,
16 None => return Err(crate::operation::copy_object::CopyObjectError::unhandled(generic)),
17 };
18
19 let _error_message = generic.message().map(|msg| msg.to_owned());
20 Err(match error_code {
21 "ObjectNotInActiveTierError" => crate::operation::copy_object::CopyObjectError::ObjectNotInActiveTierError({
22 #[allow(unused_mut)]
23 let mut tmp = {
24 #[allow(unused_mut)]
25 let mut output = crate::types::error::builders::ObjectNotInActiveTierErrorBuilder::default();
26 output =
27 crate::protocol_serde::shape_object_not_in_active_tier_error::de_object_not_in_active_tier_error_xml_err(_response_body, output)
28 .map_err(crate::operation::copy_object::CopyObjectError::unhandled)?;
29 let output = output.meta(generic);
30 output.build()
31 };
32 if tmp.message.is_none() {
33 tmp.message = _error_message;
34 }
35 tmp
36 }),
37 _ => crate::operation::copy_object::CopyObjectError::generic(generic),
38 })
39}
40
41#[allow(clippy::unnecessary_wraps)]
42pub fn de_copy_object_http_response(
43 _response_status: u16,
44 _response_headers: &::aws_smithy_runtime_api::http::Headers,
45 _response_body: &[u8],
46) -> std::result::Result<crate::operation::copy_object::CopyObjectOutput, crate::operation::copy_object::CopyObjectError> {
47 Ok({
48 #[allow(unused_mut)]
49 let mut output = crate::operation::copy_object::builders::CopyObjectOutputBuilder::default();
50 output = output.set_bucket_key_enabled(
51 crate::protocol_serde::shape_copy_object_output::de_bucket_key_enabled_header(_response_headers).map_err(|_| {
52 crate::operation::copy_object::CopyObjectError::unhandled(
53 "Failed to parse BucketKeyEnabled from header `x-amz-server-side-encryption-bucket-key-enabled",
54 )
55 })?,
56 );
57 output = output.set_copy_object_result(crate::protocol_serde::shape_copy_object_output::de_copy_object_result_payload(
58 _response_body,
59 )?);
60 output = output.set_copy_source_version_id(
61 crate::protocol_serde::shape_copy_object_output::de_copy_source_version_id_header(_response_headers).map_err(|_| {
62 crate::operation::copy_object::CopyObjectError::unhandled(
63 "Failed to parse CopySourceVersionId from header `x-amz-copy-source-version-id",
64 )
65 })?,
66 );
67 output = output.set_expiration(
68 crate::protocol_serde::shape_copy_object_output::de_expiration_header(_response_headers)
69 .map_err(|_| crate::operation::copy_object::CopyObjectError::unhandled("Failed to parse Expiration from header `x-amz-expiration"))?,
70 );
71 output = output.set_request_charged(
72 crate::protocol_serde::shape_copy_object_output::de_request_charged_header(_response_headers).map_err(|_| {
73 crate::operation::copy_object::CopyObjectError::unhandled("Failed to parse RequestCharged from header `x-amz-request-charged")
74 })?,
75 );
76 output = output.set_sse_customer_algorithm(
77 crate::protocol_serde::shape_copy_object_output::de_sse_customer_algorithm_header(_response_headers).map_err(|_| {
78 crate::operation::copy_object::CopyObjectError::unhandled(
79 "Failed to parse SSECustomerAlgorithm from header `x-amz-server-side-encryption-customer-algorithm",
80 )
81 })?,
82 );
83 output = output.set_sse_customer_key_md5(
84 crate::protocol_serde::shape_copy_object_output::de_sse_customer_key_md5_header(_response_headers).map_err(|_| {
85 crate::operation::copy_object::CopyObjectError::unhandled(
86 "Failed to parse SSECustomerKeyMD5 from header `x-amz-server-side-encryption-customer-key-MD5",
87 )
88 })?,
89 );
90 output = output.set_ssekms_encryption_context(
91 crate::protocol_serde::shape_copy_object_output::de_ssekms_encryption_context_header(_response_headers).map_err(|_| {
92 crate::operation::copy_object::CopyObjectError::unhandled(
93 "Failed to parse SSEKMSEncryptionContext from header `x-amz-server-side-encryption-context",
94 )
95 })?,
96 );
97 output = output.set_ssekms_key_id(
98 crate::protocol_serde::shape_copy_object_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
99 crate::operation::copy_object::CopyObjectError::unhandled(
100 "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
101 )
102 })?,
103 );
104 output = output.set_server_side_encryption(
105 crate::protocol_serde::shape_copy_object_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
106 crate::operation::copy_object::CopyObjectError::unhandled(
107 "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
108 )
109 })?,
110 );
111 output = output.set_version_id(
112 crate::protocol_serde::shape_copy_object_output::de_version_id_header(_response_headers)
113 .map_err(|_| crate::operation::copy_object::CopyObjectError::unhandled("Failed to parse VersionId from header `x-amz-version-id"))?,
114 );
115 output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
116 output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
117 output.build()
118 })
119}
120
121pub fn ser_copy_object_headers(
122 input: &crate::operation::copy_object::CopyObjectInput,
123 mut builder: ::http::request::Builder,
124) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
125 if let ::std::option::Option::Some(inner_1) = &input.acl {
126 let formatted_2 = inner_1.as_str();
127 if !formatted_2.is_empty() {
128 let header_value = formatted_2;
129 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
130 ::aws_smithy_types::error::operation::BuildError::invalid_field(
131 "acl",
132 format!("`{}` cannot be used as a header value: {}", &header_value, err),
133 )
134 })?;
135 builder = builder.header("x-amz-acl", header_value);
136 }
137 }
138 if let ::std::option::Option::Some(inner_3) = &input.cache_control {
139 let formatted_4 = inner_3.as_str();
140 if !formatted_4.is_empty() {
141 let header_value = formatted_4;
142 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
143 ::aws_smithy_types::error::operation::BuildError::invalid_field(
144 "cache_control",
145 format!("`{}` cannot be used as a header value: {}", &header_value, err),
146 )
147 })?;
148 builder = builder.header("Cache-Control", header_value);
149 }
150 }
151 if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
152 let formatted_6 = inner_5.as_str();
153 if !formatted_6.is_empty() {
154 let header_value = formatted_6;
155 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
156 ::aws_smithy_types::error::operation::BuildError::invalid_field(
157 "checksum_algorithm",
158 format!("`{}` cannot be used as a header value: {}", &header_value, err),
159 )
160 })?;
161 builder = builder.header("x-amz-checksum-algorithm", header_value);
162 }
163 }
164 if let ::std::option::Option::Some(inner_7) = &input.content_disposition {
165 let formatted_8 = inner_7.as_str();
166 if !formatted_8.is_empty() {
167 let header_value = formatted_8;
168 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
169 ::aws_smithy_types::error::operation::BuildError::invalid_field(
170 "content_disposition",
171 format!("`{}` cannot be used as a header value: {}", &header_value, err),
172 )
173 })?;
174 builder = builder.header("Content-Disposition", header_value);
175 }
176 }
177 if let ::std::option::Option::Some(inner_9) = &input.content_encoding {
178 let formatted_10 = inner_9.as_str();
179 if !formatted_10.is_empty() {
180 let header_value = formatted_10;
181 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
182 ::aws_smithy_types::error::operation::BuildError::invalid_field(
183 "content_encoding",
184 format!("`{}` cannot be used as a header value: {}", &header_value, err),
185 )
186 })?;
187 builder = builder.header("Content-Encoding", header_value);
188 }
189 }
190 if let ::std::option::Option::Some(inner_11) = &input.content_language {
191 let formatted_12 = inner_11.as_str();
192 if !formatted_12.is_empty() {
193 let header_value = formatted_12;
194 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
195 ::aws_smithy_types::error::operation::BuildError::invalid_field(
196 "content_language",
197 format!("`{}` cannot be used as a header value: {}", &header_value, err),
198 )
199 })?;
200 builder = builder.header("Content-Language", header_value);
201 }
202 }
203 if let ::std::option::Option::Some(inner_13) = &input.content_type {
204 let formatted_14 = inner_13.as_str();
205 if !formatted_14.is_empty() {
206 let header_value = formatted_14;
207 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
208 ::aws_smithy_types::error::operation::BuildError::invalid_field(
209 "content_type",
210 format!("`{}` cannot be used as a header value: {}", &header_value, err),
211 )
212 })?;
213 builder = builder.header("Content-Type", header_value);
214 }
215 }
216 if let ::std::option::Option::Some(inner_15) = &input.copy_source {
217 let formatted_16 = inner_15.as_str();
218 if !formatted_16.is_empty() {
219 let header_value = formatted_16;
220 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
221 ::aws_smithy_types::error::operation::BuildError::invalid_field(
222 "copy_source",
223 format!("`{}` cannot be used as a header value: {}", &header_value, err),
224 )
225 })?;
226 builder = builder.header("x-amz-copy-source", header_value);
227 }
228 }
229 if let ::std::option::Option::Some(inner_17) = &input.copy_source_if_match {
230 let formatted_18 = inner_17.as_str();
231 if !formatted_18.is_empty() {
232 let header_value = formatted_18;
233 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
234 ::aws_smithy_types::error::operation::BuildError::invalid_field(
235 "copy_source_if_match",
236 format!("`{}` cannot be used as a header value: {}", &header_value, err),
237 )
238 })?;
239 builder = builder.header("x-amz-copy-source-if-match", header_value);
240 }
241 }
242 if let ::std::option::Option::Some(inner_19) = &input.copy_source_if_modified_since {
243 let formatted_20 = inner_19.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
244 if !formatted_20.is_empty() {
245 let header_value = formatted_20;
246 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
247 ::aws_smithy_types::error::operation::BuildError::invalid_field(
248 "copy_source_if_modified_since",
249 format!("`{}` cannot be used as a header value: {}", &header_value, err),
250 )
251 })?;
252 builder = builder.header("x-amz-copy-source-if-modified-since", header_value);
253 }
254 }
255 if let ::std::option::Option::Some(inner_21) = &input.copy_source_if_none_match {
256 let formatted_22 = inner_21.as_str();
257 if !formatted_22.is_empty() {
258 let header_value = formatted_22;
259 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
260 ::aws_smithy_types::error::operation::BuildError::invalid_field(
261 "copy_source_if_none_match",
262 format!("`{}` cannot be used as a header value: {}", &header_value, err),
263 )
264 })?;
265 builder = builder.header("x-amz-copy-source-if-none-match", header_value);
266 }
267 }
268 if let ::std::option::Option::Some(inner_23) = &input.copy_source_if_unmodified_since {
269 let formatted_24 = inner_23.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
270 if !formatted_24.is_empty() {
271 let header_value = formatted_24;
272 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
273 ::aws_smithy_types::error::operation::BuildError::invalid_field(
274 "copy_source_if_unmodified_since",
275 format!("`{}` cannot be used as a header value: {}", &header_value, err),
276 )
277 })?;
278 builder = builder.header("x-amz-copy-source-if-unmodified-since", header_value);
279 }
280 }
281 if let ::std::option::Option::Some(inner_25) = &input.expires {
282 let formatted_26 = inner_25.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
283 if !formatted_26.is_empty() {
284 let header_value = formatted_26;
285 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
286 ::aws_smithy_types::error::operation::BuildError::invalid_field(
287 "expires",
288 format!("`{}` cannot be used as a header value: {}", &header_value, err),
289 )
290 })?;
291 builder = builder.header("Expires", header_value);
292 }
293 }
294 if let ::std::option::Option::Some(inner_27) = &input.grant_full_control {
295 let formatted_28 = inner_27.as_str();
296 if !formatted_28.is_empty() {
297 let header_value = formatted_28;
298 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
299 ::aws_smithy_types::error::operation::BuildError::invalid_field(
300 "grant_full_control",
301 format!("`{}` cannot be used as a header value: {}", &header_value, err),
302 )
303 })?;
304 builder = builder.header("x-amz-grant-full-control", header_value);
305 }
306 }
307 if let ::std::option::Option::Some(inner_29) = &input.grant_read {
308 let formatted_30 = inner_29.as_str();
309 if !formatted_30.is_empty() {
310 let header_value = formatted_30;
311 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
312 ::aws_smithy_types::error::operation::BuildError::invalid_field(
313 "grant_read",
314 format!("`{}` cannot be used as a header value: {}", &header_value, err),
315 )
316 })?;
317 builder = builder.header("x-amz-grant-read", header_value);
318 }
319 }
320 if let ::std::option::Option::Some(inner_31) = &input.grant_read_acp {
321 let formatted_32 = inner_31.as_str();
322 if !formatted_32.is_empty() {
323 let header_value = formatted_32;
324 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
325 ::aws_smithy_types::error::operation::BuildError::invalid_field(
326 "grant_read_acp",
327 format!("`{}` cannot be used as a header value: {}", &header_value, err),
328 )
329 })?;
330 builder = builder.header("x-amz-grant-read-acp", header_value);
331 }
332 }
333 if let ::std::option::Option::Some(inner_33) = &input.grant_write_acp {
334 let formatted_34 = inner_33.as_str();
335 if !formatted_34.is_empty() {
336 let header_value = formatted_34;
337 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
338 ::aws_smithy_types::error::operation::BuildError::invalid_field(
339 "grant_write_acp",
340 format!("`{}` cannot be used as a header value: {}", &header_value, err),
341 )
342 })?;
343 builder = builder.header("x-amz-grant-write-acp", header_value);
344 }
345 }
346 if let ::std::option::Option::Some(inner_35) = &input.metadata_directive {
347 let formatted_36 = inner_35.as_str();
348 if !formatted_36.is_empty() {
349 let header_value = formatted_36;
350 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
351 ::aws_smithy_types::error::operation::BuildError::invalid_field(
352 "metadata_directive",
353 format!("`{}` cannot be used as a header value: {}", &header_value, err),
354 )
355 })?;
356 builder = builder.header("x-amz-metadata-directive", header_value);
357 }
358 }
359 if let ::std::option::Option::Some(inner_37) = &input.tagging_directive {
360 let formatted_38 = inner_37.as_str();
361 if !formatted_38.is_empty() {
362 let header_value = formatted_38;
363 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
364 ::aws_smithy_types::error::operation::BuildError::invalid_field(
365 "tagging_directive",
366 format!("`{}` cannot be used as a header value: {}", &header_value, err),
367 )
368 })?;
369 builder = builder.header("x-amz-tagging-directive", header_value);
370 }
371 }
372 if let ::std::option::Option::Some(inner_39) = &input.server_side_encryption {
373 let formatted_40 = inner_39.as_str();
374 if !formatted_40.is_empty() {
375 let header_value = formatted_40;
376 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
377 ::aws_smithy_types::error::operation::BuildError::invalid_field(
378 "server_side_encryption",
379 format!("`{}` cannot be used as a header value: {}", &header_value, err),
380 )
381 })?;
382 builder = builder.header("x-amz-server-side-encryption", header_value);
383 }
384 }
385 if let ::std::option::Option::Some(inner_41) = &input.storage_class {
386 let formatted_42 = inner_41.as_str();
387 if !formatted_42.is_empty() {
388 let header_value = formatted_42;
389 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
390 ::aws_smithy_types::error::operation::BuildError::invalid_field(
391 "storage_class",
392 format!("`{}` cannot be used as a header value: {}", &header_value, err),
393 )
394 })?;
395 builder = builder.header("x-amz-storage-class", header_value);
396 }
397 }
398 if let ::std::option::Option::Some(inner_43) = &input.website_redirect_location {
399 let formatted_44 = inner_43.as_str();
400 if !formatted_44.is_empty() {
401 let header_value = formatted_44;
402 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
403 ::aws_smithy_types::error::operation::BuildError::invalid_field(
404 "website_redirect_location",
405 format!("`{}` cannot be used as a header value: {}", &header_value, err),
406 )
407 })?;
408 builder = builder.header("x-amz-website-redirect-location", header_value);
409 }
410 }
411 if let ::std::option::Option::Some(inner_45) = &input.sse_customer_algorithm {
412 let formatted_46 = inner_45.as_str();
413 if !formatted_46.is_empty() {
414 let header_value = formatted_46;
415 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
416 ::aws_smithy_types::error::operation::BuildError::invalid_field(
417 "sse_customer_algorithm",
418 format!("`{}` cannot be used as a header value: {}", &header_value, err),
419 )
420 })?;
421 builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
422 }
423 }
424 if let ::std::option::Option::Some(inner_47) = &input.sse_customer_key {
425 let formatted_48 = inner_47.as_str();
426 if !formatted_48.is_empty() {
427 let header_value = formatted_48;
428 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
429 ::aws_smithy_types::error::operation::BuildError::invalid_field(
430 "sse_customer_key",
431 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
432 )
433 })?;
434 builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
435 }
436 }
437 if let ::std::option::Option::Some(inner_49) = &input.sse_customer_key_md5 {
438 let formatted_50 = inner_49.as_str();
439 if !formatted_50.is_empty() {
440 let header_value = formatted_50;
441 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
442 ::aws_smithy_types::error::operation::BuildError::invalid_field(
443 "sse_customer_key_md5",
444 format!("`{}` cannot be used as a header value: {}", &header_value, err),
445 )
446 })?;
447 builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
448 }
449 }
450 if let ::std::option::Option::Some(inner_51) = &input.ssekms_key_id {
451 let formatted_52 = inner_51.as_str();
452 if !formatted_52.is_empty() {
453 let header_value = formatted_52;
454 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
455 ::aws_smithy_types::error::operation::BuildError::invalid_field(
456 "ssekms_key_id",
457 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
458 )
459 })?;
460 builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
461 }
462 }
463 if let ::std::option::Option::Some(inner_53) = &input.ssekms_encryption_context {
464 let formatted_54 = inner_53.as_str();
465 if !formatted_54.is_empty() {
466 let header_value = formatted_54;
467 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
468 ::aws_smithy_types::error::operation::BuildError::invalid_field(
469 "ssekms_encryption_context",
470 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
471 )
472 })?;
473 builder = builder.header("x-amz-server-side-encryption-context", header_value);
474 }
475 }
476 if let ::std::option::Option::Some(inner_55) = &input.bucket_key_enabled {
477 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_55);
478 let formatted_56 = encoder.encode();
479 if !formatted_56.is_empty() {
480 let header_value = formatted_56;
481 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
482 ::aws_smithy_types::error::operation::BuildError::invalid_field(
483 "bucket_key_enabled",
484 format!("`{}` cannot be used as a header value: {}", &header_value, err),
485 )
486 })?;
487 builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
488 }
489 }
490 if let ::std::option::Option::Some(inner_57) = &input.copy_source_sse_customer_algorithm {
491 let formatted_58 = inner_57.as_str();
492 if !formatted_58.is_empty() {
493 let header_value = formatted_58;
494 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
495 ::aws_smithy_types::error::operation::BuildError::invalid_field(
496 "copy_source_sse_customer_algorithm",
497 format!("`{}` cannot be used as a header value: {}", &header_value, err),
498 )
499 })?;
500 builder = builder.header("x-amz-copy-source-server-side-encryption-customer-algorithm", header_value);
501 }
502 }
503 if let ::std::option::Option::Some(inner_59) = &input.copy_source_sse_customer_key {
504 let formatted_60 = inner_59.as_str();
505 if !formatted_60.is_empty() {
506 let header_value = formatted_60;
507 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
508 ::aws_smithy_types::error::operation::BuildError::invalid_field(
509 "copy_source_sse_customer_key",
510 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
511 )
512 })?;
513 builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key", header_value);
514 }
515 }
516 if let ::std::option::Option::Some(inner_61) = &input.copy_source_sse_customer_key_md5 {
517 let formatted_62 = inner_61.as_str();
518 if !formatted_62.is_empty() {
519 let header_value = formatted_62;
520 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
521 ::aws_smithy_types::error::operation::BuildError::invalid_field(
522 "copy_source_sse_customer_key_md5",
523 format!("`{}` cannot be used as a header value: {}", &header_value, err),
524 )
525 })?;
526 builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key-MD5", header_value);
527 }
528 }
529 if let ::std::option::Option::Some(inner_63) = &input.request_payer {
530 let formatted_64 = inner_63.as_str();
531 if !formatted_64.is_empty() {
532 let header_value = formatted_64;
533 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
534 ::aws_smithy_types::error::operation::BuildError::invalid_field(
535 "request_payer",
536 format!("`{}` cannot be used as a header value: {}", &header_value, err),
537 )
538 })?;
539 builder = builder.header("x-amz-request-payer", header_value);
540 }
541 }
542 if let ::std::option::Option::Some(inner_65) = &input.tagging {
543 let formatted_66 = inner_65.as_str();
544 if !formatted_66.is_empty() {
545 let header_value = formatted_66;
546 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
547 ::aws_smithy_types::error::operation::BuildError::invalid_field(
548 "tagging",
549 format!("`{}` cannot be used as a header value: {}", &header_value, err),
550 )
551 })?;
552 builder = builder.header("x-amz-tagging", header_value);
553 }
554 }
555 if let ::std::option::Option::Some(inner_67) = &input.object_lock_mode {
556 let formatted_68 = inner_67.as_str();
557 if !formatted_68.is_empty() {
558 let header_value = formatted_68;
559 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
560 ::aws_smithy_types::error::operation::BuildError::invalid_field(
561 "object_lock_mode",
562 format!("`{}` cannot be used as a header value: {}", &header_value, err),
563 )
564 })?;
565 builder = builder.header("x-amz-object-lock-mode", header_value);
566 }
567 }
568 if let ::std::option::Option::Some(inner_69) = &input.object_lock_retain_until_date {
569 let formatted_70 = inner_69.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
570 if !formatted_70.is_empty() {
571 let header_value = formatted_70;
572 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
573 ::aws_smithy_types::error::operation::BuildError::invalid_field(
574 "object_lock_retain_until_date",
575 format!("`{}` cannot be used as a header value: {}", &header_value, err),
576 )
577 })?;
578 builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
579 }
580 }
581 if let ::std::option::Option::Some(inner_71) = &input.object_lock_legal_hold_status {
582 let formatted_72 = inner_71.as_str();
583 if !formatted_72.is_empty() {
584 let header_value = formatted_72;
585 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
586 ::aws_smithy_types::error::operation::BuildError::invalid_field(
587 "object_lock_legal_hold_status",
588 format!("`{}` cannot be used as a header value: {}", &header_value, err),
589 )
590 })?;
591 builder = builder.header("x-amz-object-lock-legal-hold", header_value);
592 }
593 }
594 if let ::std::option::Option::Some(inner_73) = &input.expected_bucket_owner {
595 let formatted_74 = inner_73.as_str();
596 if !formatted_74.is_empty() {
597 let header_value = formatted_74;
598 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
599 ::aws_smithy_types::error::operation::BuildError::invalid_field(
600 "expected_bucket_owner",
601 format!("`{}` cannot be used as a header value: {}", &header_value, err),
602 )
603 })?;
604 builder = builder.header("x-amz-expected-bucket-owner", header_value);
605 }
606 }
607 if let ::std::option::Option::Some(inner_75) = &input.expected_source_bucket_owner {
608 let formatted_76 = inner_75.as_str();
609 if !formatted_76.is_empty() {
610 let header_value = formatted_76;
611 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
612 ::aws_smithy_types::error::operation::BuildError::invalid_field(
613 "expected_source_bucket_owner",
614 format!("`{}` cannot be used as a header value: {}", &header_value, err),
615 )
616 })?;
617 builder = builder.header("x-amz-source-expected-bucket-owner", header_value);
618 }
619 }
620 if let ::std::option::Option::Some(inner_77) = &input.metadata {
621 {
622 for (k, v) in inner_77 {
623 use std::str::FromStr;
624 let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
625 ::aws_smithy_types::error::operation::BuildError::invalid_field(
626 "metadata",
627 format!("`{k}` cannot be used as a header name: {err}"),
628 )
629 })?;
630 let header_value = v.as_str();
631 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
632 ::aws_smithy_types::error::operation::BuildError::invalid_field(
633 "metadata",
634 format!("`{}` cannot be used as a header value: {}", v, err),
635 )
636 })?;
637 builder = builder.header(header_name, header_value);
638 }
639 }
640 }
641 Ok(builder)
642}