AWS SDK

rev. c6b0442b38530d1e023b3a36621480dfe66ee6b5 (ignoring whitespace)

Files changed:

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

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

                 },
                 |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_object_acl::PutObjectAclError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_object_acl::PutObjectAclError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_acl::PutObjectAclError>::builder()
                     .transient_errors({

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_object_legal_hold.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_object_legal_hold::PutObjectLegalHoldError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_object_legal_hold::PutObjectLegalHoldError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_legal_hold::PutObjectLegalHoldError>::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_object_lock_configuration.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_object_lock_configuration::PutObjectLockConfigurationError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
                     crate::operation::put_object_lock_configuration::PutObjectLockConfigurationError,

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_object_retention.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_object_retention::PutObjectRetentionError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_object_retention::PutObjectRetentionError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_retention::PutObjectRetentionError>::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_object_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_object_tagging::PutObjectTaggingError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::put_object_tagging::PutObjectTaggingError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object_tagging::PutObjectTaggingError>::builder()
                     .transient_errors({

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_public_access_block.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_public_access_block::PutPublicAccessBlockError>::new())
 .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<crate::operation::put_public_access_block::PutPublicAccessBlockError>::new())
 .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_public_access_block::PutPublicAccessBlockError>::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/restore_object.rs

@@ -134,134 +194,194 @@

↥ 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;
-146
+                        }
-147
+                    }
-148
                     // 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();
-151
                     // 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);
-156
                     // From the httpChecksum trait
                     let http_checksum_required = false;
-159
                     let is_presigned_req = cfg.load::<crate::presigning::PresigningMarker>().is_some();
-161
                     // 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");
-177
+                        }
                         _ => {}
-179
+                    }
-180
                     // 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::restore_object::RestoreObjectError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::restore_object::RestoreObjectError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::restore_object::RestoreObjectError>::builder()
                     .transient_errors({

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part.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::upload_part::UploadPartError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::upload_part::UploadPartError,
             >::new())
             .with_retry_classifier(
                 ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::upload_part::UploadPartError>::builder()
                     .transient_errors({

Pages: 1 2