rev. fd67870c8763076fc6895510f5e759abfe0cb35c (ignoring whitespace)
@@ -22,22 +82,81 @@
22 22 | this.inner.as_mut().poll(cx)
|
23 23 | }
|
24 24 | }
|
25 25 |
|
26 26 | impl<B>
|
27 27 | ::aws_smithy_http_server::request::FromRequest<
|
28 28 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
29 29 | B,
|
30 30 | > for crate::input::OperationWithNestedStructureInput
|
31 31 | where
|
32 32 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
33 33 | B: 'static,
|
34 34 |
|
35 35 | B::Data: Send,
|
36 36 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
37 37 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
38 38 | {
|
39 39 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
40 40 | type Future = OperationWithNestedStructureInputFuture;
|
41 41 |
|
42 42 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
43 43 | let fut = async move {
|
44 44 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
45 45 | request.headers(),
|
46 46 | &CONTENT_TYPE_OPERATIONWITHNESTEDSTRUCTURE,
|
47 47 | ) {
|
48 48 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
49 49 | }
|
50 50 | crate::protocol_serde::shape_operation_with_nested_structure::de_operation_with_nested_structure_http_request(request)
|
51 51 | .await
|
52 - | .map_err(Into::into)
|
53 52 | };
|
54 53 | use ::futures_util::future::TryFutureExt;
|
55 54 | let fut = fut.map_err(
|
56 55 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
57 56 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
58 57 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
59 58 | e,
|
60 59 | )
|
61 60 | },
|
62 61 | );
|
63 62 | OperationWithNestedStructureInputFuture {
|
64 63 | inner: Box::pin(fut),
|
65 64 | }
|
66 65 | }
|
67 66 | }
|
68 67 | impl
|
69 68 | ::aws_smithy_http_server::response::IntoResponse<
|
70 69 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
71 70 | > for crate::output::OperationWithNestedStructureOutput
|
72 71 | {
|
73 72 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
74 73 | match crate::protocol_serde::shape_operation_with_nested_structure::ser_operation_with_nested_structure_http_response(self) {
|
75 74 | Ok(response) => response,
|
76 75 | Err(e) => {
|
77 76 | ::tracing::error!(error = %e, "failed to serialize response");
|
78 77 | ::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))
|
79 78 | }
|
80 79 | }
|
81 80 | }
|
82 81 | }
|
@@ -122,121 +182,180 @@
122 121 | this.inner.as_mut().poll(cx)
|
123 122 | }
|
124 123 | }
|
125 124 |
|
126 125 | impl<B>
|
127 126 | ::aws_smithy_http_server::request::FromRequest<
|
128 127 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
129 128 | B,
|
130 129 | > for crate::input::OperationWithDefaultsInput
|
131 130 | where
|
132 131 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
133 132 | B: 'static,
|
134 133 |
|
135 134 | B::Data: Send,
|
136 135 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
137 136 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
138 137 | {
|
139 138 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
140 139 | type Future = OperationWithDefaultsInputFuture;
|
141 140 |
|
142 141 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
143 142 | let fut = async move {
|
144 143 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
145 144 | request.headers(),
|
146 145 | &CONTENT_TYPE_OPERATIONWITHDEFAULTS,
|
147 146 | ) {
|
148 147 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
149 148 | }
|
150 149 | crate::protocol_serde::shape_operation_with_defaults::de_operation_with_defaults_http_request(request)
|
151 150 | .await
|
152 - | .map_err(Into::into)
|
153 151 | };
|
154 152 | use ::futures_util::future::TryFutureExt;
|
155 153 | let fut = fut.map_err(
|
156 154 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
157 155 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
158 156 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
159 157 | e,
|
160 158 | )
|
161 159 | },
|
162 160 | );
|
163 161 | OperationWithDefaultsInputFuture {
|
164 162 | inner: Box::pin(fut),
|
165 163 | }
|
166 164 | }
|
167 165 | }
|
168 166 | impl
|
169 167 | ::aws_smithy_http_server::response::IntoResponse<
|
170 168 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
171 169 | > for crate::output::OperationWithDefaultsOutput
|
172 170 | {
|
173 171 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
174 172 | match crate::protocol_serde::shape_operation_with_defaults::ser_operation_with_defaults_http_response(self) {
|
175 173 | Ok(response) => response,
|
176 174 | Err(e) => {
|
177 175 | ::tracing::error!(error = %e, "failed to serialize response");
|
178 176 | ::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))
|
179 177 | }
|
180 178 | }
|
181 179 | }
|
182 180 | }
|
@@ -222,220 +282,279 @@
222 220 | this.inner.as_mut().poll(cx)
|
223 221 | }
|
224 222 | }
|
225 223 |
|
226 224 | impl<B>
|
227 225 | ::aws_smithy_http_server::request::FromRequest<
|
228 226 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
229 227 | B,
|
230 228 | > for crate::input::ContentTypeParametersInput
|
231 229 | where
|
232 230 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
233 231 | B: 'static,
|
234 232 |
|
235 233 | B::Data: Send,
|
236 234 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
237 235 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
238 236 | {
|
239 237 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
240 238 | type Future = ContentTypeParametersInputFuture;
|
241 239 |
|
242 240 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
243 241 | let fut = async move {
|
244 242 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
245 243 | request.headers(),
|
246 244 | &CONTENT_TYPE_CONTENTTYPEPARAMETERS,
|
247 245 | ) {
|
248 246 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
249 247 | }
|
250 248 | crate::protocol_serde::shape_content_type_parameters::de_content_type_parameters_http_request(request)
|
251 249 | .await
|
252 - | .map_err(Into::into)
|
253 250 | };
|
254 251 | use ::futures_util::future::TryFutureExt;
|
255 252 | let fut = fut.map_err(
|
256 253 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
257 254 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
258 255 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
259 256 | e,
|
260 257 | )
|
261 258 | },
|
262 259 | );
|
263 260 | ContentTypeParametersInputFuture {
|
264 261 | inner: Box::pin(fut),
|
265 262 | }
|
266 263 | }
|
267 264 | }
|
268 265 | impl
|
269 266 | ::aws_smithy_http_server::response::IntoResponse<
|
270 267 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
271 268 | > for crate::output::ContentTypeParametersOutput
|
272 269 | {
|
273 270 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
274 271 | match crate::protocol_serde::shape_content_type_parameters::ser_content_type_parameters_http_response(self) {
|
275 272 | Ok(response) => response,
|
276 273 | Err(e) => {
|
277 274 | ::tracing::error!(error = %e, "failed to serialize response");
|
278 275 | ::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))
|
279 276 | }
|
280 277 | }
|
281 278 | }
|
282 279 | }
|
@@ -322,319 +382,378 @@
322 319 | this.inner.as_mut().poll(cx)
|
323 320 | }
|
324 321 | }
|
325 322 |
|
326 323 | impl<B>
|
327 324 | ::aws_smithy_http_server::request::FromRequest<
|
328 325 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
329 326 | B,
|
330 327 | > for crate::input::PutWithContentEncodingInput
|
331 328 | where
|
332 329 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
333 330 | B: 'static,
|
334 331 |
|
335 332 | B::Data: Send,
|
336 333 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
337 334 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
338 335 | {
|
339 336 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
340 337 | type Future = PutWithContentEncodingInputFuture;
|
341 338 |
|
342 339 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
343 340 | let fut = async move {
|
344 341 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
345 342 | request.headers(),
|
346 343 | &CONTENT_TYPE_PUTWITHCONTENTENCODING,
|
347 344 | ) {
|
348 345 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
349 346 | }
|
350 347 | crate::protocol_serde::shape_put_with_content_encoding::de_put_with_content_encoding_http_request(request)
|
351 348 | .await
|
352 - | .map_err(Into::into)
|
353 349 | };
|
354 350 | use ::futures_util::future::TryFutureExt;
|
355 351 | let fut = fut.map_err(
|
356 352 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
357 353 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
358 354 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
359 355 | e,
|
360 356 | )
|
361 357 | },
|
362 358 | );
|
363 359 | PutWithContentEncodingInputFuture {
|
364 360 | inner: Box::pin(fut),
|
365 361 | }
|
366 362 | }
|
367 363 | }
|
368 364 | impl
|
369 365 | ::aws_smithy_http_server::response::IntoResponse<
|
370 366 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
371 367 | > for crate::output::PutWithContentEncodingOutput
|
372 368 | {
|
373 369 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
374 370 | match crate::protocol_serde::shape_put_with_content_encoding::ser_put_with_content_encoding_http_response(self) {
|
375 371 | Ok(response) => response,
|
376 372 | Err(e) => {
|
377 373 | ::tracing::error!(error = %e, "failed to serialize response");
|
378 374 | ::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))
|
379 375 | }
|
380 376 | }
|
381 377 | }
|
382 378 | }
|
@@ -424,420 +484,479 @@
424 420 | }
|
425 421 |
|
426 422 | impl<B>
|
427 423 | ::aws_smithy_http_server::request::FromRequest<
|
428 424 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
429 425 | B,
|
430 426 | > for crate::input::FractionalSecondsInput
|
431 427 | where
|
432 428 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
433 429 | B: 'static,
|
434 430 |
|
435 431 | B::Data: Send,
|
436 432 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
437 433 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
438 434 | {
|
439 435 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
440 436 | type Future = FractionalSecondsInputFuture;
|
441 437 |
|
442 438 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
443 439 | let fut = async move {
|
444 440 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
445 441 | request.headers(),
|
446 442 | &CONTENT_TYPE_FRACTIONALSECONDS,
|
447 443 | ) {
|
448 444 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
449 445 | }
|
450 446 | crate::protocol_serde::shape_fractional_seconds::de_fractional_seconds_http_request(
|
451 447 | request,
|
452 448 | )
|
453 449 | .await
|
454 - | .map_err(Into::into)
|
455 450 | };
|
456 451 | use ::futures_util::future::TryFutureExt;
|
457 452 | let fut = fut.map_err(
|
458 453 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
459 454 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
460 455 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
461 456 | e,
|
462 457 | )
|
463 458 | },
|
464 459 | );
|
465 460 | FractionalSecondsInputFuture {
|
466 461 | inner: Box::pin(fut),
|
467 462 | }
|
468 463 | }
|
469 464 | }
|
470 465 | impl
|
471 466 | ::aws_smithy_http_server::response::IntoResponse<
|
472 467 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
473 468 | > for crate::output::FractionalSecondsOutput
|
474 469 | {
|
475 470 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
476 471 | match crate::protocol_serde::shape_fractional_seconds::ser_fractional_seconds_http_response(
|
477 472 | self,
|
478 473 | ) {
|
479 474 | Ok(response) => response,
|
480 475 | Err(e) => {
|
481 476 | ::tracing::error!(error = %e, "failed to serialize response");
|
482 477 | ::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))
|
483 478 | }
|
484 479 | }
|
@@ -530,525 +590,584 @@
530 525 | this.inner.as_mut().poll(cx)
|
531 526 | }
|
532 527 | }
|
533 528 |
|
534 529 | impl<B>
|
535 530 | ::aws_smithy_http_server::request::FromRequest<
|
536 531 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
537 532 | B,
|
538 533 | > for crate::input::DatetimeOffsetsInput
|
539 534 | where
|
540 535 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
541 536 | B: 'static,
|
542 537 |
|
543 538 | B::Data: Send,
|
544 539 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
545 540 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
546 541 | {
|
547 542 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
548 543 | type Future = DatetimeOffsetsInputFuture;
|
549 544 |
|
550 545 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
551 546 | let fut = async move {
|
552 547 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
553 548 | request.headers(),
|
554 549 | &CONTENT_TYPE_DATETIMEOFFSETS,
|
555 550 | ) {
|
556 551 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
557 552 | }
|
558 553 | crate::protocol_serde::shape_datetime_offsets::de_datetime_offsets_http_request(request)
|
559 554 | .await
|
560 - | .map_err(Into::into)
|
561 555 | };
|
562 556 | use ::futures_util::future::TryFutureExt;
|
563 557 | let fut = fut.map_err(
|
564 558 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
565 559 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
566 560 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
567 561 | e,
|
568 562 | )
|
569 563 | },
|
570 564 | );
|
571 565 | DatetimeOffsetsInputFuture {
|
572 566 | inner: Box::pin(fut),
|
573 567 | }
|
574 568 | }
|
575 569 | }
|
576 570 | impl
|
577 571 | ::aws_smithy_http_server::response::IntoResponse<
|
578 572 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
579 573 | > for crate::output::DatetimeOffsetsOutput
|
580 574 | {
|
581 575 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
582 576 | match crate::protocol_serde::shape_datetime_offsets::ser_datetime_offsets_http_response(
|
583 577 | self,
|
584 578 | ) {
|
585 579 | Ok(response) => response,
|
586 580 | Err(e) => {
|
587 581 | ::tracing::error!(error = %e, "failed to serialize response");
|
588 582 | ::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))
|
589 583 | }
|
590 584 | }
|
@@ -635,629 +695,688 @@
635 629 | this.inner.as_mut().poll(cx)
|
636 630 | }
|
637 631 | }
|
638 632 |
|
639 633 | impl<B>
|
640 634 | ::aws_smithy_http_server::request::FromRequest<
|
641 635 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
642 636 | B,
|
643 637 | > for crate::input::TestPostNoInputNoPayloadInput
|
644 638 | where
|
645 639 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
646 640 | B: 'static,
|
647 641 |
|
648 642 | B::Data: Send,
|
649 643 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
650 644 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
651 645 | {
|
652 646 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
653 647 | type Future = TestPostNoInputNoPayloadInputFuture;
|
654 648 |
|
655 649 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
656 650 | let fut = async move {
|
657 651 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
658 652 | request.headers(),
|
659 653 | &CONTENT_TYPE_TESTPOSTNOINPUTNOPAYLOAD,
|
660 654 | ) {
|
661 655 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
662 656 | }
|
663 657 | crate::protocol_serde::shape_test_post_no_input_no_payload::de_test_post_no_input_no_payload_http_request(request)
|
664 658 | .await
|
665 - | .map_err(Into::into)
|
666 659 | };
|
667 660 | use ::futures_util::future::TryFutureExt;
|
668 661 | let fut = fut.map_err(
|
669 662 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
670 663 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
671 664 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
672 665 | e,
|
673 666 | )
|
674 667 | },
|
675 668 | );
|
676 669 | TestPostNoInputNoPayloadInputFuture {
|
677 670 | inner: Box::pin(fut),
|
678 671 | }
|
679 672 | }
|
680 673 | }
|
681 674 | impl
|
682 675 | ::aws_smithy_http_server::response::IntoResponse<
|
683 676 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
684 677 | > for crate::output::TestPostNoInputNoPayloadOutput
|
685 678 | {
|
686 679 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
687 680 | match crate::protocol_serde::shape_test_post_no_input_no_payload::ser_test_post_no_input_no_payload_http_response(self) {
|
688 681 | Ok(response) => response,
|
689 682 | Err(e) => {
|
690 683 | ::tracing::error!(error = %e, "failed to serialize response");
|
691 684 | ::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))
|
692 685 | }
|
693 686 | }
|
694 687 | }
|
695 688 | }
|
@@ -735,728 +795,787 @@
735 728 | this.inner.as_mut().poll(cx)
|
736 729 | }
|
737 730 | }
|
738 731 |
|
739 732 | impl<B>
|
740 733 | ::aws_smithy_http_server::request::FromRequest<
|
741 734 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
742 735 | B,
|
743 736 | > for crate::input::TestGetNoInputNoPayloadInput
|
744 737 | where
|
745 738 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
746 739 | B: 'static,
|
747 740 |
|
748 741 | B::Data: Send,
|
749 742 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
750 743 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
751 744 | {
|
752 745 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
753 746 | type Future = TestGetNoInputNoPayloadInputFuture;
|
754 747 |
|
755 748 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
756 749 | let fut = async move {
|
757 750 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
758 751 | request.headers(),
|
759 752 | &CONTENT_TYPE_TESTGETNOINPUTNOPAYLOAD,
|
760 753 | ) {
|
761 754 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
762 755 | }
|
763 756 | crate::protocol_serde::shape_test_get_no_input_no_payload::de_test_get_no_input_no_payload_http_request(request)
|
764 757 | .await
|
765 - | .map_err(Into::into)
|
766 758 | };
|
767 759 | use ::futures_util::future::TryFutureExt;
|
768 760 | let fut = fut.map_err(
|
769 761 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
770 762 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
771 763 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
772 764 | e,
|
773 765 | )
|
774 766 | },
|
775 767 | );
|
776 768 | TestGetNoInputNoPayloadInputFuture {
|
777 769 | inner: Box::pin(fut),
|
778 770 | }
|
779 771 | }
|
780 772 | }
|
781 773 | impl
|
782 774 | ::aws_smithy_http_server::response::IntoResponse<
|
783 775 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
784 776 | > for crate::output::TestGetNoInputNoPayloadOutput
|
785 777 | {
|
786 778 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
787 779 | match crate::protocol_serde::shape_test_get_no_input_no_payload::ser_test_get_no_input_no_payload_http_response(self) {
|
788 780 | Ok(response) => response,
|
789 781 | Err(e) => {
|
790 782 | ::tracing::error!(error = %e, "failed to serialize response");
|
791 783 | ::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))
|
792 784 | }
|
793 785 | }
|
794 786 | }
|
795 787 | }
|
@@ -837,829 +897,888 @@
837 829 | }
|
838 830 |
|
839 831 | impl<B>
|
840 832 | ::aws_smithy_http_server::request::FromRequest<
|
841 833 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
842 834 | B,
|
843 835 | > for crate::input::TestPostNoPayloadInput
|
844 836 | where
|
845 837 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
846 838 | B: 'static,
|
847 839 |
|
848 840 | B::Data: Send,
|
849 841 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
850 842 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
851 843 | {
|
852 844 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
853 845 | type Future = TestPostNoPayloadInputFuture;
|
854 846 |
|
855 847 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
856 848 | let fut = async move {
|
857 849 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
858 850 | request.headers(),
|
859 851 | &CONTENT_TYPE_TESTPOSTNOPAYLOAD,
|
860 852 | ) {
|
861 853 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
862 854 | }
|
863 855 | crate::protocol_serde::shape_test_post_no_payload::de_test_post_no_payload_http_request(
|
864 856 | request,
|
865 857 | )
|
866 858 | .await
|
867 - | .map_err(Into::into)
|
868 859 | };
|
869 860 | use ::futures_util::future::TryFutureExt;
|
870 861 | let fut = fut.map_err(
|
871 862 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
872 863 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
873 864 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
874 865 | e,
|
875 866 | )
|
876 867 | },
|
877 868 | );
|
878 869 | TestPostNoPayloadInputFuture {
|
879 870 | inner: Box::pin(fut),
|
880 871 | }
|
881 872 | }
|
882 873 | }
|
883 874 | impl
|
884 875 | ::aws_smithy_http_server::response::IntoResponse<
|
885 876 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
886 877 | > for crate::output::TestPostNoPayloadOutput
|
887 878 | {
|
888 879 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
889 880 | match crate::protocol_serde::shape_test_post_no_payload::ser_test_post_no_payload_http_response(self) {
|
890 881 | Ok(response) => response,
|
891 882 | Err(e) => {
|
892 883 | ::tracing::error!(error = %e, "failed to serialize response");
|
893 884 | ::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))
|
894 885 | }
|
895 886 | }
|
896 887 | }
|
897 888 | }
|
@@ -943,934 +1003,993 @@
943 934 | }
|
944 935 |
|
945 936 | impl<B>
|
946 937 | ::aws_smithy_http_server::request::FromRequest<
|
947 938 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
948 939 | B,
|
949 940 | > for crate::input::TestGetNoPayloadInput
|
950 941 | where
|
951 942 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
952 943 | B: 'static,
|
953 944 |
|
954 945 | B::Data: Send,
|
955 946 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
956 947 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
957 948 | {
|
958 949 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
959 950 | type Future = TestGetNoPayloadInputFuture;
|
960 951 |
|
961 952 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
962 953 | let fut = async move {
|
963 954 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
964 955 | request.headers(),
|
965 956 | &CONTENT_TYPE_TESTGETNOPAYLOAD,
|
966 957 | ) {
|
967 958 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
968 959 | }
|
969 960 | crate::protocol_serde::shape_test_get_no_payload::de_test_get_no_payload_http_request(
|
970 961 | request,
|
971 962 | )
|
972 963 | .await
|
973 - | .map_err(Into::into)
|
974 964 | };
|
975 965 | use ::futures_util::future::TryFutureExt;
|
976 966 | let fut = fut.map_err(
|
977 967 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
978 968 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
979 969 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
980 970 | e,
|
981 971 | )
|
982 972 | },
|
983 973 | );
|
984 974 | TestGetNoPayloadInputFuture {
|
985 975 | inner: Box::pin(fut),
|
986 976 | }
|
987 977 | }
|
988 978 | }
|
989 979 | impl
|
990 980 | ::aws_smithy_http_server::response::IntoResponse<
|
991 981 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
992 982 | > for crate::output::TestGetNoPayloadOutput
|
993 983 | {
|
994 984 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
995 985 | match crate::protocol_serde::shape_test_get_no_payload::ser_test_get_no_payload_http_response(self) {
|
996 986 | Ok(response) => response,
|
997 987 | Err(e) => {
|
998 988 | ::tracing::error!(error = %e, "failed to serialize response");
|
999 989 | ::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))
|
1000 990 | }
|
1001 991 | }
|
1002 992 | }
|
1003 993 | }
|
@@ -1042,1032 +1102,1091 @@
1042 1032 | self: std::pin::Pin<&mut Self>,
|
1043 1033 | cx: &mut std::task::Context<'_>,
|
1044 1034 | ) -> std::task::Poll<Self::Output> {
|
1045 1035 | let this = self.project();
|
1046 1036 | this.inner.as_mut().poll(cx)
|
1047 1037 | }
|
1048 1038 | }
|
1049 1039 |
|
1050 1040 | impl<B>
|
1051 1041 | ::aws_smithy_http_server::request::FromRequest<
|
1052 1042 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1053 1043 | B,
|
1054 1044 | > for crate::input::TestPayloadBlobInput
|
1055 1045 | where
|
1056 1046 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
1057 1047 | B: 'static,
|
1058 1048 |
|
1059 1049 | B::Data: Send,
|
1060 1050 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
1061 1051 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
1062 1052 | {
|
1063 1053 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
1064 1054 | type Future = TestPayloadBlobInputFuture;
|
1065 1055 |
|
1066 1056 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
1067 1057 | let fut = async move {
|
1068 1058 | crate::protocol_serde::shape_test_payload_blob::de_test_payload_blob_http_request(
|
1069 1059 | request,
|
1070 1060 | )
|
1071 1061 | .await
|
1072 - | .map_err(Into::into)
|
1073 1062 | };
|
1074 1063 | use ::futures_util::future::TryFutureExt;
|
1075 1064 | let fut = fut.map_err(
|
1076 1065 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
1077 1066 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
1078 1067 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
1079 1068 | e,
|
1080 1069 | )
|
1081 1070 | },
|
1082 1071 | );
|
1083 1072 | TestPayloadBlobInputFuture {
|
1084 1073 | inner: Box::pin(fut),
|
1085 1074 | }
|
1086 1075 | }
|
1087 1076 | }
|
1088 1077 | impl
|
1089 1078 | ::aws_smithy_http_server::response::IntoResponse<
|
1090 1079 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1091 1080 | > for crate::output::TestPayloadBlobOutput
|
1092 1081 | {
|
1093 1082 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
1094 1083 | match crate::protocol_serde::shape_test_payload_blob::ser_test_payload_blob_http_response(
|
1095 1084 | self,
|
1096 1085 | ) {
|
1097 1086 | Ok(response) => response,
|
1098 1087 | Err(e) => {
|
1099 1088 | ::tracing::error!(error = %e, "failed to serialize response");
|
1100 1089 | ::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))
|
1101 1090 | }
|
1102 1091 | }
|
@@ -1148,1137 +1208,1196 @@
1148 1137 | this.inner.as_mut().poll(cx)
|
1149 1138 | }
|
1150 1139 | }
|
1151 1140 |
|
1152 1141 | impl<B>
|
1153 1142 | ::aws_smithy_http_server::request::FromRequest<
|
1154 1143 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1155 1144 | B,
|
1156 1145 | > for crate::input::TestPayloadStructureInput
|
1157 1146 | where
|
1158 1147 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
1159 1148 | B: 'static,
|
1160 1149 |
|
1161 1150 | B::Data: Send,
|
1162 1151 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
1163 1152 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
1164 1153 | {
|
1165 1154 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
1166 1155 | type Future = TestPayloadStructureInputFuture;
|
1167 1156 |
|
1168 1157 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
1169 1158 | let fut = async move {
|
1170 1159 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
1171 1160 | request.headers(),
|
1172 1161 | &CONTENT_TYPE_TESTPAYLOADSTRUCTURE,
|
1173 1162 | ) {
|
1174 1163 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
1175 1164 | }
|
1176 1165 | crate::protocol_serde::shape_test_payload_structure::de_test_payload_structure_http_request(request)
|
1177 1166 | .await
|
1178 - | .map_err(Into::into)
|
1179 1167 | };
|
1180 1168 | use ::futures_util::future::TryFutureExt;
|
1181 1169 | let fut = fut.map_err(
|
1182 1170 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
1183 1171 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
1184 1172 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
1185 1173 | e,
|
1186 1174 | )
|
1187 1175 | },
|
1188 1176 | );
|
1189 1177 | TestPayloadStructureInputFuture {
|
1190 1178 | inner: Box::pin(fut),
|
1191 1179 | }
|
1192 1180 | }
|
1193 1181 | }
|
1194 1182 | impl
|
1195 1183 | ::aws_smithy_http_server::response::IntoResponse<
|
1196 1184 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1197 1185 | > for crate::output::TestPayloadStructureOutput
|
1198 1186 | {
|
1199 1187 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
1200 1188 | match crate::protocol_serde::shape_test_payload_structure::ser_test_payload_structure_http_response(self) {
|
1201 1189 | Ok(response) => response,
|
1202 1190 | Err(e) => {
|
1203 1191 | ::tracing::error!(error = %e, "failed to serialize response");
|
1204 1192 | ::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))
|
1205 1193 | }
|
1206 1194 | }
|
1207 1195 | }
|
1208 1196 | }
|
@@ -1250,1238 +1310,1297 @@
1250 1238 | }
|
1251 1239 |
|
1252 1240 | impl<B>
|
1253 1241 | ::aws_smithy_http_server::request::FromRequest<
|
1254 1242 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1255 1243 | B,
|
1256 1244 | > for crate::input::TestBodyStructureInput
|
1257 1245 | where
|
1258 1246 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
1259 1247 | B: 'static,
|
1260 1248 |
|
1261 1249 | B::Data: Send,
|
1262 1250 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
1263 1251 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
1264 1252 | {
|
1265 1253 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
1266 1254 | type Future = TestBodyStructureInputFuture;
|
1267 1255 |
|
1268 1256 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
1269 1257 | let fut = async move {
|
1270 1258 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
1271 1259 | request.headers(),
|
1272 1260 | &CONTENT_TYPE_TESTBODYSTRUCTURE,
|
1273 1261 | ) {
|
1274 1262 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
1275 1263 | }
|
1276 1264 | crate::protocol_serde::shape_test_body_structure::de_test_body_structure_http_request(
|
1277 1265 | request,
|
1278 1266 | )
|
1279 1267 | .await
|
1280 - | .map_err(Into::into)
|
1281 1268 | };
|
1282 1269 | use ::futures_util::future::TryFutureExt;
|
1283 1270 | let fut = fut.map_err(
|
1284 1271 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
1285 1272 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
1286 1273 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
1287 1274 | e,
|
1288 1275 | )
|
1289 1276 | },
|
1290 1277 | );
|
1291 1278 | TestBodyStructureInputFuture {
|
1292 1279 | inner: Box::pin(fut),
|
1293 1280 | }
|
1294 1281 | }
|
1295 1282 | }
|
1296 1283 | impl
|
1297 1284 | ::aws_smithy_http_server::response::IntoResponse<
|
1298 1285 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1299 1286 | > for crate::output::TestBodyStructureOutput
|
1300 1287 | {
|
1301 1288 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
1302 1289 | match crate::protocol_serde::shape_test_body_structure::ser_test_body_structure_http_response(self) {
|
1303 1290 | Ok(response) => response,
|
1304 1291 | Err(e) => {
|
1305 1292 | ::tracing::error!(error = %e, "failed to serialize response");
|
1306 1293 | ::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))
|
1307 1294 | }
|
1308 1295 | }
|
1309 1296 | }
|
1310 1297 | }
|
@@ -1359,1346 +1419,1405 @@
1359 1346 | this.inner.as_mut().poll(cx)
|
1360 1347 | }
|
1361 1348 | }
|
1362 1349 |
|
1363 1350 | impl<B>
|
1364 1351 | ::aws_smithy_http_server::request::FromRequest<
|
1365 1352 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1366 1353 | B,
|
1367 1354 | > for crate::input::MalformedAcceptWithGenericStringInput
|
1368 1355 | where
|
1369 1356 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
1370 1357 | B: 'static,
|
1371 1358 |
|
1372 1359 | B::Data: Send,
|
1373 1360 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
1374 1361 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
1375 1362 | {
|
1376 1363 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
1377 1364 | type Future = MalformedAcceptWithGenericStringInputFuture;
|
1378 1365 |
|
1379 1366 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
1380 1367 | let fut = async move {
|
1381 1368 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
1382 1369 | request.headers(),
|
1383 1370 | &CONTENT_TYPE_MALFORMEDACCEPTWITHGENERICSTRING,
|
1384 1371 | ) {
|
1385 1372 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
1386 1373 | }
|
1387 1374 | crate::protocol_serde::shape_malformed_accept_with_generic_string::de_malformed_accept_with_generic_string_http_request(request)
|
1388 1375 | .await
|
1389 - | .map_err(Into::into)
|
1390 1376 | };
|
1391 1377 | use ::futures_util::future::TryFutureExt;
|
1392 1378 | let fut = fut.map_err(
|
1393 1379 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
1394 1380 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
1395 1381 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
1396 1382 | e,
|
1397 1383 | )
|
1398 1384 | },
|
1399 1385 | );
|
1400 1386 | MalformedAcceptWithGenericStringInputFuture {
|
1401 1387 | inner: Box::pin(fut),
|
1402 1388 | }
|
1403 1389 | }
|
1404 1390 | }
|
1405 1391 | impl
|
1406 1392 | ::aws_smithy_http_server::response::IntoResponse<
|
1407 1393 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1408 1394 | > for crate::output::MalformedAcceptWithGenericStringOutput
|
1409 1395 | {
|
1410 1396 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
1411 1397 | match crate::protocol_serde::shape_malformed_accept_with_generic_string::ser_malformed_accept_with_generic_string_http_response(self) {
|
1412 1398 | Ok(response) => response,
|
1413 1399 | Err(e) => {
|
1414 1400 | ::tracing::error!(error = %e, "failed to serialize response");
|
1415 1401 | ::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))
|
1416 1402 | }
|
1417 1403 | }
|
1418 1404 | }
|
1419 1405 | }
|
@@ -1464,1450 +1524,1509 @@
1464 1450 | this.inner.as_mut().poll(cx)
|
1465 1451 | }
|
1466 1452 | }
|
1467 1453 |
|
1468 1454 | impl<B>
|
1469 1455 | ::aws_smithy_http_server::request::FromRequest<
|
1470 1456 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1471 1457 | B,
|
1472 1458 | > for crate::input::MalformedAcceptWithPayloadInput
|
1473 1459 | where
|
1474 1460 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
1475 1461 | B: 'static,
|
1476 1462 |
|
1477 1463 | B::Data: Send,
|
1478 1464 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
1479 1465 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
1480 1466 | {
|
1481 1467 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
1482 1468 | type Future = MalformedAcceptWithPayloadInputFuture;
|
1483 1469 |
|
1484 1470 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
1485 1471 | let fut = async move {
|
1486 1472 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
1487 1473 | request.headers(),
|
1488 1474 | &CONTENT_TYPE_MALFORMEDACCEPTWITHPAYLOAD,
|
1489 1475 | ) {
|
1490 1476 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
1491 1477 | }
|
1492 1478 | crate::protocol_serde::shape_malformed_accept_with_payload::de_malformed_accept_with_payload_http_request(request)
|
1493 1479 | .await
|
1494 - | .map_err(Into::into)
|
1495 1480 | };
|
1496 1481 | use ::futures_util::future::TryFutureExt;
|
1497 1482 | let fut = fut.map_err(
|
1498 1483 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
1499 1484 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
1500 1485 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
1501 1486 | e,
|
1502 1487 | )
|
1503 1488 | },
|
1504 1489 | );
|
1505 1490 | MalformedAcceptWithPayloadInputFuture {
|
1506 1491 | inner: Box::pin(fut),
|
1507 1492 | }
|
1508 1493 | }
|
1509 1494 | }
|
1510 1495 | impl
|
1511 1496 | ::aws_smithy_http_server::response::IntoResponse<
|
1512 1497 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1513 1498 | > for crate::output::MalformedAcceptWithPayloadOutput
|
1514 1499 | {
|
1515 1500 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
1516 1501 | match crate::protocol_serde::shape_malformed_accept_with_payload::ser_malformed_accept_with_payload_http_response(self) {
|
1517 1502 | Ok(response) => response,
|
1518 1503 | Err(e) => {
|
1519 1504 | ::tracing::error!(error = %e, "failed to serialize response");
|
1520 1505 | ::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))
|
1521 1506 | }
|
1522 1507 | }
|
1523 1508 | }
|
1524 1509 | }
|
@@ -1564,1549 +1624,1608 @@
1564 1549 | this.inner.as_mut().poll(cx)
|
1565 1550 | }
|
1566 1551 | }
|
1567 1552 |
|
1568 1553 | impl<B>
|
1569 1554 | ::aws_smithy_http_server::request::FromRequest<
|
1570 1555 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1571 1556 | B,
|
1572 1557 | > for crate::input::MalformedAcceptWithBodyInput
|
1573 1558 | where
|
1574 1559 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
1575 1560 | B: 'static,
|
1576 1561 |
|
1577 1562 | B::Data: Send,
|
1578 1563 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
1579 1564 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
1580 1565 | {
|
1581 1566 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
1582 1567 | type Future = MalformedAcceptWithBodyInputFuture;
|
1583 1568 |
|
1584 1569 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
1585 1570 | let fut = async move {
|
1586 1571 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
1587 1572 | request.headers(),
|
1588 1573 | &CONTENT_TYPE_MALFORMEDACCEPTWITHBODY,
|
1589 1574 | ) {
|
1590 1575 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
1591 1576 | }
|
1592 1577 | crate::protocol_serde::shape_malformed_accept_with_body::de_malformed_accept_with_body_http_request(request)
|
1593 1578 | .await
|
1594 - | .map_err(Into::into)
|
1595 1579 | };
|
1596 1580 | use ::futures_util::future::TryFutureExt;
|
1597 1581 | let fut = fut.map_err(
|
1598 1582 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
1599 1583 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
1600 1584 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
1601 1585 | e,
|
1602 1586 | )
|
1603 1587 | },
|
1604 1588 | );
|
1605 1589 | MalformedAcceptWithBodyInputFuture {
|
1606 1590 | inner: Box::pin(fut),
|
1607 1591 | }
|
1608 1592 | }
|
1609 1593 | }
|
1610 1594 | impl
|
1611 1595 | ::aws_smithy_http_server::response::IntoResponse<
|
1612 1596 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1613 1597 | > for crate::output::MalformedAcceptWithBodyOutput
|
1614 1598 | {
|
1615 1599 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
1616 1600 | match crate::protocol_serde::shape_malformed_accept_with_body::ser_malformed_accept_with_body_http_response(self) {
|
1617 1601 | Ok(response) => response,
|
1618 1602 | Err(e) => {
|
1619 1603 | ::tracing::error!(error = %e, "failed to serialize response");
|
1620 1604 | ::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))
|
1621 1605 | }
|
1622 1606 | }
|
1623 1607 | }
|
1624 1608 | }
|
@@ -1664,1648 +1724,1707 @@
1664 1648 | this.inner.as_mut().poll(cx)
|
1665 1649 | }
|
1666 1650 | }
|
1667 1651 |
|
1668 1652 | impl<B>
|
1669 1653 | ::aws_smithy_http_server::request::FromRequest<
|
1670 1654 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1671 1655 | B,
|
1672 1656 | > for crate::input::MalformedContentTypeWithGenericStringInput
|
1673 1657 | where
|
1674 1658 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
1675 1659 | B: 'static,
|
1676 1660 |
|
1677 1661 | B::Data: Send,
|
1678 1662 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
1679 1663 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
1680 1664 | {
|
1681 1665 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
1682 1666 | type Future = MalformedContentTypeWithGenericStringInputFuture;
|
1683 1667 |
|
1684 1668 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
1685 1669 | let fut = async move {
|
1686 1670 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
1687 1671 | request.headers(),
|
1688 1672 | &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHGENERICSTRING,
|
1689 1673 | ) {
|
1690 1674 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
1691 1675 | }
|
1692 1676 | crate::protocol_serde::shape_malformed_content_type_with_generic_string::de_malformed_content_type_with_generic_string_http_request(request)
|
1693 1677 | .await
|
1694 - | .map_err(Into::into)
|
1695 1678 | };
|
1696 1679 | use ::futures_util::future::TryFutureExt;
|
1697 1680 | let fut = fut.map_err(
|
1698 1681 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
1699 1682 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
1700 1683 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
1701 1684 | e,
|
1702 1685 | )
|
1703 1686 | },
|
1704 1687 | );
|
1705 1688 | MalformedContentTypeWithGenericStringInputFuture {
|
1706 1689 | inner: Box::pin(fut),
|
1707 1690 | }
|
1708 1691 | }
|
1709 1692 | }
|
1710 1693 | impl
|
1711 1694 | ::aws_smithy_http_server::response::IntoResponse<
|
1712 1695 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1713 1696 | > for crate::output::MalformedContentTypeWithGenericStringOutput
|
1714 1697 | {
|
1715 1698 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
1716 1699 | match crate::protocol_serde::shape_malformed_content_type_with_generic_string::ser_malformed_content_type_with_generic_string_http_response(self) {
|
1717 1700 | Ok(response) => response,
|
1718 1701 | Err(e) => {
|
1719 1702 | ::tracing::error!(error = %e, "failed to serialize response");
|
1720 1703 | ::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))
|
1721 1704 | }
|
1722 1705 | }
|
1723 1706 | }
|
1724 1707 | }
|
@@ -1764,1747 +1824,1806 @@
1764 1747 | this.inner.as_mut().poll(cx)
|
1765 1748 | }
|
1766 1749 | }
|
1767 1750 |
|
1768 1751 | impl<B>
|
1769 1752 | ::aws_smithy_http_server::request::FromRequest<
|
1770 1753 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1771 1754 | B,
|
1772 1755 | > for crate::input::MalformedContentTypeWithPayloadInput
|
1773 1756 | where
|
1774 1757 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
1775 1758 | B: 'static,
|
1776 1759 |
|
1777 1760 | B::Data: Send,
|
1778 1761 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
1779 1762 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
1780 1763 | {
|
1781 1764 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
1782 1765 | type Future = MalformedContentTypeWithPayloadInputFuture;
|
1783 1766 |
|
1784 1767 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
1785 1768 | let fut = async move {
|
1786 1769 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
1787 1770 | request.headers(),
|
1788 1771 | &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHPAYLOAD,
|
1789 1772 | ) {
|
1790 1773 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
1791 1774 | }
|
1792 1775 | crate::protocol_serde::shape_malformed_content_type_with_payload::de_malformed_content_type_with_payload_http_request(request)
|
1793 1776 | .await
|
1794 - | .map_err(Into::into)
|
1795 1777 | };
|
1796 1778 | use ::futures_util::future::TryFutureExt;
|
1797 1779 | let fut = fut.map_err(
|
1798 1780 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
1799 1781 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
1800 1782 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
1801 1783 | e,
|
1802 1784 | )
|
1803 1785 | },
|
1804 1786 | );
|
1805 1787 | MalformedContentTypeWithPayloadInputFuture {
|
1806 1788 | inner: Box::pin(fut),
|
1807 1789 | }
|
1808 1790 | }
|
1809 1791 | }
|
1810 1792 | impl
|
1811 1793 | ::aws_smithy_http_server::response::IntoResponse<
|
1812 1794 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1813 1795 | > for crate::output::MalformedContentTypeWithPayloadOutput
|
1814 1796 | {
|
1815 1797 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
1816 1798 | match crate::protocol_serde::shape_malformed_content_type_with_payload::ser_malformed_content_type_with_payload_http_response(self) {
|
1817 1799 | Ok(response) => response,
|
1818 1800 | Err(e) => {
|
1819 1801 | ::tracing::error!(error = %e, "failed to serialize response");
|
1820 1802 | ::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))
|
1821 1803 | }
|
1822 1804 | }
|
1823 1805 | }
|
1824 1806 | }
|
@@ -1864,1846 +1924,1905 @@
1864 1846 | this.inner.as_mut().poll(cx)
|
1865 1847 | }
|
1866 1848 | }
|
1867 1849 |
|
1868 1850 | impl<B>
|
1869 1851 | ::aws_smithy_http_server::request::FromRequest<
|
1870 1852 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1871 1853 | B,
|
1872 1854 | > for crate::input::MalformedContentTypeWithBodyInput
|
1873 1855 | where
|
1874 1856 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
1875 1857 | B: 'static,
|
1876 1858 |
|
1877 1859 | B::Data: Send,
|
1878 1860 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
1879 1861 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
1880 1862 | {
|
1881 1863 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
1882 1864 | type Future = MalformedContentTypeWithBodyInputFuture;
|
1883 1865 |
|
1884 1866 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
1885 1867 | let fut = async move {
|
1886 1868 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
1887 1869 | request.headers(),
|
1888 1870 | &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHBODY,
|
1889 1871 | ) {
|
1890 1872 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
1891 1873 | }
|
1892 1874 | crate::protocol_serde::shape_malformed_content_type_with_body::de_malformed_content_type_with_body_http_request(request)
|
1893 1875 | .await
|
1894 - | .map_err(Into::into)
|
1895 1876 | };
|
1896 1877 | use ::futures_util::future::TryFutureExt;
|
1897 1878 | let fut = fut.map_err(
|
1898 1879 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
1899 1880 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
1900 1881 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
1901 1882 | e,
|
1902 1883 | )
|
1903 1884 | },
|
1904 1885 | );
|
1905 1886 | MalformedContentTypeWithBodyInputFuture {
|
1906 1887 | inner: Box::pin(fut),
|
1907 1888 | }
|
1908 1889 | }
|
1909 1890 | }
|
1910 1891 | impl
|
1911 1892 | ::aws_smithy_http_server::response::IntoResponse<
|
1912 1893 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1913 1894 | > for crate::output::MalformedContentTypeWithBodyOutput
|
1914 1895 | {
|
1915 1896 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
1916 1897 | match crate::protocol_serde::shape_malformed_content_type_with_body::ser_malformed_content_type_with_body_http_response(self) {
|
1917 1898 | Ok(response) => response,
|
1918 1899 | Err(e) => {
|
1919 1900 | ::tracing::error!(error = %e, "failed to serialize response");
|
1920 1901 | ::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))
|
1921 1902 | }
|
1922 1903 | }
|
1923 1904 | }
|
1924 1905 | }
|
@@ -1964,1945 +2024,2004 @@
1964 1945 | this.inner.as_mut().poll(cx)
|
1965 1946 | }
|
1966 1947 | }
|
1967 1948 |
|
1968 1949 | impl<B>
|
1969 1950 | ::aws_smithy_http_server::request::FromRequest<
|
1970 1951 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
1971 1952 | B,
|
1972 1953 | > for crate::input::MalformedContentTypeWithoutBodyInput
|
1973 1954 | where
|
1974 1955 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
1975 1956 | B: 'static,
|
1976 1957 |
|
1977 1958 | B::Data: Send,
|
1978 1959 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
1979 1960 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
1980 1961 | {
|
1981 1962 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
1982 1963 | type Future = MalformedContentTypeWithoutBodyInputFuture;
|
1983 1964 |
|
1984 1965 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
1985 1966 | let fut = async move {
|
1986 1967 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
1987 1968 | request.headers(),
|
1988 1969 | &CONTENT_TYPE_MALFORMEDCONTENTTYPEWITHOUTBODY,
|
1989 1970 | ) {
|
1990 1971 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
1991 1972 | }
|
1992 1973 | crate::protocol_serde::shape_malformed_content_type_without_body::de_malformed_content_type_without_body_http_request(request)
|
1993 1974 | .await
|
1994 - | .map_err(Into::into)
|
1995 1975 | };
|
1996 1976 | use ::futures_util::future::TryFutureExt;
|
1997 1977 | let fut = fut.map_err(
|
1998 1978 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
1999 1979 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
2000 1980 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
2001 1981 | e,
|
2002 1982 | )
|
2003 1983 | },
|
2004 1984 | );
|
2005 1985 | MalformedContentTypeWithoutBodyInputFuture {
|
2006 1986 | inner: Box::pin(fut),
|
2007 1987 | }
|
2008 1988 | }
|
2009 1989 | }
|
2010 1990 | impl
|
2011 1991 | ::aws_smithy_http_server::response::IntoResponse<
|
2012 1992 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2013 1993 | > for crate::output::MalformedContentTypeWithoutBodyOutput
|
2014 1994 | {
|
2015 1995 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
2016 1996 | match crate::protocol_serde::shape_malformed_content_type_without_body::ser_malformed_content_type_without_body_http_response(self) {
|
2017 1997 | Ok(response) => response,
|
2018 1998 | Err(e) => {
|
2019 1999 | ::tracing::error!(error = %e, "failed to serialize response");
|
2020 2000 | ::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))
|
2021 2001 | }
|
2022 2002 | }
|
2023 2003 | }
|
2024 2004 | }
|
@@ -2064,2044 +2124,2103 @@
2064 2044 | this.inner.as_mut().poll(cx)
|
2065 2045 | }
|
2066 2046 | }
|
2067 2047 |
|
2068 2048 | impl<B>
|
2069 2049 | ::aws_smithy_http_server::request::FromRequest<
|
2070 2050 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2071 2051 | B,
|
2072 2052 | > for crate::input::MalformedTimestampBodyHttpDateInput
|
2073 2053 | where
|
2074 2054 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
2075 2055 | B: 'static,
|
2076 2056 |
|
2077 2057 | B::Data: Send,
|
2078 2058 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
2079 2059 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
2080 2060 | {
|
2081 2061 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
2082 2062 | type Future = MalformedTimestampBodyHttpDateInputFuture;
|
2083 2063 |
|
2084 2064 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
2085 2065 | let fut = async move {
|
2086 2066 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
2087 2067 | request.headers(),
|
2088 2068 | &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYHTTPDATE,
|
2089 2069 | ) {
|
2090 2070 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
2091 2071 | }
|
2092 2072 | crate::protocol_serde::shape_malformed_timestamp_body_http_date::de_malformed_timestamp_body_http_date_http_request(request)
|
2093 2073 | .await
|
2094 - | .map_err(Into::into)
|
2095 2074 | };
|
2096 2075 | use ::futures_util::future::TryFutureExt;
|
2097 2076 | let fut = fut.map_err(
|
2098 2077 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
2099 2078 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
2100 2079 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
2101 2080 | e,
|
2102 2081 | )
|
2103 2082 | },
|
2104 2083 | );
|
2105 2084 | MalformedTimestampBodyHttpDateInputFuture {
|
2106 2085 | inner: Box::pin(fut),
|
2107 2086 | }
|
2108 2087 | }
|
2109 2088 | }
|
2110 2089 | impl
|
2111 2090 | ::aws_smithy_http_server::response::IntoResponse<
|
2112 2091 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2113 2092 | > for crate::output::MalformedTimestampBodyHttpDateOutput
|
2114 2093 | {
|
2115 2094 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
2116 2095 | match crate::protocol_serde::shape_malformed_timestamp_body_http_date::ser_malformed_timestamp_body_http_date_http_response(self) {
|
2117 2096 | Ok(response) => response,
|
2118 2097 | Err(e) => {
|
2119 2098 | ::tracing::error!(error = %e, "failed to serialize response");
|
2120 2099 | ::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))
|
2121 2100 | }
|
2122 2101 | }
|
2123 2102 | }
|
2124 2103 | }
|
@@ -2164,2143 +2224,2202 @@
2164 2143 | this.inner.as_mut().poll(cx)
|
2165 2144 | }
|
2166 2145 | }
|
2167 2146 |
|
2168 2147 | impl<B>
|
2169 2148 | ::aws_smithy_http_server::request::FromRequest<
|
2170 2149 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2171 2150 | B,
|
2172 2151 | > for crate::input::MalformedTimestampBodyDateTimeInput
|
2173 2152 | where
|
2174 2153 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
2175 2154 | B: 'static,
|
2176 2155 |
|
2177 2156 | B::Data: Send,
|
2178 2157 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
2179 2158 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
2180 2159 | {
|
2181 2160 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
2182 2161 | type Future = MalformedTimestampBodyDateTimeInputFuture;
|
2183 2162 |
|
2184 2163 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
2185 2164 | let fut = async move {
|
2186 2165 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
2187 2166 | request.headers(),
|
2188 2167 | &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDATETIME,
|
2189 2168 | ) {
|
2190 2169 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
2191 2170 | }
|
2192 2171 | crate::protocol_serde::shape_malformed_timestamp_body_date_time::de_malformed_timestamp_body_date_time_http_request(request)
|
2193 2172 | .await
|
2194 - | .map_err(Into::into)
|
2195 2173 | };
|
2196 2174 | use ::futures_util::future::TryFutureExt;
|
2197 2175 | let fut = fut.map_err(
|
2198 2176 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
2199 2177 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
2200 2178 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
2201 2179 | e,
|
2202 2180 | )
|
2203 2181 | },
|
2204 2182 | );
|
2205 2183 | MalformedTimestampBodyDateTimeInputFuture {
|
2206 2184 | inner: Box::pin(fut),
|
2207 2185 | }
|
2208 2186 | }
|
2209 2187 | }
|
2210 2188 | impl
|
2211 2189 | ::aws_smithy_http_server::response::IntoResponse<
|
2212 2190 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2213 2191 | > for crate::output::MalformedTimestampBodyDateTimeOutput
|
2214 2192 | {
|
2215 2193 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
2216 2194 | match crate::protocol_serde::shape_malformed_timestamp_body_date_time::ser_malformed_timestamp_body_date_time_http_response(self) {
|
2217 2195 | Ok(response) => response,
|
2218 2196 | Err(e) => {
|
2219 2197 | ::tracing::error!(error = %e, "failed to serialize response");
|
2220 2198 | ::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))
|
2221 2199 | }
|
2222 2200 | }
|
2223 2201 | }
|
2224 2202 | }
|
@@ -2264,2242 +2324,2301 @@
2264 2242 | this.inner.as_mut().poll(cx)
|
2265 2243 | }
|
2266 2244 | }
|
2267 2245 |
|
2268 2246 | impl<B>
|
2269 2247 | ::aws_smithy_http_server::request::FromRequest<
|
2270 2248 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2271 2249 | B,
|
2272 2250 | > for crate::input::MalformedTimestampBodyDefaultInput
|
2273 2251 | where
|
2274 2252 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
2275 2253 | B: 'static,
|
2276 2254 |
|
2277 2255 | B::Data: Send,
|
2278 2256 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
2279 2257 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
2280 2258 | {
|
2281 2259 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
2282 2260 | type Future = MalformedTimestampBodyDefaultInputFuture;
|
2283 2261 |
|
2284 2262 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
2285 2263 | let fut = async move {
|
2286 2264 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
2287 2265 | request.headers(),
|
2288 2266 | &CONTENT_TYPE_MALFORMEDTIMESTAMPBODYDEFAULT,
|
2289 2267 | ) {
|
2290 2268 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
2291 2269 | }
|
2292 2270 | crate::protocol_serde::shape_malformed_timestamp_body_default::de_malformed_timestamp_body_default_http_request(request)
|
2293 2271 | .await
|
2294 - | .map_err(Into::into)
|
2295 2272 | };
|
2296 2273 | use ::futures_util::future::TryFutureExt;
|
2297 2274 | let fut = fut.map_err(
|
2298 2275 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
2299 2276 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
2300 2277 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
2301 2278 | e,
|
2302 2279 | )
|
2303 2280 | },
|
2304 2281 | );
|
2305 2282 | MalformedTimestampBodyDefaultInputFuture {
|
2306 2283 | inner: Box::pin(fut),
|
2307 2284 | }
|
2308 2285 | }
|
2309 2286 | }
|
2310 2287 | impl
|
2311 2288 | ::aws_smithy_http_server::response::IntoResponse<
|
2312 2289 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2313 2290 | > for crate::output::MalformedTimestampBodyDefaultOutput
|
2314 2291 | {
|
2315 2292 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
2316 2293 | match crate::protocol_serde::shape_malformed_timestamp_body_default::ser_malformed_timestamp_body_default_http_response(self) {
|
2317 2294 | Ok(response) => response,
|
2318 2295 | Err(e) => {
|
2319 2296 | ::tracing::error!(error = %e, "failed to serialize response");
|
2320 2297 | ::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))
|
2321 2298 | }
|
2322 2299 | }
|
2323 2300 | }
|
2324 2301 | }
|
@@ -2364,2341 +2424,2400 @@
2364 2341 | this.inner.as_mut().poll(cx)
|
2365 2342 | }
|
2366 2343 | }
|
2367 2344 |
|
2368 2345 | impl<B>
|
2369 2346 | ::aws_smithy_http_server::request::FromRequest<
|
2370 2347 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2371 2348 | B,
|
2372 2349 | > for crate::input::MalformedTimestampHeaderEpochInput
|
2373 2350 | where
|
2374 2351 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
2375 2352 | B: 'static,
|
2376 2353 |
|
2377 2354 | B::Data: Send,
|
2378 2355 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
2379 2356 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
2380 2357 | {
|
2381 2358 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
2382 2359 | type Future = MalformedTimestampHeaderEpochInputFuture;
|
2383 2360 |
|
2384 2361 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
2385 2362 | let fut = async move {
|
2386 2363 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
2387 2364 | request.headers(),
|
2388 2365 | &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADEREPOCH,
|
2389 2366 | ) {
|
2390 2367 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
2391 2368 | }
|
2392 2369 | crate::protocol_serde::shape_malformed_timestamp_header_epoch::de_malformed_timestamp_header_epoch_http_request(request)
|
2393 2370 | .await
|
2394 - | .map_err(Into::into)
|
2395 2371 | };
|
2396 2372 | use ::futures_util::future::TryFutureExt;
|
2397 2373 | let fut = fut.map_err(
|
2398 2374 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
2399 2375 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
2400 2376 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
2401 2377 | e,
|
2402 2378 | )
|
2403 2379 | },
|
2404 2380 | );
|
2405 2381 | MalformedTimestampHeaderEpochInputFuture {
|
2406 2382 | inner: Box::pin(fut),
|
2407 2383 | }
|
2408 2384 | }
|
2409 2385 | }
|
2410 2386 | impl
|
2411 2387 | ::aws_smithy_http_server::response::IntoResponse<
|
2412 2388 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2413 2389 | > for crate::output::MalformedTimestampHeaderEpochOutput
|
2414 2390 | {
|
2415 2391 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
2416 2392 | match crate::protocol_serde::shape_malformed_timestamp_header_epoch::ser_malformed_timestamp_header_epoch_http_response(self) {
|
2417 2393 | Ok(response) => response,
|
2418 2394 | Err(e) => {
|
2419 2395 | ::tracing::error!(error = %e, "failed to serialize response");
|
2420 2396 | ::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))
|
2421 2397 | }
|
2422 2398 | }
|
2423 2399 | }
|
2424 2400 | }
|
@@ -2464,2440 +2524,2499 @@
2464 2440 | this.inner.as_mut().poll(cx)
|
2465 2441 | }
|
2466 2442 | }
|
2467 2443 |
|
2468 2444 | impl<B>
|
2469 2445 | ::aws_smithy_http_server::request::FromRequest<
|
2470 2446 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2471 2447 | B,
|
2472 2448 | > for crate::input::MalformedTimestampHeaderDateTimeInput
|
2473 2449 | where
|
2474 2450 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
2475 2451 | B: 'static,
|
2476 2452 |
|
2477 2453 | B::Data: Send,
|
2478 2454 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
2479 2455 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
2480 2456 | {
|
2481 2457 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
2482 2458 | type Future = MalformedTimestampHeaderDateTimeInputFuture;
|
2483 2459 |
|
2484 2460 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
2485 2461 | let fut = async move {
|
2486 2462 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
2487 2463 | request.headers(),
|
2488 2464 | &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDATETIME,
|
2489 2465 | ) {
|
2490 2466 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
2491 2467 | }
|
2492 2468 | crate::protocol_serde::shape_malformed_timestamp_header_date_time::de_malformed_timestamp_header_date_time_http_request(request)
|
2493 2469 | .await
|
2494 - | .map_err(Into::into)
|
2495 2470 | };
|
2496 2471 | use ::futures_util::future::TryFutureExt;
|
2497 2472 | let fut = fut.map_err(
|
2498 2473 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
2499 2474 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
2500 2475 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
2501 2476 | e,
|
2502 2477 | )
|
2503 2478 | },
|
2504 2479 | );
|
2505 2480 | MalformedTimestampHeaderDateTimeInputFuture {
|
2506 2481 | inner: Box::pin(fut),
|
2507 2482 | }
|
2508 2483 | }
|
2509 2484 | }
|
2510 2485 | impl
|
2511 2486 | ::aws_smithy_http_server::response::IntoResponse<
|
2512 2487 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2513 2488 | > for crate::output::MalformedTimestampHeaderDateTimeOutput
|
2514 2489 | {
|
2515 2490 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
2516 2491 | match crate::protocol_serde::shape_malformed_timestamp_header_date_time::ser_malformed_timestamp_header_date_time_http_response(self) {
|
2517 2492 | Ok(response) => response,
|
2518 2493 | Err(e) => {
|
2519 2494 | ::tracing::error!(error = %e, "failed to serialize response");
|
2520 2495 | ::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))
|
2521 2496 | }
|
2522 2497 | }
|
2523 2498 | }
|
2524 2499 | }
|
@@ -2564,2539 +2624,2598 @@
2564 2539 | this.inner.as_mut().poll(cx)
|
2565 2540 | }
|
2566 2541 | }
|
2567 2542 |
|
2568 2543 | impl<B>
|
2569 2544 | ::aws_smithy_http_server::request::FromRequest<
|
2570 2545 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2571 2546 | B,
|
2572 2547 | > for crate::input::MalformedTimestampHeaderDefaultInput
|
2573 2548 | where
|
2574 2549 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
2575 2550 | B: 'static,
|
2576 2551 |
|
2577 2552 | B::Data: Send,
|
2578 2553 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
2579 2554 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
2580 2555 | {
|
2581 2556 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
2582 2557 | type Future = MalformedTimestampHeaderDefaultInputFuture;
|
2583 2558 |
|
2584 2559 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
2585 2560 | let fut = async move {
|
2586 2561 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
2587 2562 | request.headers(),
|
2588 2563 | &CONTENT_TYPE_MALFORMEDTIMESTAMPHEADERDEFAULT,
|
2589 2564 | ) {
|
2590 2565 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
2591 2566 | }
|
2592 2567 | crate::protocol_serde::shape_malformed_timestamp_header_default::de_malformed_timestamp_header_default_http_request(request)
|
2593 2568 | .await
|
2594 - | .map_err(Into::into)
|
2595 2569 | };
|
2596 2570 | use ::futures_util::future::TryFutureExt;
|
2597 2571 | let fut = fut.map_err(
|
2598 2572 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
2599 2573 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
2600 2574 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
2601 2575 | e,
|
2602 2576 | )
|
2603 2577 | },
|
2604 2578 | );
|
2605 2579 | MalformedTimestampHeaderDefaultInputFuture {
|
2606 2580 | inner: Box::pin(fut),
|
2607 2581 | }
|
2608 2582 | }
|
2609 2583 | }
|
2610 2584 | impl
|
2611 2585 | ::aws_smithy_http_server::response::IntoResponse<
|
2612 2586 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2613 2587 | > for crate::output::MalformedTimestampHeaderDefaultOutput
|
2614 2588 | {
|
2615 2589 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
2616 2590 | match crate::protocol_serde::shape_malformed_timestamp_header_default::ser_malformed_timestamp_header_default_http_response(self) {
|
2617 2591 | Ok(response) => response,
|
2618 2592 | Err(e) => {
|
2619 2593 | ::tracing::error!(error = %e, "failed to serialize response");
|
2620 2594 | ::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))
|
2621 2595 | }
|
2622 2596 | }
|
2623 2597 | }
|
2624 2598 | }
|
@@ -2664,2638 +2724,2697 @@
2664 2638 | this.inner.as_mut().poll(cx)
|
2665 2639 | }
|
2666 2640 | }
|
2667 2641 |
|
2668 2642 | impl<B>
|
2669 2643 | ::aws_smithy_http_server::request::FromRequest<
|
2670 2644 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2671 2645 | B,
|
2672 2646 | > for crate::input::MalformedTimestampQueryEpochInput
|
2673 2647 | where
|
2674 2648 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
2675 2649 | B: 'static,
|
2676 2650 |
|
2677 2651 | B::Data: Send,
|
2678 2652 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
2679 2653 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
2680 2654 | {
|
2681 2655 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
2682 2656 | type Future = MalformedTimestampQueryEpochInputFuture;
|
2683 2657 |
|
2684 2658 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
2685 2659 | let fut = async move {
|
2686 2660 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
2687 2661 | request.headers(),
|
2688 2662 | &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYEPOCH,
|
2689 2663 | ) {
|
2690 2664 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
2691 2665 | }
|
2692 2666 | crate::protocol_serde::shape_malformed_timestamp_query_epoch::de_malformed_timestamp_query_epoch_http_request(request)
|
2693 2667 | .await
|
2694 - | .map_err(Into::into)
|
2695 2668 | };
|
2696 2669 | use ::futures_util::future::TryFutureExt;
|
2697 2670 | let fut = fut.map_err(
|
2698 2671 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
2699 2672 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
2700 2673 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
2701 2674 | e,
|
2702 2675 | )
|
2703 2676 | },
|
2704 2677 | );
|
2705 2678 | MalformedTimestampQueryEpochInputFuture {
|
2706 2679 | inner: Box::pin(fut),
|
2707 2680 | }
|
2708 2681 | }
|
2709 2682 | }
|
2710 2683 | impl
|
2711 2684 | ::aws_smithy_http_server::response::IntoResponse<
|
2712 2685 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2713 2686 | > for crate::output::MalformedTimestampQueryEpochOutput
|
2714 2687 | {
|
2715 2688 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
2716 2689 | match crate::protocol_serde::shape_malformed_timestamp_query_epoch::ser_malformed_timestamp_query_epoch_http_response(self) {
|
2717 2690 | Ok(response) => response,
|
2718 2691 | Err(e) => {
|
2719 2692 | ::tracing::error!(error = %e, "failed to serialize response");
|
2720 2693 | ::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))
|
2721 2694 | }
|
2722 2695 | }
|
2723 2696 | }
|
2724 2697 | }
|
@@ -2764,2737 +2824,2796 @@
2764 2737 | this.inner.as_mut().poll(cx)
|
2765 2738 | }
|
2766 2739 | }
|
2767 2740 |
|
2768 2741 | impl<B>
|
2769 2742 | ::aws_smithy_http_server::request::FromRequest<
|
2770 2743 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2771 2744 | B,
|
2772 2745 | > for crate::input::MalformedTimestampQueryHttpDateInput
|
2773 2746 | where
|
2774 2747 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
2775 2748 | B: 'static,
|
2776 2749 |
|
2777 2750 | B::Data: Send,
|
2778 2751 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
2779 2752 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
2780 2753 | {
|
2781 2754 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
2782 2755 | type Future = MalformedTimestampQueryHttpDateInputFuture;
|
2783 2756 |
|
2784 2757 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
2785 2758 | let fut = async move {
|
2786 2759 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
2787 2760 | request.headers(),
|
2788 2761 | &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYHTTPDATE,
|
2789 2762 | ) {
|
2790 2763 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
2791 2764 | }
|
2792 2765 | crate::protocol_serde::shape_malformed_timestamp_query_http_date::de_malformed_timestamp_query_http_date_http_request(request)
|
2793 2766 | .await
|
2794 - | .map_err(Into::into)
|
2795 2767 | };
|
2796 2768 | use ::futures_util::future::TryFutureExt;
|
2797 2769 | let fut = fut.map_err(
|
2798 2770 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
2799 2771 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
2800 2772 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
2801 2773 | e,
|
2802 2774 | )
|
2803 2775 | },
|
2804 2776 | );
|
2805 2777 | MalformedTimestampQueryHttpDateInputFuture {
|
2806 2778 | inner: Box::pin(fut),
|
2807 2779 | }
|
2808 2780 | }
|
2809 2781 | }
|
2810 2782 | impl
|
2811 2783 | ::aws_smithy_http_server::response::IntoResponse<
|
2812 2784 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2813 2785 | > for crate::output::MalformedTimestampQueryHttpDateOutput
|
2814 2786 | {
|
2815 2787 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
2816 2788 | match crate::protocol_serde::shape_malformed_timestamp_query_http_date::ser_malformed_timestamp_query_http_date_http_response(self) {
|
2817 2789 | Ok(response) => response,
|
2818 2790 | Err(e) => {
|
2819 2791 | ::tracing::error!(error = %e, "failed to serialize response");
|
2820 2792 | ::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))
|
2821 2793 | }
|
2822 2794 | }
|
2823 2795 | }
|
2824 2796 | }
|
@@ -2864,2836 +2924,2895 @@
2864 2836 | this.inner.as_mut().poll(cx)
|
2865 2837 | }
|
2866 2838 | }
|
2867 2839 |
|
2868 2840 | impl<B>
|
2869 2841 | ::aws_smithy_http_server::request::FromRequest<
|
2870 2842 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2871 2843 | B,
|
2872 2844 | > for crate::input::MalformedTimestampQueryDefaultInput
|
2873 2845 | where
|
2874 2846 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
2875 2847 | B: 'static,
|
2876 2848 |
|
2877 2849 | B::Data: Send,
|
2878 2850 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
2879 2851 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
2880 2852 | {
|
2881 2853 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
2882 2854 | type Future = MalformedTimestampQueryDefaultInputFuture;
|
2883 2855 |
|
2884 2856 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
2885 2857 | let fut = async move {
|
2886 2858 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
2887 2859 | request.headers(),
|
2888 2860 | &CONTENT_TYPE_MALFORMEDTIMESTAMPQUERYDEFAULT,
|
2889 2861 | ) {
|
2890 2862 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
2891 2863 | }
|
2892 2864 | crate::protocol_serde::shape_malformed_timestamp_query_default::de_malformed_timestamp_query_default_http_request(request)
|
2893 2865 | .await
|
2894 - | .map_err(Into::into)
|
2895 2866 | };
|
2896 2867 | use ::futures_util::future::TryFutureExt;
|
2897 2868 | let fut = fut.map_err(
|
2898 2869 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
2899 2870 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
2900 2871 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
2901 2872 | e,
|
2902 2873 | )
|
2903 2874 | },
|
2904 2875 | );
|
2905 2876 | MalformedTimestampQueryDefaultInputFuture {
|
2906 2877 | inner: Box::pin(fut),
|
2907 2878 | }
|
2908 2879 | }
|
2909 2880 | }
|
2910 2881 | impl
|
2911 2882 | ::aws_smithy_http_server::response::IntoResponse<
|
2912 2883 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2913 2884 | > for crate::output::MalformedTimestampQueryDefaultOutput
|
2914 2885 | {
|
2915 2886 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
2916 2887 | match crate::protocol_serde::shape_malformed_timestamp_query_default::ser_malformed_timestamp_query_default_http_response(self) {
|
2917 2888 | Ok(response) => response,
|
2918 2889 | Err(e) => {
|
2919 2890 | ::tracing::error!(error = %e, "failed to serialize response");
|
2920 2891 | ::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))
|
2921 2892 | }
|
2922 2893 | }
|
2923 2894 | }
|
2924 2895 | }
|
@@ -2964,2935 +3024,2994 @@
2964 2935 | this.inner.as_mut().poll(cx)
|
2965 2936 | }
|
2966 2937 | }
|
2967 2938 |
|
2968 2939 | impl<B>
|
2969 2940 | ::aws_smithy_http_server::request::FromRequest<
|
2970 2941 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
2971 2942 | B,
|
2972 2943 | > for crate::input::MalformedTimestampPathEpochInput
|
2973 2944 | where
|
2974 2945 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
2975 2946 | B: 'static,
|
2976 2947 |
|
2977 2948 | B::Data: Send,
|
2978 2949 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
2979 2950 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
2980 2951 | {
|
2981 2952 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
2982 2953 | type Future = MalformedTimestampPathEpochInputFuture;
|
2983 2954 |
|
2984 2955 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
2985 2956 | let fut = async move {
|
2986 2957 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
2987 2958 | request.headers(),
|
2988 2959 | &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHEPOCH,
|
2989 2960 | ) {
|
2990 2961 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
2991 2962 | }
|
2992 2963 | crate::protocol_serde::shape_malformed_timestamp_path_epoch::de_malformed_timestamp_path_epoch_http_request(request)
|
2993 2964 | .await
|
2994 - | .map_err(Into::into)
|
2995 2965 | };
|
2996 2966 | use ::futures_util::future::TryFutureExt;
|
2997 2967 | let fut = fut.map_err(
|
2998 2968 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
2999 2969 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
3000 2970 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
3001 2971 | e,
|
3002 2972 | )
|
3003 2973 | },
|
3004 2974 | );
|
3005 2975 | MalformedTimestampPathEpochInputFuture {
|
3006 2976 | inner: Box::pin(fut),
|
3007 2977 | }
|
3008 2978 | }
|
3009 2979 | }
|
3010 2980 | impl
|
3011 2981 | ::aws_smithy_http_server::response::IntoResponse<
|
3012 2982 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3013 2983 | > for crate::output::MalformedTimestampPathEpochOutput
|
3014 2984 | {
|
3015 2985 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
3016 2986 | match crate::protocol_serde::shape_malformed_timestamp_path_epoch::ser_malformed_timestamp_path_epoch_http_response(self) {
|
3017 2987 | Ok(response) => response,
|
3018 2988 | Err(e) => {
|
3019 2989 | ::tracing::error!(error = %e, "failed to serialize response");
|
3020 2990 | ::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))
|
3021 2991 | }
|
3022 2992 | }
|
3023 2993 | }
|
3024 2994 | }
|
@@ -3064,3034 +3124,3093 @@
3064 3034 | this.inner.as_mut().poll(cx)
|
3065 3035 | }
|
3066 3036 | }
|
3067 3037 |
|
3068 3038 | impl<B>
|
3069 3039 | ::aws_smithy_http_server::request::FromRequest<
|
3070 3040 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3071 3041 | B,
|
3072 3042 | > for crate::input::MalformedTimestampPathHttpDateInput
|
3073 3043 | where
|
3074 3044 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
3075 3045 | B: 'static,
|
3076 3046 |
|
3077 3047 | B::Data: Send,
|
3078 3048 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
3079 3049 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
3080 3050 | {
|
3081 3051 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
3082 3052 | type Future = MalformedTimestampPathHttpDateInputFuture;
|
3083 3053 |
|
3084 3054 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
3085 3055 | let fut = async move {
|
3086 3056 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
3087 3057 | request.headers(),
|
3088 3058 | &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHHTTPDATE,
|
3089 3059 | ) {
|
3090 3060 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
3091 3061 | }
|
3092 3062 | crate::protocol_serde::shape_malformed_timestamp_path_http_date::de_malformed_timestamp_path_http_date_http_request(request)
|
3093 3063 | .await
|
3094 - | .map_err(Into::into)
|
3095 3064 | };
|
3096 3065 | use ::futures_util::future::TryFutureExt;
|
3097 3066 | let fut = fut.map_err(
|
3098 3067 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
3099 3068 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
3100 3069 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
3101 3070 | e,
|
3102 3071 | )
|
3103 3072 | },
|
3104 3073 | );
|
3105 3074 | MalformedTimestampPathHttpDateInputFuture {
|
3106 3075 | inner: Box::pin(fut),
|
3107 3076 | }
|
3108 3077 | }
|
3109 3078 | }
|
3110 3079 | impl
|
3111 3080 | ::aws_smithy_http_server::response::IntoResponse<
|
3112 3081 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3113 3082 | > for crate::output::MalformedTimestampPathHttpDateOutput
|
3114 3083 | {
|
3115 3084 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
3116 3085 | match crate::protocol_serde::shape_malformed_timestamp_path_http_date::ser_malformed_timestamp_path_http_date_http_response(self) {
|
3117 3086 | Ok(response) => response,
|
3118 3087 | Err(e) => {
|
3119 3088 | ::tracing::error!(error = %e, "failed to serialize response");
|
3120 3089 | ::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))
|
3121 3090 | }
|
3122 3091 | }
|
3123 3092 | }
|
3124 3093 | }
|
@@ -3164,3133 +3224,3192 @@
3164 3133 | this.inner.as_mut().poll(cx)
|
3165 3134 | }
|
3166 3135 | }
|
3167 3136 |
|
3168 3137 | impl<B>
|
3169 3138 | ::aws_smithy_http_server::request::FromRequest<
|
3170 3139 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3171 3140 | B,
|
3172 3141 | > for crate::input::MalformedTimestampPathDefaultInput
|
3173 3142 | where
|
3174 3143 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
3175 3144 | B: 'static,
|
3176 3145 |
|
3177 3146 | B::Data: Send,
|
3178 3147 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
3179 3148 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
3180 3149 | {
|
3181 3150 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
3182 3151 | type Future = MalformedTimestampPathDefaultInputFuture;
|
3183 3152 |
|
3184 3153 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
3185 3154 | let fut = async move {
|
3186 3155 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
3187 3156 | request.headers(),
|
3188 3157 | &CONTENT_TYPE_MALFORMEDTIMESTAMPPATHDEFAULT,
|
3189 3158 | ) {
|
3190 3159 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
3191 3160 | }
|
3192 3161 | crate::protocol_serde::shape_malformed_timestamp_path_default::de_malformed_timestamp_path_default_http_request(request)
|
3193 3162 | .await
|
3194 - | .map_err(Into::into)
|
3195 3163 | };
|
3196 3164 | use ::futures_util::future::TryFutureExt;
|
3197 3165 | let fut = fut.map_err(
|
3198 3166 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
3199 3167 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
3200 3168 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
3201 3169 | e,
|
3202 3170 | )
|
3203 3171 | },
|
3204 3172 | );
|
3205 3173 | MalformedTimestampPathDefaultInputFuture {
|
3206 3174 | inner: Box::pin(fut),
|
3207 3175 | }
|
3208 3176 | }
|
3209 3177 | }
|
3210 3178 | impl
|
3211 3179 | ::aws_smithy_http_server::response::IntoResponse<
|
3212 3180 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3213 3181 | > for crate::output::MalformedTimestampPathDefaultOutput
|
3214 3182 | {
|
3215 3183 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
3216 3184 | match crate::protocol_serde::shape_malformed_timestamp_path_default::ser_malformed_timestamp_path_default_http_response(self) {
|
3217 3185 | Ok(response) => response,
|
3218 3186 | Err(e) => {
|
3219 3187 | ::tracing::error!(error = %e, "failed to serialize response");
|
3220 3188 | ::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))
|
3221 3189 | }
|
3222 3190 | }
|
3223 3191 | }
|
3224 3192 | }
|
@@ -3264,3232 +3324,3291 @@
3264 3232 | this.inner.as_mut().poll(cx)
|
3265 3233 | }
|
3266 3234 | }
|
3267 3235 |
|
3268 3236 | impl<B>
|
3269 3237 | ::aws_smithy_http_server::request::FromRequest<
|
3270 3238 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3271 3239 | B,
|
3272 3240 | > for crate::input::MalformedStringInput
|
3273 3241 | where
|
3274 3242 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
3275 3243 | B: 'static,
|
3276 3244 |
|
3277 3245 | B::Data: Send,
|
3278 3246 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
3279 3247 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
3280 3248 | {
|
3281 3249 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
3282 3250 | type Future = MalformedStringInputFuture;
|
3283 3251 |
|
3284 3252 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
3285 3253 | let fut = async move {
|
3286 3254 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
3287 3255 | request.headers(),
|
3288 3256 | &CONTENT_TYPE_MALFORMEDSTRING,
|
3289 3257 | ) {
|
3290 3258 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
3291 3259 | }
|
3292 3260 | crate::protocol_serde::shape_malformed_string::de_malformed_string_http_request(request)
|
3293 3261 | .await
|
3294 - | .map_err(Into::into)
|
3295 3262 | };
|
3296 3263 | use ::futures_util::future::TryFutureExt;
|
3297 3264 | let fut = fut.map_err(
|
3298 3265 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
3299 3266 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
3300 3267 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
3301 3268 | e,
|
3302 3269 | )
|
3303 3270 | },
|
3304 3271 | );
|
3305 3272 | MalformedStringInputFuture {
|
3306 3273 | inner: Box::pin(fut),
|
3307 3274 | }
|
3308 3275 | }
|
3309 3276 | }
|
3310 3277 | impl
|
3311 3278 | ::aws_smithy_http_server::response::IntoResponse<
|
3312 3279 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3313 3280 | > for crate::output::MalformedStringOutput
|
3314 3281 | {
|
3315 3282 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
3316 3283 | match crate::protocol_serde::shape_malformed_string::ser_malformed_string_http_response(
|
3317 3284 | self,
|
3318 3285 | ) {
|
3319 3286 | Ok(response) => response,
|
3320 3287 | Err(e) => {
|
3321 3288 | ::tracing::error!(error = %e, "failed to serialize response");
|
3322 3289 | ::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))
|
3323 3290 | }
|
3324 3291 | }
|
@@ -3369,3336 +3429,3395 @@
3369 3336 | this.inner.as_mut().poll(cx)
|
3370 3337 | }
|
3371 3338 | }
|
3372 3339 |
|
3373 3340 | impl<B>
|
3374 3341 | ::aws_smithy_http_server::request::FromRequest<
|
3375 3342 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3376 3343 | B,
|
3377 3344 | > for crate::input::MalformedDoubleInput
|
3378 3345 | where
|
3379 3346 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
3380 3347 | B: 'static,
|
3381 3348 |
|
3382 3349 | B::Data: Send,
|
3383 3350 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
3384 3351 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
3385 3352 | {
|
3386 3353 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
3387 3354 | type Future = MalformedDoubleInputFuture;
|
3388 3355 |
|
3389 3356 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
3390 3357 | let fut = async move {
|
3391 3358 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
3392 3359 | request.headers(),
|
3393 3360 | &CONTENT_TYPE_MALFORMEDDOUBLE,
|
3394 3361 | ) {
|
3395 3362 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
3396 3363 | }
|
3397 3364 | crate::protocol_serde::shape_malformed_double::de_malformed_double_http_request(request)
|
3398 3365 | .await
|
3399 - | .map_err(Into::into)
|
3400 3366 | };
|
3401 3367 | use ::futures_util::future::TryFutureExt;
|
3402 3368 | let fut = fut.map_err(
|
3403 3369 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
3404 3370 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
3405 3371 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
3406 3372 | e,
|
3407 3373 | )
|
3408 3374 | },
|
3409 3375 | );
|
3410 3376 | MalformedDoubleInputFuture {
|
3411 3377 | inner: Box::pin(fut),
|
3412 3378 | }
|
3413 3379 | }
|
3414 3380 | }
|
3415 3381 | impl
|
3416 3382 | ::aws_smithy_http_server::response::IntoResponse<
|
3417 3383 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3418 3384 | > for crate::output::MalformedDoubleOutput
|
3419 3385 | {
|
3420 3386 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
3421 3387 | match crate::protocol_serde::shape_malformed_double::ser_malformed_double_http_response(
|
3422 3388 | self,
|
3423 3389 | ) {
|
3424 3390 | Ok(response) => response,
|
3425 3391 | Err(e) => {
|
3426 3392 | ::tracing::error!(error = %e, "failed to serialize response");
|
3427 3393 | ::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))
|
3428 3394 | }
|
3429 3395 | }
|
@@ -3474,3440 +3534,3499 @@
3474 3440 | this.inner.as_mut().poll(cx)
|
3475 3441 | }
|
3476 3442 | }
|
3477 3443 |
|
3478 3444 | impl<B>
|
3479 3445 | ::aws_smithy_http_server::request::FromRequest<
|
3480 3446 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3481 3447 | B,
|
3482 3448 | > for crate::input::MalformedFloatInput
|
3483 3449 | where
|
3484 3450 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
3485 3451 | B: 'static,
|
3486 3452 |
|
3487 3453 | B::Data: Send,
|
3488 3454 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
3489 3455 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
3490 3456 | {
|
3491 3457 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
3492 3458 | type Future = MalformedFloatInputFuture;
|
3493 3459 |
|
3494 3460 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
3495 3461 | let fut = async move {
|
3496 3462 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
3497 3463 | request.headers(),
|
3498 3464 | &CONTENT_TYPE_MALFORMEDFLOAT,
|
3499 3465 | ) {
|
3500 3466 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
3501 3467 | }
|
3502 3468 | crate::protocol_serde::shape_malformed_float::de_malformed_float_http_request(request)
|
3503 3469 | .await
|
3504 - | .map_err(Into::into)
|
3505 3470 | };
|
3506 3471 | use ::futures_util::future::TryFutureExt;
|
3507 3472 | let fut = fut.map_err(
|
3508 3473 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
3509 3474 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
3510 3475 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
3511 3476 | e,
|
3512 3477 | )
|
3513 3478 | },
|
3514 3479 | );
|
3515 3480 | MalformedFloatInputFuture {
|
3516 3481 | inner: Box::pin(fut),
|
3517 3482 | }
|
3518 3483 | }
|
3519 3484 | }
|
3520 3485 | impl
|
3521 3486 | ::aws_smithy_http_server::response::IntoResponse<
|
3522 3487 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3523 3488 | > for crate::output::MalformedFloatOutput
|
3524 3489 | {
|
3525 3490 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
3526 3491 | match crate::protocol_serde::shape_malformed_float::ser_malformed_float_http_response(self)
|
3527 3492 | {
|
3528 3493 | Ok(response) => response,
|
3529 3494 | Err(e) => {
|
3530 3495 | ::tracing::error!(error = %e, "failed to serialize response");
|
3531 3496 | ::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))
|
3532 3497 | }
|
3533 3498 | }
|
3534 3499 | }
|
@@ -3577,3542 +3637,3601 @@
3577 3542 | this.inner.as_mut().poll(cx)
|
3578 3543 | }
|
3579 3544 | }
|
3580 3545 |
|
3581 3546 | impl<B>
|
3582 3547 | ::aws_smithy_http_server::request::FromRequest<
|
3583 3548 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3584 3549 | B,
|
3585 3550 | > for crate::input::MalformedLongInput
|
3586 3551 | where
|
3587 3552 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
3588 3553 | B: 'static,
|
3589 3554 |
|
3590 3555 | B::Data: Send,
|
3591 3556 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
3592 3557 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
3593 3558 | {
|
3594 3559 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
3595 3560 | type Future = MalformedLongInputFuture;
|
3596 3561 |
|
3597 3562 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
3598 3563 | let fut = async move {
|
3599 3564 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
3600 3565 | request.headers(),
|
3601 3566 | &CONTENT_TYPE_MALFORMEDLONG,
|
3602 3567 | ) {
|
3603 3568 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
3604 3569 | }
|
3605 3570 | crate::protocol_serde::shape_malformed_long::de_malformed_long_http_request(request)
|
3606 3571 | .await
|
3607 - | .map_err(Into::into)
|
3608 3572 | };
|
3609 3573 | use ::futures_util::future::TryFutureExt;
|
3610 3574 | let fut = fut.map_err(
|
3611 3575 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
3612 3576 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
3613 3577 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
3614 3578 | e,
|
3615 3579 | )
|
3616 3580 | },
|
3617 3581 | );
|
3618 3582 | MalformedLongInputFuture {
|
3619 3583 | inner: Box::pin(fut),
|
3620 3584 | }
|
3621 3585 | }
|
3622 3586 | }
|
3623 3587 | impl
|
3624 3588 | ::aws_smithy_http_server::response::IntoResponse<
|
3625 3589 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3626 3590 | > for crate::output::MalformedLongOutput
|
3627 3591 | {
|
3628 3592 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
3629 3593 | match crate::protocol_serde::shape_malformed_long::ser_malformed_long_http_response(self) {
|
3630 3594 | Ok(response) => response,
|
3631 3595 | Err(e) => {
|
3632 3596 | ::tracing::error!(error = %e, "failed to serialize response");
|
3633 3597 | ::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))
|
3634 3598 | }
|
3635 3599 | }
|
3636 3600 | }
|
3637 3601 | }
|
@@ -3679,3643 +3739,3702 @@
3679 3643 | this.inner.as_mut().poll(cx)
|
3680 3644 | }
|
3681 3645 | }
|
3682 3646 |
|
3683 3647 | impl<B>
|
3684 3648 | ::aws_smithy_http_server::request::FromRequest<
|
3685 3649 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3686 3650 | B,
|
3687 3651 | > for crate::input::MalformedShortInput
|
3688 3652 | where
|
3689 3653 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
3690 3654 | B: 'static,
|
3691 3655 |
|
3692 3656 | B::Data: Send,
|
3693 3657 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
3694 3658 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
3695 3659 | {
|
3696 3660 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
3697 3661 | type Future = MalformedShortInputFuture;
|
3698 3662 |
|
3699 3663 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
3700 3664 | let fut = async move {
|
3701 3665 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
3702 3666 | request.headers(),
|
3703 3667 | &CONTENT_TYPE_MALFORMEDSHORT,
|
3704 3668 | ) {
|
3705 3669 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
3706 3670 | }
|
3707 3671 | crate::protocol_serde::shape_malformed_short::de_malformed_short_http_request(request)
|
3708 3672 | .await
|
3709 - | .map_err(Into::into)
|
3710 3673 | };
|
3711 3674 | use ::futures_util::future::TryFutureExt;
|
3712 3675 | let fut = fut.map_err(
|
3713 3676 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
3714 3677 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
3715 3678 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
3716 3679 | e,
|
3717 3680 | )
|
3718 3681 | },
|
3719 3682 | );
|
3720 3683 | MalformedShortInputFuture {
|
3721 3684 | inner: Box::pin(fut),
|
3722 3685 | }
|
3723 3686 | }
|
3724 3687 | }
|
3725 3688 | impl
|
3726 3689 | ::aws_smithy_http_server::response::IntoResponse<
|
3727 3690 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3728 3691 | > for crate::output::MalformedShortOutput
|
3729 3692 | {
|
3730 3693 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
3731 3694 | match crate::protocol_serde::shape_malformed_short::ser_malformed_short_http_response(self)
|
3732 3695 | {
|
3733 3696 | Ok(response) => response,
|
3734 3697 | Err(e) => {
|
3735 3698 | ::tracing::error!(error = %e, "failed to serialize response");
|
3736 3699 | ::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))
|
3737 3700 | }
|
3738 3701 | }
|
3739 3702 | }
|
@@ -3782,3745 +3842,3804 @@
3782 3745 | this.inner.as_mut().poll(cx)
|
3783 3746 | }
|
3784 3747 | }
|
3785 3748 |
|
3786 3749 | impl<B>
|
3787 3750 | ::aws_smithy_http_server::request::FromRequest<
|
3788 3751 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3789 3752 | B,
|
3790 3753 | > for crate::input::MalformedByteInput
|
3791 3754 | where
|
3792 3755 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
3793 3756 | B: 'static,
|
3794 3757 |
|
3795 3758 | B::Data: Send,
|
3796 3759 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
3797 3760 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
3798 3761 | {
|
3799 3762 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
3800 3763 | type Future = MalformedByteInputFuture;
|
3801 3764 |
|
3802 3765 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
3803 3766 | let fut = async move {
|
3804 3767 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
3805 3768 | request.headers(),
|
3806 3769 | &CONTENT_TYPE_MALFORMEDBYTE,
|
3807 3770 | ) {
|
3808 3771 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
3809 3772 | }
|
3810 3773 | crate::protocol_serde::shape_malformed_byte::de_malformed_byte_http_request(request)
|
3811 3774 | .await
|
3812 - | .map_err(Into::into)
|
3813 3775 | };
|
3814 3776 | use ::futures_util::future::TryFutureExt;
|
3815 3777 | let fut = fut.map_err(
|
3816 3778 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
3817 3779 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
3818 3780 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
3819 3781 | e,
|
3820 3782 | )
|
3821 3783 | },
|
3822 3784 | );
|
3823 3785 | MalformedByteInputFuture {
|
3824 3786 | inner: Box::pin(fut),
|
3825 3787 | }
|
3826 3788 | }
|
3827 3789 | }
|
3828 3790 | impl
|
3829 3791 | ::aws_smithy_http_server::response::IntoResponse<
|
3830 3792 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3831 3793 | > for crate::output::MalformedByteOutput
|
3832 3794 | {
|
3833 3795 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
3834 3796 | match crate::protocol_serde::shape_malformed_byte::ser_malformed_byte_http_response(self) {
|
3835 3797 | Ok(response) => response,
|
3836 3798 | Err(e) => {
|
3837 3799 | ::tracing::error!(error = %e, "failed to serialize response");
|
3838 3800 | ::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))
|
3839 3801 | }
|
3840 3802 | }
|
3841 3803 | }
|
3842 3804 | }
|
@@ -3884,3846 +3944,3905 @@
3884 3846 | this.inner.as_mut().poll(cx)
|
3885 3847 | }
|
3886 3848 | }
|
3887 3849 |
|
3888 3850 | impl<B>
|
3889 3851 | ::aws_smithy_http_server::request::FromRequest<
|
3890 3852 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3891 3853 | B,
|
3892 3854 | > for crate::input::MalformedBlobInput
|
3893 3855 | where
|
3894 3856 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
3895 3857 | B: 'static,
|
3896 3858 |
|
3897 3859 | B::Data: Send,
|
3898 3860 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
3899 3861 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
3900 3862 | {
|
3901 3863 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
3902 3864 | type Future = MalformedBlobInputFuture;
|
3903 3865 |
|
3904 3866 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
3905 3867 | let fut = async move {
|
3906 3868 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
3907 3869 | request.headers(),
|
3908 3870 | &CONTENT_TYPE_MALFORMEDBLOB,
|
3909 3871 | ) {
|
3910 3872 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
3911 3873 | }
|
3912 3874 | crate::protocol_serde::shape_malformed_blob::de_malformed_blob_http_request(request)
|
3913 3875 | .await
|
3914 - | .map_err(Into::into)
|
3915 3876 | };
|
3916 3877 | use ::futures_util::future::TryFutureExt;
|
3917 3878 | let fut = fut.map_err(
|
3918 3879 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
3919 3880 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
3920 3881 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
3921 3882 | e,
|
3922 3883 | )
|
3923 3884 | },
|
3924 3885 | );
|
3925 3886 | MalformedBlobInputFuture {
|
3926 3887 | inner: Box::pin(fut),
|
3927 3888 | }
|
3928 3889 | }
|
3929 3890 | }
|
3930 3891 | impl
|
3931 3892 | ::aws_smithy_http_server::response::IntoResponse<
|
3932 3893 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3933 3894 | > for crate::output::MalformedBlobOutput
|
3934 3895 | {
|
3935 3896 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
3936 3897 | match crate::protocol_serde::shape_malformed_blob::ser_malformed_blob_http_response(self) {
|
3937 3898 | Ok(response) => response,
|
3938 3899 | Err(e) => {
|
3939 3900 | ::tracing::error!(error = %e, "failed to serialize response");
|
3940 3901 | ::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))
|
3941 3902 | }
|
3942 3903 | }
|
3943 3904 | }
|
3944 3905 | }
|
@@ -3984,3945 +4046,4005 @@
3984 3945 | ) -> std::task::Poll<Self::Output> {
|
3985 3946 | let this = self.project();
|
3986 3947 | this.inner.as_mut().poll(cx)
|
3987 3948 | }
|
3988 3949 | }
|
3989 3950 |
|
3990 3951 | impl<B>
|
3991 3952 | ::aws_smithy_http_server::request::FromRequest<
|
3992 3953 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
3993 3954 | B,
|
3994 3955 | > for crate::input::MalformedMapInput
|
3995 3956 | where
|
3996 3957 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
3997 3958 | B: 'static,
|
3998 3959 |
|
3999 3960 | B::Data: Send,
|
4000 3961 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
4001 3962 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
4002 3963 | {
|
4003 3964 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
4004 3965 | type Future = MalformedMapInputFuture;
|
4005 3966 |
|
4006 3967 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
4007 3968 | let fut = async move {
|
4008 3969 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
4009 3970 | request.headers(),
|
4010 3971 | &CONTENT_TYPE_MALFORMEDMAP,
|
4011 3972 | ) {
|
4012 3973 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
4013 3974 | }
|
4014 - | crate::protocol_serde::shape_malformed_map::de_malformed_map_http_request(request)
|
4015 - | .await
|
4016 - | .map_err(Into::into)
|
3975 + | crate::protocol_serde::shape_malformed_map::de_malformed_map_http_request(request).await
|
4017 3976 | };
|
4018 3977 | use ::futures_util::future::TryFutureExt;
|
4019 3978 | let fut = fut.map_err(
|
4020 3979 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
4021 3980 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
4022 3981 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
4023 3982 | e,
|
4024 3983 | )
|
4025 3984 | },
|
4026 3985 | );
|
4027 3986 | MalformedMapInputFuture {
|
4028 3987 | inner: Box::pin(fut),
|
4029 3988 | }
|
4030 3989 | }
|
4031 3990 | }
|
4032 3991 | impl
|
4033 3992 | ::aws_smithy_http_server::response::IntoResponse<
|
4034 3993 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4035 3994 | > for crate::output::MalformedMapOutput
|
4036 3995 | {
|
4037 3996 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
4038 3997 | match crate::protocol_serde::shape_malformed_map::ser_malformed_map_http_response(self) {
|
4039 3998 | Ok(response) => response,
|
4040 3999 | Err(e) => {
|
4041 4000 | ::tracing::error!(error = %e, "failed to serialize response");
|
4042 4001 | ::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))
|
4043 4002 | }
|
4044 4003 | }
|
4045 4004 | }
|
4046 4005 | }
|
@@ -4088,4047 +4148,4106 @@
4088 4047 | this.inner.as_mut().poll(cx)
|
4089 4048 | }
|
4090 4049 | }
|
4091 4050 |
|
4092 4051 | impl<B>
|
4093 4052 | ::aws_smithy_http_server::request::FromRequest<
|
4094 4053 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4095 4054 | B,
|
4096 4055 | > for crate::input::MalformedListInput
|
4097 4056 | where
|
4098 4057 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
4099 4058 | B: 'static,
|
4100 4059 |
|
4101 4060 | B::Data: Send,
|
4102 4061 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
4103 4062 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
4104 4063 | {
|
4105 4064 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
4106 4065 | type Future = MalformedListInputFuture;
|
4107 4066 |
|
4108 4067 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
4109 4068 | let fut = async move {
|
4110 4069 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
4111 4070 | request.headers(),
|
4112 4071 | &CONTENT_TYPE_MALFORMEDLIST,
|
4113 4072 | ) {
|
4114 4073 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
4115 4074 | }
|
4116 4075 | crate::protocol_serde::shape_malformed_list::de_malformed_list_http_request(request)
|
4117 4076 | .await
|
4118 - | .map_err(Into::into)
|
4119 4077 | };
|
4120 4078 | use ::futures_util::future::TryFutureExt;
|
4121 4079 | let fut = fut.map_err(
|
4122 4080 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
4123 4081 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
4124 4082 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
4125 4083 | e,
|
4126 4084 | )
|
4127 4085 | },
|
4128 4086 | );
|
4129 4087 | MalformedListInputFuture {
|
4130 4088 | inner: Box::pin(fut),
|
4131 4089 | }
|
4132 4090 | }
|
4133 4091 | }
|
4134 4092 | impl
|
4135 4093 | ::aws_smithy_http_server::response::IntoResponse<
|
4136 4094 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4137 4095 | > for crate::output::MalformedListOutput
|
4138 4096 | {
|
4139 4097 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
4140 4098 | match crate::protocol_serde::shape_malformed_list::ser_malformed_list_http_response(self) {
|
4141 4099 | Ok(response) => response,
|
4142 4100 | Err(e) => {
|
4143 4101 | ::tracing::error!(error = %e, "failed to serialize response");
|
4144 4102 | ::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))
|
4145 4103 | }
|
4146 4104 | }
|
4147 4105 | }
|
4148 4106 | }
|
@@ -4192,4150 +4252,4209 @@
4192 4150 | }
|
4193 4151 |
|
4194 4152 | impl<B>
|
4195 4153 | ::aws_smithy_http_server::request::FromRequest<
|
4196 4154 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4197 4155 | B,
|
4198 4156 | > for crate::input::MalformedBooleanInput
|
4199 4157 | where
|
4200 4158 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
4201 4159 | B: 'static,
|
4202 4160 |
|
4203 4161 | B::Data: Send,
|
4204 4162 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
4205 4163 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
4206 4164 | {
|
4207 4165 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
4208 4166 | type Future = MalformedBooleanInputFuture;
|
4209 4167 |
|
4210 4168 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
4211 4169 | let fut = async move {
|
4212 4170 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
4213 4171 | request.headers(),
|
4214 4172 | &CONTENT_TYPE_MALFORMEDBOOLEAN,
|
4215 4173 | ) {
|
4216 4174 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
4217 4175 | }
|
4218 4176 | crate::protocol_serde::shape_malformed_boolean::de_malformed_boolean_http_request(
|
4219 4177 | request,
|
4220 4178 | )
|
4221 4179 | .await
|
4222 - | .map_err(Into::into)
|
4223 4180 | };
|
4224 4181 | use ::futures_util::future::TryFutureExt;
|
4225 4182 | let fut = fut.map_err(
|
4226 4183 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
4227 4184 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
4228 4185 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
4229 4186 | e,
|
4230 4187 | )
|
4231 4188 | },
|
4232 4189 | );
|
4233 4190 | MalformedBooleanInputFuture {
|
4234 4191 | inner: Box::pin(fut),
|
4235 4192 | }
|
4236 4193 | }
|
4237 4194 | }
|
4238 4195 | impl
|
4239 4196 | ::aws_smithy_http_server::response::IntoResponse<
|
4240 4197 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4241 4198 | > for crate::output::MalformedBooleanOutput
|
4242 4199 | {
|
4243 4200 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
4244 4201 | match crate::protocol_serde::shape_malformed_boolean::ser_malformed_boolean_http_response(
|
4245 4202 | self,
|
4246 4203 | ) {
|
4247 4204 | Ok(response) => response,
|
4248 4205 | Err(e) => {
|
4249 4206 | ::tracing::error!(error = %e, "failed to serialize response");
|
4250 4207 | ::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))
|
4251 4208 | }
|
4252 4209 | }
|
@@ -4298,4255 +4358,4314 @@
4298 4255 | this.inner.as_mut().poll(cx)
|
4299 4256 | }
|
4300 4257 | }
|
4301 4258 |
|
4302 4259 | impl<B>
|
4303 4260 | ::aws_smithy_http_server::request::FromRequest<
|
4304 4261 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4305 4262 | B,
|
4306 4263 | > for crate::input::MalformedUnionInput
|
4307 4264 | where
|
4308 4265 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
4309 4266 | B: 'static,
|
4310 4267 |
|
4311 4268 | B::Data: Send,
|
4312 4269 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
4313 4270 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
4314 4271 | {
|
4315 4272 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
4316 4273 | type Future = MalformedUnionInputFuture;
|
4317 4274 |
|
4318 4275 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
4319 4276 | let fut = async move {
|
4320 4277 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
4321 4278 | request.headers(),
|
4322 4279 | &CONTENT_TYPE_MALFORMEDUNION,
|
4323 4280 | ) {
|
4324 4281 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
4325 4282 | }
|
4326 4283 | crate::protocol_serde::shape_malformed_union::de_malformed_union_http_request(request)
|
4327 4284 | .await
|
4328 - | .map_err(Into::into)
|
4329 4285 | };
|
4330 4286 | use ::futures_util::future::TryFutureExt;
|
4331 4287 | let fut = fut.map_err(
|
4332 4288 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
4333 4289 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
4334 4290 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
4335 4291 | e,
|
4336 4292 | )
|
4337 4293 | },
|
4338 4294 | );
|
4339 4295 | MalformedUnionInputFuture {
|
4340 4296 | inner: Box::pin(fut),
|
4341 4297 | }
|
4342 4298 | }
|
4343 4299 | }
|
4344 4300 | impl
|
4345 4301 | ::aws_smithy_http_server::response::IntoResponse<
|
4346 4302 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4347 4303 | > for crate::output::MalformedUnionOutput
|
4348 4304 | {
|
4349 4305 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
4350 4306 | match crate::protocol_serde::shape_malformed_union::ser_malformed_union_http_response(self)
|
4351 4307 | {
|
4352 4308 | Ok(response) => response,
|
4353 4309 | Err(e) => {
|
4354 4310 | ::tracing::error!(error = %e, "failed to serialize response");
|
4355 4311 | ::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))
|
4356 4312 | }
|
4357 4313 | }
|
4358 4314 | }
|
@@ -4403,4359 +4463,4418 @@
4403 4359 | }
|
4404 4360 |
|
4405 4361 | impl<B>
|
4406 4362 | ::aws_smithy_http_server::request::FromRequest<
|
4407 4363 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4408 4364 | B,
|
4409 4365 | > for crate::input::MalformedIntegerInput
|
4410 4366 | where
|
4411 4367 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
4412 4368 | B: 'static,
|
4413 4369 |
|
4414 4370 | B::Data: Send,
|
4415 4371 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
4416 4372 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
4417 4373 | {
|
4418 4374 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
4419 4375 | type Future = MalformedIntegerInputFuture;
|
4420 4376 |
|
4421 4377 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
4422 4378 | let fut = async move {
|
4423 4379 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
4424 4380 | request.headers(),
|
4425 4381 | &CONTENT_TYPE_MALFORMEDINTEGER,
|
4426 4382 | ) {
|
4427 4383 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
4428 4384 | }
|
4429 4385 | crate::protocol_serde::shape_malformed_integer::de_malformed_integer_http_request(
|
4430 4386 | request,
|
4431 4387 | )
|
4432 4388 | .await
|
4433 - | .map_err(Into::into)
|
4434 4389 | };
|
4435 4390 | use ::futures_util::future::TryFutureExt;
|
4436 4391 | let fut = fut.map_err(
|
4437 4392 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
4438 4393 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
4439 4394 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
4440 4395 | e,
|
4441 4396 | )
|
4442 4397 | },
|
4443 4398 | );
|
4444 4399 | MalformedIntegerInputFuture {
|
4445 4400 | inner: Box::pin(fut),
|
4446 4401 | }
|
4447 4402 | }
|
4448 4403 | }
|
4449 4404 | impl
|
4450 4405 | ::aws_smithy_http_server::response::IntoResponse<
|
4451 4406 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4452 4407 | > for crate::output::MalformedIntegerOutput
|
4453 4408 | {
|
4454 4409 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
4455 4410 | match crate::protocol_serde::shape_malformed_integer::ser_malformed_integer_http_response(
|
4456 4411 | self,
|
4457 4412 | ) {
|
4458 4413 | Ok(response) => response,
|
4459 4414 | Err(e) => {
|
4460 4415 | ::tracing::error!(error = %e, "failed to serialize response");
|
4461 4416 | ::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))
|
4462 4417 | }
|
4463 4418 | }
|
@@ -4509,4464 +4569,4523 @@
4509 4464 | this.inner.as_mut().poll(cx)
|
4510 4465 | }
|
4511 4466 | }
|
4512 4467 |
|
4513 4468 | impl<B>
|
4514 4469 | ::aws_smithy_http_server::request::FromRequest<
|
4515 4470 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4516 4471 | B,
|
4517 4472 | > for crate::input::MalformedRequestBodyInput
|
4518 4473 | where
|
4519 4474 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
4520 4475 | B: 'static,
|
4521 4476 |
|
4522 4477 | B::Data: Send,
|
4523 4478 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
4524 4479 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
4525 4480 | {
|
4526 4481 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
4527 4482 | type Future = MalformedRequestBodyInputFuture;
|
4528 4483 |
|
4529 4484 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
4530 4485 | let fut = async move {
|
4531 4486 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
4532 4487 | request.headers(),
|
4533 4488 | &CONTENT_TYPE_MALFORMEDREQUESTBODY,
|
4534 4489 | ) {
|
4535 4490 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
4536 4491 | }
|
4537 4492 | crate::protocol_serde::shape_malformed_request_body::de_malformed_request_body_http_request(request)
|
4538 4493 | .await
|
4539 - | .map_err(Into::into)
|
4540 4494 | };
|
4541 4495 | use ::futures_util::future::TryFutureExt;
|
4542 4496 | let fut = fut.map_err(
|
4543 4497 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
4544 4498 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
4545 4499 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
4546 4500 | e,
|
4547 4501 | )
|
4548 4502 | },
|
4549 4503 | );
|
4550 4504 | MalformedRequestBodyInputFuture {
|
4551 4505 | inner: Box::pin(fut),
|
4552 4506 | }
|
4553 4507 | }
|
4554 4508 | }
|
4555 4509 | impl
|
4556 4510 | ::aws_smithy_http_server::response::IntoResponse<
|
4557 4511 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4558 4512 | > for crate::output::MalformedRequestBodyOutput
|
4559 4513 | {
|
4560 4514 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
4561 4515 | match crate::protocol_serde::shape_malformed_request_body::ser_malformed_request_body_http_response(self) {
|
4562 4516 | Ok(response) => response,
|
4563 4517 | Err(e) => {
|
4564 4518 | ::tracing::error!(error = %e, "failed to serialize response");
|
4565 4519 | ::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))
|
4566 4520 | }
|
4567 4521 | }
|
4568 4522 | }
|
4569 4523 | }
|
@@ -4609,4563 +4669,4622 @@
4609 4563 | this.inner.as_mut().poll(cx)
|
4610 4564 | }
|
4611 4565 | }
|
4612 4566 |
|
4613 4567 | impl<B>
|
4614 4568 | ::aws_smithy_http_server::request::FromRequest<
|
4615 4569 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4616 4570 | B,
|
4617 4571 | > for crate::input::HttpChecksumRequiredInput
|
4618 4572 | where
|
4619 4573 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
4620 4574 | B: 'static,
|
4621 4575 |
|
4622 4576 | B::Data: Send,
|
4623 4577 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
4624 4578 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
4625 4579 | {
|
4626 4580 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
4627 4581 | type Future = HttpChecksumRequiredInputFuture;
|
4628 4582 |
|
4629 4583 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
4630 4584 | let fut = async move {
|
4631 4585 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
4632 4586 | request.headers(),
|
4633 4587 | &CONTENT_TYPE_HTTPCHECKSUMREQUIRED,
|
4634 4588 | ) {
|
4635 4589 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
4636 4590 | }
|
4637 4591 | crate::protocol_serde::shape_http_checksum_required::de_http_checksum_required_http_request(request)
|
4638 4592 | .await
|
4639 - | .map_err(Into::into)
|
4640 4593 | };
|
4641 4594 | use ::futures_util::future::TryFutureExt;
|
4642 4595 | let fut = fut.map_err(
|
4643 4596 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
4644 4597 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
4645 4598 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
4646 4599 | e,
|
4647 4600 | )
|
4648 4601 | },
|
4649 4602 | );
|
4650 4603 | HttpChecksumRequiredInputFuture {
|
4651 4604 | inner: Box::pin(fut),
|
4652 4605 | }
|
4653 4606 | }
|
4654 4607 | }
|
4655 4608 | impl
|
4656 4609 | ::aws_smithy_http_server::response::IntoResponse<
|
4657 4610 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4658 4611 | > for crate::output::HttpChecksumRequiredOutput
|
4659 4612 | {
|
4660 4613 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
4661 4614 | match crate::protocol_serde::shape_http_checksum_required::ser_http_checksum_required_http_response(self) {
|
4662 4615 | Ok(response) => response,
|
4663 4616 | Err(e) => {
|
4664 4617 | ::tracing::error!(error = %e, "failed to serialize response");
|
4665 4618 | ::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))
|
4666 4619 | }
|
4667 4620 | }
|
4668 4621 | }
|
4669 4622 | }
|
@@ -4709,4662 +4769,4721 @@
4709 4662 | this.inner.as_mut().poll(cx)
|
4710 4663 | }
|
4711 4664 | }
|
4712 4665 |
|
4713 4666 | impl<B>
|
4714 4667 | ::aws_smithy_http_server::request::FromRequest<
|
4715 4668 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4716 4669 | B,
|
4717 4670 | > for crate::input::HostWithPathOperationInput
|
4718 4671 | where
|
4719 4672 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
4720 4673 | B: 'static,
|
4721 4674 |
|
4722 4675 | B::Data: Send,
|
4723 4676 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
4724 4677 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
4725 4678 | {
|
4726 4679 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
4727 4680 | type Future = HostWithPathOperationInputFuture;
|
4728 4681 |
|
4729 4682 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
4730 4683 | let fut = async move {
|
4731 4684 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
4732 4685 | request.headers(),
|
4733 4686 | &CONTENT_TYPE_HOSTWITHPATHOPERATION,
|
4734 4687 | ) {
|
4735 4688 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
4736 4689 | }
|
4737 4690 | crate::protocol_serde::shape_host_with_path_operation::de_host_with_path_operation_http_request(request)
|
4738 4691 | .await
|
4739 - | .map_err(Into::into)
|
4740 4692 | };
|
4741 4693 | use ::futures_util::future::TryFutureExt;
|
4742 4694 | let fut = fut.map_err(
|
4743 4695 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
4744 4696 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
4745 4697 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
4746 4698 | e,
|
4747 4699 | )
|
4748 4700 | },
|
4749 4701 | );
|
4750 4702 | HostWithPathOperationInputFuture {
|
4751 4703 | inner: Box::pin(fut),
|
4752 4704 | }
|
4753 4705 | }
|
4754 4706 | }
|
4755 4707 | impl
|
4756 4708 | ::aws_smithy_http_server::response::IntoResponse<
|
4757 4709 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4758 4710 | > for crate::output::HostWithPathOperationOutput
|
4759 4711 | {
|
4760 4712 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
4761 4713 | match crate::protocol_serde::shape_host_with_path_operation::ser_host_with_path_operation_http_response(self) {
|
4762 4714 | Ok(response) => response,
|
4763 4715 | Err(e) => {
|
4764 4716 | ::tracing::error!(error = %e, "failed to serialize response");
|
4765 4717 | ::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))
|
4766 4718 | }
|
4767 4719 | }
|
4768 4720 | }
|
4769 4721 | }
|
@@ -4809,4761 +4869,4820 @@
4809 4761 | this.inner.as_mut().poll(cx)
|
4810 4762 | }
|
4811 4763 | }
|
4812 4764 |
|
4813 4765 | impl<B>
|
4814 4766 | ::aws_smithy_http_server::request::FromRequest<
|
4815 4767 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4816 4768 | B,
|
4817 4769 | > for crate::input::EndpointWithHostLabelOperationInput
|
4818 4770 | where
|
4819 4771 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
4820 4772 | B: 'static,
|
4821 4773 |
|
4822 4774 | B::Data: Send,
|
4823 4775 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
4824 4776 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
4825 4777 | {
|
4826 4778 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
4827 4779 | type Future = EndpointWithHostLabelOperationInputFuture;
|
4828 4780 |
|
4829 4781 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
4830 4782 | let fut = async move {
|
4831 4783 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
4832 4784 | request.headers(),
|
4833 4785 | &CONTENT_TYPE_ENDPOINTWITHHOSTLABELOPERATION,
|
4834 4786 | ) {
|
4835 4787 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
4836 4788 | }
|
4837 4789 | crate::protocol_serde::shape_endpoint_with_host_label_operation::de_endpoint_with_host_label_operation_http_request(request)
|
4838 4790 | .await
|
4839 - | .map_err(Into::into)
|
4840 4791 | };
|
4841 4792 | use ::futures_util::future::TryFutureExt;
|
4842 4793 | let fut = fut.map_err(
|
4843 4794 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
4844 4795 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
4845 4796 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
4846 4797 | e,
|
4847 4798 | )
|
4848 4799 | },
|
4849 4800 | );
|
4850 4801 | EndpointWithHostLabelOperationInputFuture {
|
4851 4802 | inner: Box::pin(fut),
|
4852 4803 | }
|
4853 4804 | }
|
4854 4805 | }
|
4855 4806 | impl
|
4856 4807 | ::aws_smithy_http_server::response::IntoResponse<
|
4857 4808 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4858 4809 | > for crate::output::EndpointWithHostLabelOperationOutput
|
4859 4810 | {
|
4860 4811 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
4861 4812 | match crate::protocol_serde::shape_endpoint_with_host_label_operation::ser_endpoint_with_host_label_operation_http_response(self) {
|
4862 4813 | Ok(response) => response,
|
4863 4814 | Err(e) => {
|
4864 4815 | ::tracing::error!(error = %e, "failed to serialize response");
|
4865 4816 | ::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))
|
4866 4817 | }
|
4867 4818 | }
|
4868 4819 | }
|
4869 4820 | }
|
@@ -4911,4862 +4971,4921 @@
4911 4862 | }
|
4912 4863 |
|
4913 4864 | impl<B>
|
4914 4865 | ::aws_smithy_http_server::request::FromRequest<
|
4915 4866 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4916 4867 | B,
|
4917 4868 | > for crate::input::EndpointOperationInput
|
4918 4869 | where
|
4919 4870 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
4920 4871 | B: 'static,
|
4921 4872 |
|
4922 4873 | B::Data: Send,
|
4923 4874 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
4924 4875 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
4925 4876 | {
|
4926 4877 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
4927 4878 | type Future = EndpointOperationInputFuture;
|
4928 4879 |
|
4929 4880 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
4930 4881 | let fut = async move {
|
4931 4882 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
4932 4883 | request.headers(),
|
4933 4884 | &CONTENT_TYPE_ENDPOINTOPERATION,
|
4934 4885 | ) {
|
4935 4886 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
4936 4887 | }
|
4937 4888 | crate::protocol_serde::shape_endpoint_operation::de_endpoint_operation_http_request(
|
4938 4889 | request,
|
4939 4890 | )
|
4940 4891 | .await
|
4941 - | .map_err(Into::into)
|
4942 4892 | };
|
4943 4893 | use ::futures_util::future::TryFutureExt;
|
4944 4894 | let fut = fut.map_err(
|
4945 4895 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
4946 4896 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
4947 4897 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
4948 4898 | e,
|
4949 4899 | )
|
4950 4900 | },
|
4951 4901 | );
|
4952 4902 | EndpointOperationInputFuture {
|
4953 4903 | inner: Box::pin(fut),
|
4954 4904 | }
|
4955 4905 | }
|
4956 4906 | }
|
4957 4907 | impl
|
4958 4908 | ::aws_smithy_http_server::response::IntoResponse<
|
4959 4909 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
4960 4910 | > for crate::output::EndpointOperationOutput
|
4961 4911 | {
|
4962 4912 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
4963 4913 | match crate::protocol_serde::shape_endpoint_operation::ser_endpoint_operation_http_response(
|
4964 4914 | self,
|
4965 4915 | ) {
|
4966 4916 | Ok(response) => response,
|
4967 4917 | Err(e) => {
|
4968 4918 | ::tracing::error!(error = %e, "failed to serialize response");
|
4969 4919 | ::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))
|
4970 4920 | }
|
4971 4921 | }
|
@@ -5017,4967 +5077,5026 @@
5017 4967 | this.inner.as_mut().poll(cx)
|
5018 4968 | }
|
5019 4969 | }
|
5020 4970 |
|
5021 4971 | impl<B>
|
5022 4972 | ::aws_smithy_http_server::request::FromRequest<
|
5023 4973 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5024 4974 | B,
|
5025 4975 | > for crate::input::PostUnionWithJsonNameInput
|
5026 4976 | where
|
5027 4977 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
5028 4978 | B: 'static,
|
5029 4979 |
|
5030 4980 | B::Data: Send,
|
5031 4981 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
5032 4982 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
5033 4983 | {
|
5034 4984 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
5035 4985 | type Future = PostUnionWithJsonNameInputFuture;
|
5036 4986 |
|
5037 4987 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
5038 4988 | let fut = async move {
|
5039 4989 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
5040 4990 | request.headers(),
|
5041 4991 | &CONTENT_TYPE_POSTUNIONWITHJSONNAME,
|
5042 4992 | ) {
|
5043 4993 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
5044 4994 | }
|
5045 4995 | crate::protocol_serde::shape_post_union_with_json_name::de_post_union_with_json_name_http_request(request)
|
5046 4996 | .await
|
5047 - | .map_err(Into::into)
|
5048 4997 | };
|
5049 4998 | use ::futures_util::future::TryFutureExt;
|
5050 4999 | let fut = fut.map_err(
|
5051 5000 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
5052 5001 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
5053 5002 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
5054 5003 | e,
|
5055 5004 | )
|
5056 5005 | },
|
5057 5006 | );
|
5058 5007 | PostUnionWithJsonNameInputFuture {
|
5059 5008 | inner: Box::pin(fut),
|
5060 5009 | }
|
5061 5010 | }
|
5062 5011 | }
|
5063 5012 | impl
|
5064 5013 | ::aws_smithy_http_server::response::IntoResponse<
|
5065 5014 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5066 5015 | > for crate::output::PostUnionWithJsonNameOutput
|
5067 5016 | {
|
5068 5017 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
5069 5018 | match crate::protocol_serde::shape_post_union_with_json_name::ser_post_union_with_json_name_http_response(self) {
|
5070 5019 | Ok(response) => response,
|
5071 5020 | Err(e) => {
|
5072 5021 | ::tracing::error!(error = %e, "failed to serialize response");
|
5073 5022 | ::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))
|
5074 5023 | }
|
5075 5024 | }
|
5076 5025 | }
|
5077 5026 | }
|
@@ -5119,5068 +5179,5127 @@
5119 5068 | }
|
5120 5069 |
|
5121 5070 | impl<B>
|
5122 5071 | ::aws_smithy_http_server::request::FromRequest<
|
5123 5072 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5124 5073 | B,
|
5125 5074 | > for crate::input::PostPlayerActionInput
|
5126 5075 | where
|
5127 5076 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
5128 5077 | B: 'static,
|
5129 5078 |
|
5130 5079 | B::Data: Send,
|
5131 5080 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
5132 5081 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
5133 5082 | {
|
5134 5083 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
5135 5084 | type Future = PostPlayerActionInputFuture;
|
5136 5085 |
|
5137 5086 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
5138 5087 | let fut = async move {
|
5139 5088 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
5140 5089 | request.headers(),
|
5141 5090 | &CONTENT_TYPE_POSTPLAYERACTION,
|
5142 5091 | ) {
|
5143 5092 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
5144 5093 | }
|
5145 5094 | crate::protocol_serde::shape_post_player_action::de_post_player_action_http_request(
|
5146 5095 | request,
|
5147 5096 | )
|
5148 5097 | .await
|
5149 - | .map_err(Into::into)
|
5150 5098 | };
|
5151 5099 | use ::futures_util::future::TryFutureExt;
|
5152 5100 | let fut = fut.map_err(
|
5153 5101 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
5154 5102 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
5155 5103 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
5156 5104 | e,
|
5157 5105 | )
|
5158 5106 | },
|
5159 5107 | );
|
5160 5108 | PostPlayerActionInputFuture {
|
5161 5109 | inner: Box::pin(fut),
|
5162 5110 | }
|
5163 5111 | }
|
5164 5112 | }
|
5165 5113 | impl
|
5166 5114 | ::aws_smithy_http_server::response::IntoResponse<
|
5167 5115 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5168 5116 | > for crate::output::PostPlayerActionOutput
|
5169 5117 | {
|
5170 5118 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
5171 5119 | match crate::protocol_serde::shape_post_player_action::ser_post_player_action_http_response(
|
5172 5120 | self,
|
5173 5121 | ) {
|
5174 5122 | Ok(response) => response,
|
5175 5123 | Err(e) => {
|
5176 5124 | ::tracing::error!(error = %e, "failed to serialize response");
|
5177 5125 | ::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))
|
5178 5126 | }
|
5179 5127 | }
|
@@ -5223,5171 +5285,5231 @@
5223 5171 | ) -> std::task::Poll<Self::Output> {
|
5224 5172 | let this = self.project();
|
5225 5173 | this.inner.as_mut().poll(cx)
|
5226 5174 | }
|
5227 5175 | }
|
5228 5176 |
|
5229 5177 | impl<B>
|
5230 5178 | ::aws_smithy_http_server::request::FromRequest<
|
5231 5179 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5232 5180 | B,
|
5233 5181 | > for crate::input::JsonUnionsInput
|
5234 5182 | where
|
5235 5183 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
5236 5184 | B: 'static,
|
5237 5185 |
|
5238 5186 | B::Data: Send,
|
5239 5187 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
5240 5188 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
5241 5189 | {
|
5242 5190 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
5243 5191 | type Future = JsonUnionsInputFuture;
|
5244 5192 |
|
5245 5193 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
5246 5194 | let fut = async move {
|
5247 5195 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
5248 5196 | request.headers(),
|
5249 5197 | &CONTENT_TYPE_JSONUNIONS,
|
5250 5198 | ) {
|
5251 5199 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
5252 5200 | }
|
5253 - | crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request)
|
5254 - | .await
|
5255 - | .map_err(Into::into)
|
5201 + | crate::protocol_serde::shape_json_unions::de_json_unions_http_request(request).await
|
5256 5202 | };
|
5257 5203 | use ::futures_util::future::TryFutureExt;
|
5258 5204 | let fut = fut.map_err(
|
5259 5205 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
5260 5206 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
5261 5207 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
5262 5208 | e,
|
5263 5209 | )
|
5264 5210 | },
|
5265 5211 | );
|
5266 5212 | JsonUnionsInputFuture {
|
5267 5213 | inner: Box::pin(fut),
|
5268 5214 | }
|
5269 5215 | }
|
5270 5216 | }
|
5271 5217 | impl
|
5272 5218 | ::aws_smithy_http_server::response::IntoResponse<
|
5273 5219 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5274 5220 | > for crate::output::JsonUnionsOutput
|
5275 5221 | {
|
5276 5222 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
5277 5223 | match crate::protocol_serde::shape_json_unions::ser_json_unions_http_response(self) {
|
5278 5224 | Ok(response) => response,
|
5279 5225 | Err(e) => {
|
5280 5226 | ::tracing::error!(error = %e, "failed to serialize response");
|
5281 5227 | ::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))
|
5282 5228 | }
|
5283 5229 | }
|
5284 5230 | }
|
5285 5231 | }
|
@@ -5327,5273 +5387,5332 @@
5327 5273 | this.inner.as_mut().poll(cx)
|
5328 5274 | }
|
5329 5275 | }
|
5330 5276 |
|
5331 5277 | impl<B>
|
5332 5278 | ::aws_smithy_http_server::request::FromRequest<
|
5333 5279 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5334 5280 | B,
|
5335 5281 | > for crate::input::DocumentTypeAsMapValueInput
|
5336 5282 | where
|
5337 5283 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
5338 5284 | B: 'static,
|
5339 5285 |
|
5340 5286 | B::Data: Send,
|
5341 5287 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
5342 5288 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
5343 5289 | {
|
5344 5290 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
5345 5291 | type Future = DocumentTypeAsMapValueInputFuture;
|
5346 5292 |
|
5347 5293 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
5348 5294 | let fut = async move {
|
5349 5295 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
5350 5296 | request.headers(),
|
5351 5297 | &CONTENT_TYPE_DOCUMENTTYPEASMAPVALUE,
|
5352 5298 | ) {
|
5353 5299 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
5354 5300 | }
|
5355 5301 | crate::protocol_serde::shape_document_type_as_map_value::de_document_type_as_map_value_http_request(request)
|
5356 5302 | .await
|
5357 - | .map_err(Into::into)
|
5358 5303 | };
|
5359 5304 | use ::futures_util::future::TryFutureExt;
|
5360 5305 | let fut = fut.map_err(
|
5361 5306 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
5362 5307 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
5363 5308 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
5364 5309 | e,
|
5365 5310 | )
|
5366 5311 | },
|
5367 5312 | );
|
5368 5313 | DocumentTypeAsMapValueInputFuture {
|
5369 5314 | inner: Box::pin(fut),
|
5370 5315 | }
|
5371 5316 | }
|
5372 5317 | }
|
5373 5318 | impl
|
5374 5319 | ::aws_smithy_http_server::response::IntoResponse<
|
5375 5320 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5376 5321 | > for crate::output::DocumentTypeAsMapValueOutput
|
5377 5322 | {
|
5378 5323 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
5379 5324 | match crate::protocol_serde::shape_document_type_as_map_value::ser_document_type_as_map_value_http_response(self) {
|
5380 5325 | Ok(response) => response,
|
5381 5326 | Err(e) => {
|
5382 5327 | ::tracing::error!(error = %e, "failed to serialize response");
|
5383 5328 | ::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))
|
5384 5329 | }
|
5385 5330 | }
|
5386 5331 | }
|
5387 5332 | }
|
@@ -5427,5372 +5487,5431 @@
5427 5372 | this.inner.as_mut().poll(cx)
|
5428 5373 | }
|
5429 5374 | }
|
5430 5375 |
|
5431 5376 | impl<B>
|
5432 5377 | ::aws_smithy_http_server::request::FromRequest<
|
5433 5378 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5434 5379 | B,
|
5435 5380 | > for crate::input::DocumentTypeAsPayloadInput
|
5436 5381 | where
|
5437 5382 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
5438 5383 | B: 'static,
|
5439 5384 |
|
5440 5385 | B::Data: Send,
|
5441 5386 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
5442 5387 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
5443 5388 | {
|
5444 5389 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
5445 5390 | type Future = DocumentTypeAsPayloadInputFuture;
|
5446 5391 |
|
5447 5392 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
5448 5393 | let fut = async move {
|
5449 5394 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
5450 5395 | request.headers(),
|
5451 5396 | &CONTENT_TYPE_DOCUMENTTYPEASPAYLOAD,
|
5452 5397 | ) {
|
5453 5398 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
5454 5399 | }
|
5455 5400 | crate::protocol_serde::shape_document_type_as_payload::de_document_type_as_payload_http_request(request)
|
5456 5401 | .await
|
5457 - | .map_err(Into::into)
|
5458 5402 | };
|
5459 5403 | use ::futures_util::future::TryFutureExt;
|
5460 5404 | let fut = fut.map_err(
|
5461 5405 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
5462 5406 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
5463 5407 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
5464 5408 | e,
|
5465 5409 | )
|
5466 5410 | },
|
5467 5411 | );
|
5468 5412 | DocumentTypeAsPayloadInputFuture {
|
5469 5413 | inner: Box::pin(fut),
|
5470 5414 | }
|
5471 5415 | }
|
5472 5416 | }
|
5473 5417 | impl
|
5474 5418 | ::aws_smithy_http_server::response::IntoResponse<
|
5475 5419 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5476 5420 | > for crate::output::DocumentTypeAsPayloadOutput
|
5477 5421 | {
|
5478 5422 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
5479 5423 | match crate::protocol_serde::shape_document_type_as_payload::ser_document_type_as_payload_http_response(self) {
|
5480 5424 | Ok(response) => response,
|
5481 5425 | Err(e) => {
|
5482 5426 | ::tracing::error!(error = %e, "failed to serialize response");
|
5483 5427 | ::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))
|
5484 5428 | }
|
5485 5429 | }
|
5486 5430 | }
|
5487 5431 | }
|
@@ -5525,5469 +5587,5529 @@
5525 5469 | ) -> std::task::Poll<Self::Output> {
|
5526 5470 | let this = self.project();
|
5527 5471 | this.inner.as_mut().poll(cx)
|
5528 5472 | }
|
5529 5473 | }
|
5530 5474 |
|
5531 5475 | impl<B>
|
5532 5476 | ::aws_smithy_http_server::request::FromRequest<
|
5533 5477 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5534 5478 | B,
|
5535 5479 | > for crate::input::DocumentTypeInput
|
5536 5480 | where
|
5537 5481 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
5538 5482 | B: 'static,
|
5539 5483 |
|
5540 5484 | B::Data: Send,
|
5541 5485 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
5542 5486 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
5543 5487 | {
|
5544 5488 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
5545 5489 | type Future = DocumentTypeInputFuture;
|
5546 5490 |
|
5547 5491 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
5548 5492 | let fut = async move {
|
5549 5493 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
5550 5494 | request.headers(),
|
5551 5495 | &CONTENT_TYPE_DOCUMENTTYPE,
|
5552 5496 | ) {
|
5553 5497 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
5554 5498 | }
|
5555 - | crate::protocol_serde::shape_document_type::de_document_type_http_request(request)
|
5556 - | .await
|
5557 - | .map_err(Into::into)
|
5499 + | crate::protocol_serde::shape_document_type::de_document_type_http_request(request).await
|
5558 5500 | };
|
5559 5501 | use ::futures_util::future::TryFutureExt;
|
5560 5502 | let fut = fut.map_err(
|
5561 5503 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
5562 5504 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
5563 5505 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
5564 5506 | e,
|
5565 5507 | )
|
5566 5508 | },
|
5567 5509 | );
|
5568 5510 | DocumentTypeInputFuture {
|
5569 5511 | inner: Box::pin(fut),
|
5570 5512 | }
|
5571 5513 | }
|
5572 5514 | }
|
5573 5515 | impl
|
5574 5516 | ::aws_smithy_http_server::response::IntoResponse<
|
5575 5517 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5576 5518 | > for crate::output::DocumentTypeOutput
|
5577 5519 | {
|
5578 5520 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
5579 5521 | match crate::protocol_serde::shape_document_type::ser_document_type_http_response(self) {
|
5580 5522 | Ok(response) => response,
|
5581 5523 | Err(e) => {
|
5582 5524 | ::tracing::error!(error = %e, "failed to serialize response");
|
5583 5525 | ::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))
|
5584 5526 | }
|
5585 5527 | }
|
5586 5528 | }
|
5587 5529 | }
|
@@ -5627,5569 +5689,5629 @@
5627 5569 | ) -> std::task::Poll<Self::Output> {
|
5628 5570 | let this = self.project();
|
5629 5571 | this.inner.as_mut().poll(cx)
|
5630 5572 | }
|
5631 5573 | }
|
5632 5574 |
|
5633 5575 | impl<B>
|
5634 5576 | ::aws_smithy_http_server::request::FromRequest<
|
5635 5577 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5636 5578 | B,
|
5637 5579 | > for crate::input::JsonBlobsInput
|
5638 5580 | where
|
5639 5581 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
5640 5582 | B: 'static,
|
5641 5583 |
|
5642 5584 | B::Data: Send,
|
5643 5585 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
5644 5586 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
5645 5587 | {
|
5646 5588 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
5647 5589 | type Future = JsonBlobsInputFuture;
|
5648 5590 |
|
5649 5591 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
5650 5592 | let fut = async move {
|
5651 5593 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
5652 5594 | request.headers(),
|
5653 5595 | &CONTENT_TYPE_JSONBLOBS,
|
5654 5596 | ) {
|
5655 5597 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
5656 5598 | }
|
5657 - | crate::protocol_serde::shape_json_blobs::de_json_blobs_http_request(request)
|
5658 - | .await
|
5659 - | .map_err(Into::into)
|
5599 + | crate::protocol_serde::shape_json_blobs::de_json_blobs_http_request(request).await
|
5660 5600 | };
|
5661 5601 | use ::futures_util::future::TryFutureExt;
|
5662 5602 | let fut = fut.map_err(
|
5663 5603 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
5664 5604 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
5665 5605 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
5666 5606 | e,
|
5667 5607 | )
|
5668 5608 | },
|
5669 5609 | );
|
5670 5610 | JsonBlobsInputFuture {
|
5671 5611 | inner: Box::pin(fut),
|
5672 5612 | }
|
5673 5613 | }
|
5674 5614 | }
|
5675 5615 | impl
|
5676 5616 | ::aws_smithy_http_server::response::IntoResponse<
|
5677 5617 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5678 5618 | > for crate::output::JsonBlobsOutput
|
5679 5619 | {
|
5680 5620 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
5681 5621 | match crate::protocol_serde::shape_json_blobs::ser_json_blobs_http_response(self) {
|
5682 5622 | Ok(response) => response,
|
5683 5623 | Err(e) => {
|
5684 5624 | ::tracing::error!(error = %e, "failed to serialize response");
|
5685 5625 | ::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))
|
5686 5626 | }
|
5687 5627 | }
|
5688 5628 | }
|
5689 5629 | }
|
@@ -5731,5671 +5791,5730 @@
5731 5671 | this.inner.as_mut().poll(cx)
|
5732 5672 | }
|
5733 5673 | }
|
5734 5674 |
|
5735 5675 | impl<B>
|
5736 5676 | ::aws_smithy_http_server::request::FromRequest<
|
5737 5677 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5738 5678 | B,
|
5739 5679 | > for crate::input::SparseJsonMapsInput
|
5740 5680 | where
|
5741 5681 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
5742 5682 | B: 'static,
|
5743 5683 |
|
5744 5684 | B::Data: Send,
|
5745 5685 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
5746 5686 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
5747 5687 | {
|
5748 5688 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
5749 5689 | type Future = SparseJsonMapsInputFuture;
|
5750 5690 |
|
5751 5691 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
5752 5692 | let fut = async move {
|
5753 5693 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
5754 5694 | request.headers(),
|
5755 5695 | &CONTENT_TYPE_SPARSEJSONMAPS,
|
5756 5696 | ) {
|
5757 5697 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
5758 5698 | }
|
5759 5699 | crate::protocol_serde::shape_sparse_json_maps::de_sparse_json_maps_http_request(request)
|
5760 5700 | .await
|
5761 - | .map_err(Into::into)
|
5762 5701 | };
|
5763 5702 | use ::futures_util::future::TryFutureExt;
|
5764 5703 | let fut = fut.map_err(
|
5765 5704 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
5766 5705 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
5767 5706 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
5768 5707 | e,
|
5769 5708 | )
|
5770 5709 | },
|
5771 5710 | );
|
5772 5711 | SparseJsonMapsInputFuture {
|
5773 5712 | inner: Box::pin(fut),
|
5774 5713 | }
|
5775 5714 | }
|
5776 5715 | }
|
5777 5716 | impl
|
5778 5717 | ::aws_smithy_http_server::response::IntoResponse<
|
5779 5718 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5780 5719 | > for crate::output::SparseJsonMapsOutput
|
5781 5720 | {
|
5782 5721 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
5783 5722 | match crate::protocol_serde::shape_sparse_json_maps::ser_sparse_json_maps_http_response(
|
5784 5723 | self,
|
5785 5724 | ) {
|
5786 5725 | Ok(response) => response,
|
5787 5726 | Err(e) => {
|
5788 5727 | ::tracing::error!(error = %e, "failed to serialize response");
|
5789 5728 | ::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))
|
5790 5729 | }
|
5791 5730 | }
|
@@ -5834,5773 +5896,5833 @@
5834 5773 | ) -> std::task::Poll<Self::Output> {
|
5835 5774 | let this = self.project();
|
5836 5775 | this.inner.as_mut().poll(cx)
|
5837 5776 | }
|
5838 5777 | }
|
5839 5778 |
|
5840 5779 | impl<B>
|
5841 5780 | ::aws_smithy_http_server::request::FromRequest<
|
5842 5781 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5843 5782 | B,
|
5844 5783 | > for crate::input::JsonMapsInput
|
5845 5784 | where
|
5846 5785 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
5847 5786 | B: 'static,
|
5848 5787 |
|
5849 5788 | B::Data: Send,
|
5850 5789 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
5851 5790 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
5852 5791 | {
|
5853 5792 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
5854 5793 | type Future = JsonMapsInputFuture;
|
5855 5794 |
|
5856 5795 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
5857 5796 | let fut = async move {
|
5858 5797 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
5859 5798 | request.headers(),
|
5860 5799 | &CONTENT_TYPE_JSONMAPS,
|
5861 5800 | ) {
|
5862 5801 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
5863 5802 | }
|
5864 - | crate::protocol_serde::shape_json_maps::de_json_maps_http_request(request)
|
5865 - | .await
|
5866 - | .map_err(Into::into)
|
5803 + | crate::protocol_serde::shape_json_maps::de_json_maps_http_request(request).await
|
5867 5804 | };
|
5868 5805 | use ::futures_util::future::TryFutureExt;
|
5869 5806 | let fut = fut.map_err(
|
5870 5807 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
5871 5808 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
5872 5809 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
5873 5810 | e,
|
5874 5811 | )
|
5875 5812 | },
|
5876 5813 | );
|
5877 5814 | JsonMapsInputFuture {
|
5878 5815 | inner: Box::pin(fut),
|
5879 5816 | }
|
5880 5817 | }
|
5881 5818 | }
|
5882 5819 | impl
|
5883 5820 | ::aws_smithy_http_server::response::IntoResponse<
|
5884 5821 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5885 5822 | > for crate::output::JsonMapsOutput
|
5886 5823 | {
|
5887 5824 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
5888 5825 | match crate::protocol_serde::shape_json_maps::ser_json_maps_http_response(self) {
|
5889 5826 | Ok(response) => response,
|
5890 5827 | Err(e) => {
|
5891 5828 | ::tracing::error!(error = %e, "failed to serialize response");
|
5892 5829 | ::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))
|
5893 5830 | }
|
5894 5831 | }
|
5895 5832 | }
|
5896 5833 | }
|
@@ -5940,5877 +6000,5936 @@
5940 5877 | }
|
5941 5878 |
|
5942 5879 | impl<B>
|
5943 5880 | ::aws_smithy_http_server::request::FromRequest<
|
5944 5881 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5945 5882 | B,
|
5946 5883 | > for crate::input::SparseJsonListsInput
|
5947 5884 | where
|
5948 5885 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
5949 5886 | B: 'static,
|
5950 5887 |
|
5951 5888 | B::Data: Send,
|
5952 5889 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
5953 5890 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
5954 5891 | {
|
5955 5892 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
5956 5893 | type Future = SparseJsonListsInputFuture;
|
5957 5894 |
|
5958 5895 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
5959 5896 | let fut = async move {
|
5960 5897 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
5961 5898 | request.headers(),
|
5962 5899 | &CONTENT_TYPE_SPARSEJSONLISTS,
|
5963 5900 | ) {
|
5964 5901 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
5965 5902 | }
|
5966 5903 | crate::protocol_serde::shape_sparse_json_lists::de_sparse_json_lists_http_request(
|
5967 5904 | request,
|
5968 5905 | )
|
5969 5906 | .await
|
5970 - | .map_err(Into::into)
|
5971 5907 | };
|
5972 5908 | use ::futures_util::future::TryFutureExt;
|
5973 5909 | let fut = fut.map_err(
|
5974 5910 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
5975 5911 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
5976 5912 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
5977 5913 | e,
|
5978 5914 | )
|
5979 5915 | },
|
5980 5916 | );
|
5981 5917 | SparseJsonListsInputFuture {
|
5982 5918 | inner: Box::pin(fut),
|
5983 5919 | }
|
5984 5920 | }
|
5985 5921 | }
|
5986 5922 | impl
|
5987 5923 | ::aws_smithy_http_server::response::IntoResponse<
|
5988 5924 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
5989 5925 | > for crate::output::SparseJsonListsOutput
|
5990 5926 | {
|
5991 5927 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
5992 5928 | match crate::protocol_serde::shape_sparse_json_lists::ser_sparse_json_lists_http_response(
|
5993 5929 | self,
|
5994 5930 | ) {
|
5995 5931 | Ok(response) => response,
|
5996 5932 | Err(e) => {
|
5997 5933 | ::tracing::error!(error = %e, "failed to serialize response");
|
5998 5934 | ::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))
|
5999 5935 | }
|
6000 5936 | }
|
@@ -6044,5980 +6106,6040 @@
6044 5980 | ) -> std::task::Poll<Self::Output> {
|
6045 5981 | let this = self.project();
|
6046 5982 | this.inner.as_mut().poll(cx)
|
6047 5983 | }
|
6048 5984 | }
|
6049 5985 |
|
6050 5986 | impl<B>
|
6051 5987 | ::aws_smithy_http_server::request::FromRequest<
|
6052 5988 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6053 5989 | B,
|
6054 5990 | > for crate::input::JsonListsInput
|
6055 5991 | where
|
6056 5992 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
6057 5993 | B: 'static,
|
6058 5994 |
|
6059 5995 | B::Data: Send,
|
6060 5996 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
6061 5997 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
6062 5998 | {
|
6063 5999 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
6064 6000 | type Future = JsonListsInputFuture;
|
6065 6001 |
|
6066 6002 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
6067 6003 | let fut = async move {
|
6068 6004 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
6069 6005 | request.headers(),
|
6070 6006 | &CONTENT_TYPE_JSONLISTS,
|
6071 6007 | ) {
|
6072 6008 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
6073 6009 | }
|
6074 - | crate::protocol_serde::shape_json_lists::de_json_lists_http_request(request)
|
6075 - | .await
|
6076 - | .map_err(Into::into)
|
6010 + | crate::protocol_serde::shape_json_lists::de_json_lists_http_request(request).await
|
6077 6011 | };
|
6078 6012 | use ::futures_util::future::TryFutureExt;
|
6079 6013 | let fut = fut.map_err(
|
6080 6014 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
6081 6015 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
6082 6016 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
6083 6017 | e,
|
6084 6018 | )
|
6085 6019 | },
|
6086 6020 | );
|
6087 6021 | JsonListsInputFuture {
|
6088 6022 | inner: Box::pin(fut),
|
6089 6023 | }
|
6090 6024 | }
|
6091 6025 | }
|
6092 6026 | impl
|
6093 6027 | ::aws_smithy_http_server::response::IntoResponse<
|
6094 6028 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6095 6029 | > for crate::output::JsonListsOutput
|
6096 6030 | {
|
6097 6031 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
6098 6032 | match crate::protocol_serde::shape_json_lists::ser_json_lists_http_response(self) {
|
6099 6033 | Ok(response) => response,
|
6100 6034 | Err(e) => {
|
6101 6035 | ::tracing::error!(error = %e, "failed to serialize response");
|
6102 6036 | ::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))
|
6103 6037 | }
|
6104 6038 | }
|
6105 6039 | }
|
6106 6040 | }
|
@@ -6148,6082 +6208,6141 @@
6148 6082 | this.inner.as_mut().poll(cx)
|
6149 6083 | }
|
6150 6084 | }
|
6151 6085 |
|
6152 6086 | impl<B>
|
6153 6087 | ::aws_smithy_http_server::request::FromRequest<
|
6154 6088 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6155 6089 | B,
|
6156 6090 | > for crate::input::RecursiveShapesInput
|
6157 6091 | where
|
6158 6092 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
6159 6093 | B: 'static,
|
6160 6094 |
|
6161 6095 | B::Data: Send,
|
6162 6096 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
6163 6097 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
6164 6098 | {
|
6165 6099 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
6166 6100 | type Future = RecursiveShapesInputFuture;
|
6167 6101 |
|
6168 6102 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
6169 6103 | let fut = async move {
|
6170 6104 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
6171 6105 | request.headers(),
|
6172 6106 | &CONTENT_TYPE_RECURSIVESHAPES,
|
6173 6107 | ) {
|
6174 6108 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
6175 6109 | }
|
6176 6110 | crate::protocol_serde::shape_recursive_shapes::de_recursive_shapes_http_request(request)
|
6177 6111 | .await
|
6178 - | .map_err(Into::into)
|
6179 6112 | };
|
6180 6113 | use ::futures_util::future::TryFutureExt;
|
6181 6114 | let fut = fut.map_err(
|
6182 6115 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
6183 6116 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
6184 6117 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
6185 6118 | e,
|
6186 6119 | )
|
6187 6120 | },
|
6188 6121 | );
|
6189 6122 | RecursiveShapesInputFuture {
|
6190 6123 | inner: Box::pin(fut),
|
6191 6124 | }
|
6192 6125 | }
|
6193 6126 | }
|
6194 6127 | impl
|
6195 6128 | ::aws_smithy_http_server::response::IntoResponse<
|
6196 6129 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6197 6130 | > for crate::output::RecursiveShapesOutput
|
6198 6131 | {
|
6199 6132 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
6200 6133 | match crate::protocol_serde::shape_recursive_shapes::ser_recursive_shapes_http_response(
|
6201 6134 | self,
|
6202 6135 | ) {
|
6203 6136 | Ok(response) => response,
|
6204 6137 | Err(e) => {
|
6205 6138 | ::tracing::error!(error = %e, "failed to serialize response");
|
6206 6139 | ::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))
|
6207 6140 | }
|
6208 6141 | }
|
@@ -6253,6186 +6313,6245 @@
6253 6186 | this.inner.as_mut().poll(cx)
|
6254 6187 | }
|
6255 6188 | }
|
6256 6189 |
|
6257 6190 | impl<B>
|
6258 6191 | ::aws_smithy_http_server::request::FromRequest<
|
6259 6192 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6260 6193 | B,
|
6261 6194 | > for crate::input::JsonIntEnumsInput
|
6262 6195 | where
|
6263 6196 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
6264 6197 | B: 'static,
|
6265 6198 |
|
6266 6199 | B::Data: Send,
|
6267 6200 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
6268 6201 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
6269 6202 | {
|
6270 6203 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
6271 6204 | type Future = JsonIntEnumsInputFuture;
|
6272 6205 |
|
6273 6206 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
6274 6207 | let fut = async move {
|
6275 6208 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
6276 6209 | request.headers(),
|
6277 6210 | &CONTENT_TYPE_JSONINTENUMS,
|
6278 6211 | ) {
|
6279 6212 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
6280 6213 | }
|
6281 6214 | crate::protocol_serde::shape_json_int_enums::de_json_int_enums_http_request(request)
|
6282 6215 | .await
|
6283 - | .map_err(Into::into)
|
6284 6216 | };
|
6285 6217 | use ::futures_util::future::TryFutureExt;
|
6286 6218 | let fut = fut.map_err(
|
6287 6219 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
6288 6220 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
6289 6221 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
6290 6222 | e,
|
6291 6223 | )
|
6292 6224 | },
|
6293 6225 | );
|
6294 6226 | JsonIntEnumsInputFuture {
|
6295 6227 | inner: Box::pin(fut),
|
6296 6228 | }
|
6297 6229 | }
|
6298 6230 | }
|
6299 6231 | impl
|
6300 6232 | ::aws_smithy_http_server::response::IntoResponse<
|
6301 6233 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6302 6234 | > for crate::output::JsonIntEnumsOutput
|
6303 6235 | {
|
6304 6236 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
6305 6237 | match crate::protocol_serde::shape_json_int_enums::ser_json_int_enums_http_response(self) {
|
6306 6238 | Ok(response) => response,
|
6307 6239 | Err(e) => {
|
6308 6240 | ::tracing::error!(error = %e, "failed to serialize response");
|
6309 6241 | ::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))
|
6310 6242 | }
|
6311 6243 | }
|
6312 6244 | }
|
6313 6245 | }
|
@@ -6353,6285 +6415,6345 @@
6353 6285 | ) -> std::task::Poll<Self::Output> {
|
6354 6286 | let this = self.project();
|
6355 6287 | this.inner.as_mut().poll(cx)
|
6356 6288 | }
|
6357 6289 | }
|
6358 6290 |
|
6359 6291 | impl<B>
|
6360 6292 | ::aws_smithy_http_server::request::FromRequest<
|
6361 6293 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6362 6294 | B,
|
6363 6295 | > for crate::input::JsonEnumsInput
|
6364 6296 | where
|
6365 6297 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
6366 6298 | B: 'static,
|
6367 6299 |
|
6368 6300 | B::Data: Send,
|
6369 6301 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
6370 6302 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
6371 6303 | {
|
6372 6304 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
6373 6305 | type Future = JsonEnumsInputFuture;
|
6374 6306 |
|
6375 6307 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
6376 6308 | let fut = async move {
|
6377 6309 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
6378 6310 | request.headers(),
|
6379 6311 | &CONTENT_TYPE_JSONENUMS,
|
6380 6312 | ) {
|
6381 6313 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
6382 6314 | }
|
6383 - | crate::protocol_serde::shape_json_enums::de_json_enums_http_request(request)
|
6384 - | .await
|
6385 - | .map_err(Into::into)
|
6315 + | crate::protocol_serde::shape_json_enums::de_json_enums_http_request(request).await
|
6386 6316 | };
|
6387 6317 | use ::futures_util::future::TryFutureExt;
|
6388 6318 | let fut = fut.map_err(
|
6389 6319 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
6390 6320 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
6391 6321 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
6392 6322 | e,
|
6393 6323 | )
|
6394 6324 | },
|
6395 6325 | );
|
6396 6326 | JsonEnumsInputFuture {
|
6397 6327 | inner: Box::pin(fut),
|
6398 6328 | }
|
6399 6329 | }
|
6400 6330 | }
|
6401 6331 | impl
|
6402 6332 | ::aws_smithy_http_server::response::IntoResponse<
|
6403 6333 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6404 6334 | > for crate::output::JsonEnumsOutput
|
6405 6335 | {
|
6406 6336 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
6407 6337 | match crate::protocol_serde::shape_json_enums::ser_json_enums_http_response(self) {
|
6408 6338 | Ok(response) => response,
|
6409 6339 | Err(e) => {
|
6410 6340 | ::tracing::error!(error = %e, "failed to serialize response");
|
6411 6341 | ::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))
|
6412 6342 | }
|
6413 6343 | }
|
6414 6344 | }
|
6415 6345 | }
|
@@ -6457,6387 +6517,6446 @@
6457 6387 | this.inner.as_mut().poll(cx)
|
6458 6388 | }
|
6459 6389 | }
|
6460 6390 |
|
6461 6391 | impl<B>
|
6462 6392 | ::aws_smithy_http_server::request::FromRequest<
|
6463 6393 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6464 6394 | B,
|
6465 6395 | > for crate::input::JsonTimestampsInput
|
6466 6396 | where
|
6467 6397 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
6468 6398 | B: 'static,
|
6469 6399 |
|
6470 6400 | B::Data: Send,
|
6471 6401 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
6472 6402 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
6473 6403 | {
|
6474 6404 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
6475 6405 | type Future = JsonTimestampsInputFuture;
|
6476 6406 |
|
6477 6407 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
6478 6408 | let fut = async move {
|
6479 6409 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
6480 6410 | request.headers(),
|
6481 6411 | &CONTENT_TYPE_JSONTIMESTAMPS,
|
6482 6412 | ) {
|
6483 6413 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
6484 6414 | }
|
6485 6415 | crate::protocol_serde::shape_json_timestamps::de_json_timestamps_http_request(request)
|
6486 6416 | .await
|
6487 - | .map_err(Into::into)
|
6488 6417 | };
|
6489 6418 | use ::futures_util::future::TryFutureExt;
|
6490 6419 | let fut = fut.map_err(
|
6491 6420 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
6492 6421 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
6493 6422 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
6494 6423 | e,
|
6495 6424 | )
|
6496 6425 | },
|
6497 6426 | );
|
6498 6427 | JsonTimestampsInputFuture {
|
6499 6428 | inner: Box::pin(fut),
|
6500 6429 | }
|
6501 6430 | }
|
6502 6431 | }
|
6503 6432 | impl
|
6504 6433 | ::aws_smithy_http_server::response::IntoResponse<
|
6505 6434 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6506 6435 | > for crate::output::JsonTimestampsOutput
|
6507 6436 | {
|
6508 6437 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
6509 6438 | match crate::protocol_serde::shape_json_timestamps::ser_json_timestamps_http_response(self)
|
6510 6439 | {
|
6511 6440 | Ok(response) => response,
|
6512 6441 | Err(e) => {
|
6513 6442 | ::tracing::error!(error = %e, "failed to serialize response");
|
6514 6443 | ::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))
|
6515 6444 | }
|
6516 6445 | }
|
6517 6446 | }
|
@@ -6560,6489 +6620,6548 @@
6560 6489 | this.inner.as_mut().poll(cx)
|
6561 6490 | }
|
6562 6491 | }
|
6563 6492 |
|
6564 6493 | impl<B>
|
6565 6494 | ::aws_smithy_http_server::request::FromRequest<
|
6566 6495 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6567 6496 | B,
|
6568 6497 | > for crate::input::SimpleScalarPropertiesInput
|
6569 6498 | where
|
6570 6499 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
6571 6500 | B: 'static,
|
6572 6501 |
|
6573 6502 | B::Data: Send,
|
6574 6503 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
6575 6504 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
6576 6505 | {
|
6577 6506 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
6578 6507 | type Future = SimpleScalarPropertiesInputFuture;
|
6579 6508 |
|
6580 6509 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
6581 6510 | let fut = async move {
|
6582 6511 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
6583 6512 | request.headers(),
|
6584 6513 | &CONTENT_TYPE_SIMPLESCALARPROPERTIES,
|
6585 6514 | ) {
|
6586 6515 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
6587 6516 | }
|
6588 6517 | crate::protocol_serde::shape_simple_scalar_properties::de_simple_scalar_properties_http_request(request)
|
6589 6518 | .await
|
6590 - | .map_err(Into::into)
|
6591 6519 | };
|
6592 6520 | use ::futures_util::future::TryFutureExt;
|
6593 6521 | let fut = fut.map_err(
|
6594 6522 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
6595 6523 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
6596 6524 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
6597 6525 | e,
|
6598 6526 | )
|
6599 6527 | },
|
6600 6528 | );
|
6601 6529 | SimpleScalarPropertiesInputFuture {
|
6602 6530 | inner: Box::pin(fut),
|
6603 6531 | }
|
6604 6532 | }
|
6605 6533 | }
|
6606 6534 | impl
|
6607 6535 | ::aws_smithy_http_server::response::IntoResponse<
|
6608 6536 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6609 6537 | > for crate::output::SimpleScalarPropertiesOutput
|
6610 6538 | {
|
6611 6539 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
6612 6540 | match crate::protocol_serde::shape_simple_scalar_properties::ser_simple_scalar_properties_http_response(self) {
|
6613 6541 | Ok(response) => response,
|
6614 6542 | Err(e) => {
|
6615 6543 | ::tracing::error!(error = %e, "failed to serialize response");
|
6616 6544 | ::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))
|
6617 6545 | }
|
6618 6546 | }
|
6619 6547 | }
|
6620 6548 | }
|
@@ -6662,6590 +6722,6649 @@
6662 6590 | }
|
6663 6591 |
|
6664 6592 | impl<B>
|
6665 6593 | ::aws_smithy_http_server::request::FromRequest<
|
6666 6594 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6667 6595 | B,
|
6668 6596 | > for crate::input::GreetingWithErrorsInput
|
6669 6597 | where
|
6670 6598 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
6671 6599 | B: 'static,
|
6672 6600 |
|
6673 6601 | B::Data: Send,
|
6674 6602 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
6675 6603 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
6676 6604 | {
|
6677 6605 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
6678 6606 | type Future = GreetingWithErrorsInputFuture;
|
6679 6607 |
|
6680 6608 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
6681 6609 | let fut = async move {
|
6682 6610 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
6683 6611 | request.headers(),
|
6684 6612 | &CONTENT_TYPE_GREETINGWITHERRORS,
|
6685 6613 | ) {
|
6686 6614 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
6687 6615 | }
|
6688 6616 | crate::protocol_serde::shape_greeting_with_errors::de_greeting_with_errors_http_request(
|
6689 6617 | request,
|
6690 6618 | )
|
6691 6619 | .await
|
6692 - | .map_err(Into::into)
|
6693 6620 | };
|
6694 6621 | use ::futures_util::future::TryFutureExt;
|
6695 6622 | let fut = fut.map_err(
|
6696 6623 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
6697 6624 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
6698 6625 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
6699 6626 | e,
|
6700 6627 | )
|
6701 6628 | },
|
6702 6629 | );
|
6703 6630 | GreetingWithErrorsInputFuture {
|
6704 6631 | inner: Box::pin(fut),
|
6705 6632 | }
|
6706 6633 | }
|
6707 6634 | }
|
6708 6635 | impl
|
6709 6636 | ::aws_smithy_http_server::response::IntoResponse<
|
6710 6637 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6711 6638 | > for crate::output::GreetingWithErrorsOutput
|
6712 6639 | {
|
6713 6640 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
6714 6641 | match crate::protocol_serde::shape_greeting_with_errors::ser_greeting_with_errors_http_response(self) {
|
6715 6642 | Ok(response) => response,
|
6716 6643 | Err(e) => {
|
6717 6644 | ::tracing::error!(error = %e, "failed to serialize response");
|
6718 6645 | ::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))
|
6719 6646 | }
|
6720 6647 | }
|
6721 6648 | }
|
6722 6649 | }
|
@@ -6772,6699 +6832,6758 @@
6772 6699 | }
|
6773 6700 | }
|
6774 6701 |
|
6775 6702 | impl<B>
|
6776 6703 | ::aws_smithy_http_server::request::FromRequest<
|
6777 6704 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6778 6705 | B,
|
6779 6706 | > for crate::input::StreamingTraitsWithMediaTypeInput
|
6780 6707 | where
|
6781 6708 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
6782 6709 | B: 'static,
|
6783 6710 |
|
6784 6711 | B: Into<::aws_smithy_types::byte_stream::ByteStream>,
|
6785 6712 | B::Data: Send,
|
6786 6713 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
6787 6714 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
6788 6715 | {
|
6789 6716 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
6790 6717 | type Future = StreamingTraitsWithMediaTypeInputFuture;
|
6791 6718 |
|
6792 6719 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
6793 6720 | let fut = async move {
|
6794 6721 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
6795 6722 | request.headers(),
|
6796 6723 | &CONTENT_TYPE_STREAMINGTRAITSWITHMEDIATYPE,
|
6797 6724 | ) {
|
6798 6725 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
6799 6726 | }
|
6800 6727 | crate::protocol_serde::shape_streaming_traits_with_media_type::de_streaming_traits_with_media_type_http_request(request)
|
6801 6728 | .await
|
6802 - | .map_err(Into::into)
|
6803 6729 | };
|
6804 6730 | use ::futures_util::future::TryFutureExt;
|
6805 6731 | let fut = fut.map_err(
|
6806 6732 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
6807 6733 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
6808 6734 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
6809 6735 | e,
|
6810 6736 | )
|
6811 6737 | },
|
6812 6738 | );
|
6813 6739 | StreamingTraitsWithMediaTypeInputFuture {
|
6814 6740 | inner: Box::pin(fut),
|
6815 6741 | }
|
6816 6742 | }
|
6817 6743 | }
|
6818 6744 | impl
|
6819 6745 | ::aws_smithy_http_server::response::IntoResponse<
|
6820 6746 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6821 6747 | > for crate::output::StreamingTraitsWithMediaTypeOutput
|
6822 6748 | {
|
6823 6749 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
6824 6750 | match crate::protocol_serde::shape_streaming_traits_with_media_type::ser_streaming_traits_with_media_type_http_response(self) {
|
6825 6751 | Ok(response) => response,
|
6826 6752 | Err(e) => {
|
6827 6753 | ::tracing::error!(error = %e, "failed to serialize response");
|
6828 6754 | ::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))
|
6829 6755 | }
|
6830 6756 | }
|
6831 6757 | }
|
6832 6758 | }
|
@@ -6873,6799 +6933,6858 @@
6873 6799 | }
|
6874 6800 | }
|
6875 6801 |
|
6876 6802 | impl<B>
|
6877 6803 | ::aws_smithy_http_server::request::FromRequest<
|
6878 6804 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6879 6805 | B,
|
6880 6806 | > for crate::input::StreamingTraitsRequireLengthInput
|
6881 6807 | where
|
6882 6808 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
6883 6809 | B: 'static,
|
6884 6810 |
|
6885 6811 | B: Into<::aws_smithy_types::byte_stream::ByteStream>,
|
6886 6812 | B::Data: Send,
|
6887 6813 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
6888 6814 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
6889 6815 | {
|
6890 6816 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
6891 6817 | type Future = StreamingTraitsRequireLengthInputFuture;
|
6892 6818 |
|
6893 6819 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
6894 6820 | let fut = async move {
|
6895 6821 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
6896 6822 | request.headers(),
|
6897 6823 | &CONTENT_TYPE_STREAMINGTRAITSREQUIRELENGTH,
|
6898 6824 | ) {
|
6899 6825 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
6900 6826 | }
|
6901 6827 | crate::protocol_serde::shape_streaming_traits_require_length::de_streaming_traits_require_length_http_request(request)
|
6902 6828 | .await
|
6903 - | .map_err(Into::into)
|
6904 6829 | };
|
6905 6830 | use ::futures_util::future::TryFutureExt;
|
6906 6831 | let fut = fut.map_err(
|
6907 6832 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
6908 6833 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
6909 6834 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
6910 6835 | e,
|
6911 6836 | )
|
6912 6837 | },
|
6913 6838 | );
|
6914 6839 | StreamingTraitsRequireLengthInputFuture {
|
6915 6840 | inner: Box::pin(fut),
|
6916 6841 | }
|
6917 6842 | }
|
6918 6843 | }
|
6919 6844 | impl
|
6920 6845 | ::aws_smithy_http_server::response::IntoResponse<
|
6921 6846 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6922 6847 | > for crate::output::StreamingTraitsRequireLengthOutput
|
6923 6848 | {
|
6924 6849 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
6925 6850 | match crate::protocol_serde::shape_streaming_traits_require_length::ser_streaming_traits_require_length_http_response(self) {
|
6926 6851 | Ok(response) => response,
|
6927 6852 | Err(e) => {
|
6928 6853 | ::tracing::error!(error = %e, "failed to serialize response");
|
6929 6854 | ::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))
|
6930 6855 | }
|
6931 6856 | }
|
6932 6857 | }
|
6933 6858 | }
|
@@ -6974,6899 +7034,6958 @@
6974 6899 | }
|
6975 6900 | }
|
6976 6901 |
|
6977 6902 | impl<B>
|
6978 6903 | ::aws_smithy_http_server::request::FromRequest<
|
6979 6904 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
6980 6905 | B,
|
6981 6906 | > for crate::input::StreamingTraitsInput
|
6982 6907 | where
|
6983 6908 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
6984 6909 | B: 'static,
|
6985 6910 |
|
6986 6911 | B: Into<::aws_smithy_types::byte_stream::ByteStream>,
|
6987 6912 | B::Data: Send,
|
6988 6913 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
6989 6914 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
6990 6915 | {
|
6991 6916 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
6992 6917 | type Future = StreamingTraitsInputFuture;
|
6993 6918 |
|
6994 6919 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
6995 6920 | let fut = async move {
|
6996 6921 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
6997 6922 | request.headers(),
|
6998 6923 | &CONTENT_TYPE_STREAMINGTRAITS,
|
6999 6924 | ) {
|
7000 6925 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
7001 6926 | }
|
7002 6927 | crate::protocol_serde::shape_streaming_traits::de_streaming_traits_http_request(request)
|
7003 6928 | .await
|
7004 - | .map_err(Into::into)
|
7005 6929 | };
|
7006 6930 | use ::futures_util::future::TryFutureExt;
|
7007 6931 | let fut = fut.map_err(
|
7008 6932 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
7009 6933 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
7010 6934 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
7011 6935 | e,
|
7012 6936 | )
|
7013 6937 | },
|
7014 6938 | );
|
7015 6939 | StreamingTraitsInputFuture {
|
7016 6940 | inner: Box::pin(fut),
|
7017 6941 | }
|
7018 6942 | }
|
7019 6943 | }
|
7020 6944 | impl
|
7021 6945 | ::aws_smithy_http_server::response::IntoResponse<
|
7022 6946 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7023 6947 | > for crate::output::StreamingTraitsOutput
|
7024 6948 | {
|
7025 6949 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
7026 6950 | match crate::protocol_serde::shape_streaming_traits::ser_streaming_traits_http_response(
|
7027 6951 | self,
|
7028 6952 | ) {
|
7029 6953 | Ok(response) => response,
|
7030 6954 | Err(e) => {
|
7031 6955 | ::tracing::error!(error = %e, "failed to serialize response");
|
7032 6956 | ::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))
|
7033 6957 | }
|
7034 6958 | }
|
@@ -7081,7005 +7141,7064 @@
7081 7005 | }
|
7082 7006 |
|
7083 7007 | impl<B>
|
7084 7008 | ::aws_smithy_http_server::request::FromRequest<
|
7085 7009 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7086 7010 | B,
|
7087 7011 | > for crate::input::HttpResponseCodeInput
|
7088 7012 | where
|
7089 7013 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
7090 7014 | B: 'static,
|
7091 7015 |
|
7092 7016 | B::Data: Send,
|
7093 7017 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
7094 7018 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
7095 7019 | {
|
7096 7020 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
7097 7021 | type Future = HttpResponseCodeInputFuture;
|
7098 7022 |
|
7099 7023 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
7100 7024 | let fut = async move {
|
7101 7025 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
7102 7026 | request.headers(),
|
7103 7027 | &CONTENT_TYPE_HTTPRESPONSECODE,
|
7104 7028 | ) {
|
7105 7029 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
7106 7030 | }
|
7107 7031 | crate::protocol_serde::shape_http_response_code::de_http_response_code_http_request(
|
7108 7032 | request,
|
7109 7033 | )
|
7110 7034 | .await
|
7111 - | .map_err(Into::into)
|
7112 7035 | };
|
7113 7036 | use ::futures_util::future::TryFutureExt;
|
7114 7037 | let fut = fut.map_err(
|
7115 7038 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
7116 7039 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
7117 7040 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
7118 7041 | e,
|
7119 7042 | )
|
7120 7043 | },
|
7121 7044 | );
|
7122 7045 | HttpResponseCodeInputFuture {
|
7123 7046 | inner: Box::pin(fut),
|
7124 7047 | }
|
7125 7048 | }
|
7126 7049 | }
|
7127 7050 | impl
|
7128 7051 | ::aws_smithy_http_server::response::IntoResponse<
|
7129 7052 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7130 7053 | > for crate::output::HttpResponseCodeOutput
|
7131 7054 | {
|
7132 7055 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
7133 7056 | match crate::protocol_serde::shape_http_response_code::ser_http_response_code_http_response(
|
7134 7057 | self,
|
7135 7058 | ) {
|
7136 7059 | Ok(response) => response,
|
7137 7060 | Err(e) => {
|
7138 7061 | ::tracing::error!(error = %e, "failed to serialize response");
|
7139 7062 | ::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))
|
7140 7063 | }
|
7141 7064 | }
|
@@ -7187,7110 +7247,7169 @@
7187 7110 | this.inner.as_mut().poll(cx)
|
7188 7111 | }
|
7189 7112 | }
|
7190 7113 |
|
7191 7114 | impl<B>
|
7192 7115 | ::aws_smithy_http_server::request::FromRequest<
|
7193 7116 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7194 7117 | B,
|
7195 7118 | > for crate::input::HttpPayloadWithUnionInput
|
7196 7119 | where
|
7197 7120 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
7198 7121 | B: 'static,
|
7199 7122 |
|
7200 7123 | B::Data: Send,
|
7201 7124 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
7202 7125 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
7203 7126 | {
|
7204 7127 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
7205 7128 | type Future = HttpPayloadWithUnionInputFuture;
|
7206 7129 |
|
7207 7130 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
7208 7131 | let fut = async move {
|
7209 7132 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
7210 7133 | request.headers(),
|
7211 7134 | &CONTENT_TYPE_HTTPPAYLOADWITHUNION,
|
7212 7135 | ) {
|
7213 7136 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
7214 7137 | }
|
7215 7138 | crate::protocol_serde::shape_http_payload_with_union::de_http_payload_with_union_http_request(request)
|
7216 7139 | .await
|
7217 - | .map_err(Into::into)
|
7218 7140 | };
|
7219 7141 | use ::futures_util::future::TryFutureExt;
|
7220 7142 | let fut = fut.map_err(
|
7221 7143 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
7222 7144 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
7223 7145 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
7224 7146 | e,
|
7225 7147 | )
|
7226 7148 | },
|
7227 7149 | );
|
7228 7150 | HttpPayloadWithUnionInputFuture {
|
7229 7151 | inner: Box::pin(fut),
|
7230 7152 | }
|
7231 7153 | }
|
7232 7154 | }
|
7233 7155 | impl
|
7234 7156 | ::aws_smithy_http_server::response::IntoResponse<
|
7235 7157 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7236 7158 | > for crate::output::HttpPayloadWithUnionOutput
|
7237 7159 | {
|
7238 7160 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
7239 7161 | match crate::protocol_serde::shape_http_payload_with_union::ser_http_payload_with_union_http_response(self) {
|
7240 7162 | Ok(response) => response,
|
7241 7163 | Err(e) => {
|
7242 7164 | ::tracing::error!(error = %e, "failed to serialize response");
|
7243 7165 | ::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))
|
7244 7166 | }
|
7245 7167 | }
|
7246 7168 | }
|
7247 7169 | }
|
@@ -7294,7216 +7354,7275 @@
7294 7216 | }
|
7295 7217 |
|
7296 7218 | impl<B>
|
7297 7219 | ::aws_smithy_http_server::request::FromRequest<
|
7298 7220 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7299 7221 | B,
|
7300 7222 | > for crate::input::HttpStringPayloadInput
|
7301 7223 | where
|
7302 7224 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
7303 7225 | B: 'static,
|
7304 7226 |
|
7305 7227 | B::Data: Send,
|
7306 7228 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
7307 7229 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
7308 7230 | {
|
7309 7231 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
7310 7232 | type Future = HttpStringPayloadInputFuture;
|
7311 7233 |
|
7312 7234 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
7313 7235 | let fut = async move {
|
7314 7236 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
7315 7237 | request.headers(),
|
7316 7238 | &CONTENT_TYPE_HTTPSTRINGPAYLOAD,
|
7317 7239 | ) {
|
7318 7240 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
7319 7241 | }
|
7320 7242 | crate::protocol_serde::shape_http_string_payload::de_http_string_payload_http_request(
|
7321 7243 | request,
|
7322 7244 | )
|
7323 7245 | .await
|
7324 - | .map_err(Into::into)
|
7325 7246 | };
|
7326 7247 | use ::futures_util::future::TryFutureExt;
|
7327 7248 | let fut = fut.map_err(
|
7328 7249 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
7329 7250 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
7330 7251 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
7331 7252 | e,
|
7332 7253 | )
|
7333 7254 | },
|
7334 7255 | );
|
7335 7256 | HttpStringPayloadInputFuture {
|
7336 7257 | inner: Box::pin(fut),
|
7337 7258 | }
|
7338 7259 | }
|
7339 7260 | }
|
7340 7261 | impl
|
7341 7262 | ::aws_smithy_http_server::response::IntoResponse<
|
7342 7263 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7343 7264 | > for crate::output::HttpStringPayloadOutput
|
7344 7265 | {
|
7345 7266 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
7346 7267 | match crate::protocol_serde::shape_http_string_payload::ser_http_string_payload_http_response(self) {
|
7347 7268 | Ok(response) => response,
|
7348 7269 | Err(e) => {
|
7349 7270 | ::tracing::error!(error = %e, "failed to serialize response");
|
7350 7271 | ::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))
|
7351 7272 | }
|
7352 7273 | }
|
7353 7274 | }
|
7354 7275 | }
|
@@ -7405,7326 +7465,7385 @@
7405 7326 | }
|
7406 7327 |
|
7407 7328 | impl<B>
|
7408 7329 | ::aws_smithy_http_server::request::FromRequest<
|
7409 7330 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7410 7331 | B,
|
7411 7332 | > for crate::input::HttpEnumPayloadInput
|
7412 7333 | where
|
7413 7334 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
7414 7335 | B: 'static,
|
7415 7336 |
|
7416 7337 | B::Data: Send,
|
7417 7338 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
7418 7339 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
7419 7340 | {
|
7420 7341 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
7421 7342 | type Future = HttpEnumPayloadInputFuture;
|
7422 7343 |
|
7423 7344 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
7424 7345 | let fut = async move {
|
7425 7346 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
7426 7347 | request.headers(),
|
7427 7348 | &CONTENT_TYPE_HTTPENUMPAYLOAD,
|
7428 7349 | ) {
|
7429 7350 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
7430 7351 | }
|
7431 7352 | crate::protocol_serde::shape_http_enum_payload::de_http_enum_payload_http_request(
|
7432 7353 | request,
|
7433 7354 | )
|
7434 7355 | .await
|
7435 - | .map_err(Into::into)
|
7436 7356 | };
|
7437 7357 | use ::futures_util::future::TryFutureExt;
|
7438 7358 | let fut = fut.map_err(
|
7439 7359 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
7440 7360 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
7441 7361 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
7442 7362 | e,
|
7443 7363 | )
|
7444 7364 | },
|
7445 7365 | );
|
7446 7366 | HttpEnumPayloadInputFuture {
|
7447 7367 | inner: Box::pin(fut),
|
7448 7368 | }
|
7449 7369 | }
|
7450 7370 | }
|
7451 7371 | impl
|
7452 7372 | ::aws_smithy_http_server::response::IntoResponse<
|
7453 7373 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7454 7374 | > for crate::output::HttpEnumPayloadOutput
|
7455 7375 | {
|
7456 7376 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
7457 7377 | match crate::protocol_serde::shape_http_enum_payload::ser_http_enum_payload_http_response(
|
7458 7378 | self,
|
7459 7379 | ) {
|
7460 7380 | Ok(response) => response,
|
7461 7381 | Err(e) => {
|
7462 7382 | ::tracing::error!(error = %e, "failed to serialize response");
|
7463 7383 | ::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))
|
7464 7384 | }
|
7465 7385 | }
|
@@ -7511,7431 +7571,7490 @@
7511 7431 | this.inner.as_mut().poll(cx)
|
7512 7432 | }
|
7513 7433 | }
|
7514 7434 |
|
7515 7435 | impl<B>
|
7516 7436 | ::aws_smithy_http_server::request::FromRequest<
|
7517 7437 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7518 7438 | B,
|
7519 7439 | > for crate::input::HttpPayloadWithStructureInput
|
7520 7440 | where
|
7521 7441 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
7522 7442 | B: 'static,
|
7523 7443 |
|
7524 7444 | B::Data: Send,
|
7525 7445 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
7526 7446 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
7527 7447 | {
|
7528 7448 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
7529 7449 | type Future = HttpPayloadWithStructureInputFuture;
|
7530 7450 |
|
7531 7451 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
7532 7452 | let fut = async move {
|
7533 7453 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
7534 7454 | request.headers(),
|
7535 7455 | &CONTENT_TYPE_HTTPPAYLOADWITHSTRUCTURE,
|
7536 7456 | ) {
|
7537 7457 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
7538 7458 | }
|
7539 7459 | crate::protocol_serde::shape_http_payload_with_structure::de_http_payload_with_structure_http_request(request)
|
7540 7460 | .await
|
7541 - | .map_err(Into::into)
|
7542 7461 | };
|
7543 7462 | use ::futures_util::future::TryFutureExt;
|
7544 7463 | let fut = fut.map_err(
|
7545 7464 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
7546 7465 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
7547 7466 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
7548 7467 | e,
|
7549 7468 | )
|
7550 7469 | },
|
7551 7470 | );
|
7552 7471 | HttpPayloadWithStructureInputFuture {
|
7553 7472 | inner: Box::pin(fut),
|
7554 7473 | }
|
7555 7474 | }
|
7556 7475 | }
|
7557 7476 | impl
|
7558 7477 | ::aws_smithy_http_server::response::IntoResponse<
|
7559 7478 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7560 7479 | > for crate::output::HttpPayloadWithStructureOutput
|
7561 7480 | {
|
7562 7481 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
7563 7482 | match crate::protocol_serde::shape_http_payload_with_structure::ser_http_payload_with_structure_http_response(self) {
|
7564 7483 | Ok(response) => response,
|
7565 7484 | Err(e) => {
|
7566 7485 | ::tracing::error!(error = %e, "failed to serialize response");
|
7567 7486 | ::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))
|
7568 7487 | }
|
7569 7488 | }
|
7570 7489 | }
|
7571 7490 | }
|
@@ -7616,7535 +7676,7594 @@
7616 7535 | this.inner.as_mut().poll(cx)
|
7617 7536 | }
|
7618 7537 | }
|
7619 7538 |
|
7620 7539 | impl<B>
|
7621 7540 | ::aws_smithy_http_server::request::FromRequest<
|
7622 7541 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7623 7542 | B,
|
7624 7543 | > for crate::input::HttpPayloadTraitsWithMediaTypeInput
|
7625 7544 | where
|
7626 7545 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
7627 7546 | B: 'static,
|
7628 7547 |
|
7629 7548 | B::Data: Send,
|
7630 7549 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
7631 7550 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
7632 7551 | {
|
7633 7552 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
7634 7553 | type Future = HttpPayloadTraitsWithMediaTypeInputFuture;
|
7635 7554 |
|
7636 7555 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
7637 7556 | let fut = async move {
|
7638 7557 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
7639 7558 | request.headers(),
|
7640 7559 | &CONTENT_TYPE_HTTPPAYLOADTRAITSWITHMEDIATYPE,
|
7641 7560 | ) {
|
7642 7561 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
7643 7562 | }
|
7644 7563 | crate::protocol_serde::shape_http_payload_traits_with_media_type::de_http_payload_traits_with_media_type_http_request(request)
|
7645 7564 | .await
|
7646 - | .map_err(Into::into)
|
7647 7565 | };
|
7648 7566 | use ::futures_util::future::TryFutureExt;
|
7649 7567 | let fut = fut.map_err(
|
7650 7568 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
7651 7569 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
7652 7570 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
7653 7571 | e,
|
7654 7572 | )
|
7655 7573 | },
|
7656 7574 | );
|
7657 7575 | HttpPayloadTraitsWithMediaTypeInputFuture {
|
7658 7576 | inner: Box::pin(fut),
|
7659 7577 | }
|
7660 7578 | }
|
7661 7579 | }
|
7662 7580 | impl
|
7663 7581 | ::aws_smithy_http_server::response::IntoResponse<
|
7664 7582 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7665 7583 | > for crate::output::HttpPayloadTraitsWithMediaTypeOutput
|
7666 7584 | {
|
7667 7585 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
7668 7586 | match crate::protocol_serde::shape_http_payload_traits_with_media_type::ser_http_payload_traits_with_media_type_http_response(self) {
|
7669 7587 | Ok(response) => response,
|
7670 7588 | Err(e) => {
|
7671 7589 | ::tracing::error!(error = %e, "failed to serialize response");
|
7672 7590 | ::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))
|
7673 7591 | }
|
7674 7592 | }
|
7675 7593 | }
|
7676 7594 | }
|
@@ -7711,7629 +7771,7688 @@
7711 7629 | self: std::pin::Pin<&mut Self>,
|
7712 7630 | cx: &mut std::task::Context<'_>,
|
7713 7631 | ) -> std::task::Poll<Self::Output> {
|
7714 7632 | let this = self.project();
|
7715 7633 | this.inner.as_mut().poll(cx)
|
7716 7634 | }
|
7717 7635 | }
|
7718 7636 |
|
7719 7637 | impl<B>
|
7720 7638 | ::aws_smithy_http_server::request::FromRequest<
|
7721 7639 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7722 7640 | B,
|
7723 7641 | > for crate::input::HttpPayloadTraitsInput
|
7724 7642 | where
|
7725 7643 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
7726 7644 | B: 'static,
|
7727 7645 |
|
7728 7646 | B::Data: Send,
|
7729 7647 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
7730 7648 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
7731 7649 | {
|
7732 7650 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
7733 7651 | type Future = HttpPayloadTraitsInputFuture;
|
7734 7652 |
|
7735 7653 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
7736 7654 | let fut = async move {
|
7737 7655 | crate::protocol_serde::shape_http_payload_traits::de_http_payload_traits_http_request(
|
7738 7656 | request,
|
7739 7657 | )
|
7740 7658 | .await
|
7741 - | .map_err(Into::into)
|
7742 7659 | };
|
7743 7660 | use ::futures_util::future::TryFutureExt;
|
7744 7661 | let fut = fut.map_err(
|
7745 7662 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
7746 7663 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
7747 7664 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
7748 7665 | e,
|
7749 7666 | )
|
7750 7667 | },
|
7751 7668 | );
|
7752 7669 | HttpPayloadTraitsInputFuture {
|
7753 7670 | inner: Box::pin(fut),
|
7754 7671 | }
|
7755 7672 | }
|
7756 7673 | }
|
7757 7674 | impl
|
7758 7675 | ::aws_smithy_http_server::response::IntoResponse<
|
7759 7676 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7760 7677 | > for crate::output::HttpPayloadTraitsOutput
|
7761 7678 | {
|
7762 7679 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
7763 7680 | match crate::protocol_serde::shape_http_payload_traits::ser_http_payload_traits_http_response(self) {
|
7764 7681 | Ok(response) => response,
|
7765 7682 | Err(e) => {
|
7766 7683 | ::tracing::error!(error = %e, "failed to serialize response");
|
7767 7684 | ::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))
|
7768 7685 | }
|
7769 7686 | }
|
7770 7687 | }
|
7771 7688 | }
|
@@ -7815,7732 +7875,7791 @@
7815 7732 | this.inner.as_mut().poll(cx)
|
7816 7733 | }
|
7817 7734 | }
|
7818 7735 |
|
7819 7736 | impl<B>
|
7820 7737 | ::aws_smithy_http_server::request::FromRequest<
|
7821 7738 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7822 7739 | B,
|
7823 7740 | > for crate::input::HttpPrefixHeadersInResponseInput
|
7824 7741 | where
|
7825 7742 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
7826 7743 | B: 'static,
|
7827 7744 |
|
7828 7745 | B::Data: Send,
|
7829 7746 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
7830 7747 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
7831 7748 | {
|
7832 7749 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
7833 7750 | type Future = HttpPrefixHeadersInResponseInputFuture;
|
7834 7751 |
|
7835 7752 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
7836 7753 | let fut = async move {
|
7837 7754 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
7838 7755 | request.headers(),
|
7839 7756 | &CONTENT_TYPE_HTTPPREFIXHEADERSINRESPONSE,
|
7840 7757 | ) {
|
7841 7758 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
7842 7759 | }
|
7843 7760 | crate::protocol_serde::shape_http_prefix_headers_in_response::de_http_prefix_headers_in_response_http_request(request)
|
7844 7761 | .await
|
7845 - | .map_err(Into::into)
|
7846 7762 | };
|
7847 7763 | use ::futures_util::future::TryFutureExt;
|
7848 7764 | let fut = fut.map_err(
|
7849 7765 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
7850 7766 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
7851 7767 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
7852 7768 | e,
|
7853 7769 | )
|
7854 7770 | },
|
7855 7771 | );
|
7856 7772 | HttpPrefixHeadersInResponseInputFuture {
|
7857 7773 | inner: Box::pin(fut),
|
7858 7774 | }
|
7859 7775 | }
|
7860 7776 | }
|
7861 7777 | impl
|
7862 7778 | ::aws_smithy_http_server::response::IntoResponse<
|
7863 7779 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7864 7780 | > for crate::output::HttpPrefixHeadersInResponseOutput
|
7865 7781 | {
|
7866 7782 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
7867 7783 | match crate::protocol_serde::shape_http_prefix_headers_in_response::ser_http_prefix_headers_in_response_http_response(self) {
|
7868 7784 | Ok(response) => response,
|
7869 7785 | Err(e) => {
|
7870 7786 | ::tracing::error!(error = %e, "failed to serialize response");
|
7871 7787 | ::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))
|
7872 7788 | }
|
7873 7789 | }
|
7874 7790 | }
|
7875 7791 | }
|
@@ -7917,7833 +7977,7892 @@
7917 7833 | }
|
7918 7834 |
|
7919 7835 | impl<B>
|
7920 7836 | ::aws_smithy_http_server::request::FromRequest<
|
7921 7837 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7922 7838 | B,
|
7923 7839 | > for crate::input::HttpPrefixHeadersInput
|
7924 7840 | where
|
7925 7841 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
7926 7842 | B: 'static,
|
7927 7843 |
|
7928 7844 | B::Data: Send,
|
7929 7845 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
7930 7846 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
7931 7847 | {
|
7932 7848 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
7933 7849 | type Future = HttpPrefixHeadersInputFuture;
|
7934 7850 |
|
7935 7851 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
7936 7852 | let fut = async move {
|
7937 7853 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
7938 7854 | request.headers(),
|
7939 7855 | &CONTENT_TYPE_HTTPPREFIXHEADERS,
|
7940 7856 | ) {
|
7941 7857 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
7942 7858 | }
|
7943 7859 | crate::protocol_serde::shape_http_prefix_headers::de_http_prefix_headers_http_request(
|
7944 7860 | request,
|
7945 7861 | )
|
7946 7862 | .await
|
7947 - | .map_err(Into::into)
|
7948 7863 | };
|
7949 7864 | use ::futures_util::future::TryFutureExt;
|
7950 7865 | let fut = fut.map_err(
|
7951 7866 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
7952 7867 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
7953 7868 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
7954 7869 | e,
|
7955 7870 | )
|
7956 7871 | },
|
7957 7872 | );
|
7958 7873 | HttpPrefixHeadersInputFuture {
|
7959 7874 | inner: Box::pin(fut),
|
7960 7875 | }
|
7961 7876 | }
|
7962 7877 | }
|
7963 7878 | impl
|
7964 7879 | ::aws_smithy_http_server::response::IntoResponse<
|
7965 7880 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
7966 7881 | > for crate::output::HttpPrefixHeadersOutput
|
7967 7882 | {
|
7968 7883 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
7969 7884 | match crate::protocol_serde::shape_http_prefix_headers::ser_http_prefix_headers_http_response(self) {
|
7970 7885 | Ok(response) => response,
|
7971 7886 | Err(e) => {
|
7972 7887 | ::tracing::error!(error = %e, "failed to serialize response");
|
7973 7888 | ::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))
|
7974 7889 | }
|
7975 7890 | }
|
7976 7891 | }
|
7977 7892 | }
|
@@ -8021,7936 +8081,7995 @@
8021 7936 | this.inner.as_mut().poll(cx)
|
8022 7937 | }
|
8023 7938 | }
|
8024 7939 |
|
8025 7940 | impl<B>
|
8026 7941 | ::aws_smithy_http_server::request::FromRequest<
|
8027 7942 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8028 7943 | B,
|
8029 7944 | > for crate::input::QueryParamsAsStringListMapInput
|
8030 7945 | where
|
8031 7946 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
8032 7947 | B: 'static,
|
8033 7948 |
|
8034 7949 | B::Data: Send,
|
8035 7950 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
8036 7951 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
8037 7952 | {
|
8038 7953 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
8039 7954 | type Future = QueryParamsAsStringListMapInputFuture;
|
8040 7955 |
|
8041 7956 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
8042 7957 | let fut = async move {
|
8043 7958 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
8044 7959 | request.headers(),
|
8045 7960 | &CONTENT_TYPE_QUERYPARAMSASSTRINGLISTMAP,
|
8046 7961 | ) {
|
8047 7962 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
8048 7963 | }
|
8049 7964 | crate::protocol_serde::shape_query_params_as_string_list_map::de_query_params_as_string_list_map_http_request(request)
|
8050 7965 | .await
|
8051 - | .map_err(Into::into)
|
8052 7966 | };
|
8053 7967 | use ::futures_util::future::TryFutureExt;
|
8054 7968 | let fut = fut.map_err(
|
8055 7969 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
8056 7970 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
8057 7971 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
8058 7972 | e,
|
8059 7973 | )
|
8060 7974 | },
|
8061 7975 | );
|
8062 7976 | QueryParamsAsStringListMapInputFuture {
|
8063 7977 | inner: Box::pin(fut),
|
8064 7978 | }
|
8065 7979 | }
|
8066 7980 | }
|
8067 7981 | impl
|
8068 7982 | ::aws_smithy_http_server::response::IntoResponse<
|
8069 7983 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8070 7984 | > for crate::output::QueryParamsAsStringListMapOutput
|
8071 7985 | {
|
8072 7986 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
8073 7987 | match crate::protocol_serde::shape_query_params_as_string_list_map::ser_query_params_as_string_list_map_http_response(self) {
|
8074 7988 | Ok(response) => response,
|
8075 7989 | Err(e) => {
|
8076 7990 | ::tracing::error!(error = %e, "failed to serialize response");
|
8077 7991 | ::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))
|
8078 7992 | }
|
8079 7993 | }
|
8080 7994 | }
|
8081 7995 | }
|
@@ -8121,8035 +8181,8094 @@
8121 8035 | this.inner.as_mut().poll(cx)
|
8122 8036 | }
|
8123 8037 | }
|
8124 8038 |
|
8125 8039 | impl<B>
|
8126 8040 | ::aws_smithy_http_server::request::FromRequest<
|
8127 8041 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8128 8042 | B,
|
8129 8043 | > for crate::input::QueryPrecedenceInput
|
8130 8044 | where
|
8131 8045 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
8132 8046 | B: 'static,
|
8133 8047 |
|
8134 8048 | B::Data: Send,
|
8135 8049 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
8136 8050 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
8137 8051 | {
|
8138 8052 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
8139 8053 | type Future = QueryPrecedenceInputFuture;
|
8140 8054 |
|
8141 8055 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
8142 8056 | let fut = async move {
|
8143 8057 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
8144 8058 | request.headers(),
|
8145 8059 | &CONTENT_TYPE_QUERYPRECEDENCE,
|
8146 8060 | ) {
|
8147 8061 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
8148 8062 | }
|
8149 8063 | crate::protocol_serde::shape_query_precedence::de_query_precedence_http_request(request)
|
8150 8064 | .await
|
8151 - | .map_err(Into::into)
|
8152 8065 | };
|
8153 8066 | use ::futures_util::future::TryFutureExt;
|
8154 8067 | let fut = fut.map_err(
|
8155 8068 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
8156 8069 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
8157 8070 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
8158 8071 | e,
|
8159 8072 | )
|
8160 8073 | },
|
8161 8074 | );
|
8162 8075 | QueryPrecedenceInputFuture {
|
8163 8076 | inner: Box::pin(fut),
|
8164 8077 | }
|
8165 8078 | }
|
8166 8079 | }
|
8167 8080 | impl
|
8168 8081 | ::aws_smithy_http_server::response::IntoResponse<
|
8169 8082 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8170 8083 | > for crate::output::QueryPrecedenceOutput
|
8171 8084 | {
|
8172 8085 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
8173 8086 | match crate::protocol_serde::shape_query_precedence::ser_query_precedence_http_response(
|
8174 8087 | self,
|
8175 8088 | ) {
|
8176 8089 | Ok(response) => response,
|
8177 8090 | Err(e) => {
|
8178 8091 | ::tracing::error!(error = %e, "failed to serialize response");
|
8179 8092 | ::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))
|
8180 8093 | }
|
8181 8094 | }
|
@@ -8226,8139 +8286,8198 @@
8226 8139 | this.inner.as_mut().poll(cx)
|
8227 8140 | }
|
8228 8141 | }
|
8229 8142 |
|
8230 8143 | impl<B>
|
8231 8144 | ::aws_smithy_http_server::request::FromRequest<
|
8232 8145 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8233 8146 | B,
|
8234 8147 | > for crate::input::QueryIdempotencyTokenAutoFillInput
|
8235 8148 | where
|
8236 8149 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
8237 8150 | B: 'static,
|
8238 8151 |
|
8239 8152 | B::Data: Send,
|
8240 8153 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
8241 8154 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
8242 8155 | {
|
8243 8156 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
8244 8157 | type Future = QueryIdempotencyTokenAutoFillInputFuture;
|
8245 8158 |
|
8246 8159 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
8247 8160 | let fut = async move {
|
8248 8161 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
8249 8162 | request.headers(),
|
8250 8163 | &CONTENT_TYPE_QUERYIDEMPOTENCYTOKENAUTOFILL,
|
8251 8164 | ) {
|
8252 8165 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
8253 8166 | }
|
8254 8167 | crate::protocol_serde::shape_query_idempotency_token_auto_fill::de_query_idempotency_token_auto_fill_http_request(request)
|
8255 8168 | .await
|
8256 - | .map_err(Into::into)
|
8257 8169 | };
|
8258 8170 | use ::futures_util::future::TryFutureExt;
|
8259 8171 | let fut = fut.map_err(
|
8260 8172 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
8261 8173 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
8262 8174 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
8263 8175 | e,
|
8264 8176 | )
|
8265 8177 | },
|
8266 8178 | );
|
8267 8179 | QueryIdempotencyTokenAutoFillInputFuture {
|
8268 8180 | inner: Box::pin(fut),
|
8269 8181 | }
|
8270 8182 | }
|
8271 8183 | }
|
8272 8184 | impl
|
8273 8185 | ::aws_smithy_http_server::response::IntoResponse<
|
8274 8186 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8275 8187 | > for crate::output::QueryIdempotencyTokenAutoFillOutput
|
8276 8188 | {
|
8277 8189 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
8278 8190 | match crate::protocol_serde::shape_query_idempotency_token_auto_fill::ser_query_idempotency_token_auto_fill_http_response(self) {
|
8279 8191 | Ok(response) => response,
|
8280 8192 | Err(e) => {
|
8281 8193 | ::tracing::error!(error = %e, "failed to serialize response");
|
8282 8194 | ::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))
|
8283 8195 | }
|
8284 8196 | }
|
8285 8197 | }
|
8286 8198 | }
|
@@ -8326,8238 +8386,8297 @@
8326 8238 | this.inner.as_mut().poll(cx)
|
8327 8239 | }
|
8328 8240 | }
|
8329 8241 |
|
8330 8242 | impl<B>
|
8331 8243 | ::aws_smithy_http_server::request::FromRequest<
|
8332 8244 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8333 8245 | B,
|
8334 8246 | > for crate::input::OmitsSerializingEmptyListsInput
|
8335 8247 | where
|
8336 8248 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
8337 8249 | B: 'static,
|
8338 8250 |
|
8339 8251 | B::Data: Send,
|
8340 8252 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
8341 8253 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
8342 8254 | {
|
8343 8255 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
8344 8256 | type Future = OmitsSerializingEmptyListsInputFuture;
|
8345 8257 |
|
8346 8258 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
8347 8259 | let fut = async move {
|
8348 8260 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
8349 8261 | request.headers(),
|
8350 8262 | &CONTENT_TYPE_OMITSSERIALIZINGEMPTYLISTS,
|
8351 8263 | ) {
|
8352 8264 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
8353 8265 | }
|
8354 8266 | crate::protocol_serde::shape_omits_serializing_empty_lists::de_omits_serializing_empty_lists_http_request(request)
|
8355 8267 | .await
|
8356 - | .map_err(Into::into)
|
8357 8268 | };
|
8358 8269 | use ::futures_util::future::TryFutureExt;
|
8359 8270 | let fut = fut.map_err(
|
8360 8271 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
8361 8272 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
8362 8273 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
8363 8274 | e,
|
8364 8275 | )
|
8365 8276 | },
|
8366 8277 | );
|
8367 8278 | OmitsSerializingEmptyListsInputFuture {
|
8368 8279 | inner: Box::pin(fut),
|
8369 8280 | }
|
8370 8281 | }
|
8371 8282 | }
|
8372 8283 | impl
|
8373 8284 | ::aws_smithy_http_server::response::IntoResponse<
|
8374 8285 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8375 8286 | > for crate::output::OmitsSerializingEmptyListsOutput
|
8376 8287 | {
|
8377 8288 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
8378 8289 | match crate::protocol_serde::shape_omits_serializing_empty_lists::ser_omits_serializing_empty_lists_http_response(self) {
|
8379 8290 | Ok(response) => response,
|
8380 8291 | Err(e) => {
|
8381 8292 | ::tracing::error!(error = %e, "failed to serialize response");
|
8382 8293 | ::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))
|
8383 8294 | }
|
8384 8295 | }
|
8385 8296 | }
|
8386 8297 | }
|
@@ -8426,8337 +8486,8396 @@
8426 8337 | this.inner.as_mut().poll(cx)
|
8427 8338 | }
|
8428 8339 | }
|
8429 8340 |
|
8430 8341 | impl<B>
|
8431 8342 | ::aws_smithy_http_server::request::FromRequest<
|
8432 8343 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8433 8344 | B,
|
8434 8345 | > for crate::input::OmitsNullSerializesEmptyStringInput
|
8435 8346 | where
|
8436 8347 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
8437 8348 | B: 'static,
|
8438 8349 |
|
8439 8350 | B::Data: Send,
|
8440 8351 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
8441 8352 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
8442 8353 | {
|
8443 8354 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
8444 8355 | type Future = OmitsNullSerializesEmptyStringInputFuture;
|
8445 8356 |
|
8446 8357 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
8447 8358 | let fut = async move {
|
8448 8359 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
8449 8360 | request.headers(),
|
8450 8361 | &CONTENT_TYPE_OMITSNULLSERIALIZESEMPTYSTRING,
|
8451 8362 | ) {
|
8452 8363 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
8453 8364 | }
|
8454 8365 | crate::protocol_serde::shape_omits_null_serializes_empty_string::de_omits_null_serializes_empty_string_http_request(request)
|
8455 8366 | .await
|
8456 - | .map_err(Into::into)
|
8457 8367 | };
|
8458 8368 | use ::futures_util::future::TryFutureExt;
|
8459 8369 | let fut = fut.map_err(
|
8460 8370 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
8461 8371 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
8462 8372 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
8463 8373 | e,
|
8464 8374 | )
|
8465 8375 | },
|
8466 8376 | );
|
8467 8377 | OmitsNullSerializesEmptyStringInputFuture {
|
8468 8378 | inner: Box::pin(fut),
|
8469 8379 | }
|
8470 8380 | }
|
8471 8381 | }
|
8472 8382 | impl
|
8473 8383 | ::aws_smithy_http_server::response::IntoResponse<
|
8474 8384 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8475 8385 | > for crate::output::OmitsNullSerializesEmptyStringOutput
|
8476 8386 | {
|
8477 8387 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
8478 8388 | match crate::protocol_serde::shape_omits_null_serializes_empty_string::ser_omits_null_serializes_empty_string_http_response(self) {
|
8479 8389 | Ok(response) => response,
|
8480 8390 | Err(e) => {
|
8481 8391 | ::tracing::error!(error = %e, "failed to serialize response");
|
8482 8392 | ::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))
|
8483 8393 | }
|
8484 8394 | }
|
8485 8395 | }
|
8486 8396 | }
|
@@ -8526,8436 +8586,8495 @@
8526 8436 | this.inner.as_mut().poll(cx)
|
8527 8437 | }
|
8528 8438 | }
|
8529 8439 |
|
8530 8440 | impl<B>
|
8531 8441 | ::aws_smithy_http_server::request::FromRequest<
|
8532 8442 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8533 8443 | B,
|
8534 8444 | > for crate::input::IgnoreQueryParamsInResponseInput
|
8535 8445 | where
|
8536 8446 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
8537 8447 | B: 'static,
|
8538 8448 |
|
8539 8449 | B::Data: Send,
|
8540 8450 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
8541 8451 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
8542 8452 | {
|
8543 8453 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
8544 8454 | type Future = IgnoreQueryParamsInResponseInputFuture;
|
8545 8455 |
|
8546 8456 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
8547 8457 | let fut = async move {
|
8548 8458 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
8549 8459 | request.headers(),
|
8550 8460 | &CONTENT_TYPE_IGNOREQUERYPARAMSINRESPONSE,
|
8551 8461 | ) {
|
8552 8462 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
8553 8463 | }
|
8554 8464 | crate::protocol_serde::shape_ignore_query_params_in_response::de_ignore_query_params_in_response_http_request(request)
|
8555 8465 | .await
|
8556 - | .map_err(Into::into)
|
8557 8466 | };
|
8558 8467 | use ::futures_util::future::TryFutureExt;
|
8559 8468 | let fut = fut.map_err(
|
8560 8469 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
8561 8470 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
8562 8471 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
8563 8472 | e,
|
8564 8473 | )
|
8565 8474 | },
|
8566 8475 | );
|
8567 8476 | IgnoreQueryParamsInResponseInputFuture {
|
8568 8477 | inner: Box::pin(fut),
|
8569 8478 | }
|
8570 8479 | }
|
8571 8480 | }
|
8572 8481 | impl
|
8573 8482 | ::aws_smithy_http_server::response::IntoResponse<
|
8574 8483 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8575 8484 | > for crate::output::IgnoreQueryParamsInResponseOutput
|
8576 8485 | {
|
8577 8486 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
8578 8487 | match crate::protocol_serde::shape_ignore_query_params_in_response::ser_ignore_query_params_in_response_http_response(self) {
|
8579 8488 | Ok(response) => response,
|
8580 8489 | Err(e) => {
|
8581 8490 | ::tracing::error!(error = %e, "failed to serialize response");
|
8582 8491 | ::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))
|
8583 8492 | }
|
8584 8493 | }
|
8585 8494 | }
|
8586 8495 | }
|
@@ -8626,8535 +8686,8594 @@
8626 8535 | this.inner.as_mut().poll(cx)
|
8627 8536 | }
|
8628 8537 | }
|
8629 8538 |
|
8630 8539 | impl<B>
|
8631 8540 | ::aws_smithy_http_server::request::FromRequest<
|
8632 8541 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8633 8542 | B,
|
8634 8543 | > for crate::input::ConstantAndVariableQueryStringInput
|
8635 8544 | where
|
8636 8545 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
8637 8546 | B: 'static,
|
8638 8547 |
|
8639 8548 | B::Data: Send,
|
8640 8549 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
8641 8550 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
8642 8551 | {
|
8643 8552 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
8644 8553 | type Future = ConstantAndVariableQueryStringInputFuture;
|
8645 8554 |
|
8646 8555 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
8647 8556 | let fut = async move {
|
8648 8557 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
8649 8558 | request.headers(),
|
8650 8559 | &CONTENT_TYPE_CONSTANTANDVARIABLEQUERYSTRING,
|
8651 8560 | ) {
|
8652 8561 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
8653 8562 | }
|
8654 8563 | crate::protocol_serde::shape_constant_and_variable_query_string::de_constant_and_variable_query_string_http_request(request)
|
8655 8564 | .await
|
8656 - | .map_err(Into::into)
|
8657 8565 | };
|
8658 8566 | use ::futures_util::future::TryFutureExt;
|
8659 8567 | let fut = fut.map_err(
|
8660 8568 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
8661 8569 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
8662 8570 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
8663 8571 | e,
|
8664 8572 | )
|
8665 8573 | },
|
8666 8574 | );
|
8667 8575 | ConstantAndVariableQueryStringInputFuture {
|
8668 8576 | inner: Box::pin(fut),
|
8669 8577 | }
|
8670 8578 | }
|
8671 8579 | }
|
8672 8580 | impl
|
8673 8581 | ::aws_smithy_http_server::response::IntoResponse<
|
8674 8582 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8675 8583 | > for crate::output::ConstantAndVariableQueryStringOutput
|
8676 8584 | {
|
8677 8585 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
8678 8586 | match crate::protocol_serde::shape_constant_and_variable_query_string::ser_constant_and_variable_query_string_http_response(self) {
|
8679 8587 | Ok(response) => response,
|
8680 8588 | Err(e) => {
|
8681 8589 | ::tracing::error!(error = %e, "failed to serialize response");
|
8682 8590 | ::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))
|
8683 8591 | }
|
8684 8592 | }
|
8685 8593 | }
|
8686 8594 | }
|
@@ -8726,8634 +8786,8693 @@
8726 8634 | this.inner.as_mut().poll(cx)
|
8727 8635 | }
|
8728 8636 | }
|
8729 8637 |
|
8730 8638 | impl<B>
|
8731 8639 | ::aws_smithy_http_server::request::FromRequest<
|
8732 8640 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8733 8641 | B,
|
8734 8642 | > for crate::input::ConstantQueryStringInput
|
8735 8643 | where
|
8736 8644 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
8737 8645 | B: 'static,
|
8738 8646 |
|
8739 8647 | B::Data: Send,
|
8740 8648 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
8741 8649 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
8742 8650 | {
|
8743 8651 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
8744 8652 | type Future = ConstantQueryStringInputFuture;
|
8745 8653 |
|
8746 8654 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
8747 8655 | let fut = async move {
|
8748 8656 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
8749 8657 | request.headers(),
|
8750 8658 | &CONTENT_TYPE_CONSTANTQUERYSTRING,
|
8751 8659 | ) {
|
8752 8660 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
8753 8661 | }
|
8754 8662 | crate::protocol_serde::shape_constant_query_string::de_constant_query_string_http_request(request)
|
8755 8663 | .await
|
8756 - | .map_err(Into::into)
|
8757 8664 | };
|
8758 8665 | use ::futures_util::future::TryFutureExt;
|
8759 8666 | let fut = fut.map_err(
|
8760 8667 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
8761 8668 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
8762 8669 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
8763 8670 | e,
|
8764 8671 | )
|
8765 8672 | },
|
8766 8673 | );
|
8767 8674 | ConstantQueryStringInputFuture {
|
8768 8675 | inner: Box::pin(fut),
|
8769 8676 | }
|
8770 8677 | }
|
8771 8678 | }
|
8772 8679 | impl
|
8773 8680 | ::aws_smithy_http_server::response::IntoResponse<
|
8774 8681 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8775 8682 | > for crate::output::ConstantQueryStringOutput
|
8776 8683 | {
|
8777 8684 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
8778 8685 | match crate::protocol_serde::shape_constant_query_string::ser_constant_query_string_http_response(self) {
|
8779 8686 | Ok(response) => response,
|
8780 8687 | Err(e) => {
|
8781 8688 | ::tracing::error!(error = %e, "failed to serialize response");
|
8782 8689 | ::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))
|
8783 8690 | }
|
8784 8691 | }
|
8785 8692 | }
|
8786 8693 | }
|
@@ -8826,8733 +8886,8792 @@
8826 8733 | this.inner.as_mut().poll(cx)
|
8827 8734 | }
|
8828 8735 | }
|
8829 8736 |
|
8830 8737 | impl<B>
|
8831 8738 | ::aws_smithy_http_server::request::FromRequest<
|
8832 8739 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8833 8740 | B,
|
8834 8741 | > for crate::input::AllQueryStringTypesInput
|
8835 8742 | where
|
8836 8743 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
8837 8744 | B: 'static,
|
8838 8745 |
|
8839 8746 | B::Data: Send,
|
8840 8747 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
8841 8748 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
8842 8749 | {
|
8843 8750 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
8844 8751 | type Future = AllQueryStringTypesInputFuture;
|
8845 8752 |
|
8846 8753 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
8847 8754 | let fut = async move {
|
8848 8755 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
8849 8756 | request.headers(),
|
8850 8757 | &CONTENT_TYPE_ALLQUERYSTRINGTYPES,
|
8851 8758 | ) {
|
8852 8759 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
8853 8760 | }
|
8854 8761 | crate::protocol_serde::shape_all_query_string_types::de_all_query_string_types_http_request(request)
|
8855 8762 | .await
|
8856 - | .map_err(Into::into)
|
8857 8763 | };
|
8858 8764 | use ::futures_util::future::TryFutureExt;
|
8859 8765 | let fut = fut.map_err(
|
8860 8766 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
8861 8767 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
8862 8768 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
8863 8769 | e,
|
8864 8770 | )
|
8865 8771 | },
|
8866 8772 | );
|
8867 8773 | AllQueryStringTypesInputFuture {
|
8868 8774 | inner: Box::pin(fut),
|
8869 8775 | }
|
8870 8776 | }
|
8871 8777 | }
|
8872 8778 | impl
|
8873 8779 | ::aws_smithy_http_server::response::IntoResponse<
|
8874 8780 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8875 8781 | > for crate::output::AllQueryStringTypesOutput
|
8876 8782 | {
|
8877 8783 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
8878 8784 | match crate::protocol_serde::shape_all_query_string_types::ser_all_query_string_types_http_response(self) {
|
8879 8785 | Ok(response) => response,
|
8880 8786 | Err(e) => {
|
8881 8787 | ::tracing::error!(error = %e, "failed to serialize response");
|
8882 8788 | ::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))
|
8883 8789 | }
|
8884 8790 | }
|
8885 8791 | }
|
8886 8792 | }
|
@@ -8926,8832 +8986,8891 @@
8926 8832 | this.inner.as_mut().poll(cx)
|
8927 8833 | }
|
8928 8834 | }
|
8929 8835 |
|
8930 8836 | impl<B>
|
8931 8837 | ::aws_smithy_http_server::request::FromRequest<
|
8932 8838 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8933 8839 | B,
|
8934 8840 | > for crate::input::HttpRequestWithRegexLiteralInput
|
8935 8841 | where
|
8936 8842 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
8937 8843 | B: 'static,
|
8938 8844 |
|
8939 8845 | B::Data: Send,
|
8940 8846 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
8941 8847 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
8942 8848 | {
|
8943 8849 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
8944 8850 | type Future = HttpRequestWithRegexLiteralInputFuture;
|
8945 8851 |
|
8946 8852 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
8947 8853 | let fut = async move {
|
8948 8854 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
8949 8855 | request.headers(),
|
8950 8856 | &CONTENT_TYPE_HTTPREQUESTWITHREGEXLITERAL,
|
8951 8857 | ) {
|
8952 8858 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
8953 8859 | }
|
8954 8860 | crate::protocol_serde::shape_http_request_with_regex_literal::de_http_request_with_regex_literal_http_request(request)
|
8955 8861 | .await
|
8956 - | .map_err(Into::into)
|
8957 8862 | };
|
8958 8863 | use ::futures_util::future::TryFutureExt;
|
8959 8864 | let fut = fut.map_err(
|
8960 8865 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
8961 8866 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
8962 8867 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
8963 8868 | e,
|
8964 8869 | )
|
8965 8870 | },
|
8966 8871 | );
|
8967 8872 | HttpRequestWithRegexLiteralInputFuture {
|
8968 8873 | inner: Box::pin(fut),
|
8969 8874 | }
|
8970 8875 | }
|
8971 8876 | }
|
8972 8877 | impl
|
8973 8878 | ::aws_smithy_http_server::response::IntoResponse<
|
8974 8879 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
8975 8880 | > for crate::output::HttpRequestWithRegexLiteralOutput
|
8976 8881 | {
|
8977 8882 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
8978 8883 | match crate::protocol_serde::shape_http_request_with_regex_literal::ser_http_request_with_regex_literal_http_response(self) {
|
8979 8884 | Ok(response) => response,
|
8980 8885 | Err(e) => {
|
8981 8886 | ::tracing::error!(error = %e, "failed to serialize response");
|
8982 8887 | ::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))
|
8983 8888 | }
|
8984 8889 | }
|
8985 8890 | }
|
8986 8891 | }
|
@@ -9026,8931 +9086,8990 @@
9026 8931 | this.inner.as_mut().poll(cx)
|
9027 8932 | }
|
9028 8933 | }
|
9029 8934 |
|
9030 8935 | impl<B>
|
9031 8936 | ::aws_smithy_http_server::request::FromRequest<
|
9032 8937 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9033 8938 | B,
|
9034 8939 | > for crate::input::HttpRequestWithFloatLabelsInput
|
9035 8940 | where
|
9036 8941 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
9037 8942 | B: 'static,
|
9038 8943 |
|
9039 8944 | B::Data: Send,
|
9040 8945 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
9041 8946 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
9042 8947 | {
|
9043 8948 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
9044 8949 | type Future = HttpRequestWithFloatLabelsInputFuture;
|
9045 8950 |
|
9046 8951 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
9047 8952 | let fut = async move {
|
9048 8953 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
9049 8954 | request.headers(),
|
9050 8955 | &CONTENT_TYPE_HTTPREQUESTWITHFLOATLABELS,
|
9051 8956 | ) {
|
9052 8957 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
9053 8958 | }
|
9054 8959 | crate::protocol_serde::shape_http_request_with_float_labels::de_http_request_with_float_labels_http_request(request)
|
9055 8960 | .await
|
9056 - | .map_err(Into::into)
|
9057 8961 | };
|
9058 8962 | use ::futures_util::future::TryFutureExt;
|
9059 8963 | let fut = fut.map_err(
|
9060 8964 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
9061 8965 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
9062 8966 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
9063 8967 | e,
|
9064 8968 | )
|
9065 8969 | },
|
9066 8970 | );
|
9067 8971 | HttpRequestWithFloatLabelsInputFuture {
|
9068 8972 | inner: Box::pin(fut),
|
9069 8973 | }
|
9070 8974 | }
|
9071 8975 | }
|
9072 8976 | impl
|
9073 8977 | ::aws_smithy_http_server::response::IntoResponse<
|
9074 8978 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9075 8979 | > for crate::output::HttpRequestWithFloatLabelsOutput
|
9076 8980 | {
|
9077 8981 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
9078 8982 | match crate::protocol_serde::shape_http_request_with_float_labels::ser_http_request_with_float_labels_http_response(self) {
|
9079 8983 | Ok(response) => response,
|
9080 8984 | Err(e) => {
|
9081 8985 | ::tracing::error!(error = %e, "failed to serialize response");
|
9082 8986 | ::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))
|
9083 8987 | }
|
9084 8988 | }
|
9085 8989 | }
|
9086 8990 | }
|
@@ -9126,9030 +9186,9089 @@
9126 9030 | this.inner.as_mut().poll(cx)
|
9127 9031 | }
|
9128 9032 | }
|
9129 9033 |
|
9130 9034 | impl<B>
|
9131 9035 | ::aws_smithy_http_server::request::FromRequest<
|
9132 9036 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9133 9037 | B,
|
9134 9038 | > for crate::input::HttpRequestWithGreedyLabelInPathInput
|
9135 9039 | where
|
9136 9040 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
9137 9041 | B: 'static,
|
9138 9042 |
|
9139 9043 | B::Data: Send,
|
9140 9044 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
9141 9045 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
9142 9046 | {
|
9143 9047 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
9144 9048 | type Future = HttpRequestWithGreedyLabelInPathInputFuture;
|
9145 9049 |
|
9146 9050 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
9147 9051 | let fut = async move {
|
9148 9052 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
9149 9053 | request.headers(),
|
9150 9054 | &CONTENT_TYPE_HTTPREQUESTWITHGREEDYLABELINPATH,
|
9151 9055 | ) {
|
9152 9056 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
9153 9057 | }
|
9154 9058 | crate::protocol_serde::shape_http_request_with_greedy_label_in_path::de_http_request_with_greedy_label_in_path_http_request(request)
|
9155 9059 | .await
|
9156 - | .map_err(Into::into)
|
9157 9060 | };
|
9158 9061 | use ::futures_util::future::TryFutureExt;
|
9159 9062 | let fut = fut.map_err(
|
9160 9063 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
9161 9064 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
9162 9065 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
9163 9066 | e,
|
9164 9067 | )
|
9165 9068 | },
|
9166 9069 | );
|
9167 9070 | HttpRequestWithGreedyLabelInPathInputFuture {
|
9168 9071 | inner: Box::pin(fut),
|
9169 9072 | }
|
9170 9073 | }
|
9171 9074 | }
|
9172 9075 | impl
|
9173 9076 | ::aws_smithy_http_server::response::IntoResponse<
|
9174 9077 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9175 9078 | > for crate::output::HttpRequestWithGreedyLabelInPathOutput
|
9176 9079 | {
|
9177 9080 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
9178 9081 | match crate::protocol_serde::shape_http_request_with_greedy_label_in_path::ser_http_request_with_greedy_label_in_path_http_response(self) {
|
9179 9082 | Ok(response) => response,
|
9180 9083 | Err(e) => {
|
9181 9084 | ::tracing::error!(error = %e, "failed to serialize response");
|
9182 9085 | ::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))
|
9183 9086 | }
|
9184 9087 | }
|
9185 9088 | }
|
9186 9089 | }
|
@@ -9226,9129 +9286,9188 @@
9226 9129 | this.inner.as_mut().poll(cx)
|
9227 9130 | }
|
9228 9131 | }
|
9229 9132 |
|
9230 9133 | impl<B>
|
9231 9134 | ::aws_smithy_http_server::request::FromRequest<
|
9232 9135 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9233 9136 | B,
|
9234 9137 | > for crate::input::HttpRequestWithLabelsAndTimestampFormatInput
|
9235 9138 | where
|
9236 9139 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
9237 9140 | B: 'static,
|
9238 9141 |
|
9239 9142 | B::Data: Send,
|
9240 9143 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
9241 9144 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
9242 9145 | {
|
9243 9146 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
9244 9147 | type Future = HttpRequestWithLabelsAndTimestampFormatInputFuture;
|
9245 9148 |
|
9246 9149 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
9247 9150 | let fut = async move {
|
9248 9151 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
9249 9152 | request.headers(),
|
9250 9153 | &CONTENT_TYPE_HTTPREQUESTWITHLABELSANDTIMESTAMPFORMAT,
|
9251 9154 | ) {
|
9252 9155 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
9253 9156 | }
|
9254 9157 | crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format::de_http_request_with_labels_and_timestamp_format_http_request(request)
|
9255 9158 | .await
|
9256 - | .map_err(Into::into)
|
9257 9159 | };
|
9258 9160 | use ::futures_util::future::TryFutureExt;
|
9259 9161 | let fut = fut.map_err(
|
9260 9162 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
9261 9163 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
9262 9164 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
9263 9165 | e,
|
9264 9166 | )
|
9265 9167 | },
|
9266 9168 | );
|
9267 9169 | HttpRequestWithLabelsAndTimestampFormatInputFuture {
|
9268 9170 | inner: Box::pin(fut),
|
9269 9171 | }
|
9270 9172 | }
|
9271 9173 | }
|
9272 9174 | impl
|
9273 9175 | ::aws_smithy_http_server::response::IntoResponse<
|
9274 9176 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9275 9177 | > for crate::output::HttpRequestWithLabelsAndTimestampFormatOutput
|
9276 9178 | {
|
9277 9179 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
9278 9180 | match crate::protocol_serde::shape_http_request_with_labels_and_timestamp_format::ser_http_request_with_labels_and_timestamp_format_http_response(self) {
|
9279 9181 | Ok(response) => response,
|
9280 9182 | Err(e) => {
|
9281 9183 | ::tracing::error!(error = %e, "failed to serialize response");
|
9282 9184 | ::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))
|
9283 9185 | }
|
9284 9186 | }
|
9285 9187 | }
|
9286 9188 | }
|
@@ -9326,9228 +9386,9287 @@
9326 9228 | this.inner.as_mut().poll(cx)
|
9327 9229 | }
|
9328 9230 | }
|
9329 9231 |
|
9330 9232 | impl<B>
|
9331 9233 | ::aws_smithy_http_server::request::FromRequest<
|
9332 9234 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9333 9235 | B,
|
9334 9236 | > for crate::input::HttpRequestWithLabelsInput
|
9335 9237 | where
|
9336 9238 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
9337 9239 | B: 'static,
|
9338 9240 |
|
9339 9241 | B::Data: Send,
|
9340 9242 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
9341 9243 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
9342 9244 | {
|
9343 9245 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
9344 9246 | type Future = HttpRequestWithLabelsInputFuture;
|
9345 9247 |
|
9346 9248 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
9347 9249 | let fut = async move {
|
9348 9250 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
9349 9251 | request.headers(),
|
9350 9252 | &CONTENT_TYPE_HTTPREQUESTWITHLABELS,
|
9351 9253 | ) {
|
9352 9254 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
9353 9255 | }
|
9354 9256 | crate::protocol_serde::shape_http_request_with_labels::de_http_request_with_labels_http_request(request)
|
9355 9257 | .await
|
9356 - | .map_err(Into::into)
|
9357 9258 | };
|
9358 9259 | use ::futures_util::future::TryFutureExt;
|
9359 9260 | let fut = fut.map_err(
|
9360 9261 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
9361 9262 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
9362 9263 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
9363 9264 | e,
|
9364 9265 | )
|
9365 9266 | },
|
9366 9267 | );
|
9367 9268 | HttpRequestWithLabelsInputFuture {
|
9368 9269 | inner: Box::pin(fut),
|
9369 9270 | }
|
9370 9271 | }
|
9371 9272 | }
|
9372 9273 | impl
|
9373 9274 | ::aws_smithy_http_server::response::IntoResponse<
|
9374 9275 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9375 9276 | > for crate::output::HttpRequestWithLabelsOutput
|
9376 9277 | {
|
9377 9278 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
9378 9279 | match crate::protocol_serde::shape_http_request_with_labels::ser_http_request_with_labels_http_response(self) {
|
9379 9280 | Ok(response) => response,
|
9380 9281 | Err(e) => {
|
9381 9282 | ::tracing::error!(error = %e, "failed to serialize response");
|
9382 9283 | ::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))
|
9383 9284 | }
|
9384 9285 | }
|
9385 9286 | }
|
9386 9287 | }
|
@@ -9428,9329 +9488,9388 @@
9428 9329 | }
|
9429 9330 |
|
9430 9331 | impl<B>
|
9431 9332 | ::aws_smithy_http_server::request::FromRequest<
|
9432 9333 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9433 9334 | B,
|
9434 9335 | > for crate::input::MediaTypeHeaderInput
|
9435 9336 | where
|
9436 9337 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
9437 9338 | B: 'static,
|
9438 9339 |
|
9439 9340 | B::Data: Send,
|
9440 9341 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
9441 9342 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
9442 9343 | {
|
9443 9344 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
9444 9345 | type Future = MediaTypeHeaderInputFuture;
|
9445 9346 |
|
9446 9347 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
9447 9348 | let fut = async move {
|
9448 9349 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
9449 9350 | request.headers(),
|
9450 9351 | &CONTENT_TYPE_MEDIATYPEHEADER,
|
9451 9352 | ) {
|
9452 9353 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
9453 9354 | }
|
9454 9355 | crate::protocol_serde::shape_media_type_header::de_media_type_header_http_request(
|
9455 9356 | request,
|
9456 9357 | )
|
9457 9358 | .await
|
9458 - | .map_err(Into::into)
|
9459 9359 | };
|
9460 9360 | use ::futures_util::future::TryFutureExt;
|
9461 9361 | let fut = fut.map_err(
|
9462 9362 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
9463 9363 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
9464 9364 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
9465 9365 | e,
|
9466 9366 | )
|
9467 9367 | },
|
9468 9368 | );
|
9469 9369 | MediaTypeHeaderInputFuture {
|
9470 9370 | inner: Box::pin(fut),
|
9471 9371 | }
|
9472 9372 | }
|
9473 9373 | }
|
9474 9374 | impl
|
9475 9375 | ::aws_smithy_http_server::response::IntoResponse<
|
9476 9376 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9477 9377 | > for crate::output::MediaTypeHeaderOutput
|
9478 9378 | {
|
9479 9379 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
9480 9380 | match crate::protocol_serde::shape_media_type_header::ser_media_type_header_http_response(
|
9481 9381 | self,
|
9482 9382 | ) {
|
9483 9383 | Ok(response) => response,
|
9484 9384 | Err(e) => {
|
9485 9385 | ::tracing::error!(error = %e, "failed to serialize response");
|
9486 9386 | ::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))
|
9487 9387 | }
|
9488 9388 | }
|
@@ -9534,9434 +9594,9493 @@
9534 9434 | this.inner.as_mut().poll(cx)
|
9535 9435 | }
|
9536 9436 | }
|
9537 9437 |
|
9538 9438 | impl<B>
|
9539 9439 | ::aws_smithy_http_server::request::FromRequest<
|
9540 9440 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9541 9441 | B,
|
9542 9442 | > for crate::input::TimestampFormatHeadersInput
|
9543 9443 | where
|
9544 9444 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
9545 9445 | B: 'static,
|
9546 9446 |
|
9547 9447 | B::Data: Send,
|
9548 9448 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
9549 9449 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
9550 9450 | {
|
9551 9451 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
9552 9452 | type Future = TimestampFormatHeadersInputFuture;
|
9553 9453 |
|
9554 9454 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
9555 9455 | let fut = async move {
|
9556 9456 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
9557 9457 | request.headers(),
|
9558 9458 | &CONTENT_TYPE_TIMESTAMPFORMATHEADERS,
|
9559 9459 | ) {
|
9560 9460 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
9561 9461 | }
|
9562 9462 | crate::protocol_serde::shape_timestamp_format_headers::de_timestamp_format_headers_http_request(request)
|
9563 9463 | .await
|
9564 - | .map_err(Into::into)
|
9565 9464 | };
|
9566 9465 | use ::futures_util::future::TryFutureExt;
|
9567 9466 | let fut = fut.map_err(
|
9568 9467 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
9569 9468 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
9570 9469 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
9571 9470 | e,
|
9572 9471 | )
|
9573 9472 | },
|
9574 9473 | );
|
9575 9474 | TimestampFormatHeadersInputFuture {
|
9576 9475 | inner: Box::pin(fut),
|
9577 9476 | }
|
9578 9477 | }
|
9579 9478 | }
|
9580 9479 | impl
|
9581 9480 | ::aws_smithy_http_server::response::IntoResponse<
|
9582 9481 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9583 9482 | > for crate::output::TimestampFormatHeadersOutput
|
9584 9483 | {
|
9585 9484 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
9586 9485 | match crate::protocol_serde::shape_timestamp_format_headers::ser_timestamp_format_headers_http_response(self) {
|
9587 9486 | Ok(response) => response,
|
9588 9487 | Err(e) => {
|
9589 9488 | ::tracing::error!(error = %e, "failed to serialize response");
|
9590 9489 | ::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))
|
9591 9490 | }
|
9592 9491 | }
|
9593 9492 | }
|
9594 9493 | }
|
@@ -9634,9533 +9694,9592 @@
9634 9533 | this.inner.as_mut().poll(cx)
|
9635 9534 | }
|
9636 9535 | }
|
9637 9536 |
|
9638 9537 | impl<B>
|
9639 9538 | ::aws_smithy_http_server::request::FromRequest<
|
9640 9539 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9641 9540 | B,
|
9642 9541 | > for crate::input::NullAndEmptyHeadersServerInput
|
9643 9542 | where
|
9644 9543 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
9645 9544 | B: 'static,
|
9646 9545 |
|
9647 9546 | B::Data: Send,
|
9648 9547 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
9649 9548 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
9650 9549 | {
|
9651 9550 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
9652 9551 | type Future = NullAndEmptyHeadersServerInputFuture;
|
9653 9552 |
|
9654 9553 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
9655 9554 | let fut = async move {
|
9656 9555 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
9657 9556 | request.headers(),
|
9658 9557 | &CONTENT_TYPE_NULLANDEMPTYHEADERSSERVER,
|
9659 9558 | ) {
|
9660 9559 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
9661 9560 | }
|
9662 9561 | crate::protocol_serde::shape_null_and_empty_headers_server::de_null_and_empty_headers_server_http_request(request)
|
9663 9562 | .await
|
9664 - | .map_err(Into::into)
|
9665 9563 | };
|
9666 9564 | use ::futures_util::future::TryFutureExt;
|
9667 9565 | let fut = fut.map_err(
|
9668 9566 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
9669 9567 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
9670 9568 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
9671 9569 | e,
|
9672 9570 | )
|
9673 9571 | },
|
9674 9572 | );
|
9675 9573 | NullAndEmptyHeadersServerInputFuture {
|
9676 9574 | inner: Box::pin(fut),
|
9677 9575 | }
|
9678 9576 | }
|
9679 9577 | }
|
9680 9578 | impl
|
9681 9579 | ::aws_smithy_http_server::response::IntoResponse<
|
9682 9580 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9683 9581 | > for crate::output::NullAndEmptyHeadersServerOutput
|
9684 9582 | {
|
9685 9583 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
9686 9584 | match crate::protocol_serde::shape_null_and_empty_headers_server::ser_null_and_empty_headers_server_http_response(self) {
|
9687 9585 | Ok(response) => response,
|
9688 9586 | Err(e) => {
|
9689 9587 | ::tracing::error!(error = %e, "failed to serialize response");
|
9690 9588 | ::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))
|
9691 9589 | }
|
9692 9590 | }
|
9693 9591 | }
|
9694 9592 | }
|
@@ -9734,9632 +9794,9691 @@
9734 9632 | this.inner.as_mut().poll(cx)
|
9735 9633 | }
|
9736 9634 | }
|
9737 9635 |
|
9738 9636 | impl<B>
|
9739 9637 | ::aws_smithy_http_server::request::FromRequest<
|
9740 9638 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9741 9639 | B,
|
9742 9640 | > for crate::input::NullAndEmptyHeadersClientInput
|
9743 9641 | where
|
9744 9642 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
9745 9643 | B: 'static,
|
9746 9644 |
|
9747 9645 | B::Data: Send,
|
9748 9646 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
9749 9647 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
9750 9648 | {
|
9751 9649 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
9752 9650 | type Future = NullAndEmptyHeadersClientInputFuture;
|
9753 9651 |
|
9754 9652 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
9755 9653 | let fut = async move {
|
9756 9654 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
9757 9655 | request.headers(),
|
9758 9656 | &CONTENT_TYPE_NULLANDEMPTYHEADERSCLIENT,
|
9759 9657 | ) {
|
9760 9658 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
9761 9659 | }
|
9762 9660 | crate::protocol_serde::shape_null_and_empty_headers_client::de_null_and_empty_headers_client_http_request(request)
|
9763 9661 | .await
|
9764 - | .map_err(Into::into)
|
9765 9662 | };
|
9766 9663 | use ::futures_util::future::TryFutureExt;
|
9767 9664 | let fut = fut.map_err(
|
9768 9665 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
9769 9666 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
9770 9667 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
9771 9668 | e,
|
9772 9669 | )
|
9773 9670 | },
|
9774 9671 | );
|
9775 9672 | NullAndEmptyHeadersClientInputFuture {
|
9776 9673 | inner: Box::pin(fut),
|
9777 9674 | }
|
9778 9675 | }
|
9779 9676 | }
|
9780 9677 | impl
|
9781 9678 | ::aws_smithy_http_server::response::IntoResponse<
|
9782 9679 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9783 9680 | > for crate::output::NullAndEmptyHeadersClientOutput
|
9784 9681 | {
|
9785 9682 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
9786 9683 | match crate::protocol_serde::shape_null_and_empty_headers_client::ser_null_and_empty_headers_client_http_response(self) {
|
9787 9684 | Ok(response) => response,
|
9788 9685 | Err(e) => {
|
9789 9686 | ::tracing::error!(error = %e, "failed to serialize response");
|
9790 9687 | ::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))
|
9791 9688 | }
|
9792 9689 | }
|
9793 9690 | }
|
9794 9691 | }
|
@@ -9834,9731 +9894,9790 @@
9834 9731 | this.inner.as_mut().poll(cx)
|
9835 9732 | }
|
9836 9733 | }
|
9837 9734 |
|
9838 9735 | impl<B>
|
9839 9736 | ::aws_smithy_http_server::request::FromRequest<
|
9840 9737 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9841 9738 | B,
|
9842 9739 | > for crate::input::InputAndOutputWithHeadersInput
|
9843 9740 | where
|
9844 9741 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
9845 9742 | B: 'static,
|
9846 9743 |
|
9847 9744 | B::Data: Send,
|
9848 9745 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
9849 9746 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
9850 9747 | {
|
9851 9748 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
9852 9749 | type Future = InputAndOutputWithHeadersInputFuture;
|
9853 9750 |
|
9854 9751 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
9855 9752 | let fut = async move {
|
9856 9753 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
9857 9754 | request.headers(),
|
9858 9755 | &CONTENT_TYPE_INPUTANDOUTPUTWITHHEADERS,
|
9859 9756 | ) {
|
9860 9757 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
9861 9758 | }
|
9862 9759 | crate::protocol_serde::shape_input_and_output_with_headers::de_input_and_output_with_headers_http_request(request)
|
9863 9760 | .await
|
9864 - | .map_err(Into::into)
|
9865 9761 | };
|
9866 9762 | use ::futures_util::future::TryFutureExt;
|
9867 9763 | let fut = fut.map_err(
|
9868 9764 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
9869 9765 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
9870 9766 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
9871 9767 | e,
|
9872 9768 | )
|
9873 9769 | },
|
9874 9770 | );
|
9875 9771 | InputAndOutputWithHeadersInputFuture {
|
9876 9772 | inner: Box::pin(fut),
|
9877 9773 | }
|
9878 9774 | }
|
9879 9775 | }
|
9880 9776 | impl
|
9881 9777 | ::aws_smithy_http_server::response::IntoResponse<
|
9882 9778 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9883 9779 | > for crate::output::InputAndOutputWithHeadersOutput
|
9884 9780 | {
|
9885 9781 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
9886 9782 | match crate::protocol_serde::shape_input_and_output_with_headers::ser_input_and_output_with_headers_http_response(self) {
|
9887 9783 | Ok(response) => response,
|
9888 9784 | Err(e) => {
|
9889 9785 | ::tracing::error!(error = %e, "failed to serialize response");
|
9890 9786 | ::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))
|
9891 9787 | }
|
9892 9788 | }
|
9893 9789 | }
|
9894 9790 | }
|
@@ -9934,9830 +9994,9889 @@
9934 9830 | this.inner.as_mut().poll(cx)
|
9935 9831 | }
|
9936 9832 | }
|
9937 9833 |
|
9938 9834 | impl<B>
|
9939 9835 | ::aws_smithy_http_server::request::FromRequest<
|
9940 9836 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9941 9837 | B,
|
9942 9838 | > for crate::input::UnitInputAndOutputInput
|
9943 9839 | where
|
9944 9840 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
9945 9841 | B: 'static,
|
9946 9842 |
|
9947 9843 | B::Data: Send,
|
9948 9844 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
9949 9845 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
9950 9846 | {
|
9951 9847 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
9952 9848 | type Future = UnitInputAndOutputInputFuture;
|
9953 9849 |
|
9954 9850 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
9955 9851 | let fut = async move {
|
9956 9852 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
9957 9853 | request.headers(),
|
9958 9854 | &CONTENT_TYPE_UNITINPUTANDOUTPUT,
|
9959 9855 | ) {
|
9960 9856 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
9961 9857 | }
|
9962 9858 | crate::protocol_serde::shape_unit_input_and_output::de_unit_input_and_output_http_request(request)
|
9963 9859 | .await
|
9964 - | .map_err(Into::into)
|
9965 9860 | };
|
9966 9861 | use ::futures_util::future::TryFutureExt;
|
9967 9862 | let fut = fut.map_err(
|
9968 9863 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
9969 9864 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
9970 9865 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
9971 9866 | e,
|
9972 9867 | )
|
9973 9868 | },
|
9974 9869 | );
|
9975 9870 | UnitInputAndOutputInputFuture {
|
9976 9871 | inner: Box::pin(fut),
|
9977 9872 | }
|
9978 9873 | }
|
9979 9874 | }
|
9980 9875 | impl
|
9981 9876 | ::aws_smithy_http_server::response::IntoResponse<
|
9982 9877 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
9983 9878 | > for crate::output::UnitInputAndOutputOutput
|
9984 9879 | {
|
9985 9880 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
9986 9881 | match crate::protocol_serde::shape_unit_input_and_output::ser_unit_input_and_output_http_response(self) {
|
9987 9882 | Ok(response) => response,
|
9988 9883 | Err(e) => {
|
9989 9884 | ::tracing::error!(error = %e, "failed to serialize response");
|
9990 9885 | ::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))
|
9991 9886 | }
|
9992 9887 | }
|
9993 9888 | }
|
9994 9889 | }
|
@@ -10034,9929 +10094,9988 @@
10034 9929 | this.inner.as_mut().poll(cx)
|
10035 9930 | }
|
10036 9931 | }
|
10037 9932 |
|
10038 9933 | impl<B>
|
10039 9934 | ::aws_smithy_http_server::request::FromRequest<
|
10040 9935 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
10041 9936 | B,
|
10042 9937 | > for crate::input::EmptyInputAndEmptyOutputInput
|
10043 9938 | where
|
10044 9939 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
10045 9940 | B: 'static,
|
10046 9941 |
|
10047 9942 | B::Data: Send,
|
10048 9943 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
10049 9944 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
10050 9945 | {
|
10051 9946 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
10052 9947 | type Future = EmptyInputAndEmptyOutputInputFuture;
|
10053 9948 |
|
10054 9949 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
10055 9950 | let fut = async move {
|
10056 9951 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
10057 9952 | request.headers(),
|
10058 9953 | &CONTENT_TYPE_EMPTYINPUTANDEMPTYOUTPUT,
|
10059 9954 | ) {
|
10060 9955 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
10061 9956 | }
|
10062 9957 | crate::protocol_serde::shape_empty_input_and_empty_output::de_empty_input_and_empty_output_http_request(request)
|
10063 9958 | .await
|
10064 - | .map_err(Into::into)
|
10065 9959 | };
|
10066 9960 | use ::futures_util::future::TryFutureExt;
|
10067 9961 | let fut = fut.map_err(
|
10068 9962 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
10069 9963 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
10070 9964 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
10071 9965 | e,
|
10072 9966 | )
|
10073 9967 | },
|
10074 9968 | );
|
10075 9969 | EmptyInputAndEmptyOutputInputFuture {
|
10076 9970 | inner: Box::pin(fut),
|
10077 9971 | }
|
10078 9972 | }
|
10079 9973 | }
|
10080 9974 | impl
|
10081 9975 | ::aws_smithy_http_server::response::IntoResponse<
|
10082 9976 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
10083 9977 | > for crate::output::EmptyInputAndEmptyOutputOutput
|
10084 9978 | {
|
10085 9979 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
10086 9980 | match crate::protocol_serde::shape_empty_input_and_empty_output::ser_empty_input_and_empty_output_http_response(self) {
|
10087 9981 | Ok(response) => response,
|
10088 9982 | Err(e) => {
|
10089 9983 | ::tracing::error!(error = %e, "failed to serialize response");
|
10090 9984 | ::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))
|
10091 9985 | }
|
10092 9986 | }
|
10093 9987 | }
|
10094 9988 | }
|
@@ -10136,10030 +10196,10089 @@
10136 10030 | }
|
10137 10031 |
|
10138 10032 | impl<B>
|
10139 10033 | ::aws_smithy_http_server::request::FromRequest<
|
10140 10034 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
10141 10035 | B,
|
10142 10036 | > for crate::input::NoInputAndOutputInput
|
10143 10037 | where
|
10144 10038 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
10145 10039 | B: 'static,
|
10146 10040 |
|
10147 10041 | B::Data: Send,
|
10148 10042 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
10149 10043 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
10150 10044 | {
|
10151 10045 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
10152 10046 | type Future = NoInputAndOutputInputFuture;
|
10153 10047 |
|
10154 10048 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
10155 10049 | let fut = async move {
|
10156 10050 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
10157 10051 | request.headers(),
|
10158 10052 | &CONTENT_TYPE_NOINPUTANDOUTPUT,
|
10159 10053 | ) {
|
10160 10054 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
10161 10055 | }
|
10162 10056 | crate::protocol_serde::shape_no_input_and_output::de_no_input_and_output_http_request(
|
10163 10057 | request,
|
10164 10058 | )
|
10165 10059 | .await
|
10166 - | .map_err(Into::into)
|
10167 10060 | };
|
10168 10061 | use ::futures_util::future::TryFutureExt;
|
10169 10062 | let fut = fut.map_err(
|
10170 10063 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
10171 10064 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
10172 10065 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
10173 10066 | e,
|
10174 10067 | )
|
10175 10068 | },
|
10176 10069 | );
|
10177 10070 | NoInputAndOutputInputFuture {
|
10178 10071 | inner: Box::pin(fut),
|
10179 10072 | }
|
10180 10073 | }
|
10181 10074 | }
|
10182 10075 | impl
|
10183 10076 | ::aws_smithy_http_server::response::IntoResponse<
|
10184 10077 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
10185 10078 | > for crate::output::NoInputAndOutputOutput
|
10186 10079 | {
|
10187 10080 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
10188 10081 | match crate::protocol_serde::shape_no_input_and_output::ser_no_input_and_output_http_response(self) {
|
10189 10082 | Ok(response) => response,
|
10190 10083 | Err(e) => {
|
10191 10084 | ::tracing::error!(error = %e, "failed to serialize response");
|
10192 10085 | ::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))
|
10193 10086 | }
|
10194 10087 | }
|
10195 10088 | }
|
10196 10089 | }
|
@@ -10240,10133 +10300,10192 @@
10240 10133 | this.inner.as_mut().poll(cx)
|
10241 10134 | }
|
10242 10135 | }
|
10243 10136 |
|
10244 10137 | impl<B>
|
10245 10138 | ::aws_smithy_http_server::request::FromRequest<
|
10246 10139 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
10247 10140 | B,
|
10248 10141 | > for crate::input::NoInputAndNoOutputInput
|
10249 10142 | where
|
10250 10143 | B: ::aws_smithy_http_server::body::HttpBody + Send,
|
10251 10144 | B: 'static,
|
10252 10145 |
|
10253 10146 | B::Data: Send,
|
10254 10147 | ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
|
10255 10148 | From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
|
10256 10149 | {
|
10257 10150 | type Rejection = ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError;
|
10258 10151 | type Future = NoInputAndNoOutputInputFuture;
|
10259 10152 |
|
10260 10153 | fn from_request(request: ::http::Request<B>) -> Self::Future {
|
10261 10154 | let fut = async move {
|
10262 10155 | if !::aws_smithy_http_server::protocol::accept_header_classifier(
|
10263 10156 | request.headers(),
|
10264 10157 | &CONTENT_TYPE_NOINPUTANDNOOUTPUT,
|
10265 10158 | ) {
|
10266 10159 | return Err(::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection::NotAcceptable);
|
10267 10160 | }
|
10268 10161 | crate::protocol_serde::shape_no_input_and_no_output::de_no_input_and_no_output_http_request(request)
|
10269 10162 | .await
|
10270 - | .map_err(Into::into)
|
10271 10163 | };
|
10272 10164 | use ::futures_util::future::TryFutureExt;
|
10273 10165 | let fut = fut.map_err(
|
10274 10166 | |e: ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection| {
|
10275 10167 | ::tracing::debug!(error = %e, "failed to deserialize request");
|
10276 10168 | ::aws_smithy_http_server::protocol::rest_json_1::runtime_error::RuntimeError::from(
|
10277 10169 | e,
|
10278 10170 | )
|
10279 10171 | },
|
10280 10172 | );
|
10281 10173 | NoInputAndNoOutputInputFuture {
|
10282 10174 | inner: Box::pin(fut),
|
10283 10175 | }
|
10284 10176 | }
|
10285 10177 | }
|
10286 10178 | impl
|
10287 10179 | ::aws_smithy_http_server::response::IntoResponse<
|
10288 10180 | ::aws_smithy_http_server::protocol::rest_json_1::RestJson1,
|
10289 10181 | > for crate::output::NoInputAndNoOutputOutput
|
10290 10182 | {
|
10291 10183 | fn into_response(self) -> ::aws_smithy_http_server::response::Response {
|
10292 10184 | match crate::protocol_serde::shape_no_input_and_no_output::ser_no_input_and_no_output_http_response(self) {
|
10293 10185 | Ok(response) => response,
|
10294 10186 | Err(e) => {
|
10295 10187 | ::tracing::error!(error = %e, "failed to serialize response");
|
10296 10188 | ::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))
|
10297 10189 | }
|
10298 10190 | }
|
10299 10191 | }
|
10300 10192 | }
|