Client Test

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/list_changed_blocks/_list_changed_blocks_output.rs

@@ -23,23 +220,228 @@

     pub fn expiry_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
         self.expiry_time.as_ref()
-25
+    }
     /// <p>The size of the volume in GB.</p>
     pub fn volume_size(&self) -> ::std::option::Option<i64> {
         self.volume_size
-29
+    }
     /// <p>The token to use to retrieve the next page of results. This value is null when there are no more results to return.</p>
     pub fn next_token(&self) -> ::std::option::Option<&str> {
         self.next_token.as_deref()
-33
+    }
     /// <p>An array of objects containing information about the changed blocks.</p>
     ///
     /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.changed_blocks.is_none()`.
     pub fn changed_blocks(&self) -> &[crate::types::ChangedBlock] {
         self.changed_blocks.as_deref().unwrap_or_default()
-39
+    }
-40
+}
 static LISTCHANGEDBLOCKSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ebs.synthetic#ListChangedBlocksOutput",

     "com.amazonaws.ebs.synthetic",
     "ListChangedBlocksOutput",
 );
 static LISTCHANGEDBLOCKSOUTPUT_MEMBER_BLOCK_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListChangedBlocksOutput$BlockSize",
         "com.amazonaws.ebs.synthetic",
         "ListChangedBlocksOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "block_size",
     "BlockSize",
 ,
 );
 static LISTCHANGEDBLOCKSOUTPUT_MEMBER_EXPIRY_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListChangedBlocksOutput$ExpiryTime",
         "com.amazonaws.ebs.synthetic",
         "ListChangedBlocksOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "expiry_time",
     "ExpiryTime",
 ,
 );
 static LISTCHANGEDBLOCKSOUTPUT_MEMBER_VOLUME_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListChangedBlocksOutput$VolumeSize",
         "com.amazonaws.ebs.synthetic",
         "ListChangedBlocksOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "volume_size",
     "VolumeSize",
 ,
 );
 static LISTCHANGEDBLOCKSOUTPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListChangedBlocksOutput$NextToken",
         "com.amazonaws.ebs.synthetic",
         "ListChangedBlocksOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "NextToken",
 ,
 );
 static LISTCHANGEDBLOCKSOUTPUT_MEMBER_CHANGED_BLOCKS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListChangedBlocksOutput$ChangedBlocks",
         "com.amazonaws.ebs.synthetic",
         "ListChangedBlocksOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "changed_blocks",
     "ChangedBlocks",
 ,
 );
 static LISTCHANGEDBLOCKSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTCHANGEDBLOCKSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTCHANGEDBLOCKSOUTPUT_MEMBER_BLOCK_SIZE,
         &LISTCHANGEDBLOCKSOUTPUT_MEMBER_EXPIRY_TIME,
         &LISTCHANGEDBLOCKSOUTPUT_MEMBER_VOLUME_SIZE,
         &LISTCHANGEDBLOCKSOUTPUT_MEMBER_NEXT_TOKEN,
         &LISTCHANGEDBLOCKSOUTPUT_MEMBER_CHANGED_BLOCKS,
     ],
 );
 impl ListChangedBlocksOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTCHANGEDBLOCKSOUTPUT_SCHEMA;
-110
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListChangedBlocksOutput {
     #[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.block_size {
             ser.write_integer(&LISTCHANGEDBLOCKSOUTPUT_MEMBER_BLOCK_SIZE, *val)?;
-119
+        }
         if let Some(ref val) = self.expiry_time {
             ser.write_timestamp(&LISTCHANGEDBLOCKSOUTPUT_MEMBER_EXPIRY_TIME, val)?;
-122
+        }
         if let Some(ref val) = self.volume_size {
             ser.write_long(&LISTCHANGEDBLOCKSOUTPUT_MEMBER_VOLUME_SIZE, *val)?;
-125
+        }
         if let Some(ref val) = self.next_token {
             ser.write_string(&LISTCHANGEDBLOCKSOUTPUT_MEMBER_NEXT_TOKEN, val)?;
-128
+        }
         if let Some(ref val) = self.changed_blocks {
             ser.write_list(
                 &LISTCHANGEDBLOCKSOUTPUT_MEMBER_CHANGED_BLOCKS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::ChangedBlock::SCHEMA, item)?;
-135
+                    }
                     Ok(())
                 },
             )?;
-139
+        }
         Ok(())
-141
+    }
-142
+}
 impl ListChangedBlocksOutput {
     /// 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(&LISTCHANGEDBLOCKSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTCHANGEDBLOCKSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.block_size = Some(deser.read_integer(member)?);
-161
+                }
                 Some(1) => {
                     builder.expiry_time = Some(deser.read_timestamp(member)?);
-164
+                }
                 Some(2) => {
                     builder.volume_size = Some(deser.read_long(member)?);
-167
+                }
                 Some(3) => {
                     builder.next_token = Some(deser.read_string(member)?);
-170
+                }
                 Some(4) => {
                     builder.changed_blocks = 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::ChangedBlock::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::ChangedBlock::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-180
+                }
                 _ => {}
-182
+            }
             Ok(())
         })?;
         Ok(builder.build())
-186
+    }
-187
+}
 impl ListChangedBlocksOutput {
     /// 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 ListChangedBlocksOutput {
     /// Creates a new builder-style object to manufacture [`ListChangedBlocksOutput`](crate::operation::list_changed_blocks::ListChangedBlocksOutput).
     pub fn builder() -> crate::operation::list_changed_blocks::builders::ListChangedBlocksOutputBuilder {
         crate::operation::list_changed_blocks::builders::ListChangedBlocksOutputBuilder::default()
-203
+    }
-204
+}
-205
 /// A builder for [`ListChangedBlocksOutput`](crate::operation::list_changed_blocks::ListChangedBlocksOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ListChangedBlocksOutputBuilder {
     pub(crate) block_size: ::std::option::Option<i32>,
     pub(crate) expiry_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) volume_size: ::std::option::Option<i64>,
     pub(crate) next_token: ::std::option::Option<::std::string::String>,
     pub(crate) changed_blocks: ::std::option::Option<::std::vec::Vec<crate::types::ChangedBlock>>,
-215
+}
 impl ListChangedBlocksOutputBuilder {
     /// <p>The size of the block.</p>
     pub fn block_size(mut self, input: i32) -> Self {
         self.block_size = ::std::option::Option::Some(input);
         self
-221
+    }
     /// <p>The size of the block.</p>
     pub fn set_block_size(mut self, input: ::std::option::Option<i32>) -> Self {
         self.block_size = input;
         self
-226
+    }
     /// <p>The size of the block.</p>
     pub fn get_block_size(&self) -> &::std::option::Option<i32> {

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/list_snapshot_blocks.rs

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

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

↧ Expand context

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

@@ -102,106 +254,390 @@

↥ Expand context

         ));
-107
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::SensitiveOutput);
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("ListSnapshotBlocks", "EBS"));
-110
         ::std::option::Option::Some(cfg.freeze())
-112
+    }
-113
     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("ListSnapshotBlocks")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(ListSnapshotBlocksEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::list_snapshot_blocks::ListSnapshotBlocksError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::list_snapshot_blocks::ListSnapshotBlocksError,
             >::new());
-128
         ::std::borrow::Cow::Owned(rcb)
-130
+    }
-131
+}
-132
 #[derive(Debug)]
 struct ListSnapshotBlocksResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ListSnapshotBlocksResponseDeserializer {
     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());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 200 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-152
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_list_snapshot_blocks::de_list_snapshot_blocks_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_list_snapshot_blocks::de_list_snapshot_blocks_http_response(status, headers, body)
             let generic = generic_builder.build();
             let error_code = match generic.code() {
                 ::std::option::Option::Some(code) => code,
                 ::std::option::Option::None => {
                     return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                         ::aws_smithy_runtime_api::box_error::BoxError::from(
                             crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::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 {
                 "AccessDeniedException" => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::AccessDeniedError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::AccessDeniedError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::AccessDeniedError::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
                 }),
                 "InternalServerException" => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::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
                 }),
                 "RequestThrottledException" => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::RequestThrottledError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::RequestThrottledError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::RequestThrottledError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ResourceNotFoundException" => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::ResourceNotFoundError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundError::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
                 }),
                 "ServiceQuotaExceededException" => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::ServiceQuotaExceededError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceQuotaExceededError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceQuotaExceededError::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
                 }),
                 "ValidationException" => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::ValidationError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::list_snapshot_blocks::ListSnapshotBlocksError::generic(generic),
             };
         crate::protocol_serde::type_erase_result(parse_result)
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, ListSnapshotBlocks::OUTPUT_SCHEMA, _cfg)
                 .map_err(|e| {
                     ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
                 })?;
             let body = response.body().bytes().expect("body loaded");
             let output = crate::operation::list_snapshot_blocks::ListSnapshotBlocksOutput::deserialize_with_response(
                 &mut *deser,
                 response.headers(),
                 response.status().into(),
                 body,
-+
+            )
             .map_err(|e| {
                 ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
             })?;
             ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
-+
+        }
-339
+    }
-340
+}
 #[derive(Debug)]
 struct ListSnapshotBlocksRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for ListSnapshotBlocksRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input
             .downcast::<crate::operation::list_snapshot_blocks::ListSnapshotBlocksInput>()
             .expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             #[allow(clippy::uninlined_format_args)]
             fn uri_base(
                 _input: &crate::operation::list_snapshot_blocks::ListSnapshotBlocksInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.snapshot_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("snapshot_id", "cannot be empty or unset"))?;
                 let snapshot_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if snapshot_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "snapshot_id",
                         "cannot be empty or unset",
                     ));
--
+                }
                 ::std::write!(output, "/snapshots/{SnapshotId}/blocks", SnapshotId = snapshot_id).expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             fn uri_query(
                 _input: &crate::operation::list_snapshot_blocks::ListSnapshotBlocksInput,
                 mut output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 let mut query = ::aws_smithy_http::query::Writer::new(output);
                 if let ::std::option::Option::Some(inner_2) = &_input.max_results {
--
+                    {
                         query.push_kv("maxResults", ::aws_smithy_types::primitive::Encoder::from(*inner_2).encode());
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_3) = &_input.starting_block_index {
--
+                    {
                         query.push_kv("startingBlockIndex", ::aws_smithy_types::primitive::Encoder::from(*inner_3).encode());
--
+                    }
--
+                }
                 if let ::std::option::Option::Some(inner_4) = &_input.next_token {
--
+                    {
                         query.push_kv("pageToken", &::aws_smithy_http::query::fmt_string(inner_4));
--
+                    }
--
+                }
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::list_snapshot_blocks::ListSnapshotBlocksInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 uri_query(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("GET").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from("");
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, ListSnapshotBlocks::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-359
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         return ::std::result::Result::Ok(request);
-361
+    }
-362
+}
 #[derive(Debug)]
 struct ListSnapshotBlocksEndpointParamsInterceptor;
-365
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ListSnapshotBlocksEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "ListSnapshotBlocksEndpointParamsInterceptor"
-369
+    }
-370

↧ 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::<ListSnapshotBlocksInput>()
             .ok_or("failed to downcast to ListSnapshotBlocksInput")?;
-385
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/list_snapshot_blocks/_list_snapshot_blocks_input.rs

@@ -15,15 +183,196 @@

↥ Expand context

 impl ListSnapshotBlocksInput {
     /// <p>The number of results to return.</p>
     pub fn max_results(&self) -> ::std::option::Option<i32> {
         self.max_results
-19
+    }
     /// <p>The block index from which the list should start. The list in the response will start from this block index or the next valid block index in the snapshot.</p>
     pub fn starting_block_index(&self) -> ::std::option::Option<i32> {
         self.starting_block_index
-23
+    }
     /// <p>The token to request the next page of results.</p>
     pub fn next_token(&self) -> ::std::option::Option<&str> {
         self.next_token.as_deref()
-27
+    }
     /// <p>The ID of the snapshot from which to get block indexes and block tokens.</p>
     pub fn snapshot_id(&self) -> ::std::option::Option<&str> {
         self.snapshot_id.as_deref()
-31
+    }
-32
+}
 static LISTSNAPSHOTBLOCKSINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ebs.synthetic#ListSnapshotBlocksInput",

     "com.amazonaws.ebs.synthetic",
     "ListSnapshotBlocksInput",
 );
 static LISTSNAPSHOTBLOCKSINPUT_MEMBER_MAX_RESULTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListSnapshotBlocksInput$MaxResults",
         "com.amazonaws.ebs.synthetic",
         "ListSnapshotBlocksInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "max_results",
     "MaxResults",
 ,
-47
+)
 .with_http_query("maxResults");
 static LISTSNAPSHOTBLOCKSINPUT_MEMBER_STARTING_BLOCK_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListSnapshotBlocksInput$StartingBlockIndex",
         "com.amazonaws.ebs.synthetic",
         "ListSnapshotBlocksInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "starting_block_index",
     "StartingBlockIndex",
 ,
-58
+)
 .with_http_query("startingBlockIndex");
 static LISTSNAPSHOTBLOCKSINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListSnapshotBlocksInput$NextToken",
         "com.amazonaws.ebs.synthetic",
         "ListSnapshotBlocksInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "NextToken",
 ,
-69
+)
 .with_http_query("pageToken");
 static LISTSNAPSHOTBLOCKSINPUT_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListSnapshotBlocksInput$SnapshotId",
         "com.amazonaws.ebs.synthetic",
         "ListSnapshotBlocksInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "snapshot_id",
     "SnapshotId",
 ,
-80
+)
 .with_http_label();
 static LISTSNAPSHOTBLOCKSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTSNAPSHOTBLOCKSINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTSNAPSHOTBLOCKSINPUT_MEMBER_MAX_RESULTS,
         &LISTSNAPSHOTBLOCKSINPUT_MEMBER_STARTING_BLOCK_INDEX,
         &LISTSNAPSHOTBLOCKSINPUT_MEMBER_NEXT_TOKEN,
         &LISTSNAPSHOTBLOCKSINPUT_MEMBER_SNAPSHOT_ID,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new("GET", "/snapshots/{SnapshotId}/blocks", None));
 impl ListSnapshotBlocksInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTSNAPSHOTBLOCKSINPUT_SCHEMA;
-96
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListSnapshotBlocksInput {
     #[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.max_results {
             ser.write_integer(&LISTSNAPSHOTBLOCKSINPUT_MEMBER_MAX_RESULTS, *val)?;
-105
+        }
         if let Some(ref val) = self.starting_block_index {
             ser.write_integer(&LISTSNAPSHOTBLOCKSINPUT_MEMBER_STARTING_BLOCK_INDEX, *val)?;
-108
+        }
         if let Some(ref val) = self.next_token {
             ser.write_string(&LISTSNAPSHOTBLOCKSINPUT_MEMBER_NEXT_TOKEN, val)?;
-111
+        }
         if let Some(ref val) = self.snapshot_id {
             ser.write_string(&LISTSNAPSHOTBLOCKSINPUT_MEMBER_SNAPSHOT_ID, val)?;
-114
+        }
         Ok(())
-116
+    }
-117
+}
 impl ListSnapshotBlocksInput {
     /// 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(&LISTSNAPSHOTBLOCKSINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTSNAPSHOTBLOCKSINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.max_results = Some(deser.read_integer(member)?);
-136
+                }
                 Some(1) => {
                     builder.starting_block_index = Some(deser.read_integer(member)?);
-139
+                }
                 Some(2) => {
                     builder.next_token = Some(deser.read_string(member)?);
-142
+                }
                 Some(3) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-145
+                }
                 _ => {}
-147
+            }
             Ok(())
         })?;
         builder.snapshot_id = builder.snapshot_id.or(Some(String::new()));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-154
+    }
-155
+}
 impl ListSnapshotBlocksInput {
     /// 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 ListSnapshotBlocksInput {
     /// Creates a new builder-style object to manufacture [`ListSnapshotBlocksInput`](crate::operation::list_snapshot_blocks::ListSnapshotBlocksInput).
     pub fn builder() -> crate::operation::list_snapshot_blocks::builders::ListSnapshotBlocksInputBuilder {
         crate::operation::list_snapshot_blocks::builders::ListSnapshotBlocksInputBuilder::default()
-171
+    }
-172
+}
-173
 /// A builder for [`ListSnapshotBlocksInput`](crate::operation::list_snapshot_blocks::ListSnapshotBlocksInput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct ListSnapshotBlocksInputBuilder {
     pub(crate) max_results: ::std::option::Option<i32>,
     pub(crate) starting_block_index: ::std::option::Option<i32>,
     pub(crate) next_token: ::std::option::Option<::std::string::String>,
     pub(crate) snapshot_id: ::std::option::Option<::std::string::String>,
-182
+}
 impl ListSnapshotBlocksInputBuilder {
     /// <p>The number of results to return.</p>
     pub fn max_results(mut self, input: i32) -> Self {
         self.max_results = ::std::option::Option::Some(input);
         self
-188
+    }
     /// <p>The number of results to return.</p>
     pub fn set_max_results(mut self, input: ::std::option::Option<i32>) -> Self {
         self.max_results = input;
         self
-193
+    }
     /// <p>The number of results to return.</p>
     pub fn get_max_results(&self) -> &::std::option::Option<i32> {
         &self.max_results

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/list_snapshot_blocks/_list_snapshot_blocks_output.rs

@@ -34,34 +231,239 @@

↥ Expand context

         self.blocks.as_deref().unwrap_or_default()
-35
+    }
     /// <p>The size of the block.</p>
     pub fn block_size(&self) -> ::std::option::Option<i32> {
         self.block_size
-39
+    }
-40
+}
 impl ::std::fmt::Debug for ListSnapshotBlocksOutput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("ListSnapshotBlocksOutput");
         formatter.field("volume_size", &self.volume_size);
         formatter.field("next_token", &self.next_token);
         formatter.field("expiry_time", &self.expiry_time);
         formatter.field("blocks", &"*** Sensitive Data Redacted ***");
         formatter.field("block_size", &self.block_size);
         formatter.finish()
-50
+    }
-51
+}
 static LISTSNAPSHOTBLOCKSOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ebs.synthetic#ListSnapshotBlocksOutput",

     "com.amazonaws.ebs.synthetic",
     "ListSnapshotBlocksOutput",
 );
 static LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_VOLUME_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListSnapshotBlocksOutput$VolumeSize",
         "com.amazonaws.ebs.synthetic",
         "ListSnapshotBlocksOutput",
     ),
     ::aws_smithy_schema::ShapeType::Long,
     "volume_size",
     "VolumeSize",
 ,
 );
 static LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListSnapshotBlocksOutput$NextToken",
         "com.amazonaws.ebs.synthetic",
         "ListSnapshotBlocksOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "next_token",
     "NextToken",
 ,
 );
 static LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_EXPIRY_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListSnapshotBlocksOutput$ExpiryTime",
         "com.amazonaws.ebs.synthetic",
         "ListSnapshotBlocksOutput",
     ),
     ::aws_smithy_schema::ShapeType::Timestamp,
     "expiry_time",
     "ExpiryTime",
 ,
 );
 static LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_BLOCKS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListSnapshotBlocksOutput$Blocks",
         "com.amazonaws.ebs.synthetic",
         "ListSnapshotBlocksOutput",
     ),
     ::aws_smithy_schema::ShapeType::List,
     "blocks",
     "Blocks",
 ,
 );
 static LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_BLOCK_SIZE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#ListSnapshotBlocksOutput$BlockSize",
         "com.amazonaws.ebs.synthetic",
         "ListSnapshotBlocksOutput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "block_size",
     "BlockSize",
 ,
 );
 static LISTSNAPSHOTBLOCKSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     LISTSNAPSHOTBLOCKSOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_VOLUME_SIZE,
         &LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_NEXT_TOKEN,
         &LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_EXPIRY_TIME,
         &LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_BLOCKS,
         &LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_BLOCK_SIZE,
     ],
 );
 impl ListSnapshotBlocksOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LISTSNAPSHOTBLOCKSOUTPUT_SCHEMA;
-121
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for ListSnapshotBlocksOutput {
     #[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.volume_size {
             ser.write_long(&LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_VOLUME_SIZE, *val)?;
-130
+        }
         if let Some(ref val) = self.next_token {
             ser.write_string(&LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_NEXT_TOKEN, val)?;
-133
+        }
         if let Some(ref val) = self.expiry_time {
             ser.write_timestamp(&LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_EXPIRY_TIME, val)?;
-136
+        }
         if let Some(ref val) = self.blocks {
             ser.write_list(
                 &LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_BLOCKS,
                 &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
                     for item in val {
                         ser.write_struct(crate::types::Block::SCHEMA, item)?;
-143
+                    }
                     Ok(())
                 },
             )?;
-147
+        }
         if let Some(ref val) = self.block_size {
             ser.write_integer(&LISTSNAPSHOTBLOCKSOUTPUT_MEMBER_BLOCK_SIZE, *val)?;
-150
+        }
         Ok(())
-152
+    }
-153
+}
 impl ListSnapshotBlocksOutput {
     /// 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(&LISTSNAPSHOTBLOCKSOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&LISTSNAPSHOTBLOCKSOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.volume_size = Some(deser.read_long(member)?);
-172
+                }
                 Some(1) => {
                     builder.next_token = Some(deser.read_string(member)?);
-175
+                }
                 Some(2) => {
                     builder.expiry_time = Some(deser.read_timestamp(member)?);
-178
+                }
                 Some(3) => {
                     builder.blocks = 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::Block::deserialize(deser)?);
                             Ok(list)
                         })?
                         let mut container = Vec::new();
                         deser.read_list(member, &mut |deser| {
                             container.push(crate::types::Block::deserialize(deser)?);
                             Ok(())
                         })?;
                         container
                     });
-188
+                }
                 Some(4) => {
                     builder.block_size = Some(deser.read_integer(member)?);
-191
+                }
                 _ => {}
-193
+            }
             Ok(())
         })?;
         Ok(builder.build())
-197
+    }
-198
+}
 impl ListSnapshotBlocksOutput {
     /// 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 ListSnapshotBlocksOutput {
     /// Creates a new builder-style object to manufacture [`ListSnapshotBlocksOutput`](crate::operation::list_snapshot_blocks::ListSnapshotBlocksOutput).
     pub fn builder() -> crate::operation::list_snapshot_blocks::builders::ListSnapshotBlocksOutputBuilder {
         crate::operation::list_snapshot_blocks::builders::ListSnapshotBlocksOutputBuilder::default()
-214
+    }
-215
+}
-216
 /// A builder for [`ListSnapshotBlocksOutput`](crate::operation::list_snapshot_blocks::ListSnapshotBlocksOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 #[non_exhaustive]

↧ Expand context

 pub struct ListSnapshotBlocksOutputBuilder {
     pub(crate) volume_size: ::std::option::Option<i64>,
     pub(crate) next_token: ::std::option::Option<::std::string::String>,
     pub(crate) expiry_time: ::std::option::Option<::aws_smithy_types::DateTime>,
     pub(crate) blocks: ::std::option::Option<::std::vec::Vec<crate::types::Block>>,
     pub(crate) block_size: ::std::option::Option<i32>,
-226
+}
 impl ListSnapshotBlocksOutputBuilder {
     /// <p>The size of the volume in GB.</p>
     pub fn volume_size(mut self, input: i64) -> Self {
         self.volume_size = ::std::option::Option::Some(input);
         self
-232
+    }
     /// <p>The size of the volume in GB.</p>
     pub fn set_volume_size(mut self, input: ::std::option::Option<i64>) -> Self {
         self.volume_size = input;
         self
-237
+    }
     /// <p>The size of the volume in GB.</p>
     pub fn get_volume_size(&self) -> &::std::option::Option<i64> {

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/put_snapshot_block.rs

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

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

@@ -101,105 +253,395 @@

↥ Expand context

                 .expect("required fields set"),
         ));
-107
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("PutSnapshotBlock", "EBS"));
-109
         ::std::option::Option::Some(cfg.freeze())
-111
+    }
-112
     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("PutSnapshotBlock")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(PutSnapshotBlockEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::put_snapshot_block::PutSnapshotBlockError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::put_snapshot_block::PutSnapshotBlockError,
             >::new());
-127
         ::std::borrow::Cow::Owned(rcb)
-129
+    }
-130
+}
-131
 #[derive(Debug)]
 struct PutSnapshotBlockResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for PutSnapshotBlockResponseDeserializer {
     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());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 201 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-151
         let parse_result = if !success && status != 201 || force_error {
             crate::protocol_serde::shape_put_snapshot_block::de_put_snapshot_block_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_put_snapshot_block::de_put_snapshot_block_http_response(status, headers, body)
             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::put_snapshot_block::PutSnapshotBlockError::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 {
                 "AccessDeniedException" => crate::operation::put_snapshot_block::PutSnapshotBlockError::AccessDeniedError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::AccessDeniedError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::AccessDeniedError::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
                 }),
                 "InternalServerException" => crate::operation::put_snapshot_block::PutSnapshotBlockError::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
                 }),
                 "RequestThrottledException" => crate::operation::put_snapshot_block::PutSnapshotBlockError::RequestThrottledError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::RequestThrottledError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::RequestThrottledError::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::put_snapshot_block::PutSnapshotBlockError::ResourceNotFoundError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundError::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
                 }),
                 "ServiceQuotaExceededException" => crate::operation::put_snapshot_block::PutSnapshotBlockError::ServiceQuotaExceededError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceQuotaExceededError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceQuotaExceededError::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
                 }),
                 "ValidationException" => crate::operation::put_snapshot_block::PutSnapshotBlockError::ValidationError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 _ => crate::operation::put_snapshot_block::PutSnapshotBlockError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol
                 .deserialize_response(response, PutSnapshotBlock::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::put_snapshot_block::PutSnapshotBlockOutput::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))
-+
+        }
-338
+    }
-339
+}
 #[derive(Debug)]
 struct PutSnapshotBlockRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for PutSnapshotBlockRequestSerializer {
     #[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::put_snapshot_block::PutSnapshotBlockInput>()
             .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::put_snapshot_block::PutSnapshotBlockInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.snapshot_id;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("snapshot_id", "cannot be empty or unset"))?;
                 let snapshot_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if snapshot_id.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "snapshot_id",
                         "cannot be empty or unset",
                     ));
--
+                }
                 let input_2 = &_input.block_index;
                 let input_2 = input_2
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("block_index", "cannot be empty or unset"))?;
                 let mut block_index_encoder = ::aws_smithy_types::primitive::Encoder::from(*input_2);
                 let block_index = block_index_encoder.encode();
                 if block_index.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "block_index",
                         "cannot be empty or unset",
                     ));
         let protocol = _cfg
             .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
             .expect("a SharedClientProtocol is required");
         let mut request = protocol
             .serialize_request(&input, PutSnapshotBlock::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         // Streaming blob payload: replace the body with the raw ByteStream.
         *request.body_mut() = input.block_data.into_inner();
         request.headers_mut().insert("Content-Type", "application/octet-stream");
         if let ::std::option::Option::Some(content_length) = request.body().content_length() {
             request.headers_mut().insert("Content-Length", content_length.to_string());
-363
+        }
                 ::std::write!(
                     output,
                     "/snapshots/{SnapshotId}/blocks/{BlockIndex}",
                     SnapshotId = snapshot_id,
                     BlockIndex = block_index
--
+                )
                 .expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::put_snapshot_block::PutSnapshotBlockInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 let builder = crate::protocol_serde::shape_put_snapshot_block::ser_put_snapshot_block_headers(input, builder)?;
                 ::std::result::Result::Ok(builder.method("PUT").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
             builder
         };
         let body = crate::protocol_serde::shape_put_snapshot_block_input::ser_block_data_http_payload(input.block_data)?.into_inner();
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
--
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-+
         return ::std::result::Result::Ok(request);
-366
+    }
-367
+}
 #[derive(Debug)]
 struct PutSnapshotBlockEndpointParamsInterceptor;
-370
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutSnapshotBlockEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "PutSnapshotBlockEndpointParamsInterceptor"
-374
+    }
-375

↧ 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::<PutSnapshotBlockInput>()
             .ok_or("failed to downcast to PutSnapshotBlockInput")?;
-390
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/put_snapshot_block/_put_snapshot_block_input.rs

@@ -49,49 +270,333 @@

↥ Expand context

     /// <p>The algorithm used to generate the checksum. Currently, the only supported algorithm is <code>SHA256</code>.</p>
     pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {
         self.checksum_algorithm.as_ref()
-52
+    }
-53
+}
 impl ::std::fmt::Debug for PutSnapshotBlockInput {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         let mut formatter = f.debug_struct("PutSnapshotBlockInput");
         formatter.field("snapshot_id", &self.snapshot_id);
         formatter.field("block_index", &self.block_index);
         formatter.field("checksum", &self.checksum);
         formatter.field("progress", &self.progress);
         formatter.field("block_data", &"*** Sensitive Data Redacted ***");
         formatter.field("data_length", &self.data_length);
         formatter.field("checksum_algorithm", &self.checksum_algorithm);
         formatter.finish()
-65
+    }
-66
+}
 static PUTSNAPSHOTBLOCKINPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ebs.synthetic#PutSnapshotBlockInput",

     "com.amazonaws.ebs.synthetic",
     "PutSnapshotBlockInput",
 );
 static PUTSNAPSHOTBLOCKINPUT_MEMBER_SNAPSHOT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#PutSnapshotBlockInput$SnapshotId",
         "com.amazonaws.ebs.synthetic",
         "PutSnapshotBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "snapshot_id",
     "SnapshotId",
 ,
-81
+)
 .with_http_label();
 static PUTSNAPSHOTBLOCKINPUT_MEMBER_BLOCK_INDEX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#PutSnapshotBlockInput$BlockIndex",
         "com.amazonaws.ebs.synthetic",
         "PutSnapshotBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "block_index",
     "BlockIndex",
 ,
-92
+)
 .with_http_label();
 static PUTSNAPSHOTBLOCKINPUT_MEMBER_CHECKSUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#PutSnapshotBlockInput$Checksum",
         "com.amazonaws.ebs.synthetic",
         "PutSnapshotBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum",
     "Checksum",
 ,
-103
+)
 .with_http_header("x-amz-Checksum");
 static PUTSNAPSHOTBLOCKINPUT_MEMBER_PROGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#PutSnapshotBlockInput$Progress",
         "com.amazonaws.ebs.synthetic",
         "PutSnapshotBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "progress",
     "Progress",
 ,
-114
+)
 .with_http_header("x-amz-Progress");
 static PUTSNAPSHOTBLOCKINPUT_MEMBER_BLOCK_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#PutSnapshotBlockInput$BlockData",
         "com.amazonaws.ebs.synthetic",
         "PutSnapshotBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::Blob,
     "block_data",
     "BlockData",
 ,
-125
+)
 .with_http_payload();
 static PUTSNAPSHOTBLOCKINPUT_MEMBER_DATA_LENGTH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#PutSnapshotBlockInput$DataLength",
         "com.amazonaws.ebs.synthetic",
         "PutSnapshotBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::Integer,
     "data_length",
     "DataLength",
 ,
-136
+)
 .with_http_header("x-amz-Data-Length");
 static PUTSNAPSHOTBLOCKINPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#PutSnapshotBlockInput$ChecksumAlgorithm",
         "com.amazonaws.ebs.synthetic",
         "PutSnapshotBlockInput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-147
+)
 .with_http_header("x-amz-Checksum-Algorithm");
 static PUTSNAPSHOTBLOCKINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTSNAPSHOTBLOCKINPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[
         &PUTSNAPSHOTBLOCKINPUT_MEMBER_SNAPSHOT_ID,
         &PUTSNAPSHOTBLOCKINPUT_MEMBER_BLOCK_INDEX,
         &PUTSNAPSHOTBLOCKINPUT_MEMBER_CHECKSUM,
         &PUTSNAPSHOTBLOCKINPUT_MEMBER_PROGRESS,
         &PUTSNAPSHOTBLOCKINPUT_MEMBER_BLOCK_DATA,
         &PUTSNAPSHOTBLOCKINPUT_MEMBER_DATA_LENGTH,
         &PUTSNAPSHOTBLOCKINPUT_MEMBER_CHECKSUM_ALGORITHM,
     ],
 );
-+
+)
 .with_http(aws_smithy_schema::traits::HttpTrait::new(
     "PUT",
     "/snapshots/{SnapshotId}/blocks/{BlockIndex}",
     Some(201),
 ));
 impl PutSnapshotBlockInput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTSNAPSHOTBLOCKINPUT_SCHEMA;
-170
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutSnapshotBlockInput {
     #[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.snapshot_id {
             ser.write_string(&PUTSNAPSHOTBLOCKINPUT_MEMBER_SNAPSHOT_ID, val)?;
-179
+        }
         if let Some(ref val) = self.block_index {
             ser.write_integer(&PUTSNAPSHOTBLOCKINPUT_MEMBER_BLOCK_INDEX, *val)?;
-182
+        }
         if let Some(ref val) = self.checksum {
             ser.write_string(&PUTSNAPSHOTBLOCKINPUT_MEMBER_CHECKSUM, val)?;
-185
+        }
         if let Some(ref val) = self.progress {
             ser.write_integer(&PUTSNAPSHOTBLOCKINPUT_MEMBER_PROGRESS, *val)?;
-188
+        }
--
+        {
             let val = &self.block_data;
             // streaming blob is serialized as the HTTP body by the protocol, not the codec
--
+        }
         if let Some(ref val) = self.data_length {
             ser.write_integer(&PUTSNAPSHOTBLOCKINPUT_MEMBER_DATA_LENGTH, *val)?;
-191
+        }
         if let Some(ref val) = self.checksum_algorithm {
             ser.write_string(&PUTSNAPSHOTBLOCKINPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-194
+        }
         Ok(())
-196
+    }
-197
+}
 impl PutSnapshotBlockInput {
     /// 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(&PUTSNAPSHOTBLOCKINPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTSNAPSHOTBLOCKINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-216
+                }
                 Some(1) => {
                     builder.block_index = Some(deser.read_integer(member)?);
-219
+                }
                 Some(2) => {
                     builder.checksum = Some(deser.read_string(member)?);
-222
+                }
                 Some(3) => {
                     builder.progress = Some(deser.read_integer(member)?);
-225
+                }
                 Some(4) => {
                     builder.block_data = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-231
+                }
                 Some(5) => {
                     builder.data_length = Some(deser.read_integer(member)?);
-234
+                }
                 Some(6) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-237
+                }
                 _ => {}
-239
+            }
             Ok(())
         })?;
         builder.snapshot_id = builder.snapshot_id.or(Some(String::new()));
         builder.block_index = builder.block_index.or(Some(0i32));
         builder.checksum = builder.checksum.or(Some(String::new()));
         builder.data_length = builder.data_length.or(Some(0i32));
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-+
+    }
-+
+}
 impl PutSnapshotBlockInput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-Checksum") {
             builder.checksum = Some(val.to_string());
-+
+        }
         if let Some(val) = headers.get("x-amz-Progress") {
             builder.progress = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-Data-Length") {
             builder.data_length = val.parse::<i32>().ok();
-+
+        }
         if let Some(val) = headers.get("x-amz-Checksum-Algorithm") {
             builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
-+
+        }
         #[allow(
             unused_variables,
             unreachable_code,
             clippy::single_match,
             clippy::match_single_binding,
             clippy::diverging_sub_expression
         )]
         deserializer.read_struct(&PUTSNAPSHOTBLOCKINPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.snapshot_id = Some(deser.read_string(member)?);
-+
+                }
                 Some(1) => {
                     builder.block_index = Some(deser.read_integer(member)?);
-+
+                }
                 Some(2) => { /* read from headers above */ }
                 Some(3) => { /* read from headers above */ }
                 Some(4) => {
                     builder.block_data = Some({
                         let _ = member;
                         ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
                     });
-+
+                }
                 Some(5) => { /* read from headers above */ }
                 Some(6) => { /* read from headers above */ }
                 _ => {}
-+
+            }
             Ok(())
         })?;
         builder
             .build()
             .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
-307
+    }
-308
+}
 impl PutSnapshotBlockInput {
     /// Creates a new builder-style object to manufacture [`PutSnapshotBlockInput`](crate::operation::put_snapshot_block::PutSnapshotBlockInput).
     pub fn builder() -> crate::operation::put_snapshot_block::builders::PutSnapshotBlockInputBuilder {
         crate::operation::put_snapshot_block::builders::PutSnapshotBlockInputBuilder::default()
-313
+    }

↧ Expand context

-314
+}
-315
 /// A builder for [`PutSnapshotBlockInput`](crate::operation::put_snapshot_block::PutSnapshotBlockInput).
 #[derive(::std::default::Default)]
 #[non_exhaustive]
 pub struct PutSnapshotBlockInputBuilder {
     pub(crate) snapshot_id: ::std::option::Option<::std::string::String>,
     pub(crate) block_index: ::std::option::Option<i32>,
     pub(crate) checksum: ::std::option::Option<::std::string::String>,
     pub(crate) progress: ::std::option::Option<i32>,
     pub(crate) block_data: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
     pub(crate) data_length: ::std::option::Option<i32>,
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
-327
+}
 impl PutSnapshotBlockInputBuilder {
     /// <p>The ID of the snapshot.</p>
     /// This field is required.
     pub fn snapshot_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.snapshot_id = ::std::option::Option::Some(input.into());
         self

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/put_snapshot_block/_put_snapshot_block_output.rs

@@ -3,3 +130,151 @@

↥ Expand context

 #[non_exhaustive]
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct PutSnapshotBlockOutput {
     /// <p>The algorithm used by Amazon EBS to generate the checksum.</p>
     pub checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     /// <p>The SHA256 checksum generated for the block data by Amazon EBS.</p>
     pub checksum: ::std::option::Option<::std::string::String>,
-10
+}
 impl PutSnapshotBlockOutput {
     /// <p>The algorithm used by Amazon EBS to generate the checksum.</p>
     pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::types::ChecksumAlgorithm> {
         self.checksum_algorithm.as_ref()
-15
+    }
     /// <p>The SHA256 checksum generated for the block data by Amazon EBS.</p>
     pub fn checksum(&self) -> ::std::option::Option<&str> {
         self.checksum.as_deref()
-19
+    }
-20
+}
 static PUTSNAPSHOTBLOCKOUTPUT_SCHEMA_ID: ::aws_smithy_schema::ShapeId = ::aws_smithy_schema::ShapeId::from_static(
     "com.amazonaws.ebs.synthetic#PutSnapshotBlockOutput",

     "com.amazonaws.ebs.synthetic",
     "PutSnapshotBlockOutput",
 );
 static PUTSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM_ALGORITHM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#PutSnapshotBlockOutput$ChecksumAlgorithm",
         "com.amazonaws.ebs.synthetic",
         "PutSnapshotBlockOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum_algorithm",
     "ChecksumAlgorithm",
 ,
-35
+)
 .with_http_header("x-amz-Checksum-Algorithm");
 static PUTSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
     ::aws_smithy_schema::ShapeId::from_static(
         "com.amazonaws.ebs.synthetic#PutSnapshotBlockOutput$Checksum",
         "com.amazonaws.ebs.synthetic",
         "PutSnapshotBlockOutput",
     ),
     ::aws_smithy_schema::ShapeType::String,
     "checksum",
     "Checksum",
 ,
-46
+)
 .with_http_header("x-amz-Checksum");
 static PUTSNAPSHOTBLOCKOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
     PUTSNAPSHOTBLOCKOUTPUT_SCHEMA_ID,
     ::aws_smithy_schema::ShapeType::Structure,
     &[&PUTSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM_ALGORITHM, &PUTSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM],
 );
 impl PutSnapshotBlockOutput {
     /// The schema for this shape.
     pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PUTSNAPSHOTBLOCKOUTPUT_SCHEMA;
-56
+}
 impl ::aws_smithy_schema::serde::SerializableStruct for PutSnapshotBlockOutput {
     #[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.checksum_algorithm {
             ser.write_string(&PUTSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM_ALGORITHM, val.as_str())?;
-65
+        }
         if let Some(ref val) = self.checksum {
             ser.write_string(&PUTSNAPSHOTBLOCKOUTPUT_MEMBER_CHECKSUM, val)?;
-68
+        }
         Ok(())
-70
+    }
-71
+}
 impl PutSnapshotBlockOutput {
     /// 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(&PUTSNAPSHOTBLOCKOUTPUT_SCHEMA, (), |_, member, deser| {
         deserializer.read_struct(&PUTSNAPSHOTBLOCKOUTPUT_SCHEMA, &mut |member, deser| {
             match member.member_index() {
                 Some(0) => {
                     builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(deser.read_string(member)?.as_str()));
-90
+                }
                 Some(1) => {
                     builder.checksum = Some(deser.read_string(member)?);
-93
+                }
                 _ => {}
-95
+            }
             Ok(())
         })?;
         Ok(builder.build())
-99
+    }
-100
+}
 impl PutSnapshotBlockOutput {
     /// Deserializes this structure from a body deserializer and HTTP response headers.
     /// Header-bound members are read directly from headers, avoiding runtime
     /// member iteration overhead. Body members are read via the deserializer.
     pub fn deserialize_with_response(
         _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         headers: &::aws_smithy_runtime_api::http::Headers,
         _status: u16,
         _body: &[u8],
     ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         #[allow(unused_variables, unused_mut)]
         let mut builder = Self::builder();
         if let Some(val) = headers.get("x-amz-Checksum-Algorithm") {
             builder.checksum_algorithm = Some(crate::types::ChecksumAlgorithm::from(val));
-+
+        }
         if let Some(val) = headers.get("x-amz-Checksum") {
             builder.checksum = Some(val.to_string());
-+
+        }
         Ok(builder.build())
-+
+    }
-+
+}
 impl PutSnapshotBlockOutput {
     /// Creates a new builder-style object to manufacture [`PutSnapshotBlockOutput`](crate::operation::put_snapshot_block::PutSnapshotBlockOutput).
     pub fn builder() -> crate::operation::put_snapshot_block::builders::PutSnapshotBlockOutputBuilder {
         crate::operation::put_snapshot_block::builders::PutSnapshotBlockOutputBuilder::default()
-126
+    }
-127
+}
-128
 /// A builder for [`PutSnapshotBlockOutput`](crate::operation::put_snapshot_block::PutSnapshotBlockOutput).
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 #[non_exhaustive]

↧ Expand context

 pub struct PutSnapshotBlockOutputBuilder {
     pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
     pub(crate) checksum: ::std::option::Option<::std::string::String>,
-135
+}
 impl PutSnapshotBlockOutputBuilder {
     /// <p>The algorithm used by Amazon EBS to generate the checksum.</p>
     pub fn checksum_algorithm(mut self, input: crate::types::ChecksumAlgorithm) -> Self {
         self.checksum_algorithm = ::std::option::Option::Some(input);
         self
-141
+    }
     /// <p>The algorithm used by Amazon EBS to generate the checksum.</p>
     pub fn set_checksum_algorithm(mut self, input: ::std::option::Option<crate::types::ChecksumAlgorithm>) -> Self {
         self.checksum_algorithm = input;
         self
-146
+    }
     /// <p>The algorithm used by Amazon EBS to generate the checksum.</p>
     pub fn get_checksum_algorithm(&self) -> &::std::option::Option<crate::types::ChecksumAlgorithm> {
         &self.checksum_algorithm
-150
+    }
     /// <p>The SHA256 checksum generated for the block data by Amazon EBS.</p>

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/operation/start_snapshot.rs

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

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

@@ -109,113 +231,441 @@

↥ Expand context

         ));
-114
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::SensitiveOutput);
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("StartSnapshot", "EBS"));
-117
         ::std::option::Option::Some(cfg.freeze())
-119
+    }
-120
     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("StartSnapshot")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(StartSnapshotEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::start_snapshot::StartSnapshotError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<

                 crate::operation::start_snapshot::StartSnapshotError,
             >::new());
-135
         ::std::borrow::Cow::Owned(rcb)
-137
+    }
-138
+}
-139
 #[derive(Debug)]
 struct StartSnapshotResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StartSnapshotResponseDeserializer {
     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());
         #[allow(unused_mut)]
         let mut force_error = false;
-+
         if !success && status != 201 || force_error {
             let headers = response.headers();
             let body = response.body().bytes().expect("body loaded");
             #[allow(unused_mut)]
         let mut force_error = false;
             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))
             })?;
-159
         let parse_result = if !success && status != 201 || force_error {
             crate::protocol_serde::shape_start_snapshot::de_start_snapshot_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_start_snapshot::de_start_snapshot_http_response(status, headers, body)
             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::start_snapshot::StartSnapshotError::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 {
                 "AccessDeniedException" => crate::operation::start_snapshot::StartSnapshotError::AccessDeniedError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::AccessDeniedError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::AccessDeniedError::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
                 }),
                 "ConcurrentLimitExceededException" => crate::operation::start_snapshot::StartSnapshotError::ConcurrentLimitExceededError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ConcurrentLimitExceededError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ConcurrentLimitExceededError::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
                 }),
                 "ConflictException" => crate::operation::start_snapshot::StartSnapshotError::ConflictError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ConflictError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ConflictError::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
                 }),
                 "InternalServerException" => crate::operation::start_snapshot::StartSnapshotError::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
                 }),
                 "RequestThrottledException" => crate::operation::start_snapshot::StartSnapshotError::RequestThrottledError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::RequestThrottledError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::RequestThrottledError::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::start_snapshot::StartSnapshotError::ResourceNotFoundError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ResourceNotFoundError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ResourceNotFoundError::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
                 }),
                 "ServiceQuotaExceededException" => crate::operation::start_snapshot::StartSnapshotError::ServiceQuotaExceededError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ServiceQuotaExceededError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ServiceQuotaExceededError::deserialize_with_response(
                                 &mut *deser,
                                 response.headers(),
                                 response.status().into(),
                                 body,
-+
+                            )
                         }) {
                         ::std::result::Result::Ok(val) => val,
                         ::std::result::Result::Err(e) => {
                             return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
                                 ::aws_smithy_runtime_api::box_error::BoxError::from(e),
                             ))
-+
+                        }
                     };
         crate::protocol_serde::type_erase_result(parse_result)
                     tmp.meta = generic;
                     if tmp.message.is_none() {
                         tmp.message = _error_message;
-+
+                    }
                     tmp
                 }),
                 "ValidationException" => crate::operation::start_snapshot::StartSnapshotError::ValidationError({
                     let mut tmp = match protocol
                         .deserialize_response(response, crate::types::error::ValidationError::SCHEMA, _cfg)
                         .and_then(|mut deser| {
                             crate::types::error::ValidationError::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::start_snapshot::StartSnapshotError::generic(generic),
             };
             ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
                 ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
             ))
         } else {
             let protocol = _cfg
                 .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
                 .expect("a SharedClientProtocol is required");
             let mut deser = protocol.deserialize_response(response, StartSnapshot::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::start_snapshot::StartSnapshotOutput::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))
-+
+        }
-390
+    }
-391
+}
 #[derive(Debug)]
 struct StartSnapshotRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartSnapshotRequestSerializer {
     #[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::start_snapshot::StartSnapshotInput>()
             .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::start_snapshot::StartSnapshotInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/snapshots").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
--
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::start_snapshot::StartSnapshotInput,
                 builder: ::http_1x::request::Builder,
             ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
--
+            }
             let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_start_snapshot::ser_start_snapshot_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, StartSnapshot::INPUT_SCHEMA, "", _cfg)
             .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
-+
         return ::std::result::Result::Ok(request);
-412
+    }
-413
+}
 #[derive(Debug)]
 struct StartSnapshotEndpointParamsInterceptor;
-416
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartSnapshotEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StartSnapshotEndpointParamsInterceptor"
-420
+    }
-421

↧ 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::<StartSnapshotInput>()
             .ok_or("failed to downcast to StartSnapshotInput")?;
-436
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));

Client Test

Files changed: