AWS SDK

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/set_vault_access_policy/_set_vault_access_policy_output.rs

@@ -1,1 +80,111 @@

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct SetVaultAccessPolicyOutput {
     _request_id: Option<String>,
-7
+}
 static SETVAULTACCESSPOLICYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#SetVaultAccessPolicyOutput",
     "com.amazonaws.glacier.synthetic",
     "SetVaultAccessPolicyOutput",
 );
 static SETVAULTACCESSPOLICYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(SETVAULTACCESSPOLICYOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static SETVAULTACCESSPOLICYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static SETVAULTACCESSPOLICYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SETVAULTACCESSPOLICYOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&SETVAULTACCESSPOLICYOUTPUT_MEMBER__REQUEST_ID],
 );
 impl SetVaultAccessPolicyOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SETVAULTACCESSPOLICYOUTPUT_SCHEMA;
-28
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SetVaultAccessPolicyOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-36
+    }
-37
+}
 impl SetVaultAccessPolicyOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&SETVAULTACCESSPOLICYOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SETVAULTACCESSPOLICYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-58
+            }
             Ok(())
         })?;
         Ok(builder.build())
-62
+    }
-63
+}
 impl SetVaultAccessPolicyOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl ::aws_types::request_id::RequestId for SetVaultAccessPolicyOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-85
+    }
-86
+}
 impl SetVaultAccessPolicyOutput {
     /// Creates a new builder-style object to manufacture [`SetVaultAccessPolicyOutput`](crate::operation::set_vault_access_policy::SetVaultAccessPolicyOutput).
     pub fn builder() -> crate::operation::set_vault_access_policy::builders::SetVaultAccessPolicyOutputBuilder {
         crate::operation::set_vault_access_policy::builders::SetVaultAccessPolicyOutputBuilder::default()
-91
+    }

↧ Expand context

-92
+}
-93
 /// A builder for [`SetVaultAccessPolicyOutput`](crate::operation::set_vault_access_policy::SetVaultAccessPolicyOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct SetVaultAccessPolicyOutputBuilder {
     _request_id: Option<String>,
-99
+}
 impl SetVaultAccessPolicyOutputBuilder {
     pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         self._request_id = Some(request_id.into());
         self
-104
+    }
-105
     pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         self._request_id = request_id;
         self
-109
+    }
     /// Consumes the builder and constructs a [`SetVaultAccessPolicyOutput`](crate::operation::set_vault_access_policy::SetVaultAccessPolicyOutput).
     pub fn build(self) -> crate::operation::set_vault_access_policy::SetVaultAccessPolicyOutput {

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/set_vault_notifications.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `SetVaultNotifications`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct SetVaultNotifications;
 impl SetVaultNotifications {
     /// Creates a new `SetVaultNotifications`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::set_vault_notifications::SetVaultNotificationsInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::set_vault_notifications::SetVaultNotificationsOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::set_vault_notifications::SetVaultNotificationsInput,
     ) -> ::std::result::Result<
         crate::operation::set_vault_notifications::SetVaultNotificationsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::set_vault_notifications::SetVaultNotificationsError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::set_vault_notifications::SetVaultNotificationsError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::set_vault_notifications::SetVaultNotificationsOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -121,125 +273,400 @@

↥ Expand context

-125
+    }
-126
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("SetVaultNotifications")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(SetVaultNotificationsEndpointParamsInterceptor)
             .with_interceptor(crate::glacier_interceptors::GlacierAccountIdAutofillInterceptor::<
                 crate::operation::set_vault_notifications::SetVaultNotificationsInput,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::set_vault_notifications::SetVaultNotificationsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::set_vault_notifications::SetVaultNotificationsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::set_vault_notifications::SetVaultNotificationsError,
             >::new());
-147
         ::std::borrow::Cow::Owned(rcb)
-149
+    }
-150
+}
-151
 #[derive(Debug)]
 struct SetVaultNotificationsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for SetVaultNotificationsResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_set_vault_notifications::de_set_vault_notifications_http_error(status, headers, body)
         if !success && status != 204 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::set_vault_notifications::SetVaultNotificationsError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InvalidParameterValueException" => {
                     crate::operation::set_vault_notifications::SetVaultNotificationsError::InvalidParameterValueException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidParameterValueException::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "MissingParameterValueException" => {
                     crate::operation::set_vault_notifications::SetVaultNotificationsError::MissingParameterValueException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::MissingParameterValueException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::MissingParameterValueException::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "ResourceNotFoundException" => crate::operation::set_vault_notifications::SetVaultNotificationsError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceUnavailableException" => {
                     crate::operation::set_vault_notifications::SetVaultNotificationsError::ServiceUnavailableException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::ServiceUnavailableException::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 _ => crate::operation::set_vault_notifications::SetVaultNotificationsError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_set_vault_notifications::de_set_vault_notifications_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, SetVaultNotifications::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::set_vault_notifications::SetVaultNotificationsOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-316
+    }
-317
+}
 #[derive(Debug)]
 struct SetVaultNotificationsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for SetVaultNotificationsRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::set_vault_notifications::SetVaultNotificationsInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::set_vault_notifications::SetVaultNotificationsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.account_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("account_id", "cannot be empty or unset"))?;
                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         if protocol.supports_http_bindings() {
             let mut request = protocol
                 .serialize_request(&input, SetVaultNotifications::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
+            {
                 let mut uri = "/{accountId}/vaults/{vaultName}/notification-configuration".to_string();
                 let mut query_params: Vec<(String, String)> = Vec::new();
                 if let Some(ref val) = input.account_id {
                     uri = uri.replace("{accountId}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
-342
+                }
                 let input_2 = &_input.vault_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
                 if let Some(ref val) = input.vault_name {
                     uri = uri.replace("{vaultName}", &::aws_smithy_schema::http_protocol::percent_encode(&val.to_string()));
-345
+                }
                 ::std::write!(
                     output,
                     "/{accountId}/vaults/{vaultName}/notification-configuration",
                     accountId = account_id,
                     vaultName = vault_name
--
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::set_vault_notifications::SetVaultNotificationsInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
                 if !query_params.is_empty() {
                     uri.push(if uri.contains('?') { '&' } else { '?' });
                     let pairs: Vec<String> = query_params
                         .iter()
                         .map(|(k, v)| {
                             format!(
                                 "{}={}",
                                 ::aws_smithy_schema::http_protocol::percent_encode(k),
                                 ::aws_smithy_schema::http_protocol::percent_encode(v)
-+
+                            )
                         })
                         .collect();
                     uri.push_str(&pairs.join("&"));
-+
+                }
                 request.set_uri(uri.as_str()).expect("valid URI");
-361
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(
             crate::protocol_serde::shape_set_vault_notifications_input::ser_vault_notification_config_http_payload(&input.vault_notification_config)?,
         );
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
-+
             return ::std::result::Result::Ok(request);
         } else {
             let mut request = protocol
                 .serialize_request(&input, SetVaultNotifications::INPUT_SCHEMA, "", _cfg)
                 .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
             return ::std::result::Result::Ok(request);
-370
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-371
+    }
-372
+}
 #[derive(Debug)]
 struct SetVaultNotificationsEndpointParamsInterceptor;
-375
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SetVaultNotificationsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "SetVaultNotificationsEndpointParamsInterceptor"
-379
+    }
-380

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<SetVaultNotificationsInput>()
             .ok_or("failed to downcast to SetVaultNotificationsInput")?;
-395
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/set_vault_notifications/_set_vault_notifications_input.rs

@@ -10,10 +155,182 @@

↥ Expand context

     pub vault_name: ::std::option::Option<::std::string::String>,
     /// <p>Provides options for specifying notification configuration.</p>
     pub vault_notification_config: ::std::option::Option<crate::types::VaultNotificationConfig>,
-13
+}
 impl SetVaultNotificationsInput {
     /// <p>The <code>AccountId</code> value is the AWS account ID of the account that owns the vault. You can either specify an AWS account ID or optionally a single '<code>-</code>' (hyphen), in which case Amazon S3 Glacier uses the AWS account ID associated with the credentials used to sign the request. If you use an account ID, do not include any hyphens ('-') in the ID.</p>
     pub fn account_id(&self) -> ::std::option::Option<&str> {
         self.account_id.as_deref()
-18
+    }
     /// <p>The name of the vault.</p>
     pub fn vault_name(&self) -> ::std::option::Option<&str> {
         self.vault_name.as_deref()
-22
+    }
     /// <p>Provides options for specifying notification configuration.</p>
     pub fn vault_notification_config(&self) -> ::std::option::Option<&crate::types::VaultNotificationConfig> {
         self.vault_notification_config.as_ref()
-26
+    }
-27
+}
 static SETVAULTNOTIFICATIONSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#SetVaultNotificationsInput",

     "com.amazonaws.glacier.synthetic",
     "SetVaultNotificationsInput",
 );
 static SETVAULTNOTIFICATIONSINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#SetVaultNotificationsInput$accountId",
         "com.amazonaws.glacier.synthetic",
         "SetVaultNotificationsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "accountId",
 ,
-42
+)
 .with_http_label();
 static SETVAULTNOTIFICATIONSINPUT_MEMBER_VAULT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#SetVaultNotificationsInput$vaultName",
         "com.amazonaws.glacier.synthetic",
         "SetVaultNotificationsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vault_name",
     "vaultName",
 ,
-53
+)
 .with_http_label();
 static SETVAULTNOTIFICATIONSINPUT_MEMBER_VAULT_NOTIFICATION_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#SetVaultNotificationsInput$vaultNotificationConfig",
         "com.amazonaws.glacier.synthetic",
         "SetVaultNotificationsInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "vault_notification_config",
     "vaultNotificationConfig",
 ,
-64
+)
 .with_http_payload();
 static SETVAULTNOTIFICATIONSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SETVAULTNOTIFICATIONSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &SETVAULTNOTIFICATIONSINPUT_MEMBER_ACCOUNT_ID,
         &SETVAULTNOTIFICATIONSINPUT_MEMBER_VAULT_NAME,
         &SETVAULTNOTIFICATIONSINPUT_MEMBER_VAULT_NOTIFICATION_CONFIG,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "PUT",
     "/{accountId}/vaults/{vaultName}/notification-configuration",
     Some(204),
 ));
 impl SetVaultNotificationsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SETVAULTNOTIFICATIONSINPUT_SCHEMA;
-83
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SetVaultNotificationsInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.account_id {
             ser.write_string(&SETVAULTNOTIFICATIONSINPUT_MEMBER_ACCOUNT_ID, val)?;
-92
+        }
         if let Some(ref val) = self.vault_name {
             ser.write_string(&SETVAULTNOTIFICATIONSINPUT_MEMBER_VAULT_NAME, val)?;
-95
+        }
         if let Some(ref val) = self.vault_notification_config {
             ser.write_struct(&SETVAULTNOTIFICATIONSINPUT_MEMBER_VAULT_NOTIFICATION_CONFIG, val)?;
-98
+        }
         Ok(())
-100
+    }
-101
+}
 impl SetVaultNotificationsInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&SETVAULTNOTIFICATIONSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SETVAULTNOTIFICATIONSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-120
+                }
                 Some(1) => {
                     builder.vault_name = Some(deser.read_string(member)?);
-123
+                }
                 Some(2) => {
                     builder.vault_notification_config = Some(crate::types::VaultNotificationConfig::deserialize(deser)?);
-126
+                }
                 _ => {}
-128
+            }
             Ok(())
         })?;
         builder.account_id = builder.account_id.or(Some(String::new()));
         builder.vault_name = builder.vault_name.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl SetVaultNotificationsInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         _headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if !body.is_empty() {
             builder.vault_notification_config = Some(crate::types::VaultNotificationConfig::deserialize(deserializer)?);
-+
+        }
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-156
+    }
-157
+}
 impl crate::glacier_interceptors::GlacierAccountId for SetVaultNotificationsInput {
     fn account_id_mut(&mut self) -> &mut Option<String> {
         &mut self.account_id
-161
+    }
-162
+}

↧ Expand context

 impl SetVaultNotificationsInput {
     /// Creates a new builder-style object to manufacture [`SetVaultNotificationsInput`](crate::operation::set_vault_notifications::SetVaultNotificationsInput).
     pub fn builder() -> crate::operation::set_vault_notifications::builders::SetVaultNotificationsInputBuilder {
         crate::operation::set_vault_notifications::builders::SetVaultNotificationsInputBuilder::default()
-167
+    }
-168
+}
-169
 /// A builder for [`SetVaultNotificationsInput`](crate::operation::set_vault_notifications::SetVaultNotificationsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct SetVaultNotificationsInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) vault_name: ::std::option::Option<::std::string::String>,
     pub(crate) vault_notification_config: ::std::option::Option<crate::types::VaultNotificationConfig>,
-177
+}
 impl SetVaultNotificationsInputBuilder {
     /// <p>The <code>AccountId</code> value is the AWS account ID of the account that owns the vault. You can either specify an AWS account ID or optionally a single '<code>-</code>' (hyphen), in which case Amazon S3 Glacier uses the AWS account ID associated with the credentials used to sign the request. If you use an account ID, do not include any hyphens ('-') in the ID.</p>
     /// This field is required.
     pub fn account_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.account_id = ::std::option::Option::Some(input.into());

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/set_vault_notifications/_set_vault_notifications_output.rs

@@ -1,1 +80,111 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct SetVaultNotificationsOutput {
     _request_id: Option<String>,
-7
+}
 static SETVAULTNOTIFICATIONSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#SetVaultNotificationsOutput",
     "com.amazonaws.glacier.synthetic",
     "SetVaultNotificationsOutput",
 );
 static SETVAULTNOTIFICATIONSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema =
     ::aws_smithy_schema::Schema::new_struct(SETVAULTNOTIFICATIONSOUTPUT_SCHEMA_ID, ::aws_smithy_schema::ShapeType::Structure, &[]);
 static SETVAULTNOTIFICATIONSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static SETVAULTNOTIFICATIONSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     SETVAULTNOTIFICATIONSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&SETVAULTNOTIFICATIONSOUTPUT_MEMBER__REQUEST_ID],
 );
 impl SetVaultNotificationsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SETVAULTNOTIFICATIONSOUTPUT_SCHEMA;
-28
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for SetVaultNotificationsOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         Ok(())
-36
+    }
-37
+}
 impl SetVaultNotificationsOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&SETVAULTNOTIFICATIONSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&SETVAULTNOTIFICATIONSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-58
+            }
             Ok(())
         })?;
         Ok(builder.build())
-62
+    }
-63
+}
 impl SetVaultNotificationsOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl ::aws_types::request_id::RequestId for SetVaultNotificationsOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-85
+    }
-86
+}
 impl SetVaultNotificationsOutput {
     /// Creates a new builder-style object to manufacture [`SetVaultNotificationsOutput`](crate::operation::set_vault_notifications::SetVaultNotificationsOutput).
     pub fn builder() -> crate::operation::set_vault_notifications::builders::SetVaultNotificationsOutputBuilder {
         crate::operation::set_vault_notifications::builders::SetVaultNotificationsOutputBuilder::default()
-91
+    }

↧ Expand context

-92
+}
-93
 /// A builder for [`SetVaultNotificationsOutput`](crate::operation::set_vault_notifications::SetVaultNotificationsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct SetVaultNotificationsOutputBuilder {
     _request_id: Option<String>,
-99
+}
 impl SetVaultNotificationsOutputBuilder {
     pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         self._request_id = Some(request_id.into());
         self
-104
+    }
-105
     pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         self._request_id = request_id;
         self
-109
+    }
     /// Consumes the builder and constructs a [`SetVaultNotificationsOutput`](crate::operation::set_vault_notifications::SetVaultNotificationsOutput).
     pub fn build(self) -> crate::operation::set_vault_notifications::SetVaultNotificationsOutput {

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/upload_archive.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `UploadArchive`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UploadArchive;
 impl UploadArchive {
     /// Creates a new `UploadArchive`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::upload_archive::UploadArchiveInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::upload_archive::UploadArchiveOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::upload_archive::UploadArchiveInput,
     ) -> ::std::result::Result<
         crate::operation::upload_archive::UploadArchiveOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::upload_archive::UploadArchiveError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::upload_archive::UploadArchiveError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::upload_archive::UploadArchiveOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -119,123 +270,385 @@

↥ Expand context

-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("UploadArchive")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UploadArchiveEndpointParamsInterceptor)
             .with_interceptor(crate::glacier_interceptors::GlacierAccountIdAutofillInterceptor::<
                 crate::operation::upload_archive::UploadArchiveInput,
             >::new())
             .with_interceptor(crate::glacier_interceptors::GlacierTreeHashHeaderInterceptor::default())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::upload_archive::UploadArchiveError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::upload_archive::UploadArchiveError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::upload_archive::UploadArchiveError,
             >::new());
-145
         ::std::borrow::Cow::Owned(rcb)
-147
+    }
-148
+}
-149
 #[derive(Debug)]
 struct UploadArchiveResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UploadArchiveResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 201 || force_error {
             crate::protocol_serde::shape_upload_archive::de_upload_archive_http_error(status, headers, body)
         if !success && status != 201 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::upload_archive::UploadArchiveError::unhandled(generic)),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InvalidParameterValueException" => crate::operation::upload_archive::UploadArchiveError::InvalidParameterValueException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidParameterValueException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "MissingParameterValueException" => crate::operation::upload_archive::UploadArchiveError::MissingParameterValueException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::MissingParameterValueException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::MissingParameterValueException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "RequestTimeoutException" => crate::operation::upload_archive::UploadArchiveError::RequestTimeoutException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::RequestTimeoutException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::RequestTimeoutException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::upload_archive::UploadArchiveError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceUnavailableException" => crate::operation::upload_archive::UploadArchiveError::ServiceUnavailableException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceUnavailableException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::upload_archive::UploadArchiveError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_upload_archive::de_upload_archive_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, UploadArchive::OUTPUT_SCHEMA, _cfg).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::upload_archive::UploadArchiveOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-328
+    }
-329
+}
 #[derive(Debug)]
 struct UploadArchiveRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UploadArchiveRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::upload_archive::UploadArchiveInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::upload_archive::UploadArchiveInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.account_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("account_id", "cannot be empty or unset"))?;
                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
--
+                }
                 let input_2 = &_input.vault_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
--
+                }
                 ::std::write!(
                     output,
                     "/{accountId}/vaults/{vaultName}/archives",
                     accountId = account_id,
                     vaultName = vault_name
--
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::upload_archive::UploadArchiveInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_upload_archive::ser_upload_archive_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
             builder
         };
         let body = crate::protocol_serde::shape_upload_archive_input::ser_body_http_payload(input.body)?.into_inner();
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, UploadArchive::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         // Streaming blob payload: replace the body with the raw ByteStream.
         *request.body_mut() = input.body.into_inner();
         request.headers_mut().insert("Content-Type", "application/octet-stream");
         if let ::std::option::Option::Some(content_length) = request.body().content_length() {
             request.headers_mut().insert("Content-Length", content_length.to_string());
-353
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
         return ::std::result::Result::Ok(request);
-356
+    }
-357
+}
 #[derive(Debug)]
 struct UploadArchiveEndpointParamsInterceptor;
-360
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UploadArchiveEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UploadArchiveEndpointParamsInterceptor"
-364
+    }
-365

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<UploadArchiveInput>()
             .ok_or("failed to downcast to UploadArchiveInput")?;
-380
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/upload_archive/_upload_archive_input.rs

@@ -22,22 +207,260 @@

↥ Expand context

-22
+    }
     /// <p>The <code>AccountId</code> value is the AWS account ID of the account that owns the vault. You can either specify an AWS account ID or optionally a single '<code>-</code>' (hyphen), in which case Amazon S3 Glacier uses the AWS account ID associated with the credentials used to sign the request. If you use an account ID, do not include any hyphens ('-') in the ID.</p>
     pub fn account_id(&self) -> ::std::option::Option<&str> {
         self.account_id.as_deref()
-26
+    }
     /// <p>The optional description of the archive you are uploading.</p>
     pub fn archive_description(&self) -> ::std::option::Option<&str> {
         self.archive_description.as_deref()
-30
+    }
     /// <p>The SHA256 tree hash of the data being uploaded.</p>
     pub fn checksum(&self) -> ::std::option::Option<&str> {
         self.checksum.as_deref()
-34
+    }
     /// <p>The data to upload.</p>
     pub fn body(&self) -> &::aws_smithy_types::byte_stream::ByteStream {
         &self.body
-38
+    }
-39
+}
 static UPLOADARCHIVEINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#UploadArchiveInput",

     "com.amazonaws.glacier.synthetic",
     "UploadArchiveInput",
 );
 static UPLOADARCHIVEINPUT_MEMBER_VAULT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#UploadArchiveInput$vaultName",
         "com.amazonaws.glacier.synthetic",
         "UploadArchiveInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vault_name",
     "vaultName",
 ,
-54
+)
 .with_http_label();
 static UPLOADARCHIVEINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#UploadArchiveInput$accountId",
         "com.amazonaws.glacier.synthetic",
         "UploadArchiveInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "accountId",
 ,
-65
+)
 .with_http_label();
 static UPLOADARCHIVEINPUT_MEMBER_ARCHIVE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#UploadArchiveInput$archiveDescription",
         "com.amazonaws.glacier.synthetic",
         "UploadArchiveInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "archive_description",
     "archiveDescription",
 ,
-76
+)
 .with_http_header("x-amz-archive-description");
 static UPLOADARCHIVEINPUT_MEMBER_CHECKSUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#UploadArchiveInput$checksum",
         "com.amazonaws.glacier.synthetic",
         "UploadArchiveInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum",
 ,
-87
+)
 .with_http_header("x-amz-sha256-tree-hash");
 static UPLOADARCHIVEINPUT_MEMBER_BODY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#UploadArchiveInput$body",
         "com.amazonaws.glacier.synthetic",
         "UploadArchiveInput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "body",
 ,
-98
+)
 .with_http_payload();
 static UPLOADARCHIVEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPLOADARCHIVEINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPLOADARCHIVEINPUT_MEMBER_VAULT_NAME,
         &UPLOADARCHIVEINPUT_MEMBER_ACCOUNT_ID,
         &UPLOADARCHIVEINPUT_MEMBER_ARCHIVE_DESCRIPTION,
         &UPLOADARCHIVEINPUT_MEMBER_CHECKSUM,
         &UPLOADARCHIVEINPUT_MEMBER_BODY,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/{accountId}/vaults/{vaultName}/archives",
     Some(201),
 ));
 impl UploadArchiveInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPLOADARCHIVEINPUT_SCHEMA;
-119
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UploadArchiveInput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.vault_name {
             ser.write_string(&UPLOADARCHIVEINPUT_MEMBER_VAULT_NAME, val)?;
-128
+        }
         if let Some(ref val) = self.account_id {
             ser.write_string(&UPLOADARCHIVEINPUT_MEMBER_ACCOUNT_ID, val)?;
-131
+        }
         if let Some(ref val) = self.archive_description {
             ser.write_string(&UPLOADARCHIVEINPUT_MEMBER_ARCHIVE_DESCRIPTION, val)?;
-134
+        }
         if let Some(ref val) = self.checksum {
             ser.write_string(&UPLOADARCHIVEINPUT_MEMBER_CHECKSUM, val)?;
-137
+        }
--
+        {
             let val = &self.body;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         Ok(())
-139
+    }
-140
+}
 impl UploadArchiveInput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UPLOADARCHIVEINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPLOADARCHIVEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.vault_name = Some(deser.read_string(member)?);
-159
+                }
                 Some(1) => {
                     builder.account_id = Some(deser.read_string(member)?);
-162
+                }
                 Some(2) => {
                     builder.archive_description = Some(deser.read_string(member)?);
-165
+                }
                 Some(3) => {
                     builder.checksum = Some(deser.read_string(member)?);
-168
+                }
                 Some(4) => {
                     builder.body = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-174
+                }
                 _ => {}
-176
+            }
             Ok(())
         })?;
         builder.vault_name = builder.vault_name.or(Some(String::new()));
         builder.account_id = builder.account_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl UploadArchiveInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-archive-description") {
             builder.archive_description = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-sha256-tree-hash") {
             builder.checksum = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UPLOADARCHIVEINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.vault_name = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.account_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => { /* read from headers above */ }
                 Some(3) => { /* read from headers above */ }
                 Some(4) => {
                     builder.body = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-234
+    }
-235
+}
 impl crate::glacier_interceptors::GlacierAccountId for UploadArchiveInput {
     fn account_id_mut(&mut self) -> &mut Option<String> {
         &mut self.account_id
-239
+    }
-240
+}

↧ Expand context

 impl UploadArchiveInput {
     /// Creates a new builder-style object to manufacture [`UploadArchiveInput`](crate::operation::upload_archive::UploadArchiveInput).
     pub fn builder() -> crate::operation::upload_archive::builders::UploadArchiveInputBuilder {
         crate::operation::upload_archive::builders::UploadArchiveInputBuilder::default()
-245
+    }
-246
+}
-247
 /// A builder for [`UploadArchiveInput`](crate::operation::upload_archive::UploadArchiveInput).
 #[derive(::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UploadArchiveInputBuilder {
     pub(crate) vault_name: ::std::option::Option<::std::string::String>,
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) archive_description: ::std::option::Option<::std::string::String>,
     pub(crate) checksum: ::std::option::Option<::std::string::String>,
     pub(crate) body: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
-257
+}
 impl UploadArchiveInputBuilder {
     /// <p>The name of the vault.</p>
     /// This field is required.

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/upload_archive/_upload_archive_output.rs

@@ -34,34 +160,198 @@

↥ Expand context

 );
 static UPLOADARCHIVEOUTPUT_MEMBER_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#UploadArchiveOutput$location",
         "com.amazonaws.glacier.synthetic",
         "UploadArchiveOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "location",
 ,
-44
+)
 .with_http_header("Location");
 static UPLOADARCHIVEOUTPUT_MEMBER_CHECKSUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#UploadArchiveOutput$checksum",
         "com.amazonaws.glacier.synthetic",
         "UploadArchiveOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum",

 ,
-55
+)
 .with_http_header("x-amz-sha256-tree-hash");
 static UPLOADARCHIVEOUTPUT_MEMBER_ARCHIVE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#UploadArchiveOutput$archiveId",
         "com.amazonaws.glacier.synthetic",
         "UploadArchiveOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "archive_id",
     "archiveId",
 ,
-66
+)
 .with_http_header("x-amz-archive-id");
 static UPLOADARCHIVEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
     ::aws_smithy_schema::ShapeType::String,
     "request_id",
 ,
-+
+)
 .with_http_header("x-amzn-requestid");
 static UPLOADARCHIVEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     UPLOADARCHIVEOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &UPLOADARCHIVEOUTPUT_MEMBER_LOCATION,
         &UPLOADARCHIVEOUTPUT_MEMBER_CHECKSUM,
         &UPLOADARCHIVEOUTPUT_MEMBER_ARCHIVE_ID,
         &UPLOADARCHIVEOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl UploadArchiveOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPLOADARCHIVEOUTPUT_SCHEMA;
-88
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for UploadArchiveOutput {
     #[allow(unused_variables, clippy::diverging_sub_expression)]
     fn serialize_members(
         &self,
         ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
     ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         if let Some(ref val) = self.location {
             ser.write_string(&UPLOADARCHIVEOUTPUT_MEMBER_LOCATION, val)?;
-97
+        }
         if let Some(ref val) = self.checksum {
             ser.write_string(&UPLOADARCHIVEOUTPUT_MEMBER_CHECKSUM, val)?;
-100
+        }
         if let Some(ref val) = self.archive_id {
             ser.write_string(&UPLOADARCHIVEOUTPUT_MEMBER_ARCHIVE_ID, val)?;
-103
+        }
         Ok(())
-105
+    }
-106
+}
 impl UploadArchiveOutput {
     /// Deserializes this structure from a [`ShapeDeserializer`].
     pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
         deserializer: &mut D,
     pub fn deserialize(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&UPLOADARCHIVEOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&UPLOADARCHIVEOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.location = Some(deser.read_string(member)?);
-125
+                }
                 Some(1) => {
                     builder.checksum = Some(deser.read_string(member)?);
-128
+                }
                 Some(2) => {
                     builder.archive_id = Some(deser.read_string(member)?);
-131
+                }
                 Some(3) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-136
+            }
             Ok(())
         })?;
         Ok(builder.build())
-140
+    }
-141
+}
 impl UploadArchiveOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("Location") {
             builder.location = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-sha256-tree-hash") {
             builder.checksum = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-archive-id") {
             builder.archive_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amzn-requestid") {
             builder._request_id = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl ::aws_types::request_id::RequestId for UploadArchiveOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-172
+    }
-173
+}
 impl UploadArchiveOutput {
     /// Creates a new builder-style object to manufacture [`UploadArchiveOutput`](crate::operation::upload_archive::UploadArchiveOutput).
     pub fn builder() -> crate::operation::upload_archive::builders::UploadArchiveOutputBuilder {
         crate::operation::upload_archive::builders::UploadArchiveOutputBuilder::default()
-178
+    }

↧ Expand context

-179
+}
-180
 /// A builder for [`UploadArchiveOutput`](crate::operation::upload_archive::UploadArchiveOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UploadArchiveOutputBuilder {
     pub(crate) location: ::std::option::Option<::std::string::String>,
     pub(crate) checksum: ::std::option::Option<::std::string::String>,
     pub(crate) archive_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-189
+}
 impl UploadArchiveOutputBuilder {
     /// <p>The relative URI path of the newly added archive resource.</p>
     pub fn location(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.location = ::std::option::Option::Some(input.into());
         self
-195
+    }
     /// <p>The relative URI path of the newly added archive resource.</p>
     pub fn set_location(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.location = input;

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/upload_multipart_part.rs

@@ -1,1 +40,44 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `UploadMultipartPart`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct UploadMultipartPart;
 impl UploadMultipartPart {
     /// Creates a new `UploadMultipartPart`
     pub fn new() -> Self {
         Self
-10
+    }
     /// The schema for this operation's input shape.
     pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::upload_multipart_part::UploadMultipartPartInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::upload_multipart_part::UploadMultipartPartOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::upload_multipart_part::UploadMultipartPartInput,
     ) -> ::std::result::Result<
         crate::operation::upload_multipart_part::UploadMultipartPartOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::upload_multipart_part::UploadMultipartPartError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >| {
             err.map_service_error(|err| {
                 err.downcast::<crate::operation::upload_multipart_part::UploadMultipartPartError>()
                     .expect("correct error type")
             })
         };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::upload_multipart_part::UploadMultipartPartOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -122,126 +285,396 @@

↥ Expand context

-126
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("UploadMultipartPart")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(UploadMultipartPartEndpointParamsInterceptor)
             .with_interceptor(crate::glacier_interceptors::GlacierAccountIdAutofillInterceptor::<
                 crate::operation::upload_multipart_part::UploadMultipartPartInput,
             >::new())
             .with_interceptor(crate::glacier_interceptors::GlacierTreeHashHeaderInterceptor::default())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::upload_multipart_part::UploadMultipartPartError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::upload_multipart_part::UploadMultipartPartError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::upload_multipart_part::UploadMultipartPartError,
             >::new());
-148
         ::std::borrow::Cow::Owned(rcb)
-150
+    }
-151
+}
-152
 #[derive(Debug)]
 struct UploadMultipartPartResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UploadMultipartPartResponseDeserializer {
     fn deserialize_nonstreaming(
     fn deserialize_nonstreaming_with_config(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         _cfg: &::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
         ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         let parse_result = if !success && status != 204 || force_error {
             crate::protocol_serde::shape_upload_multipart_part::de_upload_multipart_part_http_error(status, headers, body)
         if !success && status != 204 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::upload_multipart_part::UploadMultipartPartError::unhandled(generic),
                         ),
                     ))
-+
+                }
             };
             let _error_message = generic.message().map(|msg| msg.to_owned());
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let err = match error_code {
                 "InvalidParameterValueException" => {
                     crate::operation::upload_multipart_part::UploadMultipartPartError::InvalidParameterValueException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::InvalidParameterValueException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::InvalidParameterValueException::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "MissingParameterValueException" => {
                     crate::operation::upload_multipart_part::UploadMultipartPartError::MissingParameterValueException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::MissingParameterValueException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::MissingParameterValueException::deserialize_with_response(
                                     &mut *deser,
                                     response.headers(),
                                     response.status().into(),
                                     body,
-+
+                                )
                             }) {
                             ::std::result::Result::Ok(val) => val,
                             ::std::result::Result::Err(e) => {
                                 return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                     ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                                 ))
-+
+                            }
                         };
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "RequestTimeoutException" => crate::operation::upload_multipart_part::UploadMultipartPartError::RequestTimeoutException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::RequestTimeoutException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::RequestTimeoutException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::upload_multipart_part::UploadMultipartPartError::ResourceNotFoundException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceUnavailableException" => crate::operation::upload_multipart_part::UploadMultipartPartError::ServiceUnavailableException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceUnavailableException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceUnavailableException::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::upload_multipart_part::UploadMultipartPartError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_upload_multipart_part::de_upload_multipart_part_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, UploadMultipartPart::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::upload_multipart_part::UploadMultipartPartOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-339
+    }
-340
+}
 #[derive(Debug)]
 struct UploadMultipartPartRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UploadMultipartPartRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::upload_multipart_part::UploadMultipartPartInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::upload_multipart_part::UploadMultipartPartInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.account_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("account_id", "cannot be empty or unset"))?;
                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
--
+                }
                 let input_2 = &_input.vault_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
--
+                }
                 let input_3 = &_input.upload_id;
                 let input_3 = input_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("upload_id", "cannot be empty or unset"))?;
                 let upload_id = ::aws_smithy_http::label::fmt_string(input_3, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if upload_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "upload_id",
                         "cannot be empty or unset",
                     ));
--
+                }
                 ::std::write!(
                     output,
                     "/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}",
                     accountId = account_id,
                     vaultName = vault_name,
                     uploadId = upload_id
--
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::upload_multipart_part::UploadMultipartPartInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_upload_multipart_part::ser_upload_multipart_part_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
             builder
         };
         let body = crate::protocol_serde::shape_upload_multipart_part_input::ser_body_http_payload(input.body)?.into_inner();
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, UploadMultipartPart::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         // Streaming blob payload: replace the body with the raw ByteStream.
         *request.body_mut() = input.body.into_inner();
         request.headers_mut().insert("Content-Type", "application/octet-stream");
         if let ::std::option::Option::Some(content_length) = request.body().content_length() {
             request.headers_mut().insert("Content-Length", content_length.to_string());
-364
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
         return ::std::result::Result::Ok(request);
-367
+    }
-368
+}
 #[derive(Debug)]
 struct UploadMultipartPartEndpointParamsInterceptor;
-371
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UploadMultipartPartEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "UploadMultipartPartEndpointParamsInterceptor"
-375
+    }
-376

↧ Expand context

     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<UploadMultipartPartInput>()
             .ok_or("failed to downcast to UploadMultipartPartInput")?;
-391
         let params = crate::config::endpoint::Params::builder()
             .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
             .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
             .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
             .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))

1 1	`// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.`
2 2	`#[allow(missing_docs)] // documentation missing in model`

1 1	`// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.`
2 2	`#[allow(missing_docs)] // documentation missing in model`

AWS SDK

Files changed: