AWS SDK

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

@@ -145,145 +205,205 @@

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-157
+                        }
-158
+                    }
-159
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-162
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-167
                     // From the httpChecksum trait
                     let http_checksum_required = true;
-170
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-172
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-188
+                        }
                         _ => {}
-190
+                    }
-191
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::create_bucket_metadata_table_configuration::CreateBucketMetadataTableConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::create_bucket_metadata_table_configuration::CreateBucketMetadataTableConfigurationError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::create_bucket_metadata_table_configuration::CreateBucketMetadataTableConfigurationError,

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

@@ -135,135 +195,195 @@

↥ Expand context

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-147
+                        }
-148
+                    }
-149
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-152
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-157
                     // From the httpChecksum trait
                     let http_checksum_required = true;
-160
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-162
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-178
+                        }
                         _ => {}
-180
+                    }
-181
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::delete_objects::DeleteObjectsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::delete_objects::DeleteObjectsError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::delete_objects::DeleteObjectsError>::builder()
                     .transient_errors({

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

@@ -144,144 +204,204 @@

↥ Expand context

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-156
+                        }
-157
+                    }
-158
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-161
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-166
                     // From the httpChecksum trait
                     let http_checksum_required = false;
-169
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-171
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-187
+                        }
                         _ => {}
-189
+                    }
-190
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_accelerate_configuration::PutBucketAccelerateConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_accelerate_configuration::PutBucketAccelerateConfigurationError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::put_bucket_accelerate_configuration::PutBucketAccelerateConfigurationError,

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

@@ -135,135 +195,195 @@

↥ Expand context

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-147
+                        }
-148
+                    }
-149
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-152
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-157
                     // From the httpChecksum trait
                     let http_checksum_required = true;
-160
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-162
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-178
+                        }
                         _ => {}
-180
+                    }
-181
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_acl::PutBucketAclError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_acl::PutBucketAclError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_acl::PutBucketAclError>::builder()
                     .transient_errors({

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

@@ -135,135 +195,195 @@

↥ Expand context

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-147
+                        }
-148
+                    }
-149
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-152
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-157
                     // From the httpChecksum trait
                     let http_checksum_required = true;
-160
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-162
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-178
+                        }
                         _ => {}
-180
+                    }
-181
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_cors::PutBucketCorsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_cors::PutBucketCorsError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_cors::PutBucketCorsError>::builder()
                     .transient_errors({

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

@@ -139,139 +199,199 @@

↥ Expand context

                                     let headers_to_check = request.headers().iter().filter_map(|(name, _val)| {
                                         if name.starts_with("x-amz-checksum-") {
                                             Some(name)
                                         } else {
                                             None
-144
+                                        }
                                     });
                                     for algo_header in headers_to_check {
                                         if request.headers().get(algo_header).is_some() {
                                             user_set_checksum_value = true;
-149
+                                        }
-150
+                                    }
-151
                                     // We check if the user set the checksum algo manually
                                     let user_set_checksum_algo = request.headers()
                                         .get("x-amz-sdk-checksum-algorithm")
                                         .is_some();
-156
                                     // This value is set by the user on the SdkConfig to indicate their preference
                                     let request_checksum_calculation = cfg

                                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-161
                                     // From the httpChecksum trait
                                     let http_checksum_required = true;
-164
                                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-166
                                     // If the request is presigned we do not set a default.
                                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                                     match (
                                         request_checksum_calculation,
                                         http_checksum_required,
                                         user_set_checksum_value,
                                         user_set_checksum_algo,
                                         is_presigned_req,
                                     ) {
                                         (_, _, _, _, true) => {}
                                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-182
+                                        }
                                         _ => {},
-184
+                                    }
-185
                                     // We return a bool indicating if the user did set the checksum value, if they did
                                     // we can short circuit and exit the interceptor early.
                                     Ok(user_set_checksum_value)
-189
+                                }
                                 ))
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_bucket_encryption::PutBucketEncryptionError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_bucket_encryption::PutBucketEncryptionError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_encryption::PutBucketEncryptionError>::builder().transient_errors({
                                             let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                                             transient_errors.push("InternalError");
                                             ::std::borrow::Cow::Owned(transient_errors)
                                             }).build());
-198
         ::std::borrow::Cow::Owned(rcb)

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

@@ -145,145 +205,205 @@

↥ Expand context

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-157
+                        }
-158
+                    }
-159
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-162
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-167
                     // From the httpChecksum trait
                     let http_checksum_required = true;
-170
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-172
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-188
+                        }
                         _ => {}
-190
+                    }
-191
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::put_bucket_lifecycle_configuration::PutBucketLifecycleConfigurationError,

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

@@ -135,135 +195,195 @@

↥ Expand context

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-147
+                        }
-148
+                    }
-149
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-152
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-157
                     // From the httpChecksum trait
                     let http_checksum_required = true;
-160
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-162
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-178
+                        }
                         _ => {}
-180
+                    }
-181
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_logging::PutBucketLoggingError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_logging::PutBucketLoggingError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_logging::PutBucketLoggingError>::builder()
                     .transient_errors({

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

@@ -135,135 +195,195 @@

↥ Expand context

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-147
+                        }
-148
+                    }
-149
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-152
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-157
                     // From the httpChecksum trait
                     let http_checksum_required = true;
-160
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-162
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-178
+                        }
                         _ => {}
-180
+                    }
-181
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_policy::PutBucketPolicyError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_policy::PutBucketPolicyError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_policy::PutBucketPolicyError>::builder()
                     .transient_errors({

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

@@ -142,142 +202,202 @@

↥ Expand context

                                     let headers_to_check = request.headers().iter().filter_map(|(name, _val)| {
                                         if name.starts_with("x-amz-checksum-") {
                                             Some(name)
                                         } else {
                                             None
-147
+                                        }
                                     });
                                     for algo_header in headers_to_check {
                                         if request.headers().get(algo_header).is_some() {
                                             user_set_checksum_value = true;
-152
+                                        }
-153
+                                    }
-154
                                     // We check if the user set the checksum algo manually
                                     let user_set_checksum_algo = request.headers()
                                         .get("x-amz-sdk-checksum-algorithm")
                                         .is_some();
-159
                                     // This value is set by the user on the SdkConfig to indicate their preference
                                     let request_checksum_calculation = cfg

                                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-164
                                     // From the httpChecksum trait
                                     let http_checksum_required = true;
-167
                                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-169
                                     // If the request is presigned we do not set a default.
                                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                                     match (
                                         request_checksum_calculation,
                                         http_checksum_required,
                                         user_set_checksum_value,
                                         user_set_checksum_algo,
                                         is_presigned_req,
                                     ) {
                                         (_, _, _, _, true) => {}
                                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-185
+                                        }
                                         _ => {},
-187
+                                    }
-188
                                     // We return a bool indicating if the user did set the checksum value, if they did
                                     // we can short circuit and exit the interceptor early.
                                     Ok(user_set_checksum_value)
-192
+                                }
                                 ))
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_bucket_replication::PutBucketReplicationError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_bucket_replication::PutBucketReplicationError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_replication::PutBucketReplicationError>::builder().transient_errors({
                                             let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                                             transient_errors.push("InternalError");
                                             ::std::borrow::Cow::Owned(transient_errors)
                                             }).build());
-201
         ::std::borrow::Cow::Owned(rcb)

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

@@ -139,139 +199,199 @@

↥ Expand context

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-151
+                        }
-152
+                    }
-153
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-156
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-161
                     // From the httpChecksum trait
                     let http_checksum_required = true;
-164
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-166
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-182
+                        }
                         _ => {}
-184
+                    }
-185
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::put_bucket_request_payment::PutBucketRequestPaymentError,

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

@@ -135,135 +195,195 @@

↥ Expand context

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-147
+                        }
-148
+                    }
-149
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-152
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-157
                     // From the httpChecksum trait
                     let http_checksum_required = true;
-160
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-162
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-178
+                        }
                         _ => {}
-180
+                    }
-181
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_tagging::PutBucketTaggingError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_tagging::PutBucketTaggingError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_tagging::PutBucketTaggingError>::builder()
                     .transient_errors({

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

@@ -139,139 +199,199 @@

↥ Expand context

                                     let headers_to_check = request.headers().iter().filter_map(|(name, _val)| {
                                         if name.starts_with("x-amz-checksum-") {
                                             Some(name)
                                         } else {
                                             None
-144
+                                        }
                                     });
                                     for algo_header in headers_to_check {
                                         if request.headers().get(algo_header).is_some() {
                                             user_set_checksum_value = true;
-149
+                                        }
-150
+                                    }
-151
                                     // We check if the user set the checksum algo manually
                                     let user_set_checksum_algo = request.headers()
                                         .get("x-amz-sdk-checksum-algorithm")
                                         .is_some();
-156
                                     // This value is set by the user on the SdkConfig to indicate their preference
                                     let request_checksum_calculation = cfg

                                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-161
                                     // From the httpChecksum trait
                                     let http_checksum_required = true;
-164
                                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-166
                                     // If the request is presigned we do not set a default.
                                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                                     match (
                                         request_checksum_calculation,
                                         http_checksum_required,
                                         user_set_checksum_value,
                                         user_set_checksum_algo,
                                         is_presigned_req,
                                     ) {
                                         (_, _, _, _, true) => {}
                                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-182
+                                        }
                                         _ => {},
-184
+                                    }
-185
                                     // We return a bool indicating if the user did set the checksum value, if they did
                                     // we can short circuit and exit the interceptor early.
                                     Ok(user_set_checksum_value)
-189
+                                }
                                 ))
                             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<crate::operation::put_bucket_versioning::PutBucketVersioningError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_bucket_versioning::PutBucketVersioningError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_versioning::PutBucketVersioningError>::builder().transient_errors({
                                             let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
                                             transient_errors.push("InternalError");
                                             ::std::borrow::Cow::Owned(transient_errors)
                                             }).build());
-198
         ::std::borrow::Cow::Owned(rcb)

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

@@ -135,135 +195,195 @@

↥ Expand context

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-147
+                        }
-148
+                    }
-149
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-152
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-157
                     // From the httpChecksum trait
                     let http_checksum_required = true;
-160
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-162
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-178
+                        }
                         _ => {}
-180
+                    }
-181
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_bucket_website::PutBucketWebsiteError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_bucket_website::PutBucketWebsiteError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_bucket_website::PutBucketWebsiteError>::builder()
                     .transient_errors({

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

@@ -135,135 +195,195 @@

↥ Expand context

                 },
                 |request: &mut ::aws_smithy_runtime_api::http::Request, cfg: &::aws_smithy_types::config_bag::ConfigBag| {
                     // We check if the user has set any of the checksum values manually
                     let mut user_set_checksum_value = false;
                     let headers_to_check =
                         request
                             .headers()
                             .iter()
                             .filter_map(|(name, _val)| if name.starts_with("x-amz-checksum-") { Some(name) } else { None });
                     for algo_header in headers_to_check {
                         if request.headers().get(algo_header).is_some() {
                             user_set_checksum_value = true;
-147
+                        }
-148
+                    }
-149
                     // We check if the user set the checksum algo manually
                     let user_set_checksum_algo = request.headers().get("x-amz-sdk-checksum-algorithm").is_some();
-152
                     // This value is set by the user on the SdkConfig to indicate their preference
                     let request_checksum_calculation = cfg

                         .load::<::aws_smithy_types::checksum_config::RequestChecksumCalculation>()
                         .unwrap_or(&::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported);
-157
                     // From the httpChecksum trait
                     let http_checksum_required = false;
-160
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-162
                     // If the request is presigned we do not set a default.
                     // If the RequestChecksumCalculation is WhenSupported and the user has not set a checksum value or algo
                     // we default to Crc32. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // we set the default. If it is WhenRequired and a checksum is required by the trait and the user has not
                     // set a checksum value or algo we also set the default. In all other cases we do nothing.
                     match (
                         request_checksum_calculation,
                         http_checksum_required,
                         user_set_checksum_value,
                         user_set_checksum_algo,
                         is_presigned_req,
                     ) {
                         (_, _, _, _, true) => {}
                         (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenSupported, _, false, false, _)

↧ Expand context

                         | (::aws_smithy_types::checksum_config::RequestChecksumCalculation::WhenRequired, true, false, false, _) => {
                             request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
-178
+                        }
                         _ => {}
-180
+                    }
-181
                     // We return a bool indicating if the user did set the checksum value, if they did
                     // we can short circuit and exit the interceptor early.
                     Ok(user_set_checksum_value)
                 },
             ))
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_object::PutObjectError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_object::PutObjectError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object::PutObjectError>::builder()
                     .transient_errors({

AWS SDK

Files changed: