AWS SDK

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

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

     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();
         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),
-52
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-55
+        }
-+
+    }
     Ok(builder)
-58
+}

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

@@ -23,23 +102,106 @@

↥ 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();
         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),
-59
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-62
+        }
-+
+    }
     if let ::std::option::Option::Some(inner_3) = &input.request_payer {
         let formatted_4 = inner_3.as_str();
         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),
-72
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-75
+        }
-+
+    }
     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,
     ::aws_smithy_xml::decode::XmlDecodeError,

↧ Expand context

 > {
     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(
                             crate::types::BucketAccelerateStatus::from(

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

@@ -10,10 +78,80 @@

↥ 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();
         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),
-46
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-49
+        }
-+
+    }
     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)?;
-60

↧ Expand context

     #[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
+                ;
                 builder = builder.set_owner(var_3);

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();
         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),
-53
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-56
+        }
-+
+    }
     Ok(builder)
-59
+}

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

@@ -10,10 +78,80 @@

↥ 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();
         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),
-46
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-49
+        }
-+
+    }
     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)?;
-60

↧ Expand context

     #[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)
-80
+                                ?

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();
         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),
-53
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-56
+        }
-+
+    }
     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();
         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),
-53
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-56
+        }
-+
+    }
     Ok(builder)
-59
+}

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

@@ -16,16 +84,86 @@

↥ 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();
         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),
-52
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-55
+        }
-+
+    }
     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,
     ::aws_smithy_xml::decode::XmlDecodeError,

↧ Expand context

 > {
     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({
                             let mut list_4 = builder.rules.take().unwrap_or_default();

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

@@ -12,12 +80,82 @@

↥ 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();
         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),
-48
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-51
+        }
-+
+    }
     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)?;
-62

↧ Expand context

     #[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
+        ,
         _ => return Err(::aws_smithy_xml::decode::XmlDecodeError::custom("expected LocationConstraint tag"))

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

@@ -10,10 +78,80 @@

↥ 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();
         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),
-46
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-49
+        }
-+
+    }
     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)?;
-60

↧ Expand context

     #[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
+                ;
                 builder = builder.set_logging_enabled(var_3);

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();
         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),
-53
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-56
+        }
-+
+    }
     Ok(builder)
-59
+}

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

@@ -17,17 +85,87 @@

↥ 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();
         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),
-53
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-56
+        }
-+
+    }
     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,
     ::aws_smithy_xml::decode::XmlDecodeError,

↧ Expand context

 > {
     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({
                             let mut list_4 = builder.lambda_function_configurations.take().unwrap_or_default();

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();
         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),
-55
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-58
+        }
-+
+    }
     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();
         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),
-45
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-48
+        }
-+
+    }
     Ok(builder)
-51
+}

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

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

↥ Expand context

     Err(crate::operation::get_bucket_policy_status::GetBucketPolicyStatusError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_policy_status_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_policy_status::GetBucketPolicyStatusOutput,
     crate::operation::get_bucket_policy_status::GetBucketPolicyStatusError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_policy_status::builders::GetBucketPolicyStatusOutputBuilder::default();
         output = output.set_policy_status(crate::protocol_serde::shape_get_bucket_policy_status_output::de_policy_status_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_policy_status_headers(
     input: &crate::operation::get_bucket_policy_status::GetBucketPolicyStatusInput,
     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();
         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),
-53
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-56
+        }
-+
+    }
     Ok(builder)
-59
+}

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

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

↥ Expand context

     Err(crate::operation::get_bucket_replication::GetBucketReplicationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_replication_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_replication::GetBucketReplicationOutput,
     crate::operation::get_bucket_replication::GetBucketReplicationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_replication::builders::GetBucketReplicationOutputBuilder::default();
         output = output.set_replication_configuration(
             crate::protocol_serde::shape_get_bucket_replication_output::de_replication_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_replication_headers(
     input: &crate::operation::get_bucket_replication::GetBucketReplicationInput,
     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();
         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),
-53
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-56
+        }
-+
+    }
     Ok(builder)
-59
+}

AWS SDK

Files changed: