AWS SDK

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

@@ -33,33 +101,103 @@

-33
+            }
             tmp
         }),
         _ => crate::operation::create_session::CreateSessionError::generic(generic),
     })
-38
+}
-39
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_create_session_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::create_session::CreateSessionOutput, crate::operation::create_session::CreateSessionError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::create_session::builders::CreateSessionOutputBuilder::default();
         output = crate::protocol_serde::shape_create_session::de_create_session(_response_body, output)
             .map_err(crate::operation::create_session::CreateSessionError::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));

         crate::serde_util::create_session_output_output_correct_errors(output).build()
     })
-55
+}
-56
 pub fn ser_create_session_headers(
     input: &crate::operation::create_session::CreateSessionInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.session_mode {
         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(
                     "session_mode",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-69
+                )
             })?;
             builder = builder.header("x-amz-create-session-mode", header_value);
-72
+        }
-+
+    }
     Ok(builder)
-75
+}
-76
 #[allow(unused_mut)]
 pub fn de_create_session(
     inp: &[u8],
     mut builder: crate::operation::create_session::builders::CreateSessionOutputBuilder,
 ) -> Result<crate::operation::create_session::builders::CreateSessionOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-83

↧ Expand context

     #[allow(unused_mut)]
     let mut decoder = doc.root_element()?;
     #[allow(unused_variables)]
     let start_el = decoder.start_el();
     while let Some(mut tag) = decoder.next_tag() {
         match tag.start_el() {
             s if s.matches("Credentials") /* Credentials com.amazonaws.s3.synthetic#CreateSessionOutput$Credentials */ =>  {
                 let var_3 =
                     Some(
                         crate::protocol_serde::shape_session_credentials::de_session_credentials(&mut tag)
-94
+                        ?
-95
+                    )
-96
+                ;
                 builder = builder.set_credentials(var_3);
-98
+            }
-99
+            ,
             _ => {}
-101
+        }
-102
+    }
     Ok(builder)

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

@@ -8,8 +48,50 @@

↥ Expand context

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

         output.build()
     })
-30
+}
-31
 pub fn ser_delete_bucket_headers(
     input: &crate::operation::delete_bucket::DeleteBucketInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     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),
-44
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-47
+        }
-+
+    }
     Ok(builder)
-50
+}

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

@@ -15,15 +55,57 @@

↥ Expand context

     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     Err(crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_analytics_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationOutput,
     crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output =
             crate::operation::delete_bucket_analytics_configuration::builders::DeleteBucketAnalyticsConfigurationOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-37
+}
-38
 pub fn ser_delete_bucket_analytics_configuration_headers(
     input: &crate::operation::delete_bucket_analytics_configuration::DeleteBucketAnalyticsConfigurationInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     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),
-51
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-54
+        }
-+
+    }
     Ok(builder)
-57
+}

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

@@ -8,8 +48,50 @@

↥ Expand context

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

         output.build()
     })
-30
+}
-31
 pub fn ser_delete_bucket_cors_headers(
     input: &crate::operation::delete_bucket_cors::DeleteBucketCorsInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     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),
-44
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-47
+        }
-+
+    }
     Ok(builder)
-50
+}

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

@@ -14,14 +54,56 @@

↥ 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::delete_bucket_encryption::DeleteBucketEncryptionError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_encryption_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_bucket_encryption::DeleteBucketEncryptionOutput,
     crate::operation::delete_bucket_encryption::DeleteBucketEncryptionError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_bucket_encryption::builders::DeleteBucketEncryptionOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-36
+}
-37
 pub fn ser_delete_bucket_encryption_headers(
     input: &crate::operation::delete_bucket_encryption::DeleteBucketEncryptionInput,
     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),
-50
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-53
+        }
-+
+    }
     Ok(builder)
-56
+}

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

@@ -15,15 +55,57 @@

↥ Expand context

     generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
     let generic = generic_builder.build();
     Err(crate::operation::delete_bucket_inventory_configuration::DeleteBucketInventoryConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_inventory_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_bucket_inventory_configuration::DeleteBucketInventoryConfigurationOutput,
     crate::operation::delete_bucket_inventory_configuration::DeleteBucketInventoryConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output =
             crate::operation::delete_bucket_inventory_configuration::builders::DeleteBucketInventoryConfigurationOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-37
+}
-38
 pub fn ser_delete_bucket_inventory_configuration_headers(
     input: &crate::operation::delete_bucket_inventory_configuration::DeleteBucketInventoryConfigurationInput,
     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),
-51
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-54
+        }
-+
+    }
     Ok(builder)
-57
+}

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

@@ -14,14 +54,56 @@

↥ 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::delete_bucket_lifecycle::DeleteBucketLifecycleError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_lifecycle_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_bucket_lifecycle::DeleteBucketLifecycleOutput,
     crate::operation::delete_bucket_lifecycle::DeleteBucketLifecycleError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_bucket_lifecycle::builders::DeleteBucketLifecycleOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-36
+}
-37
 pub fn ser_delete_bucket_lifecycle_headers(
     input: &crate::operation::delete_bucket_lifecycle::DeleteBucketLifecycleInput,
     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),
-50
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-53
+        }
-+
+    }
     Ok(builder)
-56
+}

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

@@ -14,14 +54,56 @@

↥ 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::delete_bucket_metrics_configuration::DeleteBucketMetricsConfigurationError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_metrics_configuration_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_bucket_metrics_configuration::DeleteBucketMetricsConfigurationOutput,
     crate::operation::delete_bucket_metrics_configuration::DeleteBucketMetricsConfigurationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_bucket_metrics_configuration::builders::DeleteBucketMetricsConfigurationOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-36
+}
-37
 pub fn ser_delete_bucket_metrics_configuration_headers(
     input: &crate::operation::delete_bucket_metrics_configuration::DeleteBucketMetricsConfigurationInput,
     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),
-50
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-53
+        }
-+
+    }
     Ok(builder)
-56
+}

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

@@ -14,14 +54,56 @@

↥ 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::delete_bucket_ownership_controls::DeleteBucketOwnershipControlsError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_ownership_controls_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_bucket_ownership_controls::DeleteBucketOwnershipControlsOutput,
     crate::operation::delete_bucket_ownership_controls::DeleteBucketOwnershipControlsError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_bucket_ownership_controls::builders::DeleteBucketOwnershipControlsOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-36
+}
-37
 pub fn ser_delete_bucket_ownership_controls_headers(
     input: &crate::operation::delete_bucket_ownership_controls::DeleteBucketOwnershipControlsInput,
     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),
-50
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-53
+        }
-+
+    }
     Ok(builder)
-56
+}

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

@@ -14,14 +54,56 @@

↥ 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::delete_bucket_policy::DeleteBucketPolicyError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_policy_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_bucket_policy::DeleteBucketPolicyOutput,
     crate::operation::delete_bucket_policy::DeleteBucketPolicyError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_bucket_policy::builders::DeleteBucketPolicyOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-36
+}
-37
 pub fn ser_delete_bucket_policy_headers(
     input: &crate::operation::delete_bucket_policy::DeleteBucketPolicyInput,
     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),
-50
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-53
+        }
-+
+    }
     Ok(builder)
-56
+}

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

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

↥ Expand context

     let generic = generic_builder.build();
     Err(crate::operation::delete_bucket_replication::DeleteBucketReplicationError::generic(
         generic,
     ))
-20
+}
-21
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_replication_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_bucket_replication::DeleteBucketReplicationOutput,
     crate::operation::delete_bucket_replication::DeleteBucketReplicationError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_bucket_replication::builders::DeleteBucketReplicationOutputBuilder::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_bucket_replication_headers(
     input: &crate::operation::delete_bucket_replication::DeleteBucketReplicationInput,
     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_delete_bucket_tagging.rs

@@ -14,14 +54,56 @@

↥ 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::delete_bucket_tagging::DeleteBucketTaggingError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_tagging_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_bucket_tagging::DeleteBucketTaggingOutput,
     crate::operation::delete_bucket_tagging::DeleteBucketTaggingError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_bucket_tagging::builders::DeleteBucketTaggingOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-36
+}
-37
 pub fn ser_delete_bucket_tagging_headers(
     input: &crate::operation::delete_bucket_tagging::DeleteBucketTaggingInput,
     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),
-50
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-53
+        }
-+
+    }
     Ok(builder)
-56
+}

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

@@ -14,14 +54,56 @@

↥ 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::delete_bucket_website::DeleteBucketWebsiteError::generic(generic))
-18
+}
-19
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_bucket_website_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_bucket_website::DeleteBucketWebsiteOutput,
     crate::operation::delete_bucket_website::DeleteBucketWebsiteError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_bucket_website::builders::DeleteBucketWebsiteOutputBuilder::default();
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-36
+}
-37
 pub fn ser_delete_bucket_website_headers(
     input: &crate::operation::delete_bucket_website::DeleteBucketWebsiteInput,
     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),
-50
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-53
+        }
-+
+    }
     Ok(builder)
-56
+}

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

@@ -23,23 +97,105 @@

↥ Expand context

     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_object::builders::DeleteObjectOutputBuilder::default();
         output = output.set_delete_marker(
             crate::protocol_serde::shape_delete_object_output::de_delete_marker_header(_response_headers).map_err(|_| {
                 crate::operation::delete_object::DeleteObjectError::unhandled("Failed to parse DeleteMarker from header `x-amz-delete-marker")
             })?,
         );
         output = output.set_request_charged(
             crate::protocol_serde::shape_delete_object_output::de_request_charged_header(_response_headers).map_err(|_| {
                 crate::operation::delete_object::DeleteObjectError::unhandled("Failed to parse RequestCharged from header `x-amz-request-charged")
             })?,
         );
         output = output.set_version_id(
             crate::protocol_serde::shape_delete_object_output::de_version_id_header(_response_headers).map_err(|_| {
                 crate::operation::delete_object::DeleteObjectError::unhandled("Failed to parse VersionId from header `x-amz-version-id")
             })?,
         );
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-45
+}
-46
 pub fn ser_delete_object_headers(
     input: &crate::operation::delete_object::DeleteObjectInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.mfa {
         let formatted_2 = inner_1.as_str();
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "mfa",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-59
+                )
             })?;
             builder = builder.header("x-amz-mfa", 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
+        }
-+
+    }
     if let ::std::option::Option::Some(inner_5) = &input.bypass_governance_retention {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
         let formatted_6 = encoder.encode();
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "bypass_governance_retention",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-86
+                )
             })?;
             builder = builder.header("x-amz-bypass-governance-retention", header_value);
-89
+        }
-+
+    }
     if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
         let formatted_8 = inner_7.as_str();
         if !formatted_8.is_empty() {
             let header_value = formatted_8;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-99
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-102
+        }
-+
+    }
     Ok(builder)
-105
+}

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

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

↥ Expand context

 pub fn de_delete_object_tagging_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::delete_object_tagging::DeleteObjectTaggingOutput,
     crate::operation::delete_object_tagging::DeleteObjectTaggingError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_object_tagging::builders::DeleteObjectTaggingOutputBuilder::default();
         output = output.set_version_id(
             crate::protocol_serde::shape_delete_object_tagging_output::de_version_id_header(_response_headers).map_err(|_| {
                 crate::operation::delete_object_tagging::DeleteObjectTaggingError::unhandled(
                     "Failed to parse VersionId from header `x-amz-version-id",
-36
+                )
             })?,
         );
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-43
+}
-44
 pub fn ser_delete_object_tagging_headers(
     input: &crate::operation::delete_object_tagging::DeleteObjectTaggingInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
         let formatted_2 = inner_1.as_str();
         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),
-57
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-60
+        }
-+
+    }
     Ok(builder)
-63
+}

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

@@ -15,15 +128,138 @@

↥ Expand context

-15
+}
-16
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_delete_objects_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::delete_objects::DeleteObjectsOutput, crate::operation::delete_objects::DeleteObjectsError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::delete_objects::builders::DeleteObjectsOutputBuilder::default();
         output = crate::protocol_serde::shape_delete_objects::de_delete_objects(_response_body, output)
             .map_err(crate::operation::delete_objects::DeleteObjectsError::unhandled)?;
         output = output.set_request_charged(
             crate::protocol_serde::shape_delete_objects_output::de_request_charged_header(_response_headers).map_err(|_| {
                 crate::operation::delete_objects::DeleteObjectsError::unhandled("Failed to parse RequestCharged from header `x-amz-request-charged")
             })?,
         );
         output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
         output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));

         output.build()
     })
-37
+}
-38
 pub fn ser_delete_objects_headers(
     input: &crate::operation::delete_objects::DeleteObjectsInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.mfa {
         let formatted_2 = inner_1.as_str();
         if !formatted_2.is_empty() {
             let header_value = formatted_2;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "mfa",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-51
+                )
             })?;
             builder = builder.header("x-amz-mfa", header_value);
-54
+        }
-+
+    }
     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),
-64
+                )
             })?;
             builder = builder.header("x-amz-request-payer", header_value);
-67
+        }
-+
+    }
     if let ::std::option::Option::Some(inner_5) = &input.bypass_governance_retention {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
         let formatted_6 = encoder.encode();
         if !formatted_6.is_empty() {
             let header_value = formatted_6;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "bypass_governance_retention",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-78
+                )
             })?;
             builder = builder.header("x-amz-bypass-governance-retention", header_value);
-81
+        }
-+
+    }
     if let ::std::option::Option::Some(inner_7) = &input.expected_bucket_owner {
         let formatted_8 = inner_7.as_str();
         if !formatted_8.is_empty() {
             let header_value = formatted_8;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "expected_bucket_owner",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-91
+                )
             })?;
             builder = builder.header("x-amz-expected-bucket-owner", header_value);
-94
+        }
-+
+    }
     if let ::std::option::Option::Some(inner_9) = &input.checksum_algorithm {
         let formatted_10 = inner_9.as_str();
         if !formatted_10.is_empty() {
             let header_value = formatted_10;
             let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 ::aws_smithy_types::error::operation::BuildError::invalid_field(
                     "checksum_algorithm",
                     format!("`{}` cannot be used as a header value: {}", &header_value, err),
-104
+                )
             })?;
             builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
-107
+        }
-+
+    }
     Ok(builder)
-110
+}
-111
 #[allow(unused_mut)]
 pub fn de_delete_objects(
     inp: &[u8],
     mut builder: crate::operation::delete_objects::builders::DeleteObjectsOutputBuilder,
 ) -> Result<crate::operation::delete_objects::builders::DeleteObjectsOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
     let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
-118

↧ Expand context

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

AWS SDK

Files changed: