Server Test

rev. fd67870c8763076fc6895510f5e759abfe0cb35c (ignoring whitespace)

Files changed:

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

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

     ) -> 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