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 let header_value = formatted_2;
128 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
129 ::aws_smithy_types::error::operation::BuildError::invalid_field(
130 "acl",
131 format!("`{}` cannot be used as a header value: {}", &header_value, err),
132 )
133 })?;
134 builder = builder.header("x-amz-acl", header_value);
135 }
136 if let ::std::option::Option::Some(inner_3) = &input.cache_control {
137 let formatted_4 = inner_3.as_str();
138 let header_value = formatted_4;
139 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
140 ::aws_smithy_types::error::operation::BuildError::invalid_field(
141 "cache_control",
142 format!("`{}` cannot be used as a header value: {}", &header_value, err),
143 )
144 })?;
145 builder = builder.header("Cache-Control", header_value);
146 }
147 if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
148 let formatted_6 = inner_5.as_str();
149 let header_value = formatted_6;
150 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
151 ::aws_smithy_types::error::operation::BuildError::invalid_field(
152 "checksum_algorithm",
153 format!("`{}` cannot be used as a header value: {}", &header_value, err),
154 )
155 })?;
156 builder = builder.header("x-amz-checksum-algorithm", header_value);
157 }
158 if let ::std::option::Option::Some(inner_7) = &input.content_disposition {
159 let formatted_8 = inner_7.as_str();
160 let header_value = formatted_8;
161 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
162 ::aws_smithy_types::error::operation::BuildError::invalid_field(
163 "content_disposition",
164 format!("`{}` cannot be used as a header value: {}", &header_value, err),
165 )
166 })?;
167 builder = builder.header("Content-Disposition", header_value);
168 }
169 if let ::std::option::Option::Some(inner_9) = &input.content_encoding {
170 let formatted_10 = inner_9.as_str();
171 let header_value = formatted_10;
172 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
173 ::aws_smithy_types::error::operation::BuildError::invalid_field(
174 "content_encoding",
175 format!("`{}` cannot be used as a header value: {}", &header_value, err),
176 )
177 })?;
178 builder = builder.header("Content-Encoding", header_value);
179 }
180 if let ::std::option::Option::Some(inner_11) = &input.content_language {
181 let formatted_12 = inner_11.as_str();
182 let header_value = formatted_12;
183 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
184 ::aws_smithy_types::error::operation::BuildError::invalid_field(
185 "content_language",
186 format!("`{}` cannot be used as a header value: {}", &header_value, err),
187 )
188 })?;
189 builder = builder.header("Content-Language", header_value);
190 }
191 if let ::std::option::Option::Some(inner_13) = &input.content_type {
192 let formatted_14 = inner_13.as_str();
193 let header_value = formatted_14;
194 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
195 ::aws_smithy_types::error::operation::BuildError::invalid_field(
196 "content_type",
197 format!("`{}` cannot be used as a header value: {}", &header_value, err),
198 )
199 })?;
200 builder = builder.header("Content-Type", header_value);
201 }
202 if let ::std::option::Option::Some(inner_15) = &input.copy_source {
203 let formatted_16 = inner_15.as_str();
204 let header_value = formatted_16;
205 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
206 ::aws_smithy_types::error::operation::BuildError::invalid_field(
207 "copy_source",
208 format!("`{}` cannot be used as a header value: {}", &header_value, err),
209 )
210 })?;
211 builder = builder.header("x-amz-copy-source", header_value);
212 }
213 if let ::std::option::Option::Some(inner_17) = &input.copy_source_if_match {
214 let formatted_18 = inner_17.as_str();
215 let header_value = formatted_18;
216 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
217 ::aws_smithy_types::error::operation::BuildError::invalid_field(
218 "copy_source_if_match",
219 format!("`{}` cannot be used as a header value: {}", &header_value, err),
220 )
221 })?;
222 builder = builder.header("x-amz-copy-source-if-match", header_value);
223 }
224 if let ::std::option::Option::Some(inner_19) = &input.copy_source_if_modified_since {
225 let formatted_20 = inner_19.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
226 let header_value = formatted_20;
227 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
228 ::aws_smithy_types::error::operation::BuildError::invalid_field(
229 "copy_source_if_modified_since",
230 format!("`{}` cannot be used as a header value: {}", &header_value, err),
231 )
232 })?;
233 builder = builder.header("x-amz-copy-source-if-modified-since", header_value);
234 }
235 if let ::std::option::Option::Some(inner_21) = &input.copy_source_if_none_match {
236 let formatted_22 = inner_21.as_str();
237 let header_value = formatted_22;
238 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
239 ::aws_smithy_types::error::operation::BuildError::invalid_field(
240 "copy_source_if_none_match",
241 format!("`{}` cannot be used as a header value: {}", &header_value, err),
242 )
243 })?;
244 builder = builder.header("x-amz-copy-source-if-none-match", header_value);
245 }
246 if let ::std::option::Option::Some(inner_23) = &input.copy_source_if_unmodified_since {
247 let formatted_24 = inner_23.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
248 let header_value = formatted_24;
249 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
250 ::aws_smithy_types::error::operation::BuildError::invalid_field(
251 "copy_source_if_unmodified_since",
252 format!("`{}` cannot be used as a header value: {}", &header_value, err),
253 )
254 })?;
255 builder = builder.header("x-amz-copy-source-if-unmodified-since", header_value);
256 }
257 if let ::std::option::Option::Some(inner_25) = &input.expires {
258 let formatted_26 = inner_25.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
259 let header_value = formatted_26;
260 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
261 ::aws_smithy_types::error::operation::BuildError::invalid_field(
262 "expires",
263 format!("`{}` cannot be used as a header value: {}", &header_value, err),
264 )
265 })?;
266 builder = builder.header("Expires", header_value);
267 }
268 if let ::std::option::Option::Some(inner_27) = &input.grant_full_control {
269 let formatted_28 = inner_27.as_str();
270 let header_value = formatted_28;
271 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
272 ::aws_smithy_types::error::operation::BuildError::invalid_field(
273 "grant_full_control",
274 format!("`{}` cannot be used as a header value: {}", &header_value, err),
275 )
276 })?;
277 builder = builder.header("x-amz-grant-full-control", header_value);
278 }
279 if let ::std::option::Option::Some(inner_29) = &input.grant_read {
280 let formatted_30 = inner_29.as_str();
281 let header_value = formatted_30;
282 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
283 ::aws_smithy_types::error::operation::BuildError::invalid_field(
284 "grant_read",
285 format!("`{}` cannot be used as a header value: {}", &header_value, err),
286 )
287 })?;
288 builder = builder.header("x-amz-grant-read", header_value);
289 }
290 if let ::std::option::Option::Some(inner_31) = &input.grant_read_acp {
291 let formatted_32 = inner_31.as_str();
292 let header_value = formatted_32;
293 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
294 ::aws_smithy_types::error::operation::BuildError::invalid_field(
295 "grant_read_acp",
296 format!("`{}` cannot be used as a header value: {}", &header_value, err),
297 )
298 })?;
299 builder = builder.header("x-amz-grant-read-acp", header_value);
300 }
301 if let ::std::option::Option::Some(inner_33) = &input.grant_write_acp {
302 let formatted_34 = inner_33.as_str();
303 let header_value = formatted_34;
304 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
305 ::aws_smithy_types::error::operation::BuildError::invalid_field(
306 "grant_write_acp",
307 format!("`{}` cannot be used as a header value: {}", &header_value, err),
308 )
309 })?;
310 builder = builder.header("x-amz-grant-write-acp", header_value);
311 }
312 if let ::std::option::Option::Some(inner_35) = &input.metadata_directive {
313 let formatted_36 = inner_35.as_str();
314 let header_value = formatted_36;
315 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
316 ::aws_smithy_types::error::operation::BuildError::invalid_field(
317 "metadata_directive",
318 format!("`{}` cannot be used as a header value: {}", &header_value, err),
319 )
320 })?;
321 builder = builder.header("x-amz-metadata-directive", header_value);
322 }
323 if let ::std::option::Option::Some(inner_37) = &input.tagging_directive {
324 let formatted_38 = inner_37.as_str();
325 let header_value = formatted_38;
326 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
327 ::aws_smithy_types::error::operation::BuildError::invalid_field(
328 "tagging_directive",
329 format!("`{}` cannot be used as a header value: {}", &header_value, err),
330 )
331 })?;
332 builder = builder.header("x-amz-tagging-directive", header_value);
333 }
334 if let ::std::option::Option::Some(inner_39) = &input.server_side_encryption {
335 let formatted_40 = inner_39.as_str();
336 let header_value = formatted_40;
337 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
338 ::aws_smithy_types::error::operation::BuildError::invalid_field(
339 "server_side_encryption",
340 format!("`{}` cannot be used as a header value: {}", &header_value, err),
341 )
342 })?;
343 builder = builder.header("x-amz-server-side-encryption", header_value);
344 }
345 if let ::std::option::Option::Some(inner_41) = &input.storage_class {
346 let formatted_42 = inner_41.as_str();
347 let header_value = formatted_42;
348 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
349 ::aws_smithy_types::error::operation::BuildError::invalid_field(
350 "storage_class",
351 format!("`{}` cannot be used as a header value: {}", &header_value, err),
352 )
353 })?;
354 builder = builder.header("x-amz-storage-class", header_value);
355 }
356 if let ::std::option::Option::Some(inner_43) = &input.website_redirect_location {
357 let formatted_44 = inner_43.as_str();
358 let header_value = formatted_44;
359 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
360 ::aws_smithy_types::error::operation::BuildError::invalid_field(
361 "website_redirect_location",
362 format!("`{}` cannot be used as a header value: {}", &header_value, err),
363 )
364 })?;
365 builder = builder.header("x-amz-website-redirect-location", header_value);
366 }
367 if let ::std::option::Option::Some(inner_45) = &input.sse_customer_algorithm {
368 let formatted_46 = inner_45.as_str();
369 let header_value = formatted_46;
370 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
371 ::aws_smithy_types::error::operation::BuildError::invalid_field(
372 "sse_customer_algorithm",
373 format!("`{}` cannot be used as a header value: {}", &header_value, err),
374 )
375 })?;
376 builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
377 }
378 if let ::std::option::Option::Some(inner_47) = &input.sse_customer_key {
379 let formatted_48 = inner_47.as_str();
380 let header_value = formatted_48;
381 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
382 ::aws_smithy_types::error::operation::BuildError::invalid_field(
383 "sse_customer_key",
384 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
385 )
386 })?;
387 builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
388 }
389 if let ::std::option::Option::Some(inner_49) = &input.sse_customer_key_md5 {
390 let formatted_50 = inner_49.as_str();
391 let header_value = formatted_50;
392 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
393 ::aws_smithy_types::error::operation::BuildError::invalid_field(
394 "sse_customer_key_md5",
395 format!("`{}` cannot be used as a header value: {}", &header_value, err),
396 )
397 })?;
398 builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
399 }
400 if let ::std::option::Option::Some(inner_51) = &input.ssekms_key_id {
401 let formatted_52 = inner_51.as_str();
402 let header_value = formatted_52;
403 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
404 ::aws_smithy_types::error::operation::BuildError::invalid_field(
405 "ssekms_key_id",
406 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
407 )
408 })?;
409 builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
410 }
411 if let ::std::option::Option::Some(inner_53) = &input.ssekms_encryption_context {
412 let formatted_54 = inner_53.as_str();
413 let header_value = formatted_54;
414 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
415 ::aws_smithy_types::error::operation::BuildError::invalid_field(
416 "ssekms_encryption_context",
417 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
418 )
419 })?;
420 builder = builder.header("x-amz-server-side-encryption-context", header_value);
421 }
422 if let ::std::option::Option::Some(inner_55) = &input.bucket_key_enabled {
423 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_55);
424 let formatted_56 = encoder.encode();
425 let header_value = formatted_56;
426 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
427 ::aws_smithy_types::error::operation::BuildError::invalid_field(
428 "bucket_key_enabled",
429 format!("`{}` cannot be used as a header value: {}", &header_value, err),
430 )
431 })?;
432 builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
433 }
434 if let ::std::option::Option::Some(inner_57) = &input.copy_source_sse_customer_algorithm {
435 let formatted_58 = inner_57.as_str();
436 let header_value = formatted_58;
437 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
438 ::aws_smithy_types::error::operation::BuildError::invalid_field(
439 "copy_source_sse_customer_algorithm",
440 format!("`{}` cannot be used as a header value: {}", &header_value, err),
441 )
442 })?;
443 builder = builder.header("x-amz-copy-source-server-side-encryption-customer-algorithm", header_value);
444 }
445 if let ::std::option::Option::Some(inner_59) = &input.copy_source_sse_customer_key {
446 let formatted_60 = inner_59.as_str();
447 let header_value = formatted_60;
448 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
449 ::aws_smithy_types::error::operation::BuildError::invalid_field(
450 "copy_source_sse_customer_key",
451 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
452 )
453 })?;
454 builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key", header_value);
455 }
456 if let ::std::option::Option::Some(inner_61) = &input.copy_source_sse_customer_key_md5 {
457 let formatted_62 = inner_61.as_str();
458 let header_value = formatted_62;
459 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
460 ::aws_smithy_types::error::operation::BuildError::invalid_field(
461 "copy_source_sse_customer_key_md5",
462 format!("`{}` cannot be used as a header value: {}", &header_value, err),
463 )
464 })?;
465 builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key-MD5", header_value);
466 }
467 if let ::std::option::Option::Some(inner_63) = &input.request_payer {
468 let formatted_64 = inner_63.as_str();
469 let header_value = formatted_64;
470 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
471 ::aws_smithy_types::error::operation::BuildError::invalid_field(
472 "request_payer",
473 format!("`{}` cannot be used as a header value: {}", &header_value, err),
474 )
475 })?;
476 builder = builder.header("x-amz-request-payer", header_value);
477 }
478 if let ::std::option::Option::Some(inner_65) = &input.tagging {
479 let formatted_66 = inner_65.as_str();
480 let header_value = formatted_66;
481 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
482 ::aws_smithy_types::error::operation::BuildError::invalid_field(
483 "tagging",
484 format!("`{}` cannot be used as a header value: {}", &header_value, err),
485 )
486 })?;
487 builder = builder.header("x-amz-tagging", header_value);
488 }
489 if let ::std::option::Option::Some(inner_67) = &input.object_lock_mode {
490 let formatted_68 = inner_67.as_str();
491 let header_value = formatted_68;
492 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
493 ::aws_smithy_types::error::operation::BuildError::invalid_field(
494 "object_lock_mode",
495 format!("`{}` cannot be used as a header value: {}", &header_value, err),
496 )
497 })?;
498 builder = builder.header("x-amz-object-lock-mode", header_value);
499 }
500 if let ::std::option::Option::Some(inner_69) = &input.object_lock_retain_until_date {
501 let formatted_70 = inner_69.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
502 let header_value = formatted_70;
503 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
504 ::aws_smithy_types::error::operation::BuildError::invalid_field(
505 "object_lock_retain_until_date",
506 format!("`{}` cannot be used as a header value: {}", &header_value, err),
507 )
508 })?;
509 builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
510 }
511 if let ::std::option::Option::Some(inner_71) = &input.object_lock_legal_hold_status {
512 let formatted_72 = inner_71.as_str();
513 let header_value = formatted_72;
514 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
515 ::aws_smithy_types::error::operation::BuildError::invalid_field(
516 "object_lock_legal_hold_status",
517 format!("`{}` cannot be used as a header value: {}", &header_value, err),
518 )
519 })?;
520 builder = builder.header("x-amz-object-lock-legal-hold", header_value);
521 }
522 if let ::std::option::Option::Some(inner_73) = &input.expected_bucket_owner {
523 let formatted_74 = inner_73.as_str();
524 let header_value = formatted_74;
525 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
526 ::aws_smithy_types::error::operation::BuildError::invalid_field(
527 "expected_bucket_owner",
528 format!("`{}` cannot be used as a header value: {}", &header_value, err),
529 )
530 })?;
531 builder = builder.header("x-amz-expected-bucket-owner", header_value);
532 }
533 if let ::std::option::Option::Some(inner_75) = &input.expected_source_bucket_owner {
534 let formatted_76 = inner_75.as_str();
535 let header_value = formatted_76;
536 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
537 ::aws_smithy_types::error::operation::BuildError::invalid_field(
538 "expected_source_bucket_owner",
539 format!("`{}` cannot be used as a header value: {}", &header_value, err),
540 )
541 })?;
542 builder = builder.header("x-amz-source-expected-bucket-owner", header_value);
543 }
544 if let ::std::option::Option::Some(inner_77) = &input.metadata {
545 {
546 for (k, v) in inner_77 {
547 use std::str::FromStr;
548 let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
549 ::aws_smithy_types::error::operation::BuildError::invalid_field(
550 "metadata",
551 format!("`{k}` cannot be used as a header name: {err}"),
552 )
553 })?;
554 let header_value = v.as_str();
555 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
556 ::aws_smithy_types::error::operation::BuildError::invalid_field(
557 "metadata",
558 format!("`{}` cannot be used as a header value: {}", v, err),
559 )
560 })?;
561 builder = builder.header(header_name, header_value);
562 }
563 }
564 }
565 Ok(builder)
566}