AWS SDK

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

@@ -21,21 +61,63 @@

 pub fn de_delete_object_tagging_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_object_tagging::DeleteObjectTaggingOutput,
     crate::operation::delete_object_tagging::DeleteObjectTaggingError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_object_tagging::builders::DeleteObjectTaggingOutputBuilder::default();
         output = output.set_version_id(
             crate::protocol_serde::shape_delete_object_tagging_output::de_version_id_header(_response_headers).map_err(|_| {
                 crate::operation::delete_object_tagging::DeleteObjectTaggingError::unhandled(
                     "Failed to parse VersionId from header `x-amz-version-id",
-36
+                )
             })?,
         );
         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()
     })
-43
+}
-44
 pub fn ser_delete_object_tagging_headers(
     input: &crate::operation::delete_object_tagging::DeleteObjectTaggingInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-61
+    }
     Ok(builder)
-63
+}

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

@@ -15,15 +127,137 @@

↥ Expand context

-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_objects_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::delete_objects::DeleteObjectsOutput, crate::operation::delete_objects::DeleteObjectsError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_objects::builders::DeleteObjectsOutputBuilder::default();
         output = crate::protocol_serde::shape_delete_objects::de_delete_objects(_response_body, output)
             .map_err(crate::operation::delete_objects::DeleteObjectsError::unhandled)?;
         output = output.set_request_charged(
             crate::protocol_serde::shape_delete_objects_output::de_request_charged_header(_response_headers).map_err(|_| {
                 crate::operation::delete_objects::DeleteObjectsError::unhandled("Failed to parse RequestCharged from header `x-amz-request-charged")
             })?,
         );
         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_objects_headers(
     input: &crate::operation::delete_objects::DeleteObjectsInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.mfa {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "mfa",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-mfa", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "mfa",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-mfa", header_value);
-+
+        }
-55
+    }
     if let ::std::option::Option::Some(inner_3) = &input.request_payer {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::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),
--
+            )
         })?;
         builder = builder.header("x-amz-request-payer", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-+
+        }
-68
+    }
     if let ::std::option::Option::Some(inner_5) = &input.bypass_governance_retention {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
         let formatted_6 = encoder.encode();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "bypass_governance_retention",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-bypass-governance-retention", header_value);
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "bypass_governance_retention",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-+
+                )
             })?;
             builder = builder.header("x-amz-bypass-governance-retention", header_value);
-+
+        }
-82
+    }
     if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
         let formatted_8 = inner_7.as_str();
         let header_value = formatted_8;
         let header_value: ::http::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),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_8.is_empty() {
             let header_value = formatted_8;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-95
+    }
     if let ::std::option::Option::Some(inner_9) = &input.checksum_algorithm {
         let formatted_10 = inner_9.as_str();
         let header_value = formatted_10;
         let header_value: ::http::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),
--
+            )
         })?;
         builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
         if !formatted_10.is_empty() {
             let header_value = formatted_10;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-+
+        }
-108
+    }
     Ok(builder)
-110
+}
-111
 #[allow(unused_mut)]
 pub fn de_delete_objects(
     inp: &[u8],
     mut builder: crate::operation::delete_objects::builders::DeleteObjectsOutputBuilder,
 ) -> Result<crate::operation::delete_objects::builders::DeleteObjectsOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;

↧ Expand context

-118
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     if !start_el.matches("DeleteResult") {
         return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
             "encountered invalid XML root: expected DeleteResult but got {:?}. This is likely a bug in the SDK.",
             start_el
         )));
-128
+    }
     while let Some(mut tag) = decoder.next_tag() {
         match tag.start_el() {
             s if s.matches("Error") /* Errors com.amazonaws.s3.synthetic#DeleteObjectsOutput$Errors */ =>  {
                 let var_11 =
                     Some(
                         Result::<::std::vec::Vec::<crate::types::Error>, ::aws_smithy_xml::decode::XmlDecodeError>::Ok({
                             let mut list_12 = builder.errors.take().unwrap_or_default();
                             list_12.push(
                                 crate::protocol_serde::shape_error::de_error(&mut tag)

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

@@ -16,16 +56,58 @@

↥ Expand context

     let generic = generic_builder.build();
     Err(crate::operation::delete_public_access_block::DeletePublicAccessBlockError::generic(
         generic,
     ))
-20
+}
-21
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_public_access_block_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_public_access_block::DeletePublicAccessBlockOutput,
     crate::operation::delete_public_access_block::DeletePublicAccessBlockError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_public_access_block::builders::DeletePublicAccessBlockOutputBuilder::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()
     })
-38
+}
-39
 pub fn ser_delete_public_access_block_headers(
     input: &crate::operation::delete_public_access_block::DeletePublicAccessBlockInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-56
+    }
     Ok(builder)
-58
+}

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

@@ -23,23 +101,105 @@

↥ Expand context

     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationOutput,
     crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_accelerate_configuration::builders::GetBucketAccelerateConfigurationOutputBuilder::default();
         output = crate::protocol_serde::shape_get_bucket_accelerate_configuration::de_get_bucket_accelerate_configuration(_response_body, output)
             .map_err(crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationError::unhandled)?;
         output = output.set_request_charged(
             crate::protocol_serde::shape_get_bucket_accelerate_configuration_output::de_request_charged_header(_response_headers).map_err(|_| {
                 crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationError::unhandled(
                     "Failed to parse RequestCharged from header `x-amz-request-charged",
-38
+                )
             })?,
         );
         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()
     })
