AWS SDK

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

@@ -19,19 +95,95 @@

-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_accelerate_configuration_http_response(
     _response_status: u16,
     _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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-58
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-61
+    }
     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| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "request_payer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-69
+            )
         })?;
         builder = builder.header("x-amz-request-payer", header_value);
-72
+    }
     Ok(builder)
-74
+}
-75

↧ Expand context

 #[allow(unused_mut)]
 pub fn de_get_bucket_accelerate_configuration(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_accelerate_configuration::builders::GetBucketAccelerateConfigurationOutputBuilder,
 ) -> std::result::Result<
     crate::operation::get_bucket_accelerate_configuration::builders::GetBucketAccelerateConfigurationOutputBuilder,
     ::aws_smithy_xml::decode::XmlDecodeError,
 > {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-85
     #[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 {start_el:?}. This is likely a bug in the SDK."
         )));
-94
+    }
     while let Some(mut tag) = decoder.next_tag() {

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

@@ -6,6 +71,71 @@

↥ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::get_bucket_acl::GetBucketAclOutput, crate::operation::get_bucket_acl::GetBucketAclError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-45
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-48
+    }
     Ok(builder)
-50
+}
-51

↧ Expand context

 #[allow(unused_mut)]
 pub fn de_get_bucket_acl(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_acl::builders::GetBucketAclOutputBuilder,
 ) -> std::result::Result<crate::operation::get_bucket_acl::builders::GetBucketAclOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-58
     #[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 {start_el:?}. This is likely a bug in the SDK."
         )));
-67
+    }
     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 =

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

@@ -13,13 +57,57 @@

↥ Expand context

         .map_err(crate::operation::get_bucket_analytics_configuration::GetBucketAnalyticsConfigurationError::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_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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-52
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-55
+    }
     Ok(builder)
-57
+}

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

@@ -6,6 +71,71 @@

↥ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::get_bucket_cors::GetBucketCorsOutput, crate::operation::get_bucket_cors::GetBucketCorsError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-45
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-48
+    }
     Ok(builder)
-50
+}
-51

↧ Expand context

 #[allow(unused_mut)]
 pub fn de_get_bucket_cors(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_cors::builders::GetBucketCorsOutputBuilder,
 ) -> std::result::Result<crate::operation::get_bucket_cors::builders::GetBucketCorsOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-58
     #[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 {start_el:?}. This is likely a bug in the SDK."
         )));
-67
+    }
     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 =

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

@@ -13,13 +57,57 @@

↥ Expand context

         .map_err(crate::operation::get_bucket_encryption::GetBucketEncryptionError::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_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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-52
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-55
+    }
     Ok(builder)
-57
+}

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

@@ -17,17 +61,61 @@

↥ Expand context

     Err(crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_intelligent_tiering_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationOutput,
     crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output =
             crate::operation::get_bucket_intelligent_tiering_configuration::builders::GetBucketIntelligentTieringConfigurationOutputBuilder::default(
             );
         output = output.set_intelligent_tiering_configuration(
             crate::protocol_serde::shape_get_bucket_intelligent_tiering_configuration_output::de_intelligent_tiering_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()
     })
-43
+}
-44
 pub fn ser_get_bucket_intelligent_tiering_configuration_headers(
     input: &crate::operation::get_bucket_intelligent_tiering_configuration::GetBucketIntelligentTieringConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-56
+            )
         })?;
         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_inventory_configuration.rs

@@ -13,13 +57,57 @@

↥ Expand context

         .map_err(crate::operation::get_bucket_inventory_configuration::GetBucketInventoryConfigurationError::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_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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-52
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-55
+    }
     Ok(builder)
-57
+}

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

@@ -22,22 +87,87 @@

↥ Expand context

     _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 = output.set_transition_default_minimum_object_size(
             crate::protocol_serde::shape_get_bucket_lifecycle_configuration_output::de_transition_default_minimum_object_size_header(
                 _response_headers,
-37
+            )
             .map_err(|_| {
                 crate::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationError::unhandled(
                     "Failed to parse TransitionDefaultMinimumObjectSize from header `x-amz-transition-default-minimum-object-size",
-41
+                )

             })?,
         );
         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()
     })
-48
+}
-49
 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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-61
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-64
+    }
     Ok(builder)
-66
+}
-67

↧ Expand context

 #[allow(unused_mut)]
 pub fn de_get_bucket_lifecycle_configuration(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_lifecycle_configuration::builders::GetBucketLifecycleConfigurationOutputBuilder,
 ) -> std::result::Result<
     crate::operation::get_bucket_lifecycle_configuration::builders::GetBucketLifecycleConfigurationOutputBuilder,
     ::aws_smithy_xml::decode::XmlDecodeError,
 > {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-77
     #[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 {start_el:?}. This is likely a bug in the SDK."
         )));
-86
+    }
     while let Some(mut tag) = decoder.next_tag() {

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

@@ -8,8 +73,73 @@

↥ Expand context

-8
+{
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::get_bucket_location::GetBucketLocationError::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_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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-47
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-50
+    }
     Ok(builder)
-52
+}
-53

↧ Expand context

 #[allow(unused_mut)]
 pub fn de_get_bucket_location(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_location::builders::GetBucketLocationOutputBuilder,
 ) -> std::result::Result<crate::operation::get_bucket_location::builders::GetBucketLocationOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-60
     #[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()
-72
+                        )
-73
+                    )

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

@@ -6,6 +71,71 @@

↥ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::get_bucket_logging::GetBucketLoggingOutput, crate::operation::get_bucket_logging::GetBucketLoggingError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-45
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-48
+    }
     Ok(builder)
-50
+}
-51

↧ Expand context

 #[allow(unused_mut)]
 pub fn de_get_bucket_logging(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_logging::builders::GetBucketLoggingOutputBuilder,
 ) -> std::result::Result<crate::operation::get_bucket_logging::builders::GetBucketLoggingOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-58
     #[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 {start_el:?}. This is likely a bug in the SDK."
         )));
-67
+    }
     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 =

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

@@ -15,15 +59,59 @@

↥ Expand context

     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     Err(crate::operation::get_bucket_metadata_configuration::GetBucketMetadataConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_metadata_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_metadata_configuration::GetBucketMetadataConfigurationOutput,
     crate::operation::get_bucket_metadata_configuration::GetBucketMetadataConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::get_bucket_metadata_configuration::builders::GetBucketMetadataConfigurationOutputBuilder::default();
         output = output.set_get_bucket_metadata_configuration_result(
             crate::protocol_serde::shape_get_bucket_metadata_configuration_output::de_get_bucket_metadata_configuration_result_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_metadata_configuration_headers(
     input: &crate::operation::get_bucket_metadata_configuration::GetBucketMetadataConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-54
+            )
         })?;
         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_metadata_table_configuration.rs

@@ -16,16 +60,60 @@

↥ Expand context

     let generic = generic_builder.build();
     Err(crate::operation::get_bucket_metadata_table_configuration::GetBucketMetadataTableConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_get_bucket_metadata_table_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::get_bucket_metadata_table_configuration::GetBucketMetadataTableConfigurationOutput,
     crate::operation::get_bucket_metadata_table_configuration::GetBucketMetadataTableConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output =
             crate::operation::get_bucket_metadata_table_configuration::builders::GetBucketMetadataTableConfigurationOutputBuilder::default();
         output = output.set_get_bucket_metadata_table_configuration_result(
             crate::protocol_serde::shape_get_bucket_metadata_table_configuration_output::de_get_bucket_metadata_table_configuration_result_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()
     })
-42
+}
-43
 pub fn ser_get_bucket_metadata_table_configuration_headers(
     input: &crate::operation::get_bucket_metadata_table_configuration::GetBucketMetadataTableConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-55
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-58
+    }
     Ok(builder)
-60
+}

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

@@ -13,13 +57,57 @@

↥ Expand context

         .map_err(crate::operation::get_bucket_metrics_configuration::GetBucketMetricsConfigurationError::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_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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-52
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-55
+    }
     Ok(builder)
-57
+}

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

@@ -13,13 +78,78 @@

↥ Expand context

         .map_err(crate::operation::get_bucket_notification_configuration::GetBucketNotificationConfigurationError::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_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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-52
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-55
+    }
     Ok(builder)
-57
+}
-58

↧ Expand context

 #[allow(unused_mut)]
 pub fn de_get_bucket_notification_configuration(
     inp: &[u8],
     mut builder: crate::operation::get_bucket_notification_configuration::builders::GetBucketNotificationConfigurationOutputBuilder,
 ) -> std::result::Result<
     crate::operation::get_bucket_notification_configuration::builders::GetBucketNotificationConfigurationOutputBuilder,
     ::aws_smithy_xml::decode::XmlDecodeError,
 > {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-68
     #[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 {start_el:?}. This is likely a bug in the SDK."
         )));
-77
+    }
     while let Some(mut tag) = decoder.next_tag() {

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

@@ -15,15 +59,59 @@

↥ Expand context

     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     Err(crate::operation::get_bucket_ownership_controls::GetBucketOwnershipControlsError::generic(
         generic,
     ))
-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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-54
+            )
         })?;
         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_policy.rs

@@ -5,5 +49,49 @@

↥ Expand context

     _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> {
     #[allow(unused_mut)]
     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> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "expected_bucket_owner",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-44
+            )
         })?;
         builder = builder.header("x-amz-expected-bucket-owner", header_value);
-47
+    }
     Ok(builder)
-49
+}

AWS SDK

Files changed: