AWS SDK

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_get_item.rs

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

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

@@ -115,119 +242,401 @@

↥ Expand context

         });
-120
         ::std::option::Option::Some(cfg.freeze())
-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("BatchGetItem")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(BatchGetItemEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::batch_get_item::BatchGetItemError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::batch_get_item::BatchGetItemError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::batch_get_item::BatchGetItemError,
             >::new());
-141
         ::std::borrow::Cow::Owned(rcb)
-143
+    }
-144
+}
-145
 #[derive(Debug)]
 struct BatchGetItemResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for BatchGetItemResponseDeserializer {
     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_batch_get_item::de_batch_get_item_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::batch_get_item::BatchGetItemError::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 {
                 "InternalServerError" => crate::operation::batch_get_item::BatchGetItemError::InternalServerError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalServerError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalServerError::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
                 }),
                 "InvalidEndpointException" => crate::operation::batch_get_item::BatchGetItemError::InvalidEndpointException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidEndpointException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidEndpointException::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
                 }),
                 "ProvisionedThroughputExceededException" => {
                     crate::operation::batch_get_item::BatchGetItemError::ProvisionedThroughputExceededException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::ProvisionedThroughputExceededException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::ProvisionedThroughputExceededException::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
                     })
-+
+                }
                 "RequestLimitExceeded" => crate::operation::batch_get_item::BatchGetItemError::RequestLimitExceeded({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::RequestLimitExceeded::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::RequestLimitExceeded::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::batch_get_item::BatchGetItemError::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
                 }),
                 "ThrottlingException" => crate::operation::batch_get_item::BatchGetItemError::ThrottlingException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ThrottlingException::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::batch_get_item::BatchGetItemError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_batch_get_item::de_batch_get_item_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, BatchGetItem::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::batch_get_item::BatchGetItemOutput::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))
-+
+        }
-350
+    }
-351
+}
 #[derive(Debug)]
 struct BatchGetItemRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for BatchGetItemRequestSerializer {
     #[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::batch_get_item::BatchGetItemInput>()
             .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::batch_get_item::BatchGetItemInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::batch_get_item::BatchGetItemInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.BatchGetItem",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_batch_get_item::ser_batch_get_item_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, BatchGetItem::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-372
+    }
-373
+}
 #[derive(Debug)]
 struct BatchGetItemEndpointParamsInterceptor;
-376
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for BatchGetItemEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "BatchGetItemEndpointParamsInterceptor"
-380
+    }
-381

↧ 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::<BatchGetItemInput>()
             .ok_or("failed to downcast to BatchGetItemInput")?;
-396
         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/dynamodb/src/operation/batch_get_item/_batch_get_item_input.rs

@@ -104,104 +253,262 @@

↥ Expand context

     /// </ul>
     pub fn request_items(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::KeysAndAttributes>> {
         self.request_items.as_ref()
-107
+    }
     /// <p>Determines the level of detail about either provisioned or on-demand throughput consumption that is returned in the response:</p>
     /// <ul>
     /// <li>
     /// <p><code>INDEXES</code> - The response includes the aggregate <code>ConsumedCapacity</code> for the operation, together with <code>ConsumedCapacity</code> for each table and secondary index that was accessed.</p>
     /// <p>Note that some operations, such as <code>GetItem</code> and <code>BatchGetItem</code>, do not access any indexes at all. In these cases, specifying <code>INDEXES</code> will only return <code>ConsumedCapacity</code> information for table(s).</p></li>
     /// <li>
     /// <p><code>TOTAL</code> - The response includes only the aggregate <code>ConsumedCapacity</code> for the operation.</p></li>
     /// <li>
     /// <p><code>NONE</code> - No <code>ConsumedCapacity</code> details are included in the response.</p></li>
     /// </ul>
     pub fn return_consumed_capacity(&self) -> ::std::option::Option<&crate::types::ReturnConsumedCapacity> {
         self.return_consumed_capacity.as_ref()
-120
+    }
-121
+}
 static BATCHGETITEMINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#BatchGetItemInput",

     "com.amazonaws.dynamodb.synthetic",
     "BatchGetItemInput",
 );
 static BATCHGETITEMINPUT_MEMBER_REQUEST_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#BatchGetItemInput$RequestItems",
         "com.amazonaws.dynamodb.synthetic",
         "BatchGetItemInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "request_items",
     "RequestItems",
 ,
 );
 static BATCHGETITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#BatchGetItemInput$ReturnConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "BatchGetItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_consumed_capacity",
     "ReturnConsumedCapacity",
 ,
 );
 static BATCHGETITEMINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     BATCHGETITEMINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &BATCHGETITEMINPUT_MEMBER_REQUEST_ITEMS,
         &BATCHGETITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY,
     ],
 );
 impl BatchGetItemInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BATCHGETITEMINPUT_SCHEMA;
-158
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for BatchGetItemInput {
     #[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.request_items {
             ser.write_map(
                 &BATCHGETITEMINPUT_MEMBER_REQUEST_ITEMS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::KeysAndAttributes::SCHEMA, value)?;
-172
+                    }
                     Ok(())
                 },
             )?;
-176
+        }
         if let Some(ref val) = self.return_consumed_capacity {
             ser.write_string(&BATCHGETITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY, val.as_str())?;
-179
+        }
         Ok(())
-181
+    }
-182
+}
 impl BatchGetItemInput {
     /// 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(&BATCHGETITEMINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&BATCHGETITEMINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.request_items = 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, crate::types::KeysAndAttributes::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::KeysAndAttributes::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-208
+                }
                 Some(1) => {
                     builder.return_consumed_capacity = Some(crate::types::ReturnConsumedCapacity::from(deser.read_string(member)?.as_str()));
-211
+                }
                 _ => {}
-213
+            }
             Ok(())
         })?;
         builder.request_items = builder.request_items.or(Some(::std::collections::HashMap::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-220
+    }
-221
+}
 impl BatchGetItemInput {
     /// 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 BatchGetItemInput {
     /// Creates a new builder-style object to manufacture [`BatchGetItemInput`](crate::operation::batch_get_item::BatchGetItemInput).
     pub fn builder() -> crate::operation::batch_get_item::builders::BatchGetItemInputBuilder {
         crate::operation::batch_get_item::builders::BatchGetItemInputBuilder::default()
-237
+    }
-238
+}
-239
 /// A builder for [`BatchGetItemInput`](crate::operation::batch_get_item::BatchGetItemInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct BatchGetItemInputBuilder {
     pub(crate) request_items: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::KeysAndAttributes>>,
     pub(crate) return_consumed_capacity: ::std::option::Option<crate::types::ReturnConsumedCapacity>,
