AWS SDK

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

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

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

@@ -118,122 +292,352 @@

↥ 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("ListParts")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListPartsEndpointParamsInterceptor)
             .with_interceptor(crate::glacier_interceptors::GlacierAccountIdAutofillInterceptor::<
                 crate::operation::list_parts::ListPartsInput,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_parts::ListPartsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_parts::ListPartsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_parts::ListPartsError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct ListPartsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListPartsResponseDeserializer {
     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_list_parts::de_list_parts_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_list_parts::de_list_parts_http_response(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::list_parts::ListPartsError::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::list_parts::ListPartsError::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::list_parts::ListPartsError::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::list_parts::ListPartsError::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::list_parts::ListPartsError::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),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::list_parts::ListPartsError::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 {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, ListParts::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::list_parts::ListPartsOutput::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))
-+
+        }
-303
+    }
-304
+}
 #[derive(Debug)]
 struct ListPartsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListPartsRequestSerializer {
     #[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::list_parts::ListPartsInput>().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::list_parts::ListPartsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.account_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("account_id", "cannot be empty or unset"))?;
                 let account_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if account_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "account_id",
                         "cannot be empty or unset",
                     ));
--
+                }
                 let input_2 = &_input.vault_name;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("vault_name", "cannot be empty or unset"))?;
                 let vault_name = ::aws_smithy_http::label::fmt_string(input_2, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if vault_name.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "vault_name",
                         "cannot be empty or unset",
                     ));
--
+                }
                 let input_3 = &_input.upload_id;
                 let input_3 = input_3
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("upload_id", "cannot be empty or unset"))?;
                 let upload_id = ::aws_smithy_http::label::fmt_string(input_3, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if upload_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "upload_id",
                         "cannot be empty or unset",
                     ));
--
+                }
                 ::std::write!(
                     output,
                     "/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}",
                     accountId = account_id,
                     vaultName = vault_name,
                     uploadId = upload_id
--
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::list_parts::ListPartsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_4) = &_input.marker {
--
+                    {
                         query.push_kv("marker", &::aws_smithy_http::query::fmt_string(inner_4));
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_5) = &_input.limit {
--
+                    {
                         query.push_kv("limit", ::aws_smithy_types::primitive::Encoder::from(*inner_5).encode());
--
+                    }
--
+                }
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_parts::ListPartsInput,
                 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)?;
                 uri_query(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, ListParts::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-321
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-323
+    }
-324
+}
 #[derive(Debug)]
 struct ListPartsEndpointParamsInterceptor;
-327
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListPartsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListPartsEndpointParamsInterceptor"
-331
+    }
-332

↧ 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::<ListPartsInput>()
             .ok_or("failed to downcast to ListPartsInput")?;
-347
         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/list_parts/_list_parts_input.rs

@@ -22,22 +208,227 @@

↥ Expand context

-22
+    }
     /// <p>The name of the vault.</p>
     pub fn vault_name(&self) -> ::std::option::Option<&str> {
         self.vault_name.as_deref()
-26
+    }
     /// <p>The upload ID of the multipart upload.</p>
     pub fn upload_id(&self) -> ::std::option::Option<&str> {
         self.upload_id.as_deref()
-30
+    }
     /// <p>An opaque string used for pagination. This value specifies the part at which the listing of parts should begin. Get the marker value from the response of a previous List Parts response. You need only include the marker if you are continuing the pagination of results started in a previous List Parts request.</p>
     pub fn marker(&self) -> ::std::option::Option<&str> {
         self.marker.as_deref()
-34
+    }
     /// <p>The maximum number of parts to be returned. The default limit is 50. The number of parts returned might be fewer than the specified limit, but the number of returned parts never exceeds the limit.</p>
     pub fn limit(&self) -> ::std::option::Option<i32> {
         self.limit
-38
+    }
-39
+}
 static LISTPARTSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#ListPartsInput",

     "com.amazonaws.glacier.synthetic",
     "ListPartsInput",
 );
 static LISTPARTSINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsInput$accountId",
         "com.amazonaws.glacier.synthetic",
         "ListPartsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "accountId",
 ,
-54
+)
 .with_http_label();
 static LISTPARTSINPUT_MEMBER_VAULT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsInput$vaultName",
         "com.amazonaws.glacier.synthetic",
         "ListPartsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vault_name",
     "vaultName",
 ,
-65
+)
 .with_http_label();
 static LISTPARTSINPUT_MEMBER_UPLOAD_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsInput$uploadId",
         "com.amazonaws.glacier.synthetic",
         "ListPartsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "upload_id",
     "uploadId",
 ,
-76
+)
 .with_http_label();
 static LISTPARTSINPUT_MEMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsInput$marker",
         "com.amazonaws.glacier.synthetic",
         "ListPartsInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "marker",
 ,
-87
+)
 .with_http_query("marker");
 static LISTPARTSINPUT_MEMBER_LIMIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsInput$limit",
         "com.amazonaws.glacier.synthetic",
         "ListPartsInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "limit",
 ,
-98
+)
 .with_http_query("limit");
 static LISTPARTSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTPARTSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTPARTSINPUT_MEMBER_ACCOUNT_ID,
         &LISTPARTSINPUT_MEMBER_VAULT_NAME,
         &LISTPARTSINPUT_MEMBER_UPLOAD_ID,
         &LISTPARTSINPUT_MEMBER_MARKER,
         &LISTPARTSINPUT_MEMBER_LIMIT,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "GET",
     "/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}",
     None,
 ));
 impl ListPartsInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTPARTSINPUT_SCHEMA;
-119
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListPartsInput {
     #[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(&LISTPARTSINPUT_MEMBER_ACCOUNT_ID, val)?;
-128
+        }
         if let Some(ref val) = self.vault_name {
             ser.write_string(&LISTPARTSINPUT_MEMBER_VAULT_NAME, val)?;
-131
+        }
         if let Some(ref val) = self.upload_id {
             ser.write_string(&LISTPARTSINPUT_MEMBER_UPLOAD_ID, val)?;
-134
+        }
         if let Some(ref val) = self.marker {
             ser.write_string(&LISTPARTSINPUT_MEMBER_MARKER, val)?;
-137
+        }
         if let Some(ref val) = self.limit {
             ser.write_integer(&LISTPARTSINPUT_MEMBER_LIMIT, *val)?;
-140
+        }
         Ok(())
-142
+    }
-143
+}
 impl ListPartsInput {
     /// 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(&LISTPARTSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTPARTSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-162
+                }
                 Some(1) => {
                     builder.vault_name = Some(deser.read_string(member)?);
-165
+                }
                 Some(2) => {
                     builder.upload_id = Some(deser.read_string(member)?);
-168
+                }
                 Some(3) => {
                     builder.marker = Some(deser.read_string(member)?);
-171
+                }
                 Some(4) => {
                     builder.limit = Some(deser.read_integer(member)?);
-174
+                }
                 _ => {}
-176
+            }
             Ok(())
         })?;
         builder.account_id = builder.account_id.or(Some(String::new()));
         builder.vault_name = builder.vault_name.or(Some(String::new()));
         builder.upload_id = builder.upload_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-185
+    }
-186
+}
 impl ListPartsInput {
     /// 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 ListPartsInput {
     fn account_id_mut(&mut self) -> &mut Option<String> {
         &mut self.account_id
-201
+    }
-202
+}
 impl ListPartsInput {
     /// Creates a new builder-style object to manufacture [`ListPartsInput`](crate::operation::list_parts::ListPartsInput).
     pub fn builder() -> crate::operation::list_parts::builders::ListPartsInputBuilder {
         crate::operation::list_parts::builders::ListPartsInputBuilder::default()
-207
+    }

↧ Expand context

-208
+}
-209
 /// A builder for [`ListPartsInput`](crate::operation::list_parts::ListPartsInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListPartsInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) vault_name: ::std::option::Option<::std::string::String>,
     pub(crate) upload_id: ::std::option::Option<::std::string::String>,
     pub(crate) marker: ::std::option::Option<::std::string::String>,
     pub(crate) limit: ::std::option::Option<i32>,
-219
+}
 impl ListPartsInputBuilder {
     /// <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
-226
+    }
     /// <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>

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

@@ -37,37 +257,324 @@

↥ Expand context

     pub fn part_size_in_bytes(&self) -> i64 {
         self.part_size_in_bytes
-39
+    }
     /// <p>The UTC time at which the multipart upload was initiated.</p>
     pub fn creation_date(&self) -> ::std::option::Option<&str> {
         self.creation_date.as_deref()
-43
+    }
     /// <p>A list of the part sizes of the multipart upload. Each object in the array contains a <code>RangeBytes</code> and <code>sha256-tree-hash</code> name/value pair.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.parts.is_none()`.
     pub fn parts(&self) -> &[crate::types::PartListElement] {
         self.parts.as_deref().unwrap_or_default()
-49
+    }
     /// <p>An opaque string that represents where to continue pagination of the results. You use the marker in a new List Parts request to obtain more jobs in the list. If there are no more parts, this value is <code>null</code>.</p>
     pub fn marker(&self) -> ::std::option::Option<&str> {
         self.marker.as_deref()
-53
+    }
-54
+}
 static LISTPARTSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#ListPartsOutput",

     "com.amazonaws.glacier.synthetic",
     "ListPartsOutput",
 );
 static LISTPARTSOUTPUT_MEMBER_MULTIPART_UPLOAD_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsOutput$MultipartUploadId",
         "com.amazonaws.glacier.synthetic",
         "ListPartsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "multipart_upload_id",
     "MultipartUploadId",
 ,
 );
 static LISTPARTSOUTPUT_MEMBER_VAULT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsOutput$VaultARN",
         "com.amazonaws.glacier.synthetic",
         "ListPartsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vault_arn",
     "VaultARN",
 ,
 );
 static LISTPARTSOUTPUT_MEMBER_ARCHIVE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsOutput$ArchiveDescription",
         "com.amazonaws.glacier.synthetic",
         "ListPartsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "archive_description",
     "ArchiveDescription",
 ,
 );
 static LISTPARTSOUTPUT_MEMBER_PART_SIZE_IN_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsOutput$PartSizeInBytes",
         "com.amazonaws.glacier.synthetic",
         "ListPartsOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "part_size_in_bytes",
     "PartSizeInBytes",
 ,
 );
 static LISTPARTSOUTPUT_MEMBER_CREATION_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsOutput$CreationDate",
         "com.amazonaws.glacier.synthetic",
         "ListPartsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "creation_date",
     "CreationDate",
 ,
 );
 static LISTPARTSOUTPUT_MEMBER_PARTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsOutput$Parts",
         "com.amazonaws.glacier.synthetic",
         "ListPartsOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "parts",
     "Parts",
 ,
 );
 static LISTPARTSOUTPUT_MEMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListPartsOutput$Marker",
         "com.amazonaws.glacier.synthetic",
         "ListPartsOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "marker",
     "Marker",
 ,
 );
 static LISTPARTSOUTPUT_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 LISTPARTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTPARTSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTPARTSOUTPUT_MEMBER_MULTIPART_UPLOAD_ID,
         &LISTPARTSOUTPUT_MEMBER_VAULT_ARN,
         &LISTPARTSOUTPUT_MEMBER_ARCHIVE_DESCRIPTION,
         &LISTPARTSOUTPUT_MEMBER_PART_SIZE_IN_BYTES,
         &LISTPARTSOUTPUT_MEMBER_CREATION_DATE,
         &LISTPARTSOUTPUT_MEMBER_PARTS,
         &LISTPARTSOUTPUT_MEMBER_MARKER,
         &LISTPARTSOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ListPartsOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTPARTSOUTPUT_SCHEMA;
-154
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListPartsOutput {
     #[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.multipart_upload_id {
             ser.write_string(&LISTPARTSOUTPUT_MEMBER_MULTIPART_UPLOAD_ID, val)?;
-163
+        }
         if let Some(ref val) = self.vault_arn {
             ser.write_string(&LISTPARTSOUTPUT_MEMBER_VAULT_ARN, val)?;
-166
+        }
         if let Some(ref val) = self.archive_description {
             ser.write_string(&LISTPARTSOUTPUT_MEMBER_ARCHIVE_DESCRIPTION, val)?;
-169
+        }
-170
+        {
             let val = &self.part_size_in_bytes;
             ser.write_long(&LISTPARTSOUTPUT_MEMBER_PART_SIZE_IN_BYTES, *val)?;
-173
+        }
         if let Some(ref val) = self.creation_date {
             ser.write_string(&LISTPARTSOUTPUT_MEMBER_CREATION_DATE, val)?;
-176
+        }
         if let Some(ref val) = self.parts {
             ser.write_list(
                 &LISTPARTSOUTPUT_MEMBER_PARTS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::PartListElement::SCHEMA, item)?;
-183
+                    }
                     Ok(())
                 },
             )?;
-187
+        }
         if let Some(ref val) = self.marker {
             ser.write_string(&LISTPARTSOUTPUT_MEMBER_MARKER, val)?;
-190
+        }
         Ok(())
-192
+    }
-193
+}
 impl ListPartsOutput {
     /// 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(&LISTPARTSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.multipart_upload_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.vault_arn = Some(deser.read_string(member)?);
-+
+                }
                 Some(2) => {
                     builder.archive_description = Some(deser.read_string(member)?);
-+
+                }
                 Some(3) => {
                     builder.part_size_in_bytes = Some(deser.read_long(member)?);
-+
+                }
                 Some(4) => {
                     builder.creation_date = Some(deser.read_string(member)?);
-+
+                }
                 Some(5) => {
                     builder.parts = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::PartListElement::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(6) => {
                     builder.marker = Some(deser.read_string(member)?);
-+
+                }
                 Some(7) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl ListPartsOutput {
     /// 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());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&LISTPARTSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTPARTSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.multipart_upload_id = Some(deser.read_string(member)?);
-274
+                }
                 Some(1) => {
                     builder.vault_arn = Some(deser.read_string(member)?);
-277
+                }
                 Some(2) => {
                     builder.archive_description = Some(deser.read_string(member)?);
-280
+                }
                 Some(3) => {
                     builder.part_size_in_bytes = Some(deser.read_long(member)?);
-283
+                }
                 Some(4) => {
                     builder.creation_date = Some(deser.read_string(member)?);
-286
+                }
                 Some(5) => {
                     builder.parts = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::PartListElement::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::PartListElement::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-296
+                }
                 Some(6) => {
                     builder.marker = Some(deser.read_string(member)?);
-299
+                }
                 _ => {}
-301
+            }
             Ok(())
         })?;
         Ok(builder.build())

↧ Expand context

-305
+    }
-306
+}
 impl ::aws_types::request_id::RequestId for ListPartsOutput {
     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-310
+    }
-311
+}
 impl ListPartsOutput {
     /// Creates a new builder-style object to manufacture [`ListPartsOutput`](crate::operation::list_parts::ListPartsOutput).
     pub fn builder() -> crate::operation::list_parts::builders::ListPartsOutputBuilder {
         crate::operation::list_parts::builders::ListPartsOutputBuilder::default()
-316
+    }
-317
+}
-318
 /// A builder for [`ListPartsOutput`](crate::operation::list_parts::ListPartsOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListPartsOutputBuilder {
     pub(crate) multipart_upload_id: ::std::option::Option<::std::string::String>,
     pub(crate) vault_arn: ::std::option::Option<::std::string::String>,

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

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

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

@@ -121,126 +250,344 @@

↥ 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("ListProvisionedCapacity")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListProvisionedCapacityEndpointParamsInterceptor)
             .with_interceptor(crate::glacier_interceptors::GlacierAccountIdAutofillInterceptor::<
                 crate::operation::list_provisioned_capacity::ListProvisionedCapacityInput,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_provisioned_capacity::ListProvisionedCapacityError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_provisioned_capacity::ListProvisionedCapacityError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_provisioned_capacity::ListProvisionedCapacityError,
             >::new());
-148
         ::std::borrow::Cow::Owned(rcb)
-150
+    }
-151
+}
-152
 #[derive(Debug)]
 struct ListProvisionedCapacityResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListProvisionedCapacityResponseDeserializer {
     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_list_provisioned_capacity::de_list_provisioned_capacity_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_list_provisioned_capacity::de_list_provisioned_capacity_http_response(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::list_provisioned_capacity::ListProvisionedCapacityError::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::list_provisioned_capacity::ListProvisionedCapacityError::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),
                                 ))
-+
+                            }
                         };
         crate::protocol_serde::type_erase_result(parse_result)
                         tmp.meta = generic;
                         if tmp.message.is_none() {
                             tmp.message = _error_message;
-+
+                        }
                         tmp
                     })
-+
+                }
                 "MissingParameterValueException" => {
                     crate::operation::list_provisioned_capacity::ListProvisionedCapacityError::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
                     })
-+
+                }
                 "ServiceUnavailableException" => {
                     crate::operation::list_provisioned_capacity::ListProvisionedCapacityError::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::list_provisioned_capacity::ListProvisionedCapacityError::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 {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, ListProvisionedCapacity::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::list_provisioned_capacity::ListProvisionedCapacityOutput::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))
-+
+        }
-293
+    }
-294
+}
 #[derive(Debug)]
 struct ListProvisionedCapacityRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListProvisionedCapacityRequestSerializer {
     #[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::list_provisioned_capacity::ListProvisionedCapacityInput>()
             .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::list_provisioned_capacity::ListProvisionedCapacityInput,
                 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",
                     ));
--
+                }
                 ::std::write!(output, "/{accountId}/provisioned-capacity", accountId = account_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_provisioned_capacity::ListProvisionedCapacityInput,
                 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, ListProvisionedCapacity::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-313
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-315
+    }
-316
+}
 #[derive(Debug)]
 struct ListProvisionedCapacityEndpointParamsInterceptor;
-319
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListProvisionedCapacityEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListProvisionedCapacityEndpointParamsInterceptor"
-323
+    }
-324

↧ 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::<ListProvisionedCapacityInput>()
             .ok_or("failed to downcast to ListProvisionedCapacityInput")?;
-339
         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/list_provisioned_capacity/_list_provisioned_capacity_input.rs

@@ -1,1 +109,126 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ListProvisionedCapacityInput {
     /// <p>The AWS account ID of the account that owns the vault. You can either specify an AWS account ID or optionally a single '-' (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, don't include any hyphens ('-') in the ID.</p>
     pub account_id: ::std::option::Option<::std::string::String>,
-8
+}
 impl ListProvisionedCapacityInput {
     /// <p>The AWS account ID of the account that owns the vault. You can either specify an AWS account ID or optionally a single '-' (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, don't include any hyphens ('-') in the ID.</p>
     pub fn account_id(&self) -> ::std::option::Option<&str> {
         self.account_id.as_deref()
-13
+    }
-14
+}
 static LISTPROVISIONEDCAPACITYINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#ListProvisionedCapacityInput",

     "com.amazonaws.glacier.synthetic",
     "ListProvisionedCapacityInput",
 );
 static LISTPROVISIONEDCAPACITYINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListProvisionedCapacityInput$accountId",
         "com.amazonaws.glacier.synthetic",
         "ListProvisionedCapacityInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "accountId",
 ,
-29
+)
 .with_http_label();
 static LISTPROVISIONEDCAPACITYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTPROVISIONEDCAPACITYINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LISTPROVISIONEDCAPACITYINPUT_MEMBER_ACCOUNT_ID],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "GET",
     "/{accountId}/provisioned-capacity",
     None,
 ));
 impl ListProvisionedCapacityInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTPROVISIONEDCAPACITYINPUT_SCHEMA;
-44
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListProvisionedCapacityInput {
     #[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(&LISTPROVISIONEDCAPACITYINPUT_MEMBER_ACCOUNT_ID, val)?;
-53
+        }
         Ok(())
-55
+    }
-56
+}
 impl ListProvisionedCapacityInput {
     /// 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(&LISTPROVISIONEDCAPACITYINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTPROVISIONEDCAPACITYINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-75
+                }
                 _ => {}
-77
+            }
             Ok(())
         })?;
         builder.account_id = builder.account_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-84
+    }
-85
+}
 impl ListProvisionedCapacityInput {
     /// 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 ListProvisionedCapacityInput {
     fn account_id_mut(&mut self) -> &mut Option<String> {
         &mut self.account_id
-100
+    }
-101
+}
 impl ListProvisionedCapacityInput {
     /// Creates a new builder-style object to manufacture [`ListProvisionedCapacityInput`](crate::operation::list_provisioned_capacity::ListProvisionedCapacityInput).
     pub fn builder() -> crate::operation::list_provisioned_capacity::builders::ListProvisionedCapacityInputBuilder {
         crate::operation::list_provisioned_capacity::builders::ListProvisionedCapacityInputBuilder::default()
-106
+    }

↧ Expand context

-107
+}
-108
 /// A builder for [`ListProvisionedCapacityInput`](crate::operation::list_provisioned_capacity::ListProvisionedCapacityInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListProvisionedCapacityInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
-114
+}
 impl ListProvisionedCapacityInputBuilder {
     /// <p>The AWS account ID of the account that owns the vault. You can either specify an AWS account ID or optionally a single '-' (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, don't 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
-121
+    }
     /// <p>The AWS account ID of the account that owns the vault. You can either specify an AWS account ID or optionally a single '-' (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, don't 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
-126
+    }

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

@@ -1,1 +118,169 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(missing_docs)] // documentation missing in model
 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ListProvisionedCapacityOutput {
     /// <p>The response body contains the following JSON fields.</p>
     pub provisioned_capacity_list: ::std::option::Option<::std::vec::Vec<crate::types::ProvisionedCapacityDescription>>,
     _request_id: Option<String>,
-9
+}
 impl ListProvisionedCapacityOutput {
     /// <p>The response body contains the following JSON fields.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.provisioned_capacity_list.is_none()`.
     pub fn provisioned_capacity_list(&self) -> &[crate::types::ProvisionedCapacityDescription] {
         self.provisioned_capacity_list.as_deref().unwrap_or_default()
-16
+    }
-17
+}
 static LISTPROVISIONEDCAPACITYOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#ListProvisionedCapacityOutput",

     "com.amazonaws.glacier.synthetic",
     "ListProvisionedCapacityOutput",
 );
 static LISTPROVISIONEDCAPACITYOUTPUT_MEMBER_PROVISIONED_CAPACITY_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListProvisionedCapacityOutput$ProvisionedCapacityList",
         "com.amazonaws.glacier.synthetic",
         "ListProvisionedCapacityOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "provisioned_capacity_list",
     "ProvisionedCapacityList",
 ,
 );
 static LISTPROVISIONEDCAPACITYOUTPUT_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 LISTPROVISIONEDCAPACITYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTPROVISIONEDCAPACITYOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LISTPROVISIONEDCAPACITYOUTPUT_MEMBER_PROVISIONED_CAPACITY_LIST],
     &[
         &LISTPROVISIONEDCAPACITYOUTPUT_MEMBER_PROVISIONED_CAPACITY_LIST,
         &LISTPROVISIONEDCAPACITYOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl ListProvisionedCapacityOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTPROVISIONEDCAPACITYOUTPUT_SCHEMA;
-51
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListProvisionedCapacityOutput {
     #[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.provisioned_capacity_list {
             ser.write_list(
                 &LISTPROVISIONEDCAPACITYOUTPUT_MEMBER_PROVISIONED_CAPACITY_LIST,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ProvisionedCapacityDescription::SCHEMA, item)?;
-64
+                    }
                     Ok(())
                 },
             )?;
-68
+        }
         Ok(())
-70
+    }
-71
+}
 impl ListProvisionedCapacityOutput {
     /// 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(&LISTPROVISIONEDCAPACITYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.provisioned_capacity_list = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ProvisionedCapacityDescription::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl ListProvisionedCapacityOutput {
     /// 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());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&LISTPROVISIONEDCAPACITYOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTPROVISIONEDCAPACITYOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.provisioned_capacity_list = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             Vec::with_capacity(cap)
                         } else {
                             Vec::new()
                         };
                         deser.read_list(member, container, |mut list, deser| {
                             list.push(crate::types::ProvisionedCapacityDescription::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ProvisionedCapacityDescription::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-141
+                }
                 _ => {}
-143
+            }
             Ok(())
         })?;
         Ok(builder.build())
-147
+    }
-148
+}
 impl ::aws_types::request_id::RequestId for ListProvisionedCapacityOutput {

↧ Expand context

     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-152
+    }
-153
+}
 impl ListProvisionedCapacityOutput {
     /// Creates a new builder-style object to manufacture [`ListProvisionedCapacityOutput`](crate::operation::list_provisioned_capacity::ListProvisionedCapacityOutput).
     pub fn builder() -> crate::operation::list_provisioned_capacity::builders::ListProvisionedCapacityOutputBuilder {
         crate::operation::list_provisioned_capacity::builders::ListProvisionedCapacityOutputBuilder::default()
-158
+    }
-159
+}
-160
 /// A builder for [`ListProvisionedCapacityOutput`](crate::operation::list_provisioned_capacity::ListProvisionedCapacityOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListProvisionedCapacityOutputBuilder {
     pub(crate) provisioned_capacity_list: ::std::option::Option<::std::vec::Vec<crate::types::ProvisionedCapacityDescription>>,
     _request_id: Option<String>,
-167
+}
 impl ListProvisionedCapacityOutputBuilder {
     /// Appends an item to `provisioned_capacity_list`.

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

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

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

@@ -121,125 +267,361 @@

↥ 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("ListTagsForVault")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListTagsForVaultEndpointParamsInterceptor)
             .with_interceptor(crate::glacier_interceptors::GlacierAccountIdAutofillInterceptor::<
                 crate::operation::list_tags_for_vault::ListTagsForVaultInput,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_tags_for_vault::ListTagsForVaultError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_tags_for_vault::ListTagsForVaultError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_tags_for_vault::ListTagsForVaultError,
             >::new());
-147
         ::std::borrow::Cow::Owned(rcb)
-149
+    }
-150
+}
-151
 #[derive(Debug)]
 struct ListTagsForVaultResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListTagsForVaultResponseDeserializer {
     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_list_tags_for_vault::de_list_tags_for_vault_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_list_tags_for_vault::de_list_tags_for_vault_http_response(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::list_tags_for_vault::ListTagsForVaultError::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::list_tags_for_vault::ListTagsForVaultError::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::list_tags_for_vault::ListTagsForVaultError::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::list_tags_for_vault::ListTagsForVaultError::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),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ServiceUnavailableException" => crate::operation::list_tags_for_vault::ListTagsForVaultError::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::list_tags_for_vault::ListTagsForVaultError::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 {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, ListTagsForVault::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::list_tags_for_vault::ListTagsForVaultOutput::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))
-+
+        }
-310
+    }
-311
+}
 #[derive(Debug)]
 struct ListTagsForVaultRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListTagsForVaultRequestSerializer {
     #[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::list_tags_for_vault::ListTagsForVaultInput>()
             .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::list_tags_for_vault::ListTagsForVaultInput,
                 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}/tags",
                     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::list_tags_for_vault::ListTagsForVaultInput,
                 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, ListTagsForVault::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-330
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-332
+    }
-333
+}
 #[derive(Debug)]
 struct ListTagsForVaultEndpointParamsInterceptor;
-336
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListTagsForVaultEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListTagsForVaultEndpointParamsInterceptor"
-340
+    }
-341

↧ 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::<ListTagsForVaultInput>()
             .ok_or("failed to downcast to ListTagsForVaultInput")?;
-356
         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/list_tags_for_vault/_list_tags_for_vault_input.rs

@@ -4,4 +133,151 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct ListTagsForVaultInput {
     /// <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 ListTagsForVaultInput {
     /// <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 LISTTAGSFORVAULTINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#ListTagsForVaultInput",

     "com.amazonaws.glacier.synthetic",
     "ListTagsForVaultInput",
 );
 static LISTTAGSFORVAULTINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListTagsForVaultInput$accountId",
         "com.amazonaws.glacier.synthetic",
         "ListTagsForVaultInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "account_id",
     "accountId",
 ,
-36
+)
 .with_http_label();
 static LISTTAGSFORVAULTINPUT_MEMBER_VAULT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListTagsForVaultInput$vaultName",
         "com.amazonaws.glacier.synthetic",
         "ListTagsForVaultInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "vault_name",
     "vaultName",
 ,
-47
+)
 .with_http_label();
 static LISTTAGSFORVAULTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTTAGSFORVAULTINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LISTTAGSFORVAULTINPUT_MEMBER_ACCOUNT_ID, &LISTTAGSFORVAULTINPUT_MEMBER_VAULT_NAME],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "GET",
     "/{accountId}/vaults/{vaultName}/tags",
     None,
 ));
 impl ListTagsForVaultInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTTAGSFORVAULTINPUT_SCHEMA;
-62
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListTagsForVaultInput {
     #[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(&LISTTAGSFORVAULTINPUT_MEMBER_ACCOUNT_ID, val)?;
-71
+        }
         if let Some(ref val) = self.vault_name {
             ser.write_string(&LISTTAGSFORVAULTINPUT_MEMBER_VAULT_NAME, val)?;
-74
+        }
         Ok(())
-76
+    }
-77
+}
 impl ListTagsForVaultInput {
     /// 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(&LISTTAGSFORVAULTINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTTAGSFORVAULTINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.account_id = Some(deser.read_string(member)?);
-96
+                }
                 Some(1) => {
                     builder.vault_name = Some(deser.read_string(member)?);
-99
+                }
                 _ => {}
-101
+            }
             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() })
-109
+    }
-110
+}
 impl ListTagsForVaultInput {
     /// 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 ListTagsForVaultInput {
     fn account_id_mut(&mut self) -> &mut Option<String> {
         &mut self.account_id
-125
+    }
-126
+}
 impl ListTagsForVaultInput {
     /// Creates a new builder-style object to manufacture [`ListTagsForVaultInput`](crate::operation::list_tags_for_vault::ListTagsForVaultInput).
     pub fn builder() -> crate::operation::list_tags_for_vault::builders::ListTagsForVaultInputBuilder {
         crate::operation::list_tags_for_vault::builders::ListTagsForVaultInputBuilder::default()
-131
+    }

↧ Expand context

-132
+}
-133
 /// A builder for [`ListTagsForVaultInput`](crate::operation::list_tags_for_vault::ListTagsForVaultInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListTagsForVaultInputBuilder {
     pub(crate) account_id: ::std::option::Option<::std::string::String>,
     pub(crate) vault_name: ::std::option::Option<::std::string::String>,
-140
+}
 impl ListTagsForVaultInputBuilder {
     /// <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
-147
+    }
     /// <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/list_tags_for_vault/_list_tags_for_vault_output.rs

@@ -1,1 +119,153 @@

↥ 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 ListTagsForVaultOutput {
     /// <p>The tags attached to the vault. Each tag is composed of a key and a value.</p>
     pub tags: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     _request_id: Option<String>,
-10
+}
 impl ListTagsForVaultOutput {
     /// <p>The tags attached to the vault. Each tag is composed of a key and a value.</p>
     pub fn tags(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
         self.tags.as_ref()
-15
+    }
-16
+}
 static LISTTAGSFORVAULTOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.glacier.synthetic#ListTagsForVaultOutput",

     "com.amazonaws.glacier.synthetic",
     "ListTagsForVaultOutput",
 );
 static LISTTAGSFORVAULTOUTPUT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.glacier.synthetic#ListTagsForVaultOutput$Tags",
         "com.amazonaws.glacier.synthetic",
         "ListTagsForVaultOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "tags",
     "Tags",
 ,
 );
 static LISTTAGSFORVAULTOUTPUT_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 LISTTAGSFORVAULTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTTAGSFORVAULTOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&LISTTAGSFORVAULTOUTPUT_MEMBER_TAGS],
     &[&LISTTAGSFORVAULTOUTPUT_MEMBER_TAGS, &LISTTAGSFORVAULTOUTPUT_MEMBER__REQUEST_ID],
 );
 impl ListTagsForVaultOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTTAGSFORVAULTOUTPUT_SCHEMA;
-47
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListTagsForVaultOutput {
     #[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.tags {
             ser.write_map(
                 &LISTTAGSFORVAULTOUTPUT_MEMBER_TAGS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
-61
+                    }
                     Ok(())
                 },
             )?;
-65
+        }
         Ok(())
-67
+    }
-68
+}
 impl ListTagsForVaultOutput {
     /// 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(&LISTTAGSFORVAULTOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTTAGSFORVAULTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.tags = Some({
                         let container = if let Some(cap) = deser.container_size() {
                             std::collections::HashMap::with_capacity(cap)
                         } else {
                             std::collections::HashMap::new()
                         };
                         deser.read_map(member, container, |mut map, key, deser| {
                             map.insert(key, deser.read_string(member)?);
                             Ok(map)
                         })?
                     });
                     builder.tags = Some(deser.read_string_string_map(member)?);
-+
+                }
                 Some(1) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl ListTagsForVaultOutput {
     /// 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());
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&LISTTAGSFORVAULTOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.tags = Some(deser.read_string_string_map(member)?);
-124
+                }
                 _ => {}
-126
+            }
             Ok(())
         })?;
         Ok(builder.build())
-130
+    }
-131
+}
 impl ::aws_types::request_id::RequestId for ListTagsForVaultOutput {
     fn request_id(&self) -> Option<&str> {

↧ Expand context

         self._request_id.as_deref()
-135
+    }
-136
+}
 impl ListTagsForVaultOutput {
     /// Creates a new builder-style object to manufacture [`ListTagsForVaultOutput`](crate::operation::list_tags_for_vault::ListTagsForVaultOutput).
     pub fn builder() -> crate::operation::list_tags_for_vault::builders::ListTagsForVaultOutputBuilder {
         crate::operation::list_tags_for_vault::builders::ListTagsForVaultOutputBuilder::default()
-141
+    }
-142
+}
-143
 /// A builder for [`ListTagsForVaultOutput`](crate::operation::list_tags_for_vault::ListTagsForVaultOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct ListTagsForVaultOutputBuilder {
     pub(crate) tags: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
     _request_id: Option<String>,
-150
+}
 impl ListTagsForVaultOutputBuilder {
     /// Adds a key-value pair to `tags`.
     ///

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

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

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

@@ -118,122 +263,352 @@

↥ 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("ListVaults")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListVaultsEndpointParamsInterceptor)
             .with_interceptor(crate::glacier_interceptors::GlacierAccountIdAutofillInterceptor::<
                 crate::operation::list_vaults::ListVaultsInput,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_vaults::ListVaultsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::list_vaults::ListVaultsError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::list_vaults::ListVaultsError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct ListVaultsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListVaultsResponseDeserializer {
     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_list_vaults::de_list_vaults_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_list_vaults::de_list_vaults_http_response(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::list_vaults::ListVaultsError::unhandled(generic)),
                     ))
-+
+                }
             };
         crate::protocol_serde::type_erase_result(parse_result)
             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::list_vaults::ListVaultsError::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::list_vaults::ListVaultsError::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::list_vaults::ListVaultsError::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::list_vaults::ListVaultsError::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::list_vaults::ListVaultsError::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 {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, ListVaults::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::list_vaults::ListVaultsOutput::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))
-+
+        }
-303
+    }
-304
+}
 #[derive(Debug)]
 struct ListVaultsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListVaultsRequestSerializer {
     #[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::list_vaults::ListVaultsInput>().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::list_vaults::ListVaultsInput,
                 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",
                     ));
--
+                }
                 ::std::write!(output, "/{accountId}/vaults", accountId = account_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::list_vaults::ListVaultsInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_2) = &_input.marker {
--
+                    {
                         query.push_kv("marker", &::aws_smithy_http::query::fmt_string(inner_2));
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.limit {
--
+                    {
                         query.push_kv("limit", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
--
+                    }
--
+                }
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_vaults::ListVaultsInput,
                 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)?;
                 uri_query(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, ListVaults::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-321
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-323
+    }
-324
+}
 #[derive(Debug)]
 struct ListVaultsEndpointParamsInterceptor;
-327
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListVaultsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListVaultsEndpointParamsInterceptor"
-331
+    }
-332

↧ 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::<ListVaultsInput>()
             .ok_or("failed to downcast to ListVaultsInput")?;
-347
         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()))

AWS SDK

Files changed: