Server Test

rev. b439bcba7c1ed0789341e9e7b416682ed5a8c82a

Files changed:

tmp-codegen-diff/codegen-server-test/rest_json/rust-server-codegen/src/protocol_serde/shape_http_request_with_labels_and_timestamp_format.rs

@@ -54,54 +133,133 @@

                     ::nom::bytes::complete::tag("/"),
                     ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((
                         ::nom::bytes::complete::take_until("/"),
                         ::nom::combinator::rest,
                     )),
                 ),
                 ::nom::sequence::preceded(
                     ::nom::bytes::complete::tag("/"),
                     ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((
                         ::nom::bytes::complete::take_until("/"),
                         ::nom::combinator::rest,
                     )),
                 ),
                 ::nom::sequence::preceded(
                     ::nom::bytes::complete::tag("/"),
                     ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((
                         ::nom::bytes::complete::take_until("/"),
                         ::nom::combinator::rest,
                     )),
                 ),

                 ::nom::sequence::preceded(
                     ::nom::bytes::complete::tag("/"),
                     ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((
                         ::nom::bytes::complete::take_until("/"),
                         ::nom::combinator::rest,
                     )),
                 ),
             ))(input_string)?;
         debug_assert_eq!("", input_string);
         input = input.set_member_epoch_seconds(
                                         crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_member_epoch_seconds(m1)?
                                     );
                                     crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_member_epoch_seconds(m1)?
                                 );
         input = input.set_member_http_date(
                                         crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_member_http_date(m2)?
                                     );
                                     crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_member_http_date(m2)?
                                 );
         input = input.set_member_date_time(
                                         crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_member_date_time(m3)?
                                     );
                                     crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_member_date_time(m3)?
                                 );
         input = input.set_default_format(
                                         crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_default_format(m4)?
                                     );
                                     crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_default_format(m4)?
                                 );
         input = input.set_target_epoch_seconds(
                                         crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_target_epoch_seconds(m5)?
                                     );
                                     crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_target_epoch_seconds(m5)?
                                 );
         input = input.set_target_http_date(
                                         crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_target_http_date(m6)?
                                     );
                                     crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_target_http_date(m6)?
                                 );
         input = input.set_target_date_time(
                                         crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_target_date_time(m7)?
                                     );
                                     crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format_input::de_target_date_time(m7)?
                                 );
         input.build()?
     })
-106
+}
-107
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_http_request_with_labels_and_timestamp_format_http_response(
     #[allow(unused_variables)] output: crate::output::HttpRequestWithLabelsAndTimestampFormatOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,

↧ Expand context

 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             "application/json",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload = "";
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?

tmp-codegen-diff/codegen-server-test/rest_json_extras/rust-server-codegen/src/operation.rs

@@ -22,22 +82,81 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-23
+    }
-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::QueryPrecedenceInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = QueryPrecedenceInputFuture;
-41

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_QUERYPRECEDENCE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_query_precedence::de_query_precedence_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-59
+                )
             },
         );

↧ Expand context

         QueryPrecedenceInputFuture {
             inner: Box::pin(fut),
-64
+        }
-65
+    }
-66
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::QueryPrecedenceOutput
-71
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-80
+            }
-81
+        }

@@ -213,212 +273,271 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-213
+    }
-214
+}
-215
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EmptyStructWithContentOnWireOpInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-224
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-228
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EmptyStructWithContentOnWireOpInputFuture;
-231

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_EMPTYSTRUCTWITHCONTENTONWIREOP,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-239
+            }
             crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::de_empty_struct_with_content_on_wire_op_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-249
+                )
             },
         );

↧ Expand context

         EmptyStructWithContentOnWireOpInputFuture {
             inner: Box::pin(fut),
-254
+        }
-255
+    }
-256
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EmptyStructWithContentOnWireOpOutput
-261
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_struct_with_content_on_wire_op::ser_empty_struct_with_content_on_wire_op_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-268
+                        }
-269
+                    }
-270
+    }
-271
+}

@@ -346,344 +406,403 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-345
+    }
-346
+}
-347
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::CaseInsensitiveErrorOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-356
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-360
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = CaseInsensitiveErrorOperationInputFuture;
-363

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_CASEINSENSITIVEERROROPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-371
+            }
             crate::protocol_serde::shape_case_insensitive_error_operation::de_case_insensitive_error_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-381
+                )
             },
         );

↧ Expand context

         CaseInsensitiveErrorOperationInputFuture {
             inner: Box::pin(fut),
-386
+        }
-387
+    }
-388
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::CaseInsensitiveErrorOperationOutput
-393
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_case_insensitive_error_operation::ser_case_insensitive_error_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-400
+                        }
-401
+                    }
-402
+    }
-403
+}

@@ -481,478 +541,537 @@

↥ Expand context

-478
+}
-479
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::NullInNonSparseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-488
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-492
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = NullInNonSparseInputFuture;
-495
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_NULLINNONSPARSE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-503
+            }
             crate::protocol_serde::shape_null_in_non_sparse::de_null_in_non_sparse_http_request(
                 request,
-506
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-515
+                )
             },
         );

↧ Expand context

         NullInNonSparseInputFuture {
             inner: Box::pin(fut),
-520
+        }
-521
+    }
-522
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::NullInNonSparseOutput
-527
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_null_in_non_sparse::ser_null_in_non_sparse_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-536
+            }
-537
+        }

@@ -620,616 +680,675 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-617
+    }
-618
+}
-619
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EscapedStringValuesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-628
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-632
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = EscapedStringValuesInputFuture;
-635

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ESCAPEDSTRINGVALUES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-643
+            }
             crate::protocol_serde::shape_escaped_string_values::de_escaped_string_values_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-653
+                )
             },
         );

↧ Expand context

         EscapedStringValuesInputFuture {
             inner: Box::pin(fut),
-658
+        }
-659
+    }
-660
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EscapedStringValuesOutput
-665
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_escaped_string_values::ser_escaped_string_values_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-672
+                        }
-673
+                    }
-674
+    }
-675
+}

@@ -834,829 +894,888 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-830
+    }
-831
+}
-832
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PrimitiveIntOpInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-841
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-845
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PrimitiveIntOpInputFuture;
-848

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PRIMITIVEINTOP,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-856
+            }
             crate::protocol_serde::shape_primitive_int_op::de_primitive_int_op_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-866
+                )
             },
         );

↧ Expand context

         PrimitiveIntOpInputFuture {
             inner: Box::pin(fut),
-871
+        }
-872
+    }
-873
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PrimitiveIntOpOutput
-878
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_op::ser_primitive_int_op_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-887
+            }
-888
+        }

@@ -974,968 +1034,1027 @@

↥ Expand context

-968
+}
-969
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MapWithEnumKeyOpInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-978
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-982
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MapWithEnumKeyOpInputFuture;
-985
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MAPWITHENUMKEYOP,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-993
+            }
             crate::protocol_serde::shape_map_with_enum_key_op::de_map_with_enum_key_op_http_request(
                 request,
-996
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1005
+                )
             },
         );

↧ Expand context

         MapWithEnumKeyOpInputFuture {
             inner: Box::pin(fut),
-1010
+        }
-1011
+    }
-1012
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MapWithEnumKeyOpOutput
-1017
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_map_with_enum_key_op::ser_map_with_enum_key_op_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1024
+                        }
-1025
+                    }
-1026
+    }
-1027
+}

@@ -1199,1192 +1259,1251 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1193
+    }
-1194
+}
-1195
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StatusResponseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1204
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1208
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StatusResponseInputFuture;
-1211

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STATUSRESPONSE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1219
+            }
             crate::protocol_serde::shape_status_response::de_status_response_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1229
+                )
             },
         );

↧ Expand context

         StatusResponseInputFuture {
             inner: Box::pin(fut),
-1234
+        }
-1235
+    }
-1236
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StatusResponseOutput
-1241
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_status_response::ser_status_response_http_response(self)
-1244
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1249
+            }
-1250
+        }
-1251
+    }

@@ -1333,1325 +1395,1385 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1328
+    }
-1329
+}
-1330
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::EnumQueryInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1339
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1343
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = EnumQueryInputFuture;
-1346
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ENUMQUERY,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1354
+            }
             crate::protocol_serde::shape_enum_query::de_enum_query_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_enum_query::de_enum_query_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1363
+                )
             },
         );

↧ Expand context

         EnumQueryInputFuture {
             inner: Box::pin(fut),
-1368
+        }
-1369
+    }
-1370
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::EnumQueryOutput
-1375
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_enum_query::ser_enum_query_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1382
+            }
-1383
+        }
-1384
+    }
-1385
+}

@@ -1514,1504 +1574,1563 @@

↥ Expand context

-1504
+}
-1505
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::PrimitiveIntHeaderInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1514
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1518
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = PrimitiveIntHeaderInputFuture;
-1521
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_PRIMITIVEINTHEADER,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1529
+            }
             crate::protocol_serde::shape_primitive_int_header::de_primitive_int_header_http_request(
                 request,
-1532
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1541
+                )
             },
         );

↧ Expand context

         PrimitiveIntHeaderInputFuture {
             inner: Box::pin(fut),
-1546
+        }
-1547
+    }
-1548
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::PrimitiveIntHeaderOutput
-1553
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_primitive_int_header::ser_primitive_int_header_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1560
+                        }
-1561
+                    }
-1562
+    }
-1563
+}

@@ -1686,1675 +1746,1734 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1676
+    }
-1677
+}
-1678
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::StringPayloadInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1687
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1691
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = StringPayloadInputFuture;
-1694

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_STRINGPAYLOAD,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1702
+            }
             crate::protocol_serde::shape_string_payload::de_string_payload_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1712
+                )
             },
         );

↧ Expand context

         StringPayloadInputFuture {
             inner: Box::pin(fut),
-1717
+        }
-1718
+    }
-1719
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::StringPayloadOutput
-1724
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_string_payload::ser_string_payload_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1731
+            }
-1732
+        }
-1733
+    }
-1734
+}

tmp-codegen-diff/codegen-server-test/rest_json_validation/rust-server-codegen/src/operation.rs

@@ -24,24 +84,83 @@

↥ Expand context

-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::SensitiveValidationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = SensitiveValidationInputFuture;
-41
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SENSITIVEVALIDATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_sensitive_validation::de_sensitive_validation_http_request(
                 request,
-52
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-61
+                )
             },
         );

↧ Expand context

         SensitiveValidationInputFuture {
             inner: Box::pin(fut),
-66
+        }
-67
+    }
-68
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::SensitiveValidationOutput
-73
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_sensitive_validation::ser_sensitive_validation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-80
+                        }
-81
+                    }
-82
+    }
-83
+}

@@ -188,187 +248,246 @@

↥ Expand context

-187
+}
-188
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::RecursiveStructuresInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-197
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-201
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = RecursiveStructuresInputFuture;
-204
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RECURSIVESTRUCTURES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-212
+            }
             crate::protocol_serde::shape_recursive_structures::de_recursive_structures_http_request(
                 request,
-215
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-224
+                )
             },
         );

↧ Expand context

         RecursiveStructuresInputFuture {
             inner: Box::pin(fut),
-229
+        }
-230
+    }
-231
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::RecursiveStructuresOutput
-236
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_recursive_structures::ser_recursive_structures_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-243
+                        }
-244
+                    }
-245
+    }
-246
+}

@@ -403,401 +463,460 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-402
+    }
-403
+}
-404
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedUniqueItemsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-413
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-417
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedUniqueItemsInputFuture;
-420

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDUNIQUEITEMS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-428
+            }
             crate::protocol_serde::shape_malformed_unique_items::de_malformed_unique_items_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-438
+                )
             },
         );

↧ Expand context

         MalformedUniqueItemsInputFuture {
             inner: Box::pin(fut),
-443
+        }
-444
+    }
-445
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedUniqueItemsOutput
-450
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_unique_items::ser_malformed_unique_items_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-457
+                        }
-458
+                    }
-459
+    }
-460
+}

@@ -1480,1477 +1540,1536 @@

↥ Expand context

-1477
+}
-1478
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedRequiredInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1487
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1491
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedRequiredInputFuture;
-1494
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDREQUIRED,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1502
+            }
             crate::protocol_serde::shape_malformed_required::de_malformed_required_http_request(
                 request,
-1505
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1514
+                )
             },
         );

↧ Expand context

         MalformedRequiredInputFuture {
             inner: Box::pin(fut),
-1519
+        }
-1520
+    }
-1521
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedRequiredOutput
-1526
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_required::ser_malformed_required_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1535
+            }
-1536
+        }

@@ -1755,1751 +1815,1810 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1752
+    }
-1753
+}
-1754
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedRangeOverrideInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1763
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1767
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedRangeOverrideInputFuture;
-1770

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDRANGEOVERRIDE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-1778
+            }
             crate::protocol_serde::shape_malformed_range_override::de_malformed_range_override_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-1788
+                )
             },
         );

↧ Expand context

         MalformedRangeOverrideInputFuture {
             inner: Box::pin(fut),
-1793
+        }
-1794
+    }
-1795
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedRangeOverrideOutput
-1800
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_range_override::ser_malformed_range_override_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-1807
+                        }
-1808
+                    }
-1809
+    }
-1810
+}

@@ -2924,2919 +2984,2978 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-2920
+    }
-2921
+}
-2922
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedRangeInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2931
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2935
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedRangeInputFuture;
-2938

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDRANGE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-2946
+            }
             crate::protocol_serde::shape_malformed_range::de_malformed_range_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-2956
+                )
             },
         );

↧ Expand context

         MalformedRangeInputFuture {
             inner: Box::pin(fut),
-2961
+        }
-2962
+    }
-2963
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedRangeOutput
-2968
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_range::ser_malformed_range_http_response(self)
-2971
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-2976
+            }
-2977
+        }
-2978
+    }

@@ -4096,4090 +4156,4149 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-4091
+    }
-4092
+}
-4093
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedPatternOverrideInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-4102
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-4106
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedPatternOverrideInputFuture;
-4109

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDPATTERNOVERRIDE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4117
+            }
             crate::protocol_serde::shape_malformed_pattern_override::de_malformed_pattern_override_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-4127
+                )
             },
         );

↧ Expand context

         MalformedPatternOverrideInputFuture {
             inner: Box::pin(fut),
-4132
+        }
-4133
+    }
-4134
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedPatternOverrideOutput
-4139
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_pattern_override::ser_malformed_pattern_override_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4146
+                        }
-4147
+                    }
-4148
+    }
-4149
+}

@@ -4733,4726 +4793,4785 @@

↥ Expand context

-4726
+}
-4727
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedPatternInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-4736
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-4740
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedPatternInputFuture;
-4743
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDPATTERN,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-4751
+            }
             crate::protocol_serde::shape_malformed_pattern::de_malformed_pattern_http_request(
                 request,
-4754
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-4763
+                )
             },
         );

↧ Expand context

         MalformedPatternInputFuture {
             inner: Box::pin(fut),
-4768
+        }
-4769
+    }
-4770
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedPatternOutput
-4775
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_pattern::ser_malformed_pattern_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-4784
+            }
-4785
+        }

@@ -5477,5469 +5537,5528 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-5470
+    }
-5471
+}
-5472
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedLengthQueryStringInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-5481
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-5485
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedLengthQueryStringInputFuture;
-5488

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLENGTHQUERYSTRING,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5496
+            }
             crate::protocol_serde::shape_malformed_length_query_string::de_malformed_length_query_string_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-5506
+                )
             },
         );

↧ Expand context

         MalformedLengthQueryStringInputFuture {
             inner: Box::pin(fut),
-5511
+        }
-5512
+    }
-5513
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedLengthQueryStringOutput
-5518
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_length_query_string::ser_malformed_length_query_string_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5525
+                        }
-5526
+                    }
-5527
+    }
-5528
+}

@@ -5636,5627 +5696,5686 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-5628
+    }
-5629
+}
-5630
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedLengthOverrideInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-5639
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-5643
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedLengthOverrideInputFuture;
-5646

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLENGTHOVERRIDE,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-5654
+            }
             crate::protocol_serde::shape_malformed_length_override::de_malformed_length_override_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-5664
+                )
             },
         );

↧ Expand context

         MalformedLengthOverrideInputFuture {
             inner: Box::pin(fut),
-5669
+        }
-5670
+    }
-5671
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedLengthOverrideOutput
-5676
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_length_override::ser_malformed_length_override_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-5683
+                        }
-5684
+                    }
-5685
+    }
-5686
+}

@@ -6318,6308 +6378,6367 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-6309
+    }
-6310
+}
-6311
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedLengthInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-6320
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-6324
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedLengthInputFuture;
-6327

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDLENGTH,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-6335
+            }
             crate::protocol_serde::shape_malformed_length::de_malformed_length_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-6345
+                )
             },
         );

↧ Expand context

         MalformedLengthInputFuture {
             inner: Box::pin(fut),
-6350
+        }
-6351
+    }
-6352
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedLengthOutput
-6357
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_length::ser_malformed_length_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-6366
+            }
-6367
+        }

@@ -7317,7306 +7377,7365 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-7307
+    }
-7308
+}
-7309
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedEnumInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-7318
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-7322
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedEnumInputFuture;
-7325

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDENUM,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-7333
+            }
             crate::protocol_serde::shape_malformed_enum::de_malformed_enum_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-7343
+                )
             },
         );

↧ Expand context

         MalformedEnumInputFuture {
             inner: Box::pin(fut),
-7348
+        }
-7349
+    }
-7350
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedEnumOutput
-7355
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_enum::ser_malformed_enum_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-7362
+            }
-7363
+        }
-7364
+    }
-7365
+}

tmp-codegen-diff/codegen-server-test/rpcv2Cbor/rust-server-codegen/src/operation.rs

@@ -24,24 +86,84 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-27
+    }
-28
+}
-29
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::Float16Input
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-38
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-42
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;

     type Future = Float16InputFuture;
-45
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_FLOAT16,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-53
+            }
             crate::protocol_serde::shape_float16::de_float16_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_float16::de_float16_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-62
+                )
             },
         );

↧ Expand context

         Float16InputFuture {
             inner: Box::pin(fut),
-67
+        }
-68
+    }
-69
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::Float16Output
-74
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_float16::ser_float16_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-81
+            }
-82
+        }
-83
+    }
-84
+}

@@ -113,111 +173,170 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-112
+    }
-113
+}
-114
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::SparseNullsOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-123
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-127
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = SparseNullsOperationInputFuture;
-130

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SPARSENULLSOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-138
+            }
             crate::protocol_serde::shape_sparse_nulls_operation::de_sparse_nulls_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-148
+                )
             },
         );

↧ Expand context

         SparseNullsOperationInputFuture {
             inner: Box::pin(fut),
-153
+        }
-154
+    }
-155
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::SparseNullsOperationOutput
-160
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_sparse_nulls_operation::ser_sparse_nulls_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-167
+                        }
-168
+                    }
-169
+    }
-170
+}

@@ -387,384 +447,443 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-385
+    }
-386
+}
-387
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::OperationWithDefaultsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-396
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-400
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = OperationWithDefaultsInputFuture;
-403

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATIONWITHDEFAULTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-411
+            }
             crate::protocol_serde::shape_operation_with_defaults::de_operation_with_defaults_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-421
+                )
             },
         );

↧ Expand context

         OperationWithDefaultsInputFuture {
             inner: Box::pin(fut),
-426
+        }
-427
+    }
-428
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::OperationWithDefaultsOutput
-433
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-440
+                        }
-441
+                    }
-442
+    }
-443
+}

@@ -664,660 +724,719 @@

↥ Expand context

-660
+}
-661
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::FractionalSecondsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-670
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-674
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = FractionalSecondsInputFuture;
-677
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_FRACTIONALSECONDS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-685
+            }
             crate::protocol_serde::shape_fractional_seconds::de_fractional_seconds_http_request(
                 request,
-688
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-697
+                )
             },
         );

↧ Expand context

         FractionalSecondsInputFuture {
             inner: Box::pin(fut),
-702
+        }
-703
+    }
-704
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::FractionalSecondsOutput
-709
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_fractional_seconds::ser_fractional_seconds_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-718
+            }
-719
+        }

@@ -755,750 +815,809 @@

↥ Expand context

-750
+}
-751
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::GreetingWithErrorsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-760
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-764
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = GreetingWithErrorsInputFuture;
-767
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GREETINGWITHERRORS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-775
+            }
             crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_request(
                 request,
-778
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-787
+                )
             },
         );

↧ Expand context

         GreetingWithErrorsInputFuture {
             inner: Box::pin(fut),
-792
+        }
-793
+    }
-794
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::GreetingWithErrorsOutput
-799
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-806
+                        }
-807
+                    }
-808
+    }
-809
+}

@@ -966,960 +1026,1019 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-961
+    }
-962
+}
-963
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::RecursiveShapesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-972
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-976
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = RecursiveShapesInputFuture;
-979

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RECURSIVESHAPES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-987
+            }
             crate::protocol_serde::shape_recursive_shapes::de_recursive_shapes_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-997
+                )
             },
         );

↧ Expand context

         RecursiveShapesInputFuture {
             inner: Box::pin(fut),
-1002
+        }
-1003
+    }
-1004
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::RecursiveShapesOutput
-1009
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_recursive_shapes::ser_recursive_shapes_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-1018
+            }
-1019
+        }

@@ -1210,1203 +1270,1262 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1204
+    }
-1205
+}
-1206
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::RpcV2CborSparseMapsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1215
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1219
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = RpcV2CborSparseMapsInputFuture;
-1222

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RPCV2CBORSPARSEMAPS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-1230
+            }
             crate::protocol_serde::shape_rpc_v2_cbor_sparse_maps::de_rpc_v2_cbor_sparse_maps_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-1240
+                )
             },
         );

↧ Expand context

         RpcV2CborSparseMapsInputFuture {
             inner: Box::pin(fut),
-1245
+        }
-1246
+    }
-1247
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::RpcV2CborSparseMapsOutput
-1252
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_rpc_v2_cbor_sparse_maps::ser_rpc_v2_cbor_sparse_maps_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-1259
+                        }
-1260
+                    }
-1261
+    }
-1262
+}

@@ -1939,1931 +1999,1990 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-1932
+    }
-1933
+}
-1934
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::RpcV2CborDenseMapsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1943
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1947
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = RpcV2CborDenseMapsInputFuture;
-1950

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RPCV2CBORDENSEMAPS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-1958
+            }
             crate::protocol_serde::shape_rpc_v2_cbor_dense_maps::de_rpc_v2_cbor_dense_maps_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-1968
+                )
             },
         );

↧ Expand context

         RpcV2CborDenseMapsInputFuture {
             inner: Box::pin(fut),
-1973
+        }
-1974
+    }
-1975
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::RpcV2CborDenseMapsOutput
-1980
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_rpc_v2_cbor_dense_maps::ser_rpc_v2_cbor_dense_maps_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-1987
+                        }
-1988
+                    }
-1989
+    }
-1990
+}

@@ -2408,2399 +2468,2458 @@

↥ Expand context

-2399
+}
-2400
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::RpcV2CborListsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-2409
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-2413
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = RpcV2CborListsInputFuture;
-2416
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RPCV2CBORLISTS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-2424
+            }
             crate::protocol_serde::shape_rpc_v2_cbor_lists::de_rpc_v2_cbor_lists_http_request(
                 request,
-2427
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-2436
+                )
             },
         );

↧ Expand context

         RpcV2CborListsInputFuture {
             inner: Box::pin(fut),
-2441
+        }
-2442
+    }
-2443
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::RpcV2CborListsOutput
-2448
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_rpc_v2_cbor_lists::ser_rpc_v2_cbor_lists_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-2457
+            }
-2458
+        }

@@ -3018,3008 +3078,3067 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-3009
+    }
-3010
+}
-3011
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::SimpleScalarPropertiesInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-3020
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-3024
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = SimpleScalarPropertiesInputFuture;
-3027

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SIMPLESCALARPROPERTIES,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-3035
+            }
             crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-3045
+                )
             },
         );

↧ Expand context

         SimpleScalarPropertiesInputFuture {
             inner: Box::pin(fut),
-3050
+        }
-3051
+    }
-3052
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::SimpleScalarPropertiesOutput
-3057
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-3064
+                        }
-3065
+                    }
-3066
+    }
-3067
+}

@@ -4714,4703 +4774,4762 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-4704
+    }
-4705
+}
-4706
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::OptionalInputOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-4715
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-4719
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = OptionalInputOutputInputFuture;
-4722

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPTIONALINPUTOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-4730
+            }
             crate::protocol_serde::shape_optional_input_output::de_optional_input_output_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-4740
+                )
             },
         );

↧ Expand context

         OptionalInputOutputInputFuture {
             inner: Box::pin(fut),
-4745
+        }
-4746
+    }
-4747
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::OptionalInputOutputOutput
-4752
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_optional_input_output::ser_optional_input_output_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-4759
+                        }
-4760
+                    }
-4761
+    }
-4762
+}

@@ -4891,4879 +4951,4938 @@

↥ Expand context

-4879
+}
-4880
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::EmptyInputOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-4889
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-4893
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = EmptyInputOutputInputFuture;
-4896
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_EMPTYINPUTOUTPUT,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-4904
+            }
             crate::protocol_serde::shape_empty_input_output::de_empty_input_output_http_request(
                 request,
-4907
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-4916
+                )
             },
         );

↧ Expand context

         EmptyInputOutputInputFuture {
             inner: Box::pin(fut),
-4921
+        }
-4922
+    }
-4923
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::EmptyInputOutputOutput
-4928
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_input_output::ser_empty_input_output_http_response(
             self,
         ) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-4937
+            }
-4938
+        }

@@ -5145,5132 +5205,5191 @@

↥ Expand context

-5132
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-5139
+    }
-5140
+}
-5141
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::NoInputOutputInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-5150
     B::Data: Send,

     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-5154
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = NoInputOutputInputFuture;
-5157
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             crate::protocol_serde::shape_no_input_output::de_no_input_output_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-5169
+                )
             },
         );

↧ Expand context

         NoInputOutputInputFuture {
             inner: Box::pin(fut),
-5174
+        }
-5175
+    }
-5176
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::NoInputOutputOutput
-5181
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_no_input_output::ser_no_input_output_http_response(self)
-5184
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-5189
+            }
-5190
+        }
-5191
+    }

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras/rust-server-codegen/src/operation.rs

@@ -27,27 +87,86 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-28
+    }
-29
+}
-30
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::RecursiveUnionOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-39
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-43
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = RecursiveUnionOperationInputFuture;
-46

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_RECURSIVEUNIONOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-54
+            }
             crate::protocol_serde::shape_recursive_union_operation::de_recursive_union_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-64
+                )
             },
         );

↧ Expand context

         RecursiveUnionOperationInputFuture {
             inner: Box::pin(fut),
-69
+        }
-70
+    }
-71
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::RecursiveUnionOperationOutput
-76
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_recursive_union_operation::ser_recursive_union_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-83
+                        }
-84
+                    }
-85
+    }
-86
+}

@@ -262,261 +322,320 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-262
+    }
-263
+}
-264
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::SingleMemberStructOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-273
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-277
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = SingleMemberStructOperationInputFuture;
-280

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SINGLEMEMBERSTRUCTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-288
+            }
             crate::protocol_serde::shape_single_member_struct_operation::de_single_member_struct_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-298
+                )
             },
         );

↧ Expand context

         SingleMemberStructOperationInputFuture {
             inner: Box::pin(fut),
-303
+        }
-304
+    }
-305
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::SingleMemberStructOperationOutput
-310
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_single_member_struct_operation::ser_single_member_struct_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-317
+                        }
-318
+                    }
-319
+    }
-320
+}

@@ -406,404 +466,463 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-405
+    }
-406
+}
-407
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::EmptyStructOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-416
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-420
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = EmptyStructOperationInputFuture;
-423

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_EMPTYSTRUCTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-431
+            }
             crate::protocol_serde::shape_empty_struct_operation::de_empty_struct_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-441
+                )
             },
         );

↧ Expand context

         EmptyStructOperationInputFuture {
             inner: Box::pin(fut),
-446
+        }
-447
+    }
-448
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::EmptyStructOperationOutput
-453
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_struct_operation::ser_empty_struct_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-460
+                        }
-461
+                    }
-462
+    }
-463
+}

@@ -551,548 +611,607 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-549
+    }
-550
+}
-551
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::ComplexStructOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-560
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-564
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = ComplexStructOperationInputFuture;
-567

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_COMPLEXSTRUCTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-575
+            }
             crate::protocol_serde::shape_complex_struct_operation::de_complex_struct_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-585
+                )
             },
         );

↧ Expand context

         ComplexStructOperationInputFuture {
             inner: Box::pin(fut),
-590
+        }
-591
+    }
-592
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::ComplexStructOperationOutput
-597
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_complex_struct_operation::ser_complex_struct_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-604
+                        }
-605
+                    }
-606
+    }
-607
+}

@@ -656,652 +716,711 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-653
+    }
-654
+}
-655
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::ErrorSerializationOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-664
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-668
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = ErrorSerializationOperationInputFuture;
-671

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_ERRORSERIALIZATIONOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-679
+            }
             crate::protocol_serde::shape_error_serialization_operation::de_error_serialization_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-689
+                )
             },
         );

↧ Expand context

         ErrorSerializationOperationInputFuture {
             inner: Box::pin(fut),
-694
+        }
-695
+    }
-696
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::ErrorSerializationOperationOutput
-701
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_error_serialization_operation::ser_error_serialization_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-708
+                        }
-709
+                    }
-710
+    }
-711
+}

@@ -845,840 +905,899 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-841
+    }
-842
+}
-843
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::SimpleStructOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-852
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-856
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = SimpleStructOperationInputFuture;
-859

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_SIMPLESTRUCTOPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-867
+            }
             crate::protocol_serde::shape_simple_struct_operation::de_simple_struct_operation_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-877
+                )
             },
         );

↧ Expand context

         SimpleStructOperationInputFuture {
             inner: Box::pin(fut),
-882
+        }
-883
+    }
-884
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::SimpleStructOperationOutput
-889
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_simple_struct_operation::ser_simple_struct_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-896
+                        }
-897
+                    }
-898
+    }
-899
+}

tmp-codegen-diff/codegen-server-test/s3/rust-server-codegen/src/operation.rs

@@ -14,14 +76,74 @@

↥ Expand context

         ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError,
     >;
-16
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-23
+    }
-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_xml::RestXml,
         B,
     > for crate::input::GetObjectInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,

-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError;
     type Future = GetObjectInputFuture;
-41
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             crate::protocol_serde::shape_get_object::de_get_object_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_get_object::de_get_object_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError::from(e)
             },
         );
         GetObjectInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-55
+        }
-56
+    }
-57
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_xml::RestXml,
     > for crate::output::GetObjectOutput
-62
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_get_object::ser_get_object_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::rest_xml::RestXml,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError::from(
                         e,
                     ),
-74
+                )

@@ -121,119 +181,178 @@

↥ Expand context

-119
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-126
+    }
-127
+}
-128
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_xml::RestXml,
         B,
     > for crate::input::DeleteObjectTaggingInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-137
     B::Data: Send,

     ::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-141
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError;
     type Future = DeleteObjectTaggingInputFuture;
-144
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             crate::protocol_serde::shape_delete_object_tagging::de_delete_object_tagging_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError::from(e)
             },
         );
         DeleteObjectTaggingInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-159
+        }
-160
+    }
-161
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_xml::RestXml,
     > for crate::output::DeleteObjectTaggingOutput
-166
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_delete_object_tagging::ser_delete_object_tagging_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_xml::RestXml>::into_response(::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError::from(e))
-173
+                        }
-174
+                    }
-175
+    }
-176
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -226,223 +286,282 @@

↥ Expand context

-223
+}
-224
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_xml::RestXml,
         B,
     > for crate::input::GetBucketLocationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-233
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-237
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError;
     type Future = GetBucketLocationInputFuture;
-240
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {

             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_GETBUCKETLOCATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection::NotAcceptable);
-248
+            }
             crate::protocol_serde::shape_get_bucket_location::de_get_bucket_location_http_request(
                 request,
-251
+            )
             .await
             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError::from(e)
             },
         );
         GetBucketLocationInputFuture {
             inner: Box::pin(fut),

↧ Expand context

-263
+        }
-264
+    }
-265
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_xml::RestXml,
     > for crate::output::GetBucketLocationOutput
-270
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_get_bucket_location::ser_get_bucket_location_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_xml::RestXml>::into_response(::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError::from(e))
-277
+                        }
-278
+                    }
-279
+    }
-280
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<

@@ -373,369 +433,428 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-370
+    }
-371
+}
-372
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_xml::RestXml,
         B,
     > for crate::input::ListObjectsV2Input
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-381
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-385
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError;
     type Future = ListObjectsV2InputFuture;
-388

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_LISTOBJECTSV2,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection::NotAcceptable);
-396
+            }
             crate::protocol_serde::shape_list_objects_v2::de_list_objects_v2_http_request(request)
                 .await
                 .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_xml::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError::from(e)
             },
         );
         ListObjectsV2InputFuture {
             inner: Box::pin(fut),

↧ Expand context

-409
+        }
-410
+    }
-411
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_xml::RestXml,
     > for crate::output::ListObjectsV2Output
-416
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_list_objects_v2::ser_list_objects_v2_http_response(self)
-419
+        {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<
                     ::aws_smithy_http_server::protocol::rest_xml::RestXml,
                 >::into_response(
                     ::aws_smithy_http_server::protocol::rest_xml::runtime_error::RuntimeError::from(
                         e,
                     ),

tmp-codegen-diff/codegen-server-test/simple/rust-server-codegen/src/operation.rs

@@ -20,20 +82,80 @@

↥ Expand context

     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-23
+    }
-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::OperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;

     type Future = OperationInputFuture;
-41
     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_OPERATION,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_operation::de_operation_http_request(request)
                 .await
                 .map_err(Into::into)
             crate::protocol_serde::shape_operation::de_operation_http_request(request).await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-58
+                )
             },
         );

↧ Expand context

         OperationInputFuture {
             inner: Box::pin(fut),
-63
+        }
-64
+    }
-65
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::OperationOutput
-70
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_operation::ser_operation_http_response(self) {
             Ok(response) => response,
             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-77
+            }
-78
+        }
-79
+    }
-80
+}

tmp-codegen-diff/codegen-server-test/unique_items/rust-server-codegen/src/operation.rs

@@ -22,22 +82,81 @@

↥ Expand context

         this.inner.as_mut().poll(cx)
-23
+    }
-24
+}
-25
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
         B,
     > for crate::input::MalformedUniqueItemsInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-34
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-38
+{
     type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
     type Future = MalformedUniqueItemsInputFuture;
-41

     fn from_request(request: ::http::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &CONTENT_TYPE_MALFORMEDUNIQUEITEMS,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
-49
+            }
             crate::protocol_serde::shape_malformed_unique_items::de_malformed_unique_items_http_request(request)
                             .await
                             .map_err(Into::into)
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
                     e,
-59
+                )
             },
         );

↧ Expand context

         MalformedUniqueItemsInputFuture {
             inner: Box::pin(fut),
-64
+        }
-65
+    }
-66
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
     > for crate::output::MalformedUniqueItemsOutput
-71
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_malformed_unique_items::ser_malformed_unique_items_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rest_json_1::RestJson1>::into_response(::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(e))
-78
+                        }
-79
+                    }
-80
+    }
-81
+}

Pages: 1 2