-246
+}
 impl BatchGetItemInputBuilder {
     /// Adds a key-value pair to `request_items`.
     ///
     /// To override the contents of this collection use [`set_request_items`](Self::set_request_items).
     ///
     /// <p>A map of one or more table names or table ARNs and, for each table, a map that describes one or more items to retrieve from that table. Each table name or ARN can be used only once per <code>BatchGetItem</code> request.</p>
     /// <p>Each element in the map of items to retrieve consists of the following:</p>
     /// <ul>
     /// <li>
     /// <p><code>ConsistentRead</code> - If <code>true</code>, a strongly consistent read is used; if <code>false</code> (the default), an eventually consistent read is used.</p></li>
     /// <li>
     /// <p><code>ExpressionAttributeNames</code> - One or more substitution tokens for attribute names in the <code>ProjectionExpression</code> parameter. The following are some use cases for using <code>ExpressionAttributeNames</code>:</p>
     /// <ul>
     /// <li>
     /// <p>To access an attribute whose name conflicts with a DynamoDB reserved word.</p></li>
     /// <li>

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_get_item/_batch_get_item_output.rs

@@ -59,59 +251,362 @@

↥ Expand context

     /// <p>If there are no unprocessed keys remaining, the response contains an empty <code>UnprocessedKeys</code> map.</p>
     pub fn unprocessed_keys(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::KeysAndAttributes>> {
         self.unprocessed_keys.as_ref()
-62
+    }
     /// <p>The read capacity units consumed by the entire <code>BatchGetItem</code> operation.</p>
     /// <p>Each element consists of:</p>
     /// <ul>
     /// <li>
     /// <p><code>TableName</code> - The table that consumed the provisioned throughput.</p></li>
     /// <li>
     /// <p><code>CapacityUnits</code> - The total number of capacity units consumed.</p></li>
     /// </ul>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.consumed_capacity.is_none()`.
     pub fn consumed_capacity(&self) -> &[crate::types::ConsumedCapacity] {
         self.consumed_capacity.as_deref().unwrap_or_default()
-75
+    }
-76
+}
 static BATCHGETITEMOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#BatchGetItemOutput",

     "com.amazonaws.dynamodb.synthetic",
     "BatchGetItemOutput",
 );
 static BATCHGETITEMOUTPUT_MEMBER_RESPONSES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#BatchGetItemOutput$Responses",
         "com.amazonaws.dynamodb.synthetic",
         "BatchGetItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "responses",
     "Responses",
 ,
 );
 static BATCHGETITEMOUTPUT_MEMBER_UNPROCESSED_KEYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#BatchGetItemOutput$UnprocessedKeys",
         "com.amazonaws.dynamodb.synthetic",
         "BatchGetItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "unprocessed_keys",
     "UnprocessedKeys",
 ,
 );
 static BATCHGETITEMOUTPUT_MEMBER_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#BatchGetItemOutput$ConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "BatchGetItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "consumed_capacity",
     "ConsumedCapacity",
 ,
 );
 static BATCHGETITEMOUTPUT_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 BATCHGETITEMOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     BATCHGETITEMOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &BATCHGETITEMOUTPUT_MEMBER_RESPONSES,
         &BATCHGETITEMOUTPUT_MEMBER_UNPROCESSED_KEYS,
         &BATCHGETITEMOUTPUT_MEMBER_CONSUMED_CAPACITY,
         &BATCHGETITEMOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl BatchGetItemOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BATCHGETITEMOUTPUT_SCHEMA;
-132
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for BatchGetItemOutput {
     #[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.responses {
             ser.write_map(
                 &BATCHGETITEMOUTPUT_MEMBER_RESPONSES,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
-+
                         ser.write_list(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for item in value {
                                     ser.write_map(
                                         &::aws_smithy_schema::prelude::DOCUMENT,
                                         &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                             for (key, value) in item {
                                                 ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                                                 ser.write_struct(crate::types::AttributeValue::SCHEMA, value)?;
-+
+                                            }
                                             Ok(())
                                         },
                                     )?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-164
+                    }
                     Ok(())
                 },
             )?;
-168
+        }
         if let Some(ref val) = self.unprocessed_keys {
             ser.write_map(
                 &BATCHGETITEMOUTPUT_MEMBER_UNPROCESSED_KEYS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         ser.write_struct(crate::types::KeysAndAttributes::SCHEMA, value)?;
-176
+                    }
                     Ok(())
                 },
             )?;
-180
+        }
         if let Some(ref val) = self.consumed_capacity {
             ser.write_list(
                 &BATCHGETITEMOUTPUT_MEMBER_CONSUMED_CAPACITY,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ConsumedCapacity::SCHEMA, item)?;
-187
+                    }
                     Ok(())
                 },
             )?;
-191
+        }
         Ok(())
-193
+    }
-194
+}
 impl BatchGetItemOutput {
     /// 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(&BATCHGETITEMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.responses = Some({
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, {
                                 let mut list = Vec::new();
                                 deser.read_list(member, &mut |deser| {
                                     list.push({
                                         let mut map = ::std::collections::HashMap::new();
                                         deser.read_map(member, &mut |key, deser| {
                                             let value = crate::types::AttributeValue::deserialize(deser)?;
                                             map.insert(key, value);
                                             Ok(())
                                         })?;
                                         map
                                     });
                                     Ok(())
                                 })?;
                                 list
                             });
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder.unprocessed_keys = Some({
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::KeysAndAttributes::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(2) => {
                     builder.consumed_capacity = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ConsumedCapacity::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(3) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl BatchGetItemOutput {
     /// 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(&BATCHGETITEMOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&BATCHGETITEMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.responses = 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, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, {
                                 let mut list = Vec::new();
                                 deser.read_list(member, &mut |deser| {
                                     list.push({
                                         let mut map = ::std::collections::HashMap::new();
                                         deser.read_map(member, &mut |key, deser| {
                                             let value = crate::types::AttributeValue::deserialize(deser)?;
                                             map.insert(key, value);
                                             Ok(())
                                         })?;
                                         map
                                     });
                                     Ok(())
                                 })?;
                                 list
                             });
                             Ok(())
                         })?;
                         container
                     });
-314
+                }
                 Some(1) => {
                     builder.unprocessed_keys = 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, crate::types::KeysAndAttributes::deserialize(deser)?);
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, crate::types::KeysAndAttributes::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-324
+                }
                 Some(2) => {
                     builder.consumed_capacity = 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::ConsumedCapacity::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ConsumedCapacity::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-334
+                }
                 _ => {}
-336
+            }
             Ok(())
         })?;
         Ok(builder.build())
-340
+    }
-341
+}
 impl ::aws_types::request_id::RequestId for BatchGetItemOutput {

↧ Expand context

     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-345
+    }
-346
+}
 impl BatchGetItemOutput {
     /// Creates a new builder-style object to manufacture [`BatchGetItemOutput`](crate::operation::batch_get_item::BatchGetItemOutput).
     pub fn builder() -> crate::operation::batch_get_item::builders::BatchGetItemOutputBuilder {
         crate::operation::batch_get_item::builders::BatchGetItemOutputBuilder::default()
-351
+    }
-352
+}
-353
 /// A builder for [`BatchGetItemOutput`](crate::operation::batch_get_item::BatchGetItemOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct BatchGetItemOutputBuilder {
     pub(crate) responses: ::std::option::Option<
         ::std::collections::HashMap<
             ::std::string::String,
             ::std::vec::Vec<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>,
         >,

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_write_item.rs

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

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

@@ -118,122 +245,458 @@

↥ Expand context

         });
-123
         ::std::option::Option::Some(cfg.freeze())
-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("BatchWriteItem")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(BatchWriteItemEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::batch_write_item::BatchWriteItemError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::batch_write_item::BatchWriteItemError,
             >::new())
             .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<

                 crate::operation::batch_write_item::BatchWriteItemError,
             >::new());
-144
         ::std::borrow::Cow::Owned(rcb)
-146
+    }
-147
+}
-148
 #[derive(Debug)]
 struct BatchWriteItemResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for BatchWriteItemResponseDeserializer {
     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_batch_write_item::de_batch_write_item_http_error(status, headers, body)
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
             let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::batch_write_item::BatchWriteItemError::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 {
                 "InternalServerError" => crate::operation::batch_write_item::BatchWriteItemError::InternalServerError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InternalServerError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InternalServerError::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
                 }),
                 "InvalidEndpointException" => crate::operation::batch_write_item::BatchWriteItemError::InvalidEndpointException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::InvalidEndpointException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::InvalidEndpointException::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
                 }),
                 "ItemCollectionSizeLimitExceededException" => {
                     crate::operation::batch_write_item::BatchWriteItemError::ItemCollectionSizeLimitExceededException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::ItemCollectionSizeLimitExceededException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::ItemCollectionSizeLimitExceededException::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
                     })
-+
+                }
                 "ProvisionedThroughputExceededException" => {
                     crate::operation::batch_write_item::BatchWriteItemError::ProvisionedThroughputExceededException({
                         let mut tmp = match protocol
                             .deserialize_response(response, crate::types::error::ProvisionedThroughputExceededException::SCHEMA, _cfg)
                             .and_then(|mut deser| {
                                 crate::types::error::ProvisionedThroughputExceededException::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
                     })
-+
+                }
                 "ReplicatedWriteConflictException" => crate::operation::batch_write_item::BatchWriteItemError::ReplicatedWriteConflictException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ReplicatedWriteConflictException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ReplicatedWriteConflictException::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
                 }),
                 "RequestLimitExceeded" => crate::operation::batch_write_item::BatchWriteItemError::RequestLimitExceeded({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::RequestLimitExceeded::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::RequestLimitExceeded::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::batch_write_item::BatchWriteItemError::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
                 }),
                 "ThrottlingException" => crate::operation::batch_write_item::BatchWriteItemError::ThrottlingException({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ThrottlingException::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ThrottlingException::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::batch_write_item::BatchWriteItemError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             crate::protocol_serde::shape_batch_write_item::de_batch_write_item_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, BatchWriteItem::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::batch_write_item::BatchWriteItemOutput::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))
-+
+        }
-407
+    }
-408
+}
 #[derive(Debug)]
 struct BatchWriteItemRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for BatchWriteItemRequestSerializer {
     #[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::batch_write_item::BatchWriteItemInput>()
             .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::batch_write_item::BatchWriteItemInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::batch_write_item::BatchWriteItemInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http_1x::header::HeaderName::from_static("x-amz-target"),
                 "DynamoDB_20120810.BatchWriteItem",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_batch_write_item::ser_batch_write_item_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, BatchWriteItem::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-429
+    }
-430
+}
 #[derive(Debug)]
 struct BatchWriteItemEndpointParamsInterceptor;
-433
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for BatchWriteItemEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "BatchWriteItemEndpointParamsInterceptor"
-437
+    }
-438

↧ 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::<BatchWriteItemInput>()
             .ok_or("failed to downcast to BatchWriteItemInput")?;
-453
         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/dynamodb/src/operation/batch_write_item/_batch_write_item_input.rs

@@ -60,60 +227,252 @@

↥ Expand context

     /// <p>Determines the level of detail about either provisioned or on-demand throughput consumption that is returned in the response:</p>
     /// <ul>
     /// <li>
     /// <p><code>INDEXES</code> - The response includes the aggregate <code>ConsumedCapacity</code> for the operation, together with <code>ConsumedCapacity</code> for each table and secondary index that was accessed.</p>
     /// <p>Note that some operations, such as <code>GetItem</code> and <code>BatchGetItem</code>, do not access any indexes at all. In these cases, specifying <code>INDEXES</code> will only return <code>ConsumedCapacity</code> information for table(s).</p></li>
     /// <li>
     /// <p><code>TOTAL</code> - The response includes only the aggregate <code>ConsumedCapacity</code> for the operation.</p></li>
     /// <li>
     /// <p><code>NONE</code> - No <code>ConsumedCapacity</code> details are included in the response.</p></li>
     /// </ul>
     pub fn return_consumed_capacity(&self) -> ::std::option::Option<&crate::types::ReturnConsumedCapacity> {
         self.return_consumed_capacity.as_ref()
-72
+    }
     /// <p>Determines whether item collection metrics are returned. If set to <code>SIZE</code>, the response includes statistics about item collections, if any, that were modified during the operation are returned in the response. If set to <code>NONE</code> (the default), no statistics are returned.</p>
     pub fn return_item_collection_metrics(&self) -> ::std::option::Option<&crate::types::ReturnItemCollectionMetrics> {
         self.return_item_collection_metrics.as_ref()
-76
+    }
-77
+}
 static BATCHWRITEITEMINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#BatchWriteItemInput",

     "com.amazonaws.dynamodb.synthetic",
     "BatchWriteItemInput",
 );
 static BATCHWRITEITEMINPUT_MEMBER_REQUEST_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#BatchWriteItemInput$RequestItems",
         "com.amazonaws.dynamodb.synthetic",
         "BatchWriteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "request_items",
     "RequestItems",
 ,
 );
 static BATCHWRITEITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#BatchWriteItemInput$ReturnConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "BatchWriteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_consumed_capacity",
     "ReturnConsumedCapacity",
 ,
 );
 static BATCHWRITEITEMINPUT_MEMBER_RETURN_ITEM_COLLECTION_METRICS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#BatchWriteItemInput$ReturnItemCollectionMetrics",
         "com.amazonaws.dynamodb.synthetic",
         "BatchWriteItemInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "return_item_collection_metrics",
     "ReturnItemCollectionMetrics",
 ,
 );
 static BATCHWRITEITEMINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     BATCHWRITEITEMINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &BATCHWRITEITEMINPUT_MEMBER_REQUEST_ITEMS,
         &BATCHWRITEITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY,
         &BATCHWRITEITEMINPUT_MEMBER_RETURN_ITEM_COLLECTION_METRICS,
     ],
 );
 impl BatchWriteItemInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BATCHWRITEITEMINPUT_SCHEMA;
-125
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for BatchWriteItemInput {
     #[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.request_items {
             ser.write_map(
                 &BATCHWRITEITEMINPUT_MEMBER_REQUEST_ITEMS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
-+
                         ser.write_list(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for item in value {
                                     ser.write_struct(crate::types::WriteRequest::SCHEMA, item)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-148
+                    }
                     Ok(())
                 },
             )?;
-152
+        }
         if let Some(ref val) = self.return_consumed_capacity {
             ser.write_string(&BATCHWRITEITEMINPUT_MEMBER_RETURN_CONSUMED_CAPACITY, val.as_str())?;
-155
+        }
         if let Some(ref val) = self.return_item_collection_metrics {
             ser.write_string(&BATCHWRITEITEMINPUT_MEMBER_RETURN_ITEM_COLLECTION_METRICS, val.as_str())?;
-158
+        }
         Ok(())
-160
+    }
-161
+}
 impl BatchWriteItemInput {
     /// 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(&BATCHWRITEITEMINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&BATCHWRITEITEMINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.request_items = 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, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, {
                                 let mut list = Vec::new();
                                 deser.read_list(member, &mut |deser| {
                                     list.push(crate::types::WriteRequest::deserialize(deser)?);
                                     Ok(())
                                 })?;
                                 list
                             });
                             Ok(())
                         })?;
                         container
                     });
-194
+                }
                 Some(1) => {
                     builder.return_consumed_capacity = Some(crate::types::ReturnConsumedCapacity::from(deser.read_string(member)?.as_str()));
-197
+                }
                 Some(2) => {
                     builder.return_item_collection_metrics =
                         Some(crate::types::ReturnItemCollectionMetrics::from(deser.read_string(member)?.as_str()));
-201
+                }
                 _ => {}
-203
+            }
             Ok(())
         })?;
         builder.request_items = builder.request_items.or(Some(::std::collections::HashMap::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-210
+    }
-211
+}
 impl BatchWriteItemInput {
     /// 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 BatchWriteItemInput {
     /// Creates a new builder-style object to manufacture [`BatchWriteItemInput`](crate::operation::batch_write_item::BatchWriteItemInput).
     pub fn builder() -> crate::operation::batch_write_item::builders::BatchWriteItemInputBuilder {
         crate::operation::batch_write_item::builders::BatchWriteItemInputBuilder::default()
-227
+    }
-228
+}
-229
 /// A builder for [`BatchWriteItemInput`](crate::operation::batch_write_item::BatchWriteItemInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct BatchWriteItemInputBuilder {
     pub(crate) request_items: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<crate::types::WriteRequest>>>,
     pub(crate) return_consumed_capacity: ::std::option::Option<crate::types::ReturnConsumedCapacity>,
     pub(crate) return_item_collection_metrics: ::std::option::Option<crate::types::ReturnItemCollectionMetrics>,
-237
+}
 impl BatchWriteItemInputBuilder {
     /// Adds a key-value pair to `request_items`.
     ///
     /// To override the contents of this collection use [`set_request_items`](Self::set_request_items).
     ///
     /// <p>A map of one or more table names or table ARNs and, for each table, a list of operations to be performed (<code>DeleteRequest</code> or <code>PutRequest</code>). Each element in the map consists of the following:</p>
     /// <ul>
     /// <li>
     /// <p><code>DeleteRequest</code> - Perform a <code>DeleteItem</code> operation on the specified item. The item to be deleted is identified by a <code>Key</code> subelement:</p>
     /// <ul>
     /// <li>
     /// <p><code>Key</code> - A map of primary key attribute values that uniquely identify the item. Each entry in this map consists of an attribute name and an attribute value. For each primary key, you must provide <i>all</i> of the key attributes. For example, with a simple primary key, you only need to provide a value for the partition key. For a composite primary key, you must provide values for <i>both</i> the partition key and the sort key.</p></li>
     /// </ul></li>
     /// <li>
     /// <p><code>PutRequest</code> - Perform a <code>PutItem</code> operation on the specified item. The item to be put is identified by an <code>Item</code> subelement:</p>

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_write_item/_batch_write_item_output.rs

@@ -82,82 +274,383 @@

↥ Expand context

         &self,
     ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::vec::Vec<crate::types::ItemCollectionMetrics>>> {
         self.item_collection_metrics.as_ref()
-85
+    }
     /// <p>The capacity units consumed by the entire <code>BatchWriteItem</code> operation.</p>
     /// <p>Each element consists of:</p>
     /// <ul>
     /// <li>
     /// <p><code>TableName</code> - The table that consumed the provisioned throughput.</p></li>
     /// <li>
     /// <p><code>CapacityUnits</code> - The total number of capacity units consumed.</p></li>
     /// </ul>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.consumed_capacity.is_none()`.
     pub fn consumed_capacity(&self) -> &[crate::types::ConsumedCapacity] {
         self.consumed_capacity.as_deref().unwrap_or_default()
-98
+    }
-99
+}
 static BATCHWRITEITEMOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.dynamodb.synthetic#BatchWriteItemOutput",

     "com.amazonaws.dynamodb.synthetic",
     "BatchWriteItemOutput",
 );
 static BATCHWRITEITEMOUTPUT_MEMBER_UNPROCESSED_ITEMS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#BatchWriteItemOutput$UnprocessedItems",
         "com.amazonaws.dynamodb.synthetic",
         "BatchWriteItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "unprocessed_items",
     "UnprocessedItems",
 ,
 );
 static BATCHWRITEITEMOUTPUT_MEMBER_ITEM_COLLECTION_METRICS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#BatchWriteItemOutput$ItemCollectionMetrics",
         "com.amazonaws.dynamodb.synthetic",
         "BatchWriteItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::Map,
     "item_collection_metrics",
     "ItemCollectionMetrics",
 ,
 );
 static BATCHWRITEITEMOUTPUT_MEMBER_CONSUMED_CAPACITY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.dynamodb.synthetic#BatchWriteItemOutput$ConsumedCapacity",
         "com.amazonaws.dynamodb.synthetic",
         "BatchWriteItemOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "consumed_capacity",
     "ConsumedCapacity",
 ,
 );
 static BATCHWRITEITEMOUTPUT_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 BATCHWRITEITEMOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     BATCHWRITEITEMOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &BATCHWRITEITEMOUTPUT_MEMBER_UNPROCESSED_ITEMS,
         &BATCHWRITEITEMOUTPUT_MEMBER_ITEM_COLLECTION_METRICS,
         &BATCHWRITEITEMOUTPUT_MEMBER_CONSUMED_CAPACITY,
         &BATCHWRITEITEMOUTPUT_MEMBER__REQUEST_ID,
     ],
 );
 impl BatchWriteItemOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &BATCHWRITEITEMOUTPUT_SCHEMA;
-155
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for BatchWriteItemOutput {
     #[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.unprocessed_items {
             ser.write_map(
                 &BATCHWRITEITEMOUTPUT_MEMBER_UNPROCESSED_ITEMS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
-+
                         ser.write_list(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for item in value {
                                     ser.write_struct(crate::types::WriteRequest::SCHEMA, item)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-178
+                    }
                     Ok(())
                 },
             )?;
-182
+        }
         if let Some(ref val) = self.item_collection_metrics {
             ser.write_map(
                 &BATCHWRITEITEMOUTPUT_MEMBER_ITEM_COLLECTION_METRICS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for (key, value) in val {
                         ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
                         todo!("schema: unsupported map value type");
-+
                         ser.write_list(
                             &::aws_smithy_schema::prelude::DOCUMENT,
                             &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                                 for item in value {
                                     ser.write_struct(crate::types::ItemCollectionMetrics::SCHEMA, item)?;
-+
+                                }
                                 Ok(())
                             },
                         )?;
-199
+                    }
                     Ok(())
                 },
             )?;
-203
+        }
         if let Some(ref val) = self.consumed_capacity {
             ser.write_list(
                 &BATCHWRITEITEMOUTPUT_MEMBER_CONSUMED_CAPACITY,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ConsumedCapacity::SCHEMA, item)?;
-210
+                    }
                     Ok(())
                 },
             )?;
-214
+        }
         Ok(())
-216
+    }
-217
+}
 impl BatchWriteItemOutput {
     /// 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(&BATCHWRITEITEMOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&BATCHWRITEITEMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.unprocessed_items = Some({
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, {
                                 let mut list = Vec::new();
                                 deser.read_list(member, &mut |deser| {
                                     list.push(crate::types::WriteRequest::deserialize(deser)?);
                                     Ok(())
                                 })?;
                                 list
                             });
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(1) => {
                     builder.item_collection_metrics = Some({
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, {
                                 let mut list = Vec::new();
                                 deser.read_list(member, &mut |deser| {
                                     list.push(crate::types::ItemCollectionMetrics::deserialize(deser)?);
                                     Ok(())
                                 })?;
                                 list
                             });
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(2) => {
                     builder.consumed_capacity = Some({
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ConsumedCapacity::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-+
+                }
                 Some(3) => {
                     builder._request_id = Some(deser.read_string(member)?);
-+
+                }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         Ok(builder.build())
-+
+    }
-+
+}
 impl BatchWriteItemOutput {
     /// 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(&BATCHWRITEITEMOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.unprocessed_items = 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, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, {
                                 let mut list = Vec::new();
                                 deser.read_list(member, &mut |deser| {
                                     list.push(crate::types::WriteRequest::deserialize(deser)?);
                                     Ok(())
                                 })?;
                                 list
                             });
                             Ok(())
                         })?;
                         container
                     });
-328
+                }
                 Some(1) => {
                     builder.item_collection_metrics = 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, todo!("deserialize nested aggregate"));
                             Ok(map)
                         })?
                         let mut container = std::collections::HashMap::new();
                         deser.read_map(member, &mut |key, deser| {
                             container.insert(key, {
                                 let mut list = Vec::new();
                                 deser.read_list(member, &mut |deser| {
                                     list.push(crate::types::ItemCollectionMetrics::deserialize(deser)?);
                                     Ok(())
                                 })?;
                                 list
                             });
                             Ok(())
                         })?;
                         container
                     });
-345
+                }
                 Some(2) => {
                     builder.consumed_capacity = 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::ConsumedCapacity::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ConsumedCapacity::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-355
+                }
                 _ => {}
-357
+            }
             Ok(())
         })?;
         Ok(builder.build())
-361
+    }
-362
+}
 impl ::aws_types::request_id::RequestId for BatchWriteItemOutput {

↧ Expand context

     fn request_id(&self) -> Option<&str> {
         self._request_id.as_deref()
-366
+    }
-367
+}
 impl BatchWriteItemOutput {
     /// Creates a new builder-style object to manufacture [`BatchWriteItemOutput`](crate::operation::batch_write_item::BatchWriteItemOutput).
     pub fn builder() -> crate::operation::batch_write_item::builders::BatchWriteItemOutputBuilder {
         crate::operation::batch_write_item::builders::BatchWriteItemOutputBuilder::default()
-372
+    }
-373
+}
-374
 /// A builder for [`BatchWriteItemOutput`](crate::operation::batch_write_item::BatchWriteItemOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]
 pub struct BatchWriteItemOutputBuilder {
     pub(crate) unprocessed_items:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<crate::types::WriteRequest>>>,
     pub(crate) item_collection_metrics:
         ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::vec::Vec<crate::types::ItemCollectionMetrics>>>,
     pub(crate) consumed_capacity: ::std::option::Option<::std::vec::Vec<crate::types::ConsumedCapacity>>,

AWS SDK

Files changed:

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_get_item.rs

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_get_item/_batch_get_item_input.rs

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_get_item/_batch_get_item_output.rs

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_write_item.rs

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_write_item/_batch_write_item_input.rs

tmp-codegen-diff/aws-sdk/sdk/dynamodb/src/operation/batch_write_item/_batch_write_item_output.rs