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