AWS SDK

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/get_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 `GetVaultNotifications`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetVaultNotifications;
 impl GetVaultNotifications {
     /// Creates a new `GetVaultNotifications`
     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::get_vault_notifications::GetVaultNotificationsInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::get_vault_notifications::GetVaultNotificationsOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::get_vault_notifications::GetVaultNotificationsInput,
     ) -> ::std::result::Result<
         crate::operation::get_vault_notifications::GetVaultNotificationsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::get_vault_notifications::GetVaultNotificationsError,
             ::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::get_vault_notifications::GetVaultNotificationsError>()
                     .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::get_vault_notifications::GetVaultNotificationsOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -121,125 +267,367 @@

↥ 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("GetVaultNotifications")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(GetVaultNotificationsEndpointParamsInterceptor)
             .with_interceptor(crate::glacier_interceptors::GlacierAccountIdAutofillInterceptor::<
                 crate::operation::get_vault_notifications::GetVaultNotificationsInput,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::get_vault_notifications::GetVaultNotificationsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::get_vault_notifications::GetVaultNotificationsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::get_vault_notifications::GetVaultNotificationsError,
             >::new());
-147
         ::std::borrow::Cow::Owned(rcb)
-149
+    }
-150
+}
-151
 #[derive(Debug)]
 struct GetVaultNotificationsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetVaultNotificationsResponseDeserializer {
     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 != 200 || force_error {
             crate::protocol_serde::shape_get_vault_notifications::de_get_vault_notifications_http_error(status, headers, body)
         if !success && status != 200 || 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::get_vault_notifications::GetVaultNotificationsError::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::get_vault_notifications::GetVaultNotificationsError::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::get_vault_notifications::GetVaultNotificationsError::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::get_vault_notifications::GetVaultNotificationsError::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::get_vault_notifications::GetVaultNotificationsError::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::get_vault_notifications::GetVaultNotificationsError::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_get_vault_notifications::de_get_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, GetVaultNotifications::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::get_vault_notifications::GetVaultNotificationsOutput::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 GetVaultNotificationsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetVaultNotificationsRequestSerializer {
     #[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::get_vault_notifications::GetVaultNotificationsInput>()
             .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::get_vault_notifications::GetVaultNotificationsInput,
                 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}/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::get_vault_notifications::GetVaultNotificationsInput,
                 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("GET").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, GetVaultNotifications::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-336
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-338
+    }
-339
+}
 #[derive(Debug)]
 struct GetVaultNotificationsEndpointParamsInterceptor;
-342
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetVaultNotificationsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "GetVaultNotificationsEndpointParamsInterceptor"
-346
+    }
-347

↧ 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::<GetVaultNotificationsInput>()
             .ok_or("failed to downcast to GetVaultNotificationsInput")?;
-362
         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/get_vault_notifications/_get_vault_notifications_input.rs

@@ -4,4 +136,154 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GetVaultNotificationsInput {
     /// <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 account_id: ::std::option::Option<::std::string::String>,
     /// <p>The name of the vault.</p>
     pub vault_name: ::std::option::Option<::std::string::String>,
-11
+}
 impl GetVaultNotificationsInput {
     /// <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()
-16
+    }
     /// <p>The name of the vault.</p>
     pub fn vault_name(&self) -> ::std::option::Option<&str> {
         self.vault_name.as_deref()
-20
+    }
-21
+}
 static GETVAULTNOTIFICATIONSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#GetVaultNotificationsInput",

     "com.amazonaws.glacier.synthetic",
     "GetVaultNotificationsInput",
 );
 static GETVAULTNOTIFICATIONSINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#GetVaultNotificationsInput$accountId",
         "com.amazonaws.glacier.synthetic",
         "GetVaultNotificationsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "accountId",
 ,
-36
+)
 .with_http_label();
 static GETVAULTNOTIFICATIONSINPUT_MEMBER_VAULT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#GetVaultNotificationsInput$vaultName",
         "com.amazonaws.glacier.synthetic",
         "GetVaultNotificationsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vault_name",
     "vaultName",
 ,
-47
+)
 .with_http_label();
 static GETVAULTNOTIFICATIONSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETVAULTNOTIFICATIONSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &GETVAULTNOTIFICATIONSINPUT_MEMBER_ACCOUNT_ID,
         &GETVAULTNOTIFICATIONSINPUT_MEMBER_VAULT_NAME,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "GET",
     "/{accountId}/vaults/{vaultName}/notification-configuration",
     None,
 ));
 impl GetVaultNotificationsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETVAULTNOTIFICATIONSINPUT_SCHEMA;
-65
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetVaultNotificationsInput {
     #[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(&GETVAULTNOTIFICATIONSINPUT_MEMBER_ACCOUNT_ID, val)?;
-74
+        }
         if let Some(ref val) = self.vault_name {
             ser.write_string(&GETVAULTNOTIFICATIONSINPUT_MEMBER_VAULT_NAME, val)?;
-77
+        }
         Ok(())
-79
+    }
-80
+}
 impl GetVaultNotificationsInput {
     /// 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(&GETVAULTNOTIFICATIONSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETVAULTNOTIFICATIONSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-99
+                }
                 Some(1) => {
                     builder.vault_name = Some(deser.read_string(member)?);
-102
+                }
                 _ => {}
-104
+            }
             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() })
-112
+    }
-113
+}
 impl GetVaultNotificationsInput {
     /// Deserializes this structure from a body deserializer and HTTP response.
     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> {
         Self::deserialize(deserializer)
-+
+    }
-+
+}
 impl crate::glacier_interceptors::GlacierAccountId for GetVaultNotificationsInput {
     fn account_id_mut(&mut self) -> &mut Option<String> {
         &mut self.account_id
-128
+    }
-129
+}
 impl GetVaultNotificationsInput {
     /// Creates a new builder-style object to manufacture [`GetVaultNotificationsInput`](crate::operation::get_vault_notifications::GetVaultNotificationsInput).
     pub fn builder() -> crate::operation::get_vault_notifications::builders::GetVaultNotificationsInputBuilder {
         crate::operation::get_vault_notifications::builders::GetVaultNotificationsInputBuilder::default()
-134
+    }

↧ Expand context

-135
+}
-136
 /// A builder for [`GetVaultNotificationsInput`](crate::operation::get_vault_notifications::GetVaultNotificationsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetVaultNotificationsInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) vault_name: ::std::option::Option<::std::string::String>,
-143
+}
 impl GetVaultNotificationsInputBuilder {
     /// <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());
         self
-150
+    }
     /// <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 set_account_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.account_id = input;
         self

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

@@ -1,1 +109,143 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /// <p>Contains the Amazon S3 Glacier response to your request.</p>
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct GetVaultNotificationsOutput {
     /// <p>Returns the notification configuration set on the vault.</p>
     pub vault_notification_config: ::std::option::Option<crate::types::VaultNotificationConfig>,
     _request_id: Option<String>,
-10
+}
 impl GetVaultNotificationsOutput {
     /// <p>Returns the notification configuration set on the vault.</p>
     pub fn vault_notification_config(&self) -> ::std::option::Option<&crate::types::VaultNotificationConfig> {
         self.vault_notification_config.as_ref()
-15
+    }
-16
+}
 static GETVAULTNOTIFICATIONSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#GetVaultNotificationsOutput",

     "com.amazonaws.glacier.synthetic",
     "GetVaultNotificationsOutput",
 );
 static GETVAULTNOTIFICATIONSOUTPUT_MEMBER_VAULT_NOTIFICATION_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#GetVaultNotificationsOutput$vaultNotificationConfig",
         "com.amazonaws.glacier.synthetic",
         "GetVaultNotificationsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "vault_notification_config",
     "vaultNotificationConfig",
 ,
-31
+)
 .with_http_payload();
 static GETVAULTNOTIFICATIONSOUTPUT_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 GETVAULTNOTIFICATIONSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     GETVAULTNOTIFICATIONSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&GETVAULTNOTIFICATIONSOUTPUT_MEMBER_VAULT_NOTIFICATION_CONFIG],
     &[
         &GETVAULTNOTIFICATIONSOUTPUT_MEMBER_VAULT_NOTIFICATION_CONFIG,
         &GETVAULTNOTIFICATIONSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl GetVaultNotificationsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETVAULTNOTIFICATIONSOUTPUT_SCHEMA;
-51
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for GetVaultNotificationsOutput {
     #[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_notification_config {
             ser.write_struct(&GETVAULTNOTIFICATIONSOUTPUT_MEMBER_VAULT_NOTIFICATION_CONFIG, val)?;
-60
+        }
         Ok(())
-62
+    }
-63
+}
 impl GetVaultNotificationsOutput {
     /// 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(&GETVAULTNOTIFICATIONSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&GETVAULTNOTIFICATIONSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.vault_notification_config = Some(crate::types::VaultNotificationConfig::deserialize(deser)?);
-82
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-87
+            }
             Ok(())
         })?;
         Ok(builder.build())
-91
+    }
-92
+}
 impl GetVaultNotificationsOutput {
     /// 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());
-+
+        }
         if !body.is_empty() {
             builder.vault_notification_config = Some(crate::types::VaultNotificationConfig::deserialize(deserializer)?);
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl ::aws_types::request_id::RequestId for GetVaultNotificationsOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-117
+    }
-118
+}
 impl GetVaultNotificationsOutput {
     /// Creates a new builder-style object to manufacture [`GetVaultNotificationsOutput`](crate::operation::get_vault_notifications::GetVaultNotificationsOutput).
     pub fn builder() -> crate::operation::get_vault_notifications::builders::GetVaultNotificationsOutputBuilder {
         crate::operation::get_vault_notifications::builders::GetVaultNotificationsOutputBuilder::default()
-123
+    }

↧ Expand context

-124
+}
-125
 /// A builder for [`GetVaultNotificationsOutput`](crate::operation::get_vault_notifications::GetVaultNotificationsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct GetVaultNotificationsOutputBuilder {
     pub(crate) vault_notification_config: ::std::option::Option<crate::types::VaultNotificationConfig>,
     _request_id: Option<String>,
-132
+}
 impl GetVaultNotificationsOutputBuilder {
     /// <p>Returns the notification configuration set on the vault.</p>
     pub fn vault_notification_config(mut self, input: crate::types::VaultNotificationConfig) -> Self {
         self.vault_notification_config = ::std::option::Option::Some(input);
         self
-138
+    }
     /// <p>Returns the notification configuration set on the vault.</p>
     pub fn set_vault_notification_config(mut self, input: ::std::option::Option<crate::types::VaultNotificationConfig>) -> Self {
         self.vault_notification_config = input;
         self
-143
+    }

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

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

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `InitiateJob`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct InitiateJob;
 impl InitiateJob {
     /// Creates a new `InitiateJob`
     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::initiate_job::InitiateJobInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::initiate_job::InitiateJobOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::initiate_job::InitiateJobInput,
     ) -> ::std::result::Result<
         crate::operation::initiate_job::InitiateJobOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::initiate_job::InitiateJobError,
             ::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::initiate_job::InitiateJobError>()
                     .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::initiate_job::InitiateJobOutput>()
                 .expect("correct output type"),
-42
+        )
-43
+    }
-44

@@ -118,122 +270,402 @@

↥ Expand context

-122
+    }
-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("InitiateJob")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(InitiateJobEndpointParamsInterceptor)
             .with_interceptor(crate::glacier_interceptors::GlacierAccountIdAutofillInterceptor::<
                 crate::operation::initiate_job::InitiateJobInput,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::initiate_job::InitiateJobError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::initiate_job::InitiateJobError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::initiate_job::InitiateJobError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct InitiateJobResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for InitiateJobResponseDeserializer {
     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 != 202 || force_error {
             crate::protocol_serde::shape_initiate_job::de_initiate_job_http_error(status, headers, body)
         if !success && status != 202 || 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::initiate_job::InitiateJobError::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 {
                 "InsufficientCapacityException" => crate::operation::initiate_job::InitiateJobError::InsufficientCapacityException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InsufficientCapacityException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InsufficientCapacityException::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
                 }),
                 "InvalidParameterValueException" => crate::operation::initiate_job::InitiateJobError::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::initiate_job::InitiateJobError::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
                 }),
                 "PolicyEnforcedException" => crate::operation::initiate_job::InitiateJobError::PolicyEnforcedException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::PolicyEnforcedException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::PolicyEnforcedException::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::initiate_job::InitiateJobError::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::initiate_job::InitiateJobError::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::initiate_job::InitiateJobError::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_initiate_job::de_initiate_job_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, InitiateJob::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::initiate_job::InitiateJobOutput::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))
-+
+        }
-351
+    }
-352
+}
 #[derive(Debug)]
 struct InitiateJobRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for InitiateJobRequestSerializer {
     #[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::initiate_job::InitiateJobInput>()
             .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::initiate_job::InitiateJobInput,
                 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}/jobs",
                     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::initiate_job::InitiateJobInput,
                 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("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/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_initiate_job_input::ser_job_parameters_http_payload(
             &input.job_parameters,
         )?);
         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);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, InitiateJob::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-373
+    }
-374
+}
 #[derive(Debug)]
 struct InitiateJobEndpointParamsInterceptor;
-377
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InitiateJobEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "InitiateJobEndpointParamsInterceptor"
-381
+    }
-382

↧ 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::<InitiateJobInput>()
             .ok_or("failed to downcast to InitiateJobInput")?;
-397
         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/initiate_job/_initiate_job_input.rs

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

↥ Expand context

     pub vault_name: ::std::option::Option<::std::string::String>,
     /// <p>Provides options for specifying job information.</p>
     pub job_parameters: ::std::option::Option<crate::types::JobParameters>,
-13
+}
 impl InitiateJobInput {
     /// <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 job information.</p>
     pub fn job_parameters(&self) -> ::std::option::Option<&crate::types::JobParameters> {
         self.job_parameters.as_ref()
-26
+    }
-27
+}
 static INITIATEJOBINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#InitiateJobInput",

     "com.amazonaws.glacier.synthetic",
     "InitiateJobInput",
 );
 static INITIATEJOBINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateJobInput$accountId",
         "com.amazonaws.glacier.synthetic",
         "InitiateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "accountId",
 ,
-42
+)
 .with_http_label();
 static INITIATEJOBINPUT_MEMBER_VAULT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateJobInput$vaultName",
         "com.amazonaws.glacier.synthetic",
         "InitiateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vault_name",
     "vaultName",
 ,
-53
+)
 .with_http_label();
 static INITIATEJOBINPUT_MEMBER_JOB_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateJobInput$jobParameters",
         "com.amazonaws.glacier.synthetic",
         "InitiateJobInput",
     ),
     ::aws_smithy_schema::ShapeType::Structure,
     "job_parameters",
     "jobParameters",
 ,
-64
+)
 .with_http_payload();
 static INITIATEJOBINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INITIATEJOBINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &INITIATEJOBINPUT_MEMBER_ACCOUNT_ID,
         &INITIATEJOBINPUT_MEMBER_VAULT_NAME,
         &INITIATEJOBINPUT_MEMBER_JOB_PARAMETERS,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/{accountId}/vaults/{vaultName}/jobs",
     Some(202),
 ));
 impl InitiateJobInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INITIATEJOBINPUT_SCHEMA;
-83
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for InitiateJobInput {
     #[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(&INITIATEJOBINPUT_MEMBER_ACCOUNT_ID, val)?;
-92
+        }
         if let Some(ref val) = self.vault_name {
             ser.write_string(&INITIATEJOBINPUT_MEMBER_VAULT_NAME, val)?;
-95
+        }
         if let Some(ref val) = self.job_parameters {
             ser.write_struct(&INITIATEJOBINPUT_MEMBER_JOB_PARAMETERS, val)?;
-98
+        }
         Ok(())
-100
+    }
-101
+}
 impl InitiateJobInput {
     /// 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(&INITIATEJOBINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INITIATEJOBINPUT_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.job_parameters = Some(crate::types::JobParameters::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 InitiateJobInput {
     /// 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.job_parameters = Some(crate::types::JobParameters::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 InitiateJobInput {
     fn account_id_mut(&mut self) -> &mut Option<String> {
         &mut self.account_id
-161
+    }
-162
+}

↧ Expand context

 impl InitiateJobInput {
     /// Creates a new builder-style object to manufacture [`InitiateJobInput`](crate::operation::initiate_job::InitiateJobInput).
     pub fn builder() -> crate::operation::initiate_job::builders::InitiateJobInputBuilder {
         crate::operation::initiate_job::builders::InitiateJobInputBuilder::default()
-167
+    }
-168
+}
-169
 /// A builder for [`InitiateJobInput`](crate::operation::initiate_job::InitiateJobInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct InitiateJobInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) vault_name: ::std::option::Option<::std::string::String>,
     pub(crate) job_parameters: ::std::option::Option<crate::types::JobParameters>,
-177
+}
 impl InitiateJobInputBuilder {
     /// <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/initiate_job/_initiate_job_output.rs

@@ -22,22 +159,197 @@

↥ Expand context

         self.job_id.as_deref()
-23
+    }
     /// <p>The path to the location of where the select results are stored.</p>
     pub fn job_output_path(&self) -> ::std::option::Option<&str> {
         self.job_output_path.as_deref()
-27
+    }
-28
+}
 static INITIATEJOBOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#InitiateJobOutput",
     "com.amazonaws.glacier.synthetic",
     "InitiateJobOutput",
 );
 static INITIATEJOBOUTPUT_MEMBER_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateJobOutput$location",
         "com.amazonaws.glacier.synthetic",
         "InitiateJobOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "location",

 ,
-43
+)
 .with_http_header("Location");
 static INITIATEJOBOUTPUT_MEMBER_JOB_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateJobOutput$jobId",
         "com.amazonaws.glacier.synthetic",
         "InitiateJobOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "job_id",
     "jobId",
 ,
-54
+)
 .with_http_header("x-amz-job-id");
 static INITIATEJOBOUTPUT_MEMBER_JOB_OUTPUT_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateJobOutput$jobOutputPath",
         "com.amazonaws.glacier.synthetic",
         "InitiateJobOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "job_output_path",
     "jobOutputPath",
 ,
-65
+)
 .with_http_header("x-amz-job-output-path");
 static INITIATEJOBOUTPUT_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 INITIATEJOBOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INITIATEJOBOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &INITIATEJOBOUTPUT_MEMBER_LOCATION,
         &INITIATEJOBOUTPUT_MEMBER_JOB_ID,
         &INITIATEJOBOUTPUT_MEMBER_JOB_OUTPUT_PATH,
         &INITIATEJOBOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl InitiateJobOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INITIATEJOBOUTPUT_SCHEMA;
-87
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for InitiateJobOutput {
     #[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(&INITIATEJOBOUTPUT_MEMBER_LOCATION, val)?;
-96
+        }
         if let Some(ref val) = self.job_id {
             ser.write_string(&INITIATEJOBOUTPUT_MEMBER_JOB_ID, val)?;
-99
+        }
         if let Some(ref val) = self.job_output_path {
             ser.write_string(&INITIATEJOBOUTPUT_MEMBER_JOB_OUTPUT_PATH, val)?;
-102
+        }
         Ok(())
-104
+    }
-105
+}
 impl InitiateJobOutput {
     /// 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(&INITIATEJOBOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INITIATEJOBOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.location = Some(deser.read_string(member)?);
-124
+                }
                 Some(1) => {
                     builder.job_id = Some(deser.read_string(member)?);
-127
+                }
                 Some(2) => {
                     builder.job_output_path = Some(deser.read_string(member)?);
-130
+                }
                 Some(3) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-135
+            }
             Ok(())
         })?;
         Ok(builder.build())
-139
+    }
-140
+}
 impl InitiateJobOutput {
     /// 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-job-id") {
             builder.job_id = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-job-output-path") {
             builder.job_output_path = 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 InitiateJobOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-171
+    }
-172
+}
 impl InitiateJobOutput {
     /// Creates a new builder-style object to manufacture [`InitiateJobOutput`](crate::operation::initiate_job::InitiateJobOutput).
     pub fn builder() -> crate::operation::initiate_job::builders::InitiateJobOutputBuilder {
         crate::operation::initiate_job::builders::InitiateJobOutputBuilder::default()
-177
+    }

↧ Expand context

-178
+}
-179
 /// A builder for [`InitiateJobOutput`](crate::operation::initiate_job::InitiateJobOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct InitiateJobOutputBuilder {
     pub(crate) location: ::std::option::Option<::std::string::String>,
     pub(crate) job_id: ::std::option::Option<::std::string::String>,
     pub(crate) job_output_path: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-188
+}
 impl InitiateJobOutputBuilder {
     /// <p>The relative URI path of the job.</p>
     pub fn location(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.location = ::std::option::Option::Some(input.into());
         self
-194
+    }
     /// <p>The relative URI path of the job.</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/initiate_multipart_upload.rs

@@ -1,1 +40,45 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Orchestration and serialization glue logic for `InitiateMultipartUpload`.
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct InitiateMultipartUpload;
 impl InitiateMultipartUpload {
     /// Creates a new `InitiateMultipartUpload`
     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::initiate_multipart_upload::InitiateMultipartUploadInput::SCHEMA;
     /// The schema for this operation's output shape.
     pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
         crate::operation::initiate_multipart_upload::InitiateMultipartUploadOutput::SCHEMA;
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::initiate_multipart_upload::InitiateMultipartUploadInput,
     ) -> ::std::result::Result<
         crate::operation::initiate_multipart_upload::InitiateMultipartUploadOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::initiate_multipart_upload::InitiateMultipartUploadError,
             ::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::initiate_multipart_upload::InitiateMultipartUploadError>()
                     .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::initiate_multipart_upload::InitiateMultipartUploadOutput>()
                 .expect("correct output type"),
-43
+        )
-44
+    }
-45

@@ -121,126 +268,370 @@

↥ Expand context

-126
+    }
-127
     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("InitiateMultipartUpload")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(InitiateMultipartUploadEndpointParamsInterceptor)
             .with_interceptor(crate::glacier_interceptors::GlacierAccountIdAutofillInterceptor::<
                 crate::operation::initiate_multipart_upload::InitiateMultipartUploadInput,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::initiate_multipart_upload::InitiateMultipartUploadError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::initiate_multipart_upload::InitiateMultipartUploadError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::initiate_multipart_upload::InitiateMultipartUploadError,
             >::new());
-148
         ::std::borrow::Cow::Owned(rcb)
-150
+    }
-151
+}
-152
 #[derive(Debug)]
 struct InitiateMultipartUploadResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for InitiateMultipartUploadResponseDeserializer {
     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_initiate_multipart_upload::de_initiate_multipart_upload_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::initiate_multipart_upload::InitiateMultipartUploadError::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::initiate_multipart_upload::InitiateMultipartUploadError::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::initiate_multipart_upload::InitiateMultipartUploadError::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::initiate_multipart_upload::InitiateMultipartUploadError::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::initiate_multipart_upload::InitiateMultipartUploadError::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::initiate_multipart_upload::InitiateMultipartUploadError::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_initiate_multipart_upload::de_initiate_multipart_upload_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, InitiateMultipartUpload::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::initiate_multipart_upload::InitiateMultipartUploadOutput::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))
-+
+        }
-319
+    }
-320
+}
 #[derive(Debug)]
 struct InitiateMultipartUploadRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for InitiateMultipartUploadRequestSerializer {
     #[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::initiate_multipart_upload::InitiateMultipartUploadInput>()
             .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::initiate_multipart_upload::InitiateMultipartUploadInput,
                 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}/multipart-uploads",
                     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::initiate_multipart_upload::InitiateMultipartUploadInput,
                 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_initiate_multipart_upload::ser_initiate_multipart_upload_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
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, InitiateMultipartUpload::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-339
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-341
+    }
-342
+}
 #[derive(Debug)]
 struct InitiateMultipartUploadEndpointParamsInterceptor;
-345
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InitiateMultipartUploadEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "InitiateMultipartUploadEndpointParamsInterceptor"
-349
+    }
-350

↧ 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::<InitiateMultipartUploadInput>()
             .ok_or("failed to downcast to InitiateMultipartUploadInput")?;
-365
         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/initiate_multipart_upload/_initiate_multipart_upload_input.rs

@@ -18,18 +181,232 @@

↥ Expand context

     /// <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()
-21
+    }
     /// <p>The name of the vault.</p>
     pub fn vault_name(&self) -> ::std::option::Option<&str> {
         self.vault_name.as_deref()
-25
+    }
     /// <p>The archive description that you are uploading in parts.</p>
     /// <p>The part size must be a megabyte (1024 KB) multiplied by a power of 2, for example 1048576 (1 MB), 2097152 (2 MB), 4194304 (4 MB), 8388608 (8 MB), and so on. The minimum allowable part size is 1 MB, and the maximum is 4 GB (4096 MB).</p>
     pub fn archive_description(&self) -> ::std::option::Option<&str> {
         self.archive_description.as_deref()
-30
+    }
     /// <p>The size of each part except the last, in bytes. The last part can be smaller than this part size.</p>
     pub fn part_size(&self) -> ::std::option::Option<&str> {
         self.part_size.as_deref()
-34
+    }
-35
+}
 static INITIATEMULTIPARTUPLOADINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#InitiateMultipartUploadInput",

     "com.amazonaws.glacier.synthetic",
     "InitiateMultipartUploadInput",
 );
 static INITIATEMULTIPARTUPLOADINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateMultipartUploadInput$accountId",
         "com.amazonaws.glacier.synthetic",
         "InitiateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "accountId",
 ,
-50
+)
 .with_http_label();
 static INITIATEMULTIPARTUPLOADINPUT_MEMBER_VAULT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateMultipartUploadInput$vaultName",
         "com.amazonaws.glacier.synthetic",
         "InitiateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vault_name",
     "vaultName",
 ,
-61
+)
 .with_http_label();
 static INITIATEMULTIPARTUPLOADINPUT_MEMBER_ARCHIVE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateMultipartUploadInput$archiveDescription",
         "com.amazonaws.glacier.synthetic",
         "InitiateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "archive_description",
     "archiveDescription",
 ,
-72
+)
 .with_http_header("x-amz-archive-description");
 static INITIATEMULTIPARTUPLOADINPUT_MEMBER_PART_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateMultipartUploadInput$partSize",
         "com.amazonaws.glacier.synthetic",
         "InitiateMultipartUploadInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "part_size",
     "partSize",
 ,
-83
+)
 .with_http_header("x-amz-part-size");
 static INITIATEMULTIPARTUPLOADINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INITIATEMULTIPARTUPLOADINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &INITIATEMULTIPARTUPLOADINPUT_MEMBER_ACCOUNT_ID,
         &INITIATEMULTIPARTUPLOADINPUT_MEMBER_VAULT_NAME,
         &INITIATEMULTIPARTUPLOADINPUT_MEMBER_ARCHIVE_DESCRIPTION,
         &INITIATEMULTIPARTUPLOADINPUT_MEMBER_PART_SIZE,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "POST",
     "/{accountId}/vaults/{vaultName}/multipart-uploads",
     Some(201),
 ));
 impl InitiateMultipartUploadInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INITIATEMULTIPARTUPLOADINPUT_SCHEMA;
-103
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for InitiateMultipartUploadInput {
     #[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(&INITIATEMULTIPARTUPLOADINPUT_MEMBER_ACCOUNT_ID, val)?;
-112
+        }
         if let Some(ref val) = self.vault_name {
             ser.write_string(&INITIATEMULTIPARTUPLOADINPUT_MEMBER_VAULT_NAME, val)?;
-115
+        }
         if let Some(ref val) = self.archive_description {
             ser.write_string(&INITIATEMULTIPARTUPLOADINPUT_MEMBER_ARCHIVE_DESCRIPTION, val)?;
-118
+        }
         if let Some(ref val) = self.part_size {
             ser.write_string(&INITIATEMULTIPARTUPLOADINPUT_MEMBER_PART_SIZE, val)?;
-121
+        }
         Ok(())
-123
+    }
-124
+}
 impl InitiateMultipartUploadInput {
     /// 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(&INITIATEMULTIPARTUPLOADINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INITIATEMULTIPARTUPLOADINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-143
+                }
                 Some(1) => {
                     builder.vault_name = Some(deser.read_string(member)?);
-146
+                }
                 Some(2) => {
                     builder.archive_description = Some(deser.read_string(member)?);
-149
+                }
                 Some(3) => {
                     builder.part_size = Some(deser.read_string(member)?);
-152
+                }
                 _ => {}
-154
+            }
             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 InitiateMultipartUploadInput {
     /// 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-part-size") {
             builder.part_size = Some(val.to_string());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&INITIATEMULTIPARTUPLOADINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.vault_name = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => { /* read from headers above */ }
                 Some(3) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-206
+    }
-207
+}
 impl crate::glacier_interceptors::GlacierAccountId for InitiateMultipartUploadInput {
     fn account_id_mut(&mut self) -> &mut Option<String> {
         &mut self.account_id
-211
+    }
-212
+}

↧ Expand context

 impl InitiateMultipartUploadInput {
     /// Creates a new builder-style object to manufacture [`InitiateMultipartUploadInput`](crate::operation::initiate_multipart_upload::InitiateMultipartUploadInput).
     pub fn builder() -> crate::operation::initiate_multipart_upload::builders::InitiateMultipartUploadInputBuilder {
         crate::operation::initiate_multipart_upload::builders::InitiateMultipartUploadInputBuilder::default()
-217
+    }
-218
+}
-219
 /// A builder for [`InitiateMultipartUploadInput`](crate::operation::initiate_multipart_upload::InitiateMultipartUploadInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct InitiateMultipartUploadInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) vault_name: ::std::option::Option<::std::string::String>,
     pub(crate) archive_description: ::std::option::Option<::std::string::String>,
     pub(crate) part_size: ::std::option::Option<::std::string::String>,
-228
+}
 impl InitiateMultipartUploadInputBuilder {
     /// <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 {

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

@@ -16,16 +135,170 @@

↥ Expand context

         self.location.as_deref()
-17
+    }
     /// <p>The ID of the multipart upload. This value is also included as part of the location.</p>
     pub fn upload_id(&self) -> ::std::option::Option<&str> {
         self.upload_id.as_deref()
-21
+    }
-22
+}
 static INITIATEMULTIPARTUPLOADOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#InitiateMultipartUploadOutput",
     "com.amazonaws.glacier.synthetic",
     "InitiateMultipartUploadOutput",
 );
 static INITIATEMULTIPARTUPLOADOUTPUT_MEMBER_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateMultipartUploadOutput$location",
         "com.amazonaws.glacier.synthetic",
         "InitiateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "location",

 ,
-37
+)
 .with_http_header("Location");
 static INITIATEMULTIPARTUPLOADOUTPUT_MEMBER_UPLOAD_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#InitiateMultipartUploadOutput$uploadId",
         "com.amazonaws.glacier.synthetic",
         "InitiateMultipartUploadOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "upload_id",
     "uploadId",
 ,
-48
+)
 .with_http_header("x-amz-multipart-upload-id");
 static INITIATEMULTIPARTUPLOADOUTPUT_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 INITIATEMULTIPARTUPLOADOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     INITIATEMULTIPARTUPLOADOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &INITIATEMULTIPARTUPLOADOUTPUT_MEMBER_LOCATION,
         &INITIATEMULTIPARTUPLOADOUTPUT_MEMBER_UPLOAD_ID,
         &INITIATEMULTIPARTUPLOADOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl InitiateMultipartUploadOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INITIATEMULTIPARTUPLOADOUTPUT_SCHEMA;
-69
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for InitiateMultipartUploadOutput {
     #[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(&INITIATEMULTIPARTUPLOADOUTPUT_MEMBER_LOCATION, val)?;
-78
+        }
         if let Some(ref val) = self.upload_id {
             ser.write_string(&INITIATEMULTIPARTUPLOADOUTPUT_MEMBER_UPLOAD_ID, val)?;
-81
+        }
         Ok(())
-83
+    }
-84
+}
 impl InitiateMultipartUploadOutput {
     /// 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(&INITIATEMULTIPARTUPLOADOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&INITIATEMULTIPARTUPLOADOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.location = Some(deser.read_string(member)?);
-103
+                }
                 Some(1) => {
                     builder.upload_id = Some(deser.read_string(member)?);
-106
+                }
                 Some(2) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-111
+            }
             Ok(())
         })?;
         Ok(builder.build())
-115
+    }
-116
+}
 impl InitiateMultipartUploadOutput {
     /// 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-multipart-upload-id") {
             builder.upload_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 InitiateMultipartUploadOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-144
+    }
-145
+}
 impl InitiateMultipartUploadOutput {
     /// Creates a new builder-style object to manufacture [`InitiateMultipartUploadOutput`](crate::operation::initiate_multipart_upload::InitiateMultipartUploadOutput).
     pub fn builder() -> crate::operation::initiate_multipart_upload::builders::InitiateMultipartUploadOutputBuilder {
         crate::operation::initiate_multipart_upload::builders::InitiateMultipartUploadOutputBuilder::default()
-150
+    }

↧ Expand context

-151
+}
-152
 /// A builder for [`InitiateMultipartUploadOutput`](crate::operation::initiate_multipart_upload::InitiateMultipartUploadOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct InitiateMultipartUploadOutputBuilder {
     pub(crate) location: ::std::option::Option<::std::string::String>,
     pub(crate) upload_id: ::std::option::Option<::std::string::String>,
     _request_id: Option<String>,
-160
+}
 impl InitiateMultipartUploadOutputBuilder {
     /// <p>The relative URI path of the multipart upload ID Amazon S3 Glacier created.</p>
     pub fn location(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.location = ::std::option::Option::Some(input.into());
         self
-166
+    }
     /// <p>The relative URI path of the multipart upload ID Amazon S3 Glacier created.</p>
     pub fn set_location(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         self.location = input;
         self

AWS SDK

Files changed: