AWS SDK

rev. 3c756f73b1f83a0eed4275d9d1e22df0b10b66fb (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/update_bucket_metadata_journal_table_configuration.rs

@@ -248,248 +327,327 @@

         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-266
+            }
             fn uri_query(

                 _input: &crate::operation::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_v("metadataJournalTable");
                 ::std::result::Result::Ok(())
-274
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_update_bucket_metadata_journal_table_configuration::ser_update_bucket_metadata_journal_table_configuration_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-285
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_update_bucket_metadata_journal_table_configuration_input::ser_journal_table_configuration_http_payload(
                 &input.journal_table_configuration,
             )?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-298
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-300
+    }
-301
+}
 #[derive(Debug)]
 struct UpdateBucketMetadataJournalTableConfigurationEndpointParamsInterceptor;
-304
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateBucketMetadataJournalTableConfigurationEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UpdateBucketMetadataJournalTableConfigurationEndpointParamsInterceptor"

↧ Expand context

-308
+    }
-309
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<UpdateBucketMetadataJournalTableConfigurationInput>()
             .ok_or("failed to downcast to UpdateBucketMetadataJournalTableConfigurationInput")?;
-324
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part.rs

@@ -265,265 +340,340 @@

↥ Expand context

                 ::std::write!(output, "/{Key}", Key = key).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-267
+            }
             fn uri_query(
                 _input: &crate::operation::upload_part::UploadPartInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_kv("x-id", "UploadPart");
                 let inner_2 = &_input.part_number;
                 let inner_2 = inner_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("part_number", "cannot be empty or unset"))?;
                 query.push_kv("partNumber", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
                 let inner_3 = &_input.upload_id;
                 let inner_3 = inner_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("upload_id", "cannot be empty or unset"))?;
                 if inner_3.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "upload_id",
                         "cannot be empty or unset",
                     ));
-288
+                }
                 query.push_kv("uploadId", &::aws_smithy_http::query::fmt_string(inner_3));
                 ::std::result::Result::Ok(())
-291
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::upload_part::UploadPartInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_upload_part::ser_upload_part_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-302
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
             builder
         };
         let body = crate::protocol_serde::shape_upload_part_input::ser_body_http_payload(input.body)?.into_inner();
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-311
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-313
+    }
-314
+}
 #[derive(Debug)]
 struct UploadPartEndpointParamsInterceptor;
-317
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UploadPartEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UploadPartEndpointParamsInterceptor"

↧ Expand context

-321
+    }
-322
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<UploadPartInput>()
             .ok_or("failed to downcast to UploadPartInput")?;
-337
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part_copy.rs

@@ -208,208 +276,276 @@

↥ Expand context

                 ::std::write!(output, "/{Key}", Key = key).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-210
+            }
             fn uri_query(
                 _input: &crate::operation::upload_part_copy::UploadPartCopyInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 query.push_kv("x-id", "UploadPartCopy");
                 let inner_2 = &_input.part_number;
                 let inner_2 = inner_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("part_number", "cannot be empty or unset"))?;
                 query.push_kv("partNumber", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
                 let inner_3 = &_input.upload_id;
                 let inner_3 = inner_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("upload_id", "cannot be empty or unset"))?;
                 if inner_3.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(

                         "upload_id",
                         "cannot be empty or unset",
                     ));
-231
+                }
                 query.push_kv("uploadId", &::aws_smithy_http::query::fmt_string(inner_3));
                 ::std::result::Result::Ok(())
-234
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::upload_part_copy::UploadPartCopyInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_upload_part_copy::ser_upload_part_copy_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
-245
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
-250
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-252
+    }
-253
+}
 #[derive(Debug)]
 struct UploadPartCopyEndpointParamsInterceptor;
-256

↧ Expand context

 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UploadPartCopyEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UploadPartCopyEndpointParamsInterceptor"
-260
+    }
-261
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<UploadPartCopyInput>()
             .ok_or("failed to downcast to UploadPartCopyInput")?;
-276

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/write_get_object_response.rs

@@ -178,178 +252,252 @@

↥ Expand context

-178
+}
 #[derive(Debug)]
 struct WriteGetObjectResponseRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for WriteGetObjectResponseRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::write_get_object_response::WriteGetObjectResponseInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(

                 _input: &crate::operation::write_get_object_response::WriteGetObjectResponseInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/WriteGetObjectResponse").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-204
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::write_get_object_response::WriteGetObjectResponseInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_write_get_object_response::ser_write_get_object_response_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-214
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
             builder
         };
         let body = crate::protocol_serde::shape_write_get_object_response_input::ser_body_http_payload(input.body)?.into_inner();
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-223
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-225
+    }
-226
+}
 #[derive(Debug)]
 struct WriteGetObjectResponseEndpointParamsInterceptor;
-229
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for WriteGetObjectResponseEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "WriteGetObjectResponseEndpointParamsInterceptor"

↧ Expand context

-233
+    }
-234
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<WriteGetObjectResponseInput>()
             .ok_or("failed to downcast to WriteGetObjectResponseInput")?;
-249
         let endpoint_prefix = {
             let request_route = _input.request_route.as_deref().unwrap_or_default();
             if request_route.is_empty() {

tmp-codegen-diff/aws-sdk/sdk/s3/src/presigning.rs

@@ -173,173 +273,271 @@

↥ Expand context

 ///
 /// **This struct has conversion convenience functions:**
 ///
 /// - [`PresignedRequest::make_http_02x_request<B>`][Self::make_http_02x_request] returns an [`http::Request<B>`](https://docs.rs/http/0.2.6/http/request/struct.Request.html)
 /// - [`PresignedRequest::into`](#impl-From<PresignedRequest>) returns an [`http::request::Builder`](https://docs.rs/http/0.2.6/http/request/struct.Builder.html)
 #[non_exhaustive]
 pub struct PresignedRequest {
     http_request: HttpRequest,
-181
+}
-182
 impl Clone for PresignedRequest {
     fn clone(&self) -> Self {
         Self {
             http_request: match self.http_request.try_clone() {
                 Some(body) => body,
                 None => {
                     unreachable!("during construction, we replaced the body with `SdkBody::empty()`")
-190
+                }
             },
-192
+        }

-193
+    }
-194
+}
-195
 impl PresignedRequest {
     #[allow(dead_code)]
     pub(crate) fn new(inner: HttpRequest) -> Result<Self, BoxError> {
         // throw out the body so we're sure it's cloneable
         let http_request = inner.map(|_body| SdkBody::empty());
         // this should never fail, a presigned request should always be convertible, but better to
         // protect against this potential panic
         let _ = http_request.try_clone().expect("must be cloneable, body is empty").try_into_http02x()?;
         let _ = http_request.try_clone().expect("must be cloneable, body is empty").try_into_http1x()?;
         Ok(Self { http_request })
-205
+    }
-206
     /// Returns the HTTP request method.
     pub fn method(&self) -> &str {
         self.http_request.method()
-210
+    }
-211
     /// Returns the HTTP request URI.
     pub fn uri(&self) -> &str {
         self.http_request.uri()
-215
+    }
-216
     /// Returns any HTTP headers that need to go along with the request, except for `Host`,
     /// which should be sent based on the endpoint in the URI by the HTTP client rather than
     /// added directly.
     pub fn headers(&self) -> impl Iterator<Item = (&str, &str)> {
         self.http_request.headers().iter()
-222
+    }
-223
     /// Given a body, produce an `http::Request` from this `PresignedRequest`
     #[deprecated = "Prefer the `make_http_1x_request()` instead by enabling the `http-1x` feature."]
     #[allow(deprecated)]
     pub fn make_http_02x_request<B>(&self, body: B) -> http::Request<B> {
         self.clone().into_http_02x_request(body)
-229
+    }
-230
     /// Converts this `PresignedRequest` directly into an `http` request.
     #[deprecated = "Prefer the `into_http_1x_request` instead by enabling the `http-1x` feature."]
     pub fn into_http_02x_request<B>(self, body: B) -> http::Request<B> {
         self.http_request
             .try_into_http02x()
             .expect("constructor validated convertibility")
             .map(|_req| body)
-238
+    }
-239
     #[cfg(feature = "http-1x")]
     /// Given a body, produce an `http_1x::Request` from this `PresignedRequest`
     pub fn make_http_1x_request<B>(&self, body: B) -> http_1x::Request<B> {
         self.clone().into_http_1x_request(body)
-243
+    }
-244
     #[cfg(feature = "http-1x")]
     /// Converts this `PresignedRequest` directly into an `http_1x` request.
     pub fn into_http_1x_request<B>(self, body: B) -> http_1x::Request<B> {
         self.http_request
             .try_into_http1x()
             .expect("constructor validated convertibility")
             .map(|_req| body)
-251
+    }
-252
+}
-253
 impl fmt::Debug for PresignedRequest {

↧ Expand context

     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("PresignedRequest")
             .field("method", &self.method())
             .field("uri", &self.uri())
             .field("headers", self.http_request.headers())
             .finish()
-261
+    }
-262
+}
-263
 /// A marker struct to be stored in the ConfigBag allowing other interceptors to know that
 /// the current request is Presigned
 #[derive(Debug)]
 pub(crate) struct PresigningMarker;
-268
 impl Storable for PresigningMarker {
     type Storer = StoreReplace<Self>;
-271
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_abort_multipart_upload.rs

@@ -40,40 +106,106 @@

↥ Expand context

     })
-41
+}
-42
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_abort_multipart_upload_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::abort_multipart_upload::AbortMultipartUploadOutput,
     crate::operation::abort_multipart_upload::AbortMultipartUploadError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::abort_multipart_upload::builders::AbortMultipartUploadOutputBuilder::default();
         output = output.set_request_charged(
             crate::protocol_serde::shape_abort_multipart_upload_output::de_request_charged_header(_response_headers).map_err(|_| {
                 crate::operation::abort_multipart_upload::AbortMultipartUploadError::unhandled(
                     "Failed to parse RequestCharged from header `x-amz-request-charged",
-59
+                )

             })?,
         );
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-66
+}
-67
 pub fn ser_abort_multipart_upload_headers(
     input: &crate::operation::abort_multipart_upload::AbortMultipartUploadInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.request_payer {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-79
+            )
         })?;
         builder = builder.header("x-amz-request-payer", header_value);
-82
+    }
     if let ::std::option::Option::Some(inner_3) = &input.expected_bucket_owner {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-90
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-93
+    }
     if let ::std::option::Option::Some(inner_5) = &input.if_match_initiated_time {
         let formatted_6 = inner_5.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "if_match_initiated_time",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-101
+            )
         })?;
         builder = builder.header("x-amz-if-match-initiated-time", header_value);
-104
+    }
     Ok(builder)
-106
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_complete_multipart_upload.rs

@@ -56,56 +265,265 @@

↥ Expand context

         );
         output = output.set_ssekms_key_id(
             crate::protocol_serde::shape_complete_multipart_upload_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
                 crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
                     "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
-61
+                )
             })?,
         );
         output = output.set_server_side_encryption(
             crate::protocol_serde::shape_complete_multipart_upload_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
                 crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
                     "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
-68
+                )
             })?,
         );
         output = output.set_version_id(
             crate::protocol_serde::shape_complete_multipart_upload_output::de_version_id_header(_response_headers).map_err(|_| {
                 crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
                     "Failed to parse VersionId from header `x-amz-version-id",
-75
+                )

             })?,
         );
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-82
+}
-83
 pub fn ser_complete_multipart_upload_headers(
     input: &crate::operation::complete_multipart_upload::CompleteMultipartUploadInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.checksum_crc32 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_crc32",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-95
+            )
         })?;
         builder = builder.header("x-amz-checksum-crc32", header_value);
-98
+    }
     if let ::std::option::Option::Some(inner_3) = &input.checksum_crc32_c {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_crc32_c",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-106
+            )
         })?;
         builder = builder.header("x-amz-checksum-crc32c", header_value);
-109
+    }
     if let ::std::option::Option::Some(inner_5) = &input.checksum_crc64_nvme {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_crc64_nvme",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-117
+            )
         })?;
         builder = builder.header("x-amz-checksum-crc64nvme", header_value);
-120
+    }
     if let ::std::option::Option::Some(inner_7) = &input.checksum_sha1 {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_sha1",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-128
+            )
         })?;
         builder = builder.header("x-amz-checksum-sha1", header_value);
-131
+    }
     if let ::std::option::Option::Some(inner_9) = &input.checksum_sha256 {
         let formatted_10 = inner_9.as_str();
         let header_value = formatted_10;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_sha256",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-139
+            )
         })?;
         builder = builder.header("x-amz-checksum-sha256", header_value);
-142
+    }
     if let ::std::option::Option::Some(inner_11) = &input.checksum_type {
         let formatted_12 = inner_11.as_str();
         let header_value = formatted_12;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-150
+            )
         })?;
         builder = builder.header("x-amz-checksum-type", header_value);
-153
+    }
     if let ::std::option::Option::Some(inner_13) = &input.mpu_object_size {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_13);
         let formatted_14 = encoder.encode();
         let header_value = formatted_14;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "mpu_object_size",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-162
+            )
         })?;
         builder = builder.header("x-amz-mp-object-size", header_value);
-165
+    }
     if let ::std::option::Option::Some(inner_15) = &input.request_payer {
         let formatted_16 = inner_15.as_str();
         let header_value = formatted_16;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-173
+            )
         })?;
         builder = builder.header("x-amz-request-payer", header_value);
-176
+    }
     if let ::std::option::Option::Some(inner_17) = &input.expected_bucket_owner {
         let formatted_18 = inner_17.as_str();
         let header_value = formatted_18;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-184
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-187
+    }
     if let ::std::option::Option::Some(inner_19) = &input.if_match {
         let formatted_20 = inner_19.as_str();
         let header_value = formatted_20;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "if_match",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-195
+            )
         })?;
         builder = builder.header("If-Match", header_value);
-198
+    }
     if let ::std::option::Option::Some(inner_21) = &input.if_none_match {
         let formatted_22 = inner_21.as_str();
         let header_value = formatted_22;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "if_none_match",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-206
+            )
         })?;
         builder = builder.header("If-None-Match", header_value);
-209
+    }
     if let ::std::option::Option::Some(inner_23) = &input.sse_customer_algorithm {
         let formatted_24 = inner_23.as_str();
         let header_value = formatted_24;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-217
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
-220
+    }
     if let ::std::option::Option::Some(inner_25) = &input.sse_customer_key {
         let formatted_26 = inner_25.as_str();
         let header_value = formatted_26;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_key",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-228
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
-231
+    }
     if let ::std::option::Option::Some(inner_27) = &input.sse_customer_key_md5 {
         let formatted_28 = inner_27.as_str();
         let header_value = formatted_28;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_key_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-239
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
-242
+    }
     Ok(builder)
-244
+}
-245

↧ Expand context

 #[allow(unused_mut)]
 pub fn de_complete_multipart_upload(
     inp: &[u8],
     mut builder: crate::operation::complete_multipart_upload::builders::CompleteMultipartUploadOutputBuilder,
 ) -> std::result::Result<
     crate::operation::complete_multipart_upload::builders::CompleteMultipartUploadOutputBuilder,
     ::aws_smithy_xml::decode::XmlDecodeError,
 > {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-255
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     if !start_el.matches("CompleteMultipartUploadResult") {
         return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
             "encountered invalid XML root: expected CompleteMultipartUploadResult but got {start_el:?}. This is likely a bug in the SDK."
         )));
-264
+    }
     while let Some(mut tag) = decoder.next_tag() {

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_copy_object.rs

@@ -93,93 +566,566 @@

↥ Expand context

                     "Failed to parse SSEKMSEncryptionContext from header `x-amz-server-side-encryption-context",
-94
+                )
             })?,
         );
         output = output.set_ssekms_key_id(
             crate::protocol_serde::shape_copy_object_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
                 crate::operation::copy_object::CopyObjectError::unhandled(
                     "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
-101
+                )
             })?,
         );
         output = output.set_server_side_encryption(
             crate::protocol_serde::shape_copy_object_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
                 crate::operation::copy_object::CopyObjectError::unhandled(
                     "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
-108
+                )
             })?,
         );
         output = output.set_version_id(
             crate::protocol_serde::shape_copy_object_output::de_version_id_header(_response_headers)

                 .map_err(|_| crate::operation::copy_object::CopyObjectError::unhandled("Failed to parse VersionId from header `x-amz-version-id"))?,
         );
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-119
+}
-120
 pub fn ser_copy_object_headers(
     input: &crate::operation::copy_object::CopyObjectInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.acl {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "acl",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-132
+            )
         })?;
         builder = builder.header("x-amz-acl", header_value);
-135
+    }
     if let ::std::option::Option::Some(inner_3) = &input.cache_control {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "cache_control",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-143
+            )
         })?;
         builder = builder.header("Cache-Control", header_value);
-146
+    }
     if let ::std::option::Option::Some(inner_5) = &input.checksum_algorithm {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-154
+            )
         })?;
         builder = builder.header("x-amz-checksum-algorithm", header_value);
-157
+    }
     if let ::std::option::Option::Some(inner_7) = &input.content_disposition {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_disposition",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-165
+            )
         })?;
         builder = builder.header("Content-Disposition", header_value);
-168
+    }
     if let ::std::option::Option::Some(inner_9) = &input.content_encoding {
         let formatted_10 = inner_9.as_str();
         let header_value = formatted_10;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_encoding",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-176
+            )
         })?;
         builder = builder.header("Content-Encoding", header_value);
-179
+    }
     if let ::std::option::Option::Some(inner_11) = &input.content_language {
         let formatted_12 = inner_11.as_str();
         let header_value = formatted_12;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_language",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-187
+            )
         })?;
         builder = builder.header("Content-Language", header_value);
-190
+    }
     if let ::std::option::Option::Some(inner_13) = &input.content_type {
         let formatted_14 = inner_13.as_str();
         let header_value = formatted_14;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-198
+            )
         })?;
         builder = builder.header("Content-Type", header_value);
-201
+    }
     if let ::std::option::Option::Some(inner_15) = &input.copy_source {
         let formatted_16 = inner_15.as_str();
         let header_value = formatted_16;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "copy_source",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-209
+            )
         })?;
         builder = builder.header("x-amz-copy-source", header_value);
-212
+    }
     if let ::std::option::Option::Some(inner_17) = &input.copy_source_if_match {
         let formatted_18 = inner_17.as_str();
         let header_value = formatted_18;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "copy_source_if_match",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-220
+            )
         })?;
         builder = builder.header("x-amz-copy-source-if-match", header_value);
-223
+    }
     if let ::std::option::Option::Some(inner_19) = &input.copy_source_if_modified_since {
         let formatted_20 = inner_19.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         let header_value = formatted_20;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "copy_source_if_modified_since",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-231
+            )
         })?;
         builder = builder.header("x-amz-copy-source-if-modified-since", header_value);
-234
+    }
     if let ::std::option::Option::Some(inner_21) = &input.copy_source_if_none_match {
         let formatted_22 = inner_21.as_str();
         let header_value = formatted_22;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "copy_source_if_none_match",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-242
+            )
         })?;
         builder = builder.header("x-amz-copy-source-if-none-match", header_value);
-245
+    }
     if let ::std::option::Option::Some(inner_23) = &input.copy_source_if_unmodified_since {
         let formatted_24 = inner_23.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         let header_value = formatted_24;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "copy_source_if_unmodified_since",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-253
+            )
         })?;
         builder = builder.header("x-amz-copy-source-if-unmodified-since", header_value);
-256
+    }
     if let ::std::option::Option::Some(inner_25) = &input.expires {
         let formatted_26 = inner_25.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         let header_value = formatted_26;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expires",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-264
+            )
         })?;
         builder = builder.header("Expires", header_value);
-267
+    }
     if let ::std::option::Option::Some(inner_27) = &input.grant_full_control {
         let formatted_28 = inner_27.as_str();
         let header_value = formatted_28;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_full_control",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-275
+            )
         })?;
         builder = builder.header("x-amz-grant-full-control", header_value);
-278
+    }
     if let ::std::option::Option::Some(inner_29) = &input.grant_read {
         let formatted_30 = inner_29.as_str();
         let header_value = formatted_30;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_read",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-286
+            )
         })?;
         builder = builder.header("x-amz-grant-read", header_value);
-289
+    }
     if let ::std::option::Option::Some(inner_31) = &input.grant_read_acp {
         let formatted_32 = inner_31.as_str();
         let header_value = formatted_32;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_read_acp",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-297
+            )
         })?;
         builder = builder.header("x-amz-grant-read-acp", header_value);
-300
+    }
     if let ::std::option::Option::Some(inner_33) = &input.grant_write_acp {
         let formatted_34 = inner_33.as_str();
         let header_value = formatted_34;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_write_acp",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-308
+            )
         })?;
         builder = builder.header("x-amz-grant-write-acp", header_value);
-311
+    }
     if let ::std::option::Option::Some(inner_35) = &input.metadata_directive {
         let formatted_36 = inner_35.as_str();
         let header_value = formatted_36;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "metadata_directive",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-319
+            )
         })?;
         builder = builder.header("x-amz-metadata-directive", header_value);
-322
+    }
     if let ::std::option::Option::Some(inner_37) = &input.tagging_directive {
         let formatted_38 = inner_37.as_str();
         let header_value = formatted_38;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "tagging_directive",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-330
+            )
         })?;
         builder = builder.header("x-amz-tagging-directive", header_value);
-333
+    }
     if let ::std::option::Option::Some(inner_39) = &input.server_side_encryption {
         let formatted_40 = inner_39.as_str();
         let header_value = formatted_40;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "server_side_encryption",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-341
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption", header_value);
-344
+    }
     if let ::std::option::Option::Some(inner_41) = &input.storage_class {
         let formatted_42 = inner_41.as_str();
         let header_value = formatted_42;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "storage_class",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-352
+            )
         })?;
         builder = builder.header("x-amz-storage-class", header_value);
-355
+    }
     if let ::std::option::Option::Some(inner_43) = &input.website_redirect_location {
         let formatted_44 = inner_43.as_str();
         let header_value = formatted_44;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "website_redirect_location",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-363
+            )
         })?;
         builder = builder.header("x-amz-website-redirect-location", header_value);
-366
+    }
     if let ::std::option::Option::Some(inner_45) = &input.sse_customer_algorithm {
         let formatted_46 = inner_45.as_str();
         let header_value = formatted_46;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-374
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
-377
+    }
     if let ::std::option::Option::Some(inner_47) = &input.sse_customer_key {
         let formatted_48 = inner_47.as_str();
         let header_value = formatted_48;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_key",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-385
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
-388
+    }
     if let ::std::option::Option::Some(inner_49) = &input.sse_customer_key_md5 {
         let formatted_50 = inner_49.as_str();
         let header_value = formatted_50;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_key_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-396
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
-399
+    }
     if let ::std::option::Option::Some(inner_51) = &input.ssekms_key_id {
         let formatted_52 = inner_51.as_str();
         let header_value = formatted_52;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "ssekms_key_id",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-407
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
-410
+    }
     if let ::std::option::Option::Some(inner_53) = &input.ssekms_encryption_context {
         let formatted_54 = inner_53.as_str();
         let header_value = formatted_54;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "ssekms_encryption_context",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-418
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-context", header_value);
-421
+    }
     if let ::std::option::Option::Some(inner_55) = &input.bucket_key_enabled {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_55);
         let formatted_56 = encoder.encode();
         let header_value = formatted_56;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "bucket_key_enabled",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-430
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
-433
+    }
     if let ::std::option::Option::Some(inner_57) = &input.copy_source_sse_customer_algorithm {
         let formatted_58 = inner_57.as_str();
         let header_value = formatted_58;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "copy_source_sse_customer_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-441
+            )
         })?;
         builder = builder.header("x-amz-copy-source-server-side-encryption-customer-algorithm", header_value);
-444
+    }
     if let ::std::option::Option::Some(inner_59) = &input.copy_source_sse_customer_key {
         let formatted_60 = inner_59.as_str();
         let header_value = formatted_60;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "copy_source_sse_customer_key",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-452
+            )
         })?;
         builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key", header_value);
-455
+    }
     if let ::std::option::Option::Some(inner_61) = &input.copy_source_sse_customer_key_md5 {
         let formatted_62 = inner_61.as_str();
         let header_value = formatted_62;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "copy_source_sse_customer_key_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-463
+            )
         })?;
         builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key-MD5", header_value);
-466
+    }
     if let ::std::option::Option::Some(inner_63) = &input.request_payer {
         let formatted_64 = inner_63.as_str();
         let header_value = formatted_64;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-474
+            )
         })?;
         builder = builder.header("x-amz-request-payer", header_value);
-477
+    }
     if let ::std::option::Option::Some(inner_65) = &input.tagging {
         let formatted_66 = inner_65.as_str();
         let header_value = formatted_66;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "tagging",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-485
+            )
         })?;
         builder = builder.header("x-amz-tagging", header_value);
-488
+    }
     if let ::std::option::Option::Some(inner_67) = &input.object_lock_mode {
         let formatted_68 = inner_67.as_str();
         let header_value = formatted_68;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "object_lock_mode",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-496
+            )
         })?;
         builder = builder.header("x-amz-object-lock-mode", header_value);
-499
+    }
     if let ::std::option::Option::Some(inner_69) = &input.object_lock_retain_until_date {
         let formatted_70 = inner_69.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
         let header_value = formatted_70;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "object_lock_retain_until_date",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-507
+            )
         })?;
         builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
-510
+    }
     if let ::std::option::Option::Some(inner_71) = &input.object_lock_legal_hold_status {
         let formatted_72 = inner_71.as_str();
         let header_value = formatted_72;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "object_lock_legal_hold_status",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-518
+            )
         })?;
         builder = builder.header("x-amz-object-lock-legal-hold", header_value);
-521
+    }
     if let ::std::option::Option::Some(inner_73) = &input.expected_bucket_owner {
         let formatted_74 = inner_73.as_str();
         let header_value = formatted_74;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-529
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-532
+    }
     if let ::std::option::Option::Some(inner_75) = &input.expected_source_bucket_owner {
         let formatted_76 = inner_75.as_str();
         let header_value = formatted_76;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_source_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-540
+            )
         })?;
         builder = builder.header("x-amz-source-expected-bucket-owner", header_value);
-543
+    }
     if let ::std::option::Option::Some(inner_77) = &input.metadata {
-545
+        {
             for (k, v) in inner_77 {
                 use std::str::FromStr;
                 let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
                 let header_name = ::http_1x::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "metadata",
                         format!("`{k}` cannot be used as a header name: {err}"),
-552
+                    )
                 })?;
                 let header_value = v.as_str();
                 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "metadata",
                         format!("`{v}` cannot be used as a header value: {err}"),
-559
+                    )
                 })?;
                 builder = builder.header(header_name, header_value);
-562
+            }
-563
+        }
-564
+    }
     Ok(builder)

↧ Expand context

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_create_bucket.rs

@@ -51,51 +173,173 @@

↥ Expand context

         _ => crate::operation::create_bucket::CreateBucketError::generic(generic),
     })
-53
+}
-54
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_create_bucket_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::create_bucket::CreateBucketOutput, crate::operation::create_bucket::CreateBucketError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::create_bucket::builders::CreateBucketOutputBuilder::default();
         output = output.set_bucket_arn(
             crate::protocol_serde::shape_create_bucket_output::de_bucket_arn_header(_response_headers).map_err(|_| {
                 crate::operation::create_bucket::CreateBucketError::unhandled("Failed to parse BucketArn from header `x-amz-bucket-arn")
             })?,
         );
         output = output.set_location(
             crate::protocol_serde::shape_create_bucket_output::de_location_header(_response_headers)

                 .map_err(|_| crate::operation::create_bucket::CreateBucketError::unhandled("Failed to parse Location from header `Location"))?,
         );
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-77
+}
-78
 pub fn ser_create_bucket_headers(
     input: &crate::operation::create_bucket::CreateBucketInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.acl {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "acl",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-90
+            )
         })?;
         builder = builder.header("x-amz-acl", header_value);
-93
+    }
     if let ::std::option::Option::Some(inner_3) = &input.grant_full_control {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_full_control",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-101
+            )
         })?;
         builder = builder.header("x-amz-grant-full-control", header_value);
-104
+    }
     if let ::std::option::Option::Some(inner_5) = &input.grant_read {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_read",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-112
+            )
         })?;
         builder = builder.header("x-amz-grant-read", header_value);
-115
+    }
     if let ::std::option::Option::Some(inner_7) = &input.grant_read_acp {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_read_acp",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-123
+            )
         })?;
         builder = builder.header("x-amz-grant-read-acp", header_value);
-126
+    }
     if let ::std::option::Option::Some(inner_9) = &input.grant_write {
         let formatted_10 = inner_9.as_str();
         let header_value = formatted_10;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_write",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-134
+            )
         })?;
         builder = builder.header("x-amz-grant-write", header_value);
-137
+    }
     if let ::std::option::Option::Some(inner_11) = &input.grant_write_acp {
         let formatted_12 = inner_11.as_str();
         let header_value = formatted_12;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_write_acp",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-145
+            )
         })?;
         builder = builder.header("x-amz-grant-write-acp", header_value);
-148
+    }
     if let ::std::option::Option::Some(inner_13) = &input.object_lock_enabled_for_bucket {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_13);
         let formatted_14 = encoder.encode();
         let header_value = formatted_14;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "object_lock_enabled_for_bucket",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-157
+            )
         })?;
         builder = builder.header("x-amz-bucket-object-lock-enabled", header_value);
-160
+    }
     if let ::std::option::Option::Some(inner_15) = &input.object_ownership {
         let formatted_16 = inner_15.as_str();
         let header_value = formatted_16;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "object_ownership",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-168
+            )
         })?;
         builder = builder.header("x-amz-object-ownership", header_value);
-171
+    }
     Ok(builder)
-173
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_create_bucket_metadata_configuration.rs

@@ -10,10 +76,76 @@

↥ Expand context

 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError::unhandled)?;
     generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     Err(crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_create_bucket_metadata_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationOutput,
     crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationError,
 > {
     Ok({

         #[allow(unused_mut)]
         let mut output = crate::operation::create_bucket_metadata_configuration::builders::CreateBucketMetadataConfigurationOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-36
+}
-37
 pub fn ser_create_bucket_metadata_configuration_headers(
     input: &crate::operation::create_bucket_metadata_configuration::CreateBucketMetadataConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.content_md5 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-49
+            )
         })?;
         builder = builder.header("Content-MD5", header_value);
-52
+    }
     if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-60
+            )
         })?;
         builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-63
+    }
     if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-71
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-74
+    }
     Ok(builder)
-76
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_create_bucket_metadata_table_configuration.rs

@@ -11,11 +77,77 @@

↥ Expand context

     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::create_bucket_metadata_table_configuration::CreateBucketMetadataTableConfigurationError::unhandled)?;
     generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     Err(crate::operation::create_bucket_metadata_table_configuration::CreateBucketMetadataTableConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_create_bucket_metadata_table_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::create_bucket_metadata_table_configuration::CreateBucketMetadataTableConfigurationOutput,
     crate::operation::create_bucket_metadata_table_configuration::CreateBucketMetadataTableConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]

         let mut output =
             crate::operation::create_bucket_metadata_table_configuration::builders::CreateBucketMetadataTableConfigurationOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-37
+}
-38
 pub fn ser_create_bucket_metadata_table_configuration_headers(
     input: &crate::operation::create_bucket_metadata_table_configuration::CreateBucketMetadataTableConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.content_md5 {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-50
+            )
         })?;
         builder = builder.header("Content-MD5", header_value);
-53
+    }
     if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-61
+            )
         })?;
         builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-64
+    }
     if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-72
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-75
+    }
     Ok(builder)
-77
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_create_multipart_upload.rs

@@ -89,89 +471,471 @@

↥ Expand context

         );
         output = output.set_ssekms_encryption_context(
             crate::protocol_serde::shape_create_multipart_upload_output::de_ssekms_encryption_context_header(_response_headers).map_err(|_| {
                 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
                     "Failed to parse SSEKMSEncryptionContext from header `x-amz-server-side-encryption-context",
-94
+                )
             })?,
         );
         output = output.set_ssekms_key_id(
             crate::protocol_serde::shape_create_multipart_upload_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
                 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
                     "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
-101
+                )
             })?,
         );
         output = output.set_server_side_encryption(
             crate::protocol_serde::shape_create_multipart_upload_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
                 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
                     "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
-108
+                )

             })?,
         );
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-115
+}
-116
 pub fn ser_create_multipart_upload_headers(
     input: &crate::operation::create_multipart_upload::CreateMultipartUploadInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.acl {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "acl",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-128
+            )
         })?;
         builder = builder.header("x-amz-acl", header_value);
-131
+    }
     if let ::std::option::Option::Some(inner_3) = &input.cache_control {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "cache_control",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-139
+            )
         })?;
         builder = builder.header("Cache-Control", header_value);
-142
+    }
     if let ::std::option::Option::Some(inner_5) = &input.content_disposition {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_disposition",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-150
+            )
         })?;
         builder = builder.header("Content-Disposition", header_value);
-153
+    }
     if let ::std::option::Option::Some(inner_7) = &input.content_encoding {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_encoding",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-161
+            )
         })?;
         builder = builder.header("Content-Encoding", header_value);
-164
+    }
     if let ::std::option::Option::Some(inner_9) = &input.content_language {
         let formatted_10 = inner_9.as_str();
         let header_value = formatted_10;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_language",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-172
+            )
         })?;
         builder = builder.header("Content-Language", header_value);
-175
+    }
     if let ::std::option::Option::Some(inner_11) = &input.content_type {
         let formatted_12 = inner_11.as_str();
         let header_value = formatted_12;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "content_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-183
+            )
         })?;
         builder = builder.header("Content-Type", header_value);
-186
+    }
     if let ::std::option::Option::Some(inner_13) = &input.expires {
         let formatted_14 = inner_13.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         let header_value = formatted_14;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expires",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-194
+            )
         })?;
         builder = builder.header("Expires", header_value);
-197
+    }
     if let ::std::option::Option::Some(inner_15) = &input.grant_full_control {
         let formatted_16 = inner_15.as_str();
         let header_value = formatted_16;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_full_control",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-205
+            )
         })?;
         builder = builder.header("x-amz-grant-full-control", header_value);
-208
+    }
     if let ::std::option::Option::Some(inner_17) = &input.grant_read {
         let formatted_18 = inner_17.as_str();
         let header_value = formatted_18;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_read",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-216
+            )
         })?;
         builder = builder.header("x-amz-grant-read", header_value);
-219
+    }
     if let ::std::option::Option::Some(inner_19) = &input.grant_read_acp {
         let formatted_20 = inner_19.as_str();
         let header_value = formatted_20;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_read_acp",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-227
+            )
         })?;
         builder = builder.header("x-amz-grant-read-acp", header_value);
-230
+    }
     if let ::std::option::Option::Some(inner_21) = &input.grant_write_acp {
         let formatted_22 = inner_21.as_str();
         let header_value = formatted_22;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "grant_write_acp",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-238
+            )
         })?;
         builder = builder.header("x-amz-grant-write-acp", header_value);
-241
+    }
     if let ::std::option::Option::Some(inner_23) = &input.server_side_encryption {
         let formatted_24 = inner_23.as_str();
         let header_value = formatted_24;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "server_side_encryption",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-249
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption", header_value);
-252
+    }
     if let ::std::option::Option::Some(inner_25) = &input.storage_class {
         let formatted_26 = inner_25.as_str();
         let header_value = formatted_26;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "storage_class",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-260
+            )
         })?;
         builder = builder.header("x-amz-storage-class", header_value);
-263
+    }
     if let ::std::option::Option::Some(inner_27) = &input.website_redirect_location {
         let formatted_28 = inner_27.as_str();
         let header_value = formatted_28;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "website_redirect_location",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-271
+            )
         })?;
         builder = builder.header("x-amz-website-redirect-location", header_value);
-274
+    }
     if let ::std::option::Option::Some(inner_29) = &input.sse_customer_algorithm {
         let formatted_30 = inner_29.as_str();
         let header_value = formatted_30;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-282
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
-285
+    }
     if let ::std::option::Option::Some(inner_31) = &input.sse_customer_key {
         let formatted_32 = inner_31.as_str();
         let header_value = formatted_32;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_key",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-293
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
-296
+    }
     if let ::std::option::Option::Some(inner_33) = &input.sse_customer_key_md5 {
         let formatted_34 = inner_33.as_str();
         let header_value = formatted_34;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "sse_customer_key_md5",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-304
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
-307
+    }
     if let ::std::option::Option::Some(inner_35) = &input.ssekms_key_id {
         let formatted_36 = inner_35.as_str();
         let header_value = formatted_36;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "ssekms_key_id",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-315
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
-318
+    }
     if let ::std::option::Option::Some(inner_37) = &input.ssekms_encryption_context {
         let formatted_38 = inner_37.as_str();
         let header_value = formatted_38;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "ssekms_encryption_context",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-326
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-context", header_value);
-329
+    }
     if let ::std::option::Option::Some(inner_39) = &input.bucket_key_enabled {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_39);
         let formatted_40 = encoder.encode();
         let header_value = formatted_40;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "bucket_key_enabled",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-338
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
-341
+    }
     if let ::std::option::Option::Some(inner_41) = &input.request_payer {
         let formatted_42 = inner_41.as_str();
         let header_value = formatted_42;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-349
+            )
         })?;
         builder = builder.header("x-amz-request-payer", header_value);
-352
+    }
     if let ::std::option::Option::Some(inner_43) = &input.tagging {
         let formatted_44 = inner_43.as_str();
         let header_value = formatted_44;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "tagging",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-360
+            )
         })?;
         builder = builder.header("x-amz-tagging", header_value);
-363
+    }
     if let ::std::option::Option::Some(inner_45) = &input.object_lock_mode {
         let formatted_46 = inner_45.as_str();
         let header_value = formatted_46;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "object_lock_mode",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-371
+            )
         })?;
         builder = builder.header("x-amz-object-lock-mode", header_value);
-374
+    }
     if let ::std::option::Option::Some(inner_47) = &input.object_lock_retain_until_date {
         let formatted_48 = inner_47.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
         let header_value = formatted_48;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "object_lock_retain_until_date",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-382
+            )
         })?;
         builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
-385
+    }
     if let ::std::option::Option::Some(inner_49) = &input.object_lock_legal_hold_status {
         let formatted_50 = inner_49.as_str();
         let header_value = formatted_50;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "object_lock_legal_hold_status",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-393
+            )
         })?;
         builder = builder.header("x-amz-object-lock-legal-hold", header_value);
-396
+    }
     if let ::std::option::Option::Some(inner_51) = &input.expected_bucket_owner {
         let formatted_52 = inner_51.as_str();
         let header_value = formatted_52;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-404
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-407
+    }
     if let ::std::option::Option::Some(inner_53) = &input.checksum_algorithm {
         let formatted_54 = inner_53.as_str();
         let header_value = formatted_54;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_algorithm",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-415
+            )
         })?;
         builder = builder.header("x-amz-checksum-algorithm", header_value);
-418
+    }
     if let ::std::option::Option::Some(inner_55) = &input.checksum_type {
         let formatted_56 = inner_55.as_str();
         let header_value = formatted_56;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "checksum_type",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-426
+            )
         })?;
         builder = builder.header("x-amz-checksum-type", header_value);
-429
+    }
     if let ::std::option::Option::Some(inner_57) = &input.metadata {
-431
+        {
             for (k, v) in inner_57 {
                 use std::str::FromStr;
                 let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
                 let header_name = ::http_1x::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "metadata",
                         format!("`{k}` cannot be used as a header name: {err}"),
-438
+                    )
                 })?;
                 let header_value = v.as_str();
                 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "metadata",
                         format!("`{v}` cannot be used as a header value: {err}"),
-445
+                    )
                 })?;
                 builder = builder.header(header_name, header_value);
-448
+            }
-449
+        }
-450
+    }
     Ok(builder)

↧ Expand context

-452
+}
-453
 #[allow(unused_mut)]
 pub fn de_create_multipart_upload(
     inp: &[u8],
     mut builder: crate::operation::create_multipart_upload::builders::CreateMultipartUploadOutputBuilder,
 ) -> std::result::Result<
     crate::operation::create_multipart_upload::builders::CreateMultipartUploadOutputBuilder,
     ::aws_smithy_xml::decode::XmlDecodeError,
 > {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-463
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     if !start_el.matches("InitiateMultipartUploadResult") {
         return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
             "encountered invalid XML root: expected InitiateMultipartUploadResult but got {start_el:?}. This is likely a bug in the SDK."
         )));

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_create_session.rs

@@ -57,57 +167,167 @@

↥ Expand context

         );
         output = output.set_ssekms_encryption_context(
             crate::protocol_serde::shape_create_session_output::de_ssekms_encryption_context_header(_response_headers).map_err(|_| {
                 crate::operation::create_session::CreateSessionError::unhandled(
                     "Failed to parse SSEKMSEncryptionContext from header `x-amz-server-side-encryption-context",
-62
+                )
             })?,
         );
         output = output.set_ssekms_key_id(
             crate::protocol_serde::shape_create_session_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
                 crate::operation::create_session::CreateSessionError::unhandled(
                     "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
-69
+                )
             })?,
         );
         output = output.set_server_side_encryption(
             crate::protocol_serde::shape_create_session_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
                 crate::operation::create_session::CreateSessionError::unhandled(
                     "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
-76
+                )

             })?,
         );
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         crate::serde_util::create_session_output_output_correct_errors(output).build()
     })
-83
+}
-84
 pub fn ser_create_session_headers(
     input: &crate::operation::create_session::CreateSessionInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.session_mode {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "session_mode",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-96
+            )
         })?;
         builder = builder.header("x-amz-create-session-mode", header_value);
-99
+    }
     if let ::std::option::Option::Some(inner_3) = &input.server_side_encryption {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "server_side_encryption",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-107
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption", header_value);
-110
+    }
     if let ::std::option::Option::Some(inner_5) = &input.ssekms_key_id {
         let formatted_6 = inner_5.as_str();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "ssekms_key_id",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-118
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
-121
+    }
     if let ::std::option::Option::Some(inner_7) = &input.ssekms_encryption_context {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "ssekms_encryption_context",
                 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
-129
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-context", header_value);
-132
+    }
     if let ::std::option::Option::Some(inner_9) = &input.bucket_key_enabled {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_9);
         let formatted_10 = encoder.encode();
         let header_value = formatted_10;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "bucket_key_enabled",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-141
+            )
         })?;
         builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
-144
+    }
     Ok(builder)
-146
+}
-147

↧ Expand context

 #[allow(unused_mut)]
 pub fn de_create_session(
     inp: &[u8],
     mut builder: crate::operation::create_session::builders::CreateSessionOutputBuilder,
 ) -> std::result::Result<crate::operation::create_session::builders::CreateSessionOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-154
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     while let Some(mut tag) = decoder.next_tag() {
         match tag.start_el() {
             s if s.matches("Credentials") /* Credentials com.amazonaws.s3.synthetic#CreateSessionOutput$Credentials */ =>  {
                 let var_11 =
                     Some(
                         crate::protocol_serde::shape_session_credentials::de_session_credentials(&mut tag)
-165
+                        ?
-166
+                    )
-167
+                ;

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_delete_bucket.rs

@@ -4,4 +48,48 @@

↥ Expand context

     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::delete_bucket::DeleteBucketOutput, crate::operation::delete_bucket::DeleteBucketError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::delete_bucket::DeleteBucketError::unhandled)?;
     generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     Err(crate::operation::delete_bucket::DeleteBucketError::generic(generic))
-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::delete_bucket::DeleteBucketOutput, crate::operation::delete_bucket::DeleteBucketError> {
     Ok({

         #[allow(unused_mut)]
         let mut output = crate::operation::delete_bucket::builders::DeleteBucketOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-30
+}
-31
 pub fn ser_delete_bucket_headers(
     input: &crate::operation::delete_bucket::DeleteBucketInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-43
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-46
+    }
     Ok(builder)
-48
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_delete_bucket_analytics_configuration.rs

@@ -11,11 +55,55 @@

↥ Expand context

     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationError::unhandled)?;
     generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     Err(crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_analytics_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationOutput,
     crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]

         let mut output =
             crate::operation::delete_bucket_analytics_configuration::builders::DeleteBucketAnalyticsConfigurationOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-37
+}
-38
 pub fn ser_delete_bucket_analytics_configuration_headers(
     input: &crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-50
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-53
+    }
     Ok(builder)
-55
+}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_delete_bucket_cors.rs

@@ -4,4 +48,48 @@

↥ Expand context

     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::delete_bucket_cors::DeleteBucketCorsOutput, crate::operation::delete_bucket_cors::DeleteBucketCorsError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::delete_bucket_cors::DeleteBucketCorsError::unhandled)?;
     generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     Err(crate::operation::delete_bucket_cors::DeleteBucketCorsError::generic(generic))
-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_cors_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::delete_bucket_cors::DeleteBucketCorsOutput, crate::operation::delete_bucket_cors::DeleteBucketCorsError> {
     Ok({

         #[allow(unused_mut)]
         let mut output = crate::operation::delete_bucket_cors::builders::DeleteBucketCorsOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         output.build()
     })
-30
+}
-31
 pub fn ser_delete_bucket_cors_headers(
     input: &crate::operation::delete_bucket_cors::DeleteBucketCorsInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-43
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-46
+    }
     Ok(builder)
-48
+}

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130