-45
+}
-46
 pub fn ser_get_bucket_accelerate_configuration_headers(
     input: &crate::operation::get_bucket_accelerate_configuration::GetBucketAccelerateConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-63
+    }
     if let ::std::option::Option::Some(inner_3) = &input.request_payer {
         let formatted_4 = inner_3.as_str();
         let header_value = formatted_4;
         let header_value: ::http::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),
--
+            )
         })?;
         builder = builder.header("x-amz-request-payer", header_value);
         if !formatted_4.is_empty() {
             let header_value = formatted_4;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-+
+        }
-76
+    }
     Ok(builder)
-78
+}
-79
 #[allow(unused_mut)]
 pub fn de_get_bucket_accelerate_configuration(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_accelerate_configuration::builders::GetBucketAccelerateConfigurationOutputBuilder,
 ) -> Result<
     crate::operation::get_bucket_accelerate_configuration::builders::GetBucketAccelerateConfigurationOutputBuilder,

↧ Expand context

     ::aws_smithy_xml::decode::XmlDecodeError,
 > {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-89
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     if !start_el.matches("AccelerateConfiguration") {
         return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
             "encountered invalid XML root: expected AccelerateConfiguration but got {:?}. This is likely a bug in the SDK.",
             start_el
         )));
-99
+    }
     while let Some(mut tag) = decoder.next_tag() {
         match tag.start_el() {
             s if s.matches("Status") /* Status com.amazonaws.s3.synthetic#GetBucketAccelerateConfigurationOutput$Status */ =>  {
                 let var_5 =
                     Some(
                         Result::<crate::types::BucketAccelerateStatus, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(

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

@@ -10,10 +77,79 @@

↥ Expand context

         .map_err(crate::operation::get_bucket_acl::GetBucketAclError::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::get_bucket_acl::GetBucketAclError::generic(generic))
-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_acl_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::get_bucket_acl::GetBucketAclOutput, crate::operation::get_bucket_acl::GetBucketAclError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_acl::builders::GetBucketAclOutputBuilder::default();
         output = crate::protocol_serde::shape_get_bucket_acl::de_get_bucket_acl(_response_body, output)
             .map_err(crate::operation::get_bucket_acl::GetBucketAclError::unhandled)?;
         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()
     })
-32
+}
-33
 pub fn ser_get_bucket_acl_headers(
     input: &crate::operation::get_bucket_acl::GetBucketAclInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-50
+    }
     Ok(builder)
-52
+}
-53
 #[allow(unused_mut)]
 pub fn de_get_bucket_acl(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_acl::builders::GetBucketAclOutputBuilder,
 ) -> Result<crate::operation::get_bucket_acl::builders::GetBucketAclOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;

↧ Expand context

-60
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     if !start_el.matches("AccessControlPolicy") {
         return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
             "encountered invalid XML root: expected AccessControlPolicy but got {:?}. This is likely a bug in the SDK.",
             start_el
         )));
-70
+    }
     while let Some(mut tag) = decoder.next_tag() {
         match tag.start_el() {
             s if s.matches("Owner") /* Owner com.amazonaws.s3.synthetic#GetBucketAclOutput$Owner */ =>  {
                 let var_3 =
                     Some(
                         crate::protocol_serde::shape_owner::de_owner(&mut tag)
-77
+                        ?
-78
+                    )
-79
+                ;

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

@@ -17,17 +57,59 @@

↥ Expand context

     Err(crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_analytics_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationOutput,
     crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_analytics_configuration::builders::GetBucketAnalyticsConfigurationOutputBuilder::default();
         output = output.set_analytics_configuration(
             crate::protocol_serde::shape_get_bucket_analytics_configuration_output::de_analytics_configuration_payload(_response_body)?,
         );
         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()
     })
-39
+}
-40
 pub fn ser_get_bucket_analytics_configuration_headers(
     input: &crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-57
+    }
     Ok(builder)
-59
+}

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

@@ -10,10 +77,79 @@

↥ Expand context

         .map_err(crate::operation::get_bucket_cors::GetBucketCorsError::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::get_bucket_cors::GetBucketCorsError::generic(generic))
-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_cors_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::get_bucket_cors::GetBucketCorsOutput, crate::operation::get_bucket_cors::GetBucketCorsError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_cors::builders::GetBucketCorsOutputBuilder::default();
         output = crate::protocol_serde::shape_get_bucket_cors::de_get_bucket_cors(_response_body, output)
             .map_err(crate::operation::get_bucket_cors::GetBucketCorsError::unhandled)?;
         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()
     })
-32
+}
-33
 pub fn ser_get_bucket_cors_headers(
     input: &crate::operation::get_bucket_cors::GetBucketCorsInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-50
+    }
     Ok(builder)
-52
+}
-53
 #[allow(unused_mut)]
 pub fn de_get_bucket_cors(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_cors::builders::GetBucketCorsOutputBuilder,
 ) -> Result<crate::operation::get_bucket_cors::builders::GetBucketCorsOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;

↧ Expand context

-60
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     if !start_el.matches("CORSConfiguration") {
         return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
             "encountered invalid XML root: expected CORSConfiguration but got {:?}. This is likely a bug in the SDK.",
             start_el
         )));
-70
+    }
     while let Some(mut tag) = decoder.next_tag() {
         match tag.start_el() {
             s if s.matches("CORSRule") /* CORSRules com.amazonaws.s3.synthetic#GetBucketCorsOutput$CORSRules */ =>  {
                 let var_3 =
                     Some(
                         Result::<::std::vec::Vec::<crate::types::CorsRule>, ::aws_smithy_xml::decode::XmlDecodeError>::Ok({
                             let mut list_4 = builder.cors_rules.take().unwrap_or_default();
                             list_4.push(
                                 crate::protocol_serde::shape_cors_rule::de_cors_rule(&mut tag)

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

@@ -17,17 +57,59 @@

↥ Expand context

     Err(crate::operation::get_bucket_encryption::GetBucketEncryptionError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_encryption_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_encryption::GetBucketEncryptionOutput,
     crate::operation::get_bucket_encryption::GetBucketEncryptionError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_encryption::builders::GetBucketEncryptionOutputBuilder::default();
         output = output.set_server_side_encryption_configuration(
             crate::protocol_serde::shape_get_bucket_encryption_output::de_server_side_encryption_configuration_payload(_response_body)?,
         );
         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()
     })
-39
+}
-40
 pub fn ser_get_bucket_encryption_headers(
     input: &crate::operation::get_bucket_encryption::GetBucketEncryptionInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-57
+    }
     Ok(builder)
-59
+}

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

@@ -17,17 +57,59 @@

↥ Expand context

     Err(crate::operation::get_bucket_inventory_configuration::GetBucketInventoryConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_inventory_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_inventory_configuration::GetBucketInventoryConfigurationOutput,
     crate::operation::get_bucket_inventory_configuration::GetBucketInventoryConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_inventory_configuration::builders::GetBucketInventoryConfigurationOutputBuilder::default();
         output = output.set_inventory_configuration(
             crate::protocol_serde::shape_get_bucket_inventory_configuration_output::de_inventory_configuration_payload(_response_body)?,
         );
         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()
     })
-39
+}
-40
 pub fn ser_get_bucket_inventory_configuration_headers(
     input: &crate::operation::get_bucket_inventory_configuration::GetBucketInventoryConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-57
+    }
     Ok(builder)
-59
+}

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

@@ -16,16 +83,85 @@

↥ Expand context

     let generic = generic_builder.build();
     Err(crate::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_lifecycle_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationOutput,
     crate::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_lifecycle_configuration::builders::GetBucketLifecycleConfigurationOutputBuilder::default();
         output = crate::protocol_serde::shape_get_bucket_lifecycle_configuration::de_get_bucket_lifecycle_configuration(_response_body, output)
             .map_err(crate::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationError::unhandled)?;
         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()
     })
-38
+}
-39
 pub fn ser_get_bucket_lifecycle_configuration_headers(
     input: &crate::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-56
+    }
     Ok(builder)
-58
+}
-59
 #[allow(unused_mut)]
 pub fn de_get_bucket_lifecycle_configuration(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_lifecycle_configuration::builders::GetBucketLifecycleConfigurationOutputBuilder,
 ) -> Result<
     crate::operation::get_bucket_lifecycle_configuration::builders::GetBucketLifecycleConfigurationOutputBuilder,

↧ Expand context

     ::aws_smithy_xml::decode::XmlDecodeError,
 > {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-69
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     if !start_el.matches("LifecycleConfiguration") {
         return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
             "encountered invalid XML root: expected LifecycleConfiguration but got {:?}. This is likely a bug in the SDK.",
             start_el
         )));
-79
+    }
     while let Some(mut tag) = decoder.next_tag() {
         match tag.start_el() {
             s if s.matches("Rule") /* Rules com.amazonaws.s3.synthetic#GetBucketLifecycleConfigurationOutput$Rules */ =>  {
                 let var_3 =
                     Some(
                         Result::<::std::vec::Vec::<crate::types::LifecycleRule>, ::aws_smithy_xml::decode::XmlDecodeError>::Ok({

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

@@ -12,12 +79,81 @@

↥ Expand context

     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::get_bucket_location::GetBucketLocationError::generic(generic))
-16
+}
-17
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_location_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::get_bucket_location::GetBucketLocationOutput, crate::operation::get_bucket_location::GetBucketLocationError>
-24
+{
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_location::builders::GetBucketLocationOutputBuilder::default();
         output = crate::protocol_serde::shape_get_bucket_location::de_get_bucket_location(_response_body, output)
             .map_err(crate::operation::get_bucket_location::GetBucketLocationError::unhandled)?;
         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()
     })
-34
+}
-35
 pub fn ser_get_bucket_location_headers(
     input: &crate::operation::get_bucket_location::GetBucketLocationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-52
+    }
     Ok(builder)
-54
+}
-55
 #[allow(unused_mut)]
 pub fn de_get_bucket_location(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_location::builders::GetBucketLocationOutputBuilder,
 ) -> Result<crate::operation::get_bucket_location::builders::GetBucketLocationOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;

↧ Expand context

-62
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     match start_el {
         s if s.matches("LocationConstraint") /* LocationConstraint com.amazonaws.s3.synthetic#GetBucketLocationOutput$LocationConstraint */ =>  {
             let var_3 =
                 Some(
                     Result::<crate::types::BucketLocationConstraint, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
                         crate::types::BucketLocationConstraint::from(
                             ::aws_smithy_xml::decode::try_data(&mut decoder)?.as_ref()
-74
+                        )
-75
+                    )
-76
+                    ?
-77
+                )
-78
+            ;
             builder = builder.set_location_constraint(var_3);
-80
+        }
-81
+        ,

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

@@ -10,10 +77,79 @@

↥ Expand context

         .map_err(crate::operation::get_bucket_logging::GetBucketLoggingError::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::get_bucket_logging::GetBucketLoggingError::generic(generic))
-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_logging_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::get_bucket_logging::GetBucketLoggingOutput, crate::operation::get_bucket_logging::GetBucketLoggingError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_logging::builders::GetBucketLoggingOutputBuilder::default();
         output = crate::protocol_serde::shape_get_bucket_logging::de_get_bucket_logging(_response_body, output)
             .map_err(crate::operation::get_bucket_logging::GetBucketLoggingError::unhandled)?;
         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()
     })
-32
+}
-33
 pub fn ser_get_bucket_logging_headers(
     input: &crate::operation::get_bucket_logging::GetBucketLoggingInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-50
+    }
     Ok(builder)
-52
+}
-53
 #[allow(unused_mut)]
 pub fn de_get_bucket_logging(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_logging::builders::GetBucketLoggingOutputBuilder,
 ) -> Result<crate::operation::get_bucket_logging::builders::GetBucketLoggingOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;

↧ Expand context

-60
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     if !start_el.matches("BucketLoggingStatus") {
         return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
             "encountered invalid XML root: expected BucketLoggingStatus but got {:?}. This is likely a bug in the SDK.",
             start_el
         )));
-70
+    }
     while let Some(mut tag) = decoder.next_tag() {
         match tag.start_el() {
             s if s.matches("LoggingEnabled") /* LoggingEnabled com.amazonaws.s3.synthetic#GetBucketLoggingOutput$LoggingEnabled */ =>  {
                 let var_3 =
                     Some(
                         crate::protocol_serde::shape_logging_enabled::de_logging_enabled(&mut tag)
-77
+                        ?
-78
+                    )
-79
+                ;

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

@@ -17,17 +57,59 @@

↥ Expand context

     Err(crate::operation::get_bucket_metrics_configuration::GetBucketMetricsConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_metrics_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_metrics_configuration::GetBucketMetricsConfigurationOutput,
     crate::operation::get_bucket_metrics_configuration::GetBucketMetricsConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_metrics_configuration::builders::GetBucketMetricsConfigurationOutputBuilder::default();
         output = output.set_metrics_configuration(
             crate::protocol_serde::shape_get_bucket_metrics_configuration_output::de_metrics_configuration_payload(_response_body)?,
         );
         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()
     })
-39
+}
-40
 pub fn ser_get_bucket_metrics_configuration_headers(
     input: &crate::operation::get_bucket_metrics_configuration::GetBucketMetricsConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-57
+    }
     Ok(builder)
-59
+}

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

@@ -17,17 +84,86 @@

↥ Expand context

     Err(crate::operation::get_bucket_notification_configuration::GetBucketNotificationConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_notification_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_notification_configuration::GetBucketNotificationConfigurationOutput,
     crate::operation::get_bucket_notification_configuration::GetBucketNotificationConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output =
             crate::operation::get_bucket_notification_configuration::builders::GetBucketNotificationConfigurationOutputBuilder::default();
         output = crate::protocol_serde::shape_get_bucket_notification_configuration::de_get_bucket_notification_configuration(_response_body, output)
             .map_err(crate::operation::get_bucket_notification_configuration::GetBucketNotificationConfigurationError::unhandled)?;
         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()
     })
-39
+}
-40
 pub fn ser_get_bucket_notification_configuration_headers(
     input: &crate::operation::get_bucket_notification_configuration::GetBucketNotificationConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-57
+    }
     Ok(builder)
-59
+}
-60
 #[allow(unused_mut)]
 pub fn de_get_bucket_notification_configuration(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_notification_configuration::builders::GetBucketNotificationConfigurationOutputBuilder,
 ) -> Result<
     crate::operation::get_bucket_notification_configuration::builders::GetBucketNotificationConfigurationOutputBuilder,

↧ Expand context

     ::aws_smithy_xml::decode::XmlDecodeError,
 > {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-70
     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     if !start_el.matches("NotificationConfiguration") {
         return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
             "encountered invalid XML root: expected NotificationConfiguration but got {:?}. This is likely a bug in the SDK.",
             start_el
         )));
-80
+    }
     while let Some(mut tag) = decoder.next_tag() {
         match tag.start_el() {
             s if s.matches("CloudFunctionConfiguration") /* LambdaFunctionConfigurations com.amazonaws.s3.synthetic#GetBucketNotificationConfigurationOutput$LambdaFunctionConfigurations */ =>  {
                 let var_3 =
                     Some(
                         Result::<::std::vec::Vec::<crate::types::LambdaFunctionConfiguration>, ::aws_smithy_xml::decode::XmlDecodeError>::Ok({

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

@@ -19,19 +59,61 @@

↥ Expand context

     ))
-20
+}
-21
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_ownership_controls_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_ownership_controls::GetBucketOwnershipControlsOutput,
     crate::operation::get_bucket_ownership_controls::GetBucketOwnershipControlsError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_ownership_controls::builders::GetBucketOwnershipControlsOutputBuilder::default();
         output = output.set_ownership_controls(
             crate::protocol_serde::shape_get_bucket_ownership_controls_output::de_ownership_controls_payload(_response_body)?,
         );
         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()
     })
-41
+}
-42
 pub fn ser_get_bucket_ownership_controls_headers(
     input: &crate::operation::get_bucket_ownership_controls::GetBucketOwnershipControlsInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-59
+    }
     Ok(builder)
-61
+}

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

@@ -9,9 +49,51 @@

↥ Expand context

     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::get_bucket_policy::GetBucketPolicyError::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::get_bucket_policy::GetBucketPolicyError::generic(generic))
-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_policy_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::get_bucket_policy::GetBucketPolicyOutput, crate::operation::get_bucket_policy::GetBucketPolicyError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_policy::builders::GetBucketPolicyOutputBuilder::default();
         output = output.set_policy(crate::protocol_serde::shape_get_bucket_policy_output::de_policy_payload(_response_body)?);
         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()
     })
-31
+}
-32
 pub fn ser_get_bucket_policy_headers(
     input: &crate::operation::get_bucket_policy::GetBucketPolicyInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::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| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
--
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::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),
-+
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-+
+        }
-49
+    }
     Ok(builder)
-51
+}

AWS SDK

Files changed: