Server Test

rev. ee474c7509d7728618c23068f3741e8e5b339ef9

Files changed:

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response-http0x/rust-server-codegen/src/sigv4_event_stream.rs

@@ -0,1 +0,325 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /// Receiver wrapper that handles SigV4 signed event stream messages
 #[derive(Debug)]
 pub struct SigV4Receiver<T, E> {
     inner: ::aws_smithy_legacy_http::event_stream::Receiver<
         crate::sigv4_event_stream::SignedEvent<T>,
         crate::sigv4_event_stream::SignedEventError<E>,
     >,
     initial_signature: ::std::option::Option<crate::sigv4_event_stream::SignatureInfo>,
-+
+}
-+
 impl<T, E> SigV4Receiver<T, E> {
     pub fn new(
         unmarshaller: impl ::aws_smithy_eventstream::frame::UnmarshallMessage<Output = T, Error = E>
             + ::std::marker::Send
             + ::std::marker::Sync
             + 'static,
         body: ::aws_smithy_types::body::SdkBody,
     ) -> Self {
         let sigv4_unmarshaller = crate::sigv4_event_stream::SigV4Unmarshaller::new(unmarshaller);
         Self {
             inner: ::aws_smithy_legacy_http::event_stream::Receiver::new(sigv4_unmarshaller, body),
             initial_signature: ::std::option::Option::None,
-+
+        }
-+
+    }
-+
     /// Get the signature from the initial message, if it was signed
     pub fn initial_signature(
         &self,
     ) -> ::std::option::Option<&crate::sigv4_event_stream::SignatureInfo> {
         self.initial_signature.as_ref()
-+
+    }
-+
     /// Try to receive an initial message of the given type.
     /// Handles SigV4-wrapped messages by extracting the inner message first.
     pub async fn try_recv_initial(
         &mut self,
         message_type: ::aws_smithy_legacy_http::event_stream::InitialMessageType,
     ) -> ::std::result::Result<
         ::std::option::Option<::aws_smithy_types::event_stream::Message>,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::sigv4_event_stream::SignedEventError<E>,
             ::aws_smithy_types::event_stream::RawMessage,
         >,
-+
+    >
     where
         E: std::error::Error + 'static,
-+
+    {
         let result = self
             .inner
             .try_recv_initial_with_preprocessor(message_type, |message| {
                 match crate::sigv4_event_stream::extract_signed_message(&message) {
                     ::std::result::Result::Ok(MaybeSignedMessage::Signed {
                         message: inner,
                         signature,
                     }) => {
                         ::std::result::Result::Ok((inner, ::std::option::Option::Some(signature)))
-+
+                    }
                     ::std::result::Result::Ok(MaybeSignedMessage::Unsigned) => {
                         ::std::result::Result::Ok((message, ::std::option::Option::None))
-+
+                    }
                     ::std::result::Result::Err(err) => ::std::result::Result::Err(
                         ::aws_smithy_runtime_api::client::result::ResponseError::builder()
                             .raw(::aws_smithy_types::event_stream::RawMessage::Decoded(
                                 message,
                             ))
                             .source(err)
                             .build(),
                     ),
-+
+                }
             })
             .await?;
         match result {
             ::std::option::Option::Some((message, signature)) => {
                 self.initial_signature = signature;
                 ::std::result::Result::Ok(::std::option::Option::Some(message))
-+
+            }
             ::std::option::Option::None => ::std::result::Result::Ok(::std::option::Option::None),
-+
+        }
-+
+    }
-+
     /// Receive the next event from the stream
     /// The SigV4Unmarshaller handles unwrapping, so we just pass through
     pub async fn recv(
         &mut self,
     ) -> ::std::result::Result<
         ::std::option::Option<crate::sigv4_event_stream::SignedEvent<T>>,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::sigv4_event_stream::SignedEventError<E>,
             ::aws_smithy_types::event_stream::RawMessage,
         >,
-+
+    >
     where
         E: std::error::Error + 'static,
-+
+    {
         self.inner.recv().await
-+
+    }
-+
+}
-+
 /// Wrapper for event stream messages that may be signed
 #[derive(Debug, Clone)]
 pub struct SignedEvent<T> {
     /// The actual event message
     pub message: T,
     /// Signature information if the message was signed
     pub signature: ::std::option::Option<crate::sigv4_event_stream::SignatureInfo>,
-+
+}
-+
 /// Error wrapper for signed event stream errors
 #[derive(Debug)]
 pub enum SignedEventError<E> {
     /// Error from the underlying event stream
     Event(E),
     /// Error extracting signed message
     InvalidSignedEvent(crate::sigv4_event_stream::ExtractionError),
-+
+}
-+
 impl<E> From<E> for SignedEventError<E> {
     fn from(err: E) -> Self {
         SignedEventError::Event(err)
-+
+    }
-+
+}
-+
 /// Information extracted from a signed event stream message
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct SignatureInfo {
     /// The chunk signature bytes from the `:chunk-signature` header
     pub chunk_signature: Vec<u8>,
     /// The timestamp from the `:date` header
     pub timestamp: ::std::time::SystemTime,
-+
+}
-+
 /// Unmarshaller wrapper that handles SigV4 signed event stream messages
 #[derive(Debug)]
 pub struct SigV4Unmarshaller<T> {
     inner: T,
-+
+}
-+
 impl<T> SigV4Unmarshaller<T> {
     pub fn new(inner: T) -> Self {
         Self { inner }
-+
+    }
-+
+}
-+
 impl<T> ::aws_smithy_eventstream::frame::UnmarshallMessage for SigV4Unmarshaller<T>
 where
     T: ::aws_smithy_eventstream::frame::UnmarshallMessage,
-+
+{
     type Output = crate::sigv4_event_stream::SignedEvent<T::Output>;
     type Error = crate::sigv4_event_stream::SignedEventError<T::Error>;
-+
     fn unmarshall(
         &self,
         message: &::aws_smithy_types::event_stream::Message,
     ) -> ::std::result::Result<
         ::aws_smithy_eventstream::frame::UnmarshalledMessage<Self::Output, Self::Error>,
         ::aws_smithy_eventstream::error::Error,
     > {
         // First, try to extract the signed message
         match crate::sigv4_event_stream::extract_signed_message(message) {
             ::std::result::Result::Ok(MaybeSignedMessage::Signed {
                 message: inner_message,
                 signature,
             }) => {
                 // Process the inner message with the base unmarshaller
                 match self.inner.unmarshall(&inner_message) {
                     ::std::result::Result::Ok(unmarshalled) => match unmarshalled {
                         ::aws_smithy_eventstream::frame::UnmarshalledMessage::Event(event) => {
                             ::std::result::Result::Ok(
                                 ::aws_smithy_eventstream::frame::UnmarshalledMessage::Event(
                                     crate::sigv4_event_stream::SignedEvent {
                                         message: event,
                                         signature: ::std::option::Option::Some(signature),
                                     },
                                 ),
-+
+                            )
-+
+                        }
                         ::aws_smithy_eventstream::frame::UnmarshalledMessage::Error(err) => {
                             ::std::result::Result::Ok(
                                 ::aws_smithy_eventstream::frame::UnmarshalledMessage::Error(
                                     crate::sigv4_event_stream::SignedEventError::Event(err),
                                 ),
-+
+                            )
-+
+                        }
                     },
                     ::std::result::Result::Err(err) => ::std::result::Result::Err(err),
-+
+                }
-+
+            }
             ::std::result::Result::Ok(MaybeSignedMessage::Unsigned) => {
                 // Process unsigned message directly
                 match self.inner.unmarshall(message) {
                     ::std::result::Result::Ok(unmarshalled) => match unmarshalled {
                         ::aws_smithy_eventstream::frame::UnmarshalledMessage::Event(event) => {
                             ::std::result::Result::Ok(
                                 ::aws_smithy_eventstream::frame::UnmarshalledMessage::Event(
                                     crate::sigv4_event_stream::SignedEvent {
                                         message: event,
                                         signature: ::std::option::Option::None,
                                     },
                                 ),
-+
+                            )
-+
+                        }
                         ::aws_smithy_eventstream::frame::UnmarshalledMessage::Error(err) => {
                             ::std::result::Result::Ok(
                                 ::aws_smithy_eventstream::frame::UnmarshalledMessage::Error(
                                     crate::sigv4_event_stream::SignedEventError::Event(err),
                                 ),
-+
+                            )
-+
+                        }
                     },
                     ::std::result::Result::Err(err) => ::std::result::Result::Err(err),
-+
+                }
-+
+            }
             ::std::result::Result::Err(extraction_err) => ::std::result::Result::Ok(
                 ::aws_smithy_eventstream::frame::UnmarshalledMessage::Error(
                     crate::sigv4_event_stream::SignedEventError::InvalidSignedEvent(extraction_err),
                 ),
             ),
-+
+        }
-+
+    }
-+
+}
-+
 /// Result of extracting a potentially signed message
 #[derive(Debug)]
 pub enum MaybeSignedMessage {
     /// Message was signed and has been extracted
     Signed {
         /// The inner message that was signed
         message: ::aws_smithy_types::event_stream::Message,
         /// Signature information from the outer message
         signature: crate::sigv4_event_stream::SignatureInfo,
     },
     /// Message was not signed (no `:chunk-signature` header present)
     Unsigned,
-+
+}
-+
 /// Extracts the inner message from a potentially signed event stream message.
 pub fn extract_signed_message(
     message: &::aws_smithy_types::event_stream::Message,
 ) -> ::std::result::Result<MaybeSignedMessage, crate::sigv4_event_stream::ExtractionError> {
     // Check if message has chunk signature
     let mut chunk_signature = None;
     let mut timestamp = None;
-+
     for header in message.headers() {
         match header.name().as_str() {
             ":chunk-signature" => {
                 if let ::aws_smithy_types::event_stream::HeaderValue::ByteArray(bytes) =
                     header.value()
-+
+                {
                     chunk_signature = Some(bytes.as_ref().to_vec());
-+
+                }
-+
+            }
             ":date" => {
                 if let ::aws_smithy_types::event_stream::HeaderValue::Timestamp(ts) = header.value()
-+
+                {
                     timestamp = Some(::std::time::SystemTime::try_from(*ts).map_err(|_err| {
                         crate::sigv4_event_stream::ExtractionError::InvalidTimestamp
                     })?);
                 } else {
                     return Err(crate::sigv4_event_stream::ExtractionError::InvalidTimestamp);
-+
+                }
-+
+            }
             _ => {}
-+
+        }
-+
+    }
-+
     let Some(chunk_signature) = chunk_signature else {
         return Ok(MaybeSignedMessage::Unsigned);
     };
-+
     let Some(timestamp) = timestamp else {
         return Err(crate::sigv4_event_stream::ExtractionError::InvalidTimestamp);
     };
-+
     // Extract inner message
     let cursor = ::std::io::Cursor::new(message.payload());
     let inner_message = ::aws_smithy_eventstream::frame::read_message_from(cursor)
         .map_err(|err| crate::sigv4_event_stream::ExtractionError::InvalidPayload { error: err })?;
-+
     Ok(MaybeSignedMessage::Signed {
         message: inner_message,
         signature: crate::sigv4_event_stream::SignatureInfo {
             chunk_signature,
             timestamp,
         },
     })
-+
+}
-+
 /// Error type for signed message extraction operations
 #[non_exhaustive]
 #[derive(Debug)]
 pub enum ExtractionError {
     /// The payload could not be decoded as a valid message
     #[non_exhaustive]
     InvalidPayload {
         error: ::aws_smithy_eventstream::error::Error,
     },
     /// The timestamp header is missing or has an invalid format
     #[non_exhaustive]
     InvalidTimestamp,
-+
+}
-+
 impl ::std::fmt::Display for ExtractionError {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match self {
             ExtractionError::InvalidPayload { error } => {
                 write!(f, "invalid payload: {}", error)
-+
+            }
             ExtractionError::InvalidTimestamp => {
                 write!(f, "invalid or missing timestamp header")
-+
+            }
-+
+        }
-+
+    }
-+
+}
-+
 impl ::std::error::Error for ExtractionError {
     fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
         match self {
             ExtractionError::InvalidPayload { error } => ::std::option::Option::Some(error),
             ExtractionError::InvalidTimestamp => ::std::option::Option::None,
-+
+        }
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response-http0x/rust-server-codegen/src/types.rs

@@ -0,1 +0,5 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 pub use ::aws_smithy_types::date_time::Format as DateTimeFormat;
 pub use ::aws_smithy_types::error::display::DisplayErrorContext;
 pub use ::aws_smithy_types::Blob;
 pub use ::aws_smithy_types::DateTime;

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response-http0x/rust-server-codegen/src/unconstrained.rs

@@ -0,1 +0,188 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-+
 impl crate::constrained::Constrained for crate::model::ComplexUnion {
     type Unconstrained =
         crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained;
-+
+}
-+
 impl From<crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained>
     for crate::constrained::MaybeConstrained<crate::model::ComplexUnion>
-+
+{
     fn from(
         value: crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained,
     ) -> Self {
         Self::Unconstrained(value)
-+
+    }
-+
+}
-+
 pub(crate) mod complex_union_unconstrained {
-+
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, Clone)]
     pub(crate) enum ComplexUnionUnconstrained {
         ComplexStruct(crate::model::complex_struct::Builder),
         List(::std::vec::Vec<::std::string::String>),
         Map(::std::collections::HashMap<::std::string::String, i32>),
         Structure(crate::model::simple_struct::Builder),
         Union(crate::model::SimpleUnion),
-+
+    }
     impl ::std::convert::TryFrom<ComplexUnionUnconstrained> for crate::model::ComplexUnion {
         type Error = crate::model::complex_union::ConstraintViolation;
-+
         fn try_from(value: ComplexUnionUnconstrained) -> ::std::result::Result<Self, Self::Error> {
             Ok(
         match value {
             crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::ComplexStruct(unconstrained) => Self::ComplexStruct(
                 unconstrained
                                         .try_into()
-+
-+
                                         .map_err(Self::Error::ComplexStruct)?
             ),
             crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::List(unconstrained) => Self::List(
                 unconstrained
             ),
             crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::Map(unconstrained) => Self::Map(
                 unconstrained
             ),
             crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::Structure(unconstrained) => Self::Structure(
                 unconstrained
                                         .try_into()
-+
-+
                                         .map_err(Self::Error::Structure)?
             ),
             crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained::Union(unconstrained) => Self::Union(
                 unconstrained
             ),
-+
+        }
-+
+    )
-+
+        }
-+
+    }
-+
+}
 pub(crate) mod complex_map_unconstrained {
-+
     #[derive(Debug, Clone)]
     pub(crate) struct ComplexMapUnconstrained(
         pub(crate)  std::collections::HashMap<
             ::std::string::String,
             crate::unconstrained::complex_union_unconstrained::ComplexUnionUnconstrained,
         >,
     );
-+
     impl From<ComplexMapUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::complex_map_constrained::ComplexMapConstrained,
-+
+        >
-+
+    {
         fn from(value: ComplexMapUnconstrained) -> Self {
             Self::Unconstrained(value)
-+
+        }
-+
+    }
     impl std::convert::TryFrom<ComplexMapUnconstrained>
         for crate::constrained::complex_map_constrained::ComplexMapConstrained
-+
+    {
         type Error = crate::model::complex_map::ConstraintViolation;
         fn try_from(value: ComplexMapUnconstrained) -> std::result::Result<Self, Self::Error> {
             let res: ::std::result::Result<
                 ::std::collections::HashMap<::std::string::String, crate::model::ComplexUnion>,
                 Self::Error,
             > = value
                 .0
                 .into_iter()
                 .map(
                     |(k, v)| match crate::model::ComplexUnion::try_from(v).map_err(Box::new) {
                         Ok(v) => Ok((k, v)),
                         Err(inner_constraint_violation) => {
                             Err(Self::Error::Value(k, inner_constraint_violation))
-+
+                        }
                     },
-+
+                )
                 .collect();
             let hm = res?;
             Ok(Self(hm))
-+
+        }
-+
+    }
-+
+}
 pub(crate) mod complex_list_unconstrained {
-+
     #[derive(Debug, Clone)]
     pub(crate) struct ComplexListUnconstrained(
         pub(crate)
             std::vec::Vec<crate::unconstrained::complex_map_unconstrained::ComplexMapUnconstrained>,
     );
-+
     impl From<ComplexListUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::complex_list_constrained::ComplexListConstrained,
-+
+        >
-+
+    {
         fn from(value: ComplexListUnconstrained) -> Self {
             Self::Unconstrained(value)
-+
+        }
-+
+    }
     impl std::convert::TryFrom<ComplexListUnconstrained>
         for crate::constrained::complex_list_constrained::ComplexListConstrained
-+
+    {
         type Error = crate::model::complex_list::ConstraintViolation;
         fn try_from(value: ComplexListUnconstrained) -> std::result::Result<Self, Self::Error> {
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::constrained::complex_map_constrained::ComplexMapConstrained>,
                 (usize, crate::model::complex_map::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner = res
                 .map_err(|(idx, inner_violation)| (idx, Box::new(inner_violation)))
                 .map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             Ok(Self(inner))
-+
+        }
-+
+    }
-+
+}
 pub(crate) mod struct_list_unconstrained {
-+
     #[derive(Debug, Clone)]
     pub(crate) struct StructListUnconstrained(
         pub(crate) std::vec::Vec<crate::model::simple_struct::Builder>,
     );
-+
     impl From<StructListUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::struct_list_constrained::StructListConstrained,
-+
+        >
-+
+    {
         fn from(value: StructListUnconstrained) -> Self {
             Self::Unconstrained(value)
-+
+        }
-+
+    }
     impl std::convert::TryFrom<StructListUnconstrained>
         for crate::constrained::struct_list_constrained::StructListConstrained
-+
+    {
         type Error = crate::model::struct_list::ConstraintViolation;
         fn try_from(value: StructListUnconstrained) -> std::result::Result<Self, Self::Error> {
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::SimpleStruct>,
                 (usize, crate::model::simple_struct::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             Ok(Self(inner))
-+
+        }
-+
+    }
-+
+}

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/Cargo.toml

@@ -1,1 +60,66 @@

↥ Expand context

 # Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 [package]
 name = "rpcv2cbor_extras_no_initial_response"
 version = "0.0.1"
 authors = ["protocoltest@example.com"]
 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"
 protocol = "smithy.protocols#rpcv2Cbor"
 [dependencies.aws-smithy-cbor]

 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-cbor"
 [dependencies.aws-smithy-eventstream]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-eventstream"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 features = ["event-stream"]
 [dependencies.aws-smithy-http-server]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server"
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 features = ["client", "http-02x"]
 features = ["http-1x", "client"]
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 features = ["http-body-1-x"]
 [dependencies.bytes]
 version = "1.4.0"
 [dependencies.futures-util]
 version = "0.3"
 [dependencies.http]
 version = "0.2.9"
 [dependencies.hyper]
 version = "0.14.26"
 [dependencies.http-1x]
 version = "1"
 package = "http"
 [dependencies.http-body-1x]
 version = "1"
 package = "http-body"
 [dependencies.http-body-util]
 version = "0.1.3"
 [dependencies.mime]
 version = "0.3"
 [dependencies.pin-project-lite]
 version = "0.2"
 [dependencies.tower]
 version = "0.4"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.aws-smithy-protocol-test]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-protocol-test"
 [dev-dependencies.bytes]
 version = "1.4.0"
 features = ["http-1x"]
 [dev-dependencies.hyper]
 version = "0.14.12"
 version = "1"
 [dev-dependencies.pretty_assertions]
 version = "1.3.0"
 [dev-dependencies.tokio]
 version = "1.23.1"
 features = ["macros", "test-util", "rt-multi-thread"]
 [dev-dependencies.tracing-test]
 version = "0.2.5"
 features = ["no-env-filter"]
 [features]
 rt-tokio = ["aws-smithy-types/rt-tokio"]

↧ Expand context

 aws-lambda = ["aws-smithy-http-server/aws-lambda"]
 request-id = ["aws-smithy-http-server/request-id"]
 default = ["rt-tokio", "request-id"]
-65
-66

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/src/lib.rs

@@ -19,19 +128,131 @@

↥ Expand context

 #![allow(rustdoc::invalid_html_tags)]
 #![forbid(unsafe_code)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 //! rpcv2cbor_extras_no_initial_response
-23
 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 //! A fast and customizable Rust implementation of the RpcV2CborService Smithy service.
 //!
 //! # Using RpcV2CborService
 //!
 //! The primary entrypoint is [`RpcV2CborService`]: it satisfies the [`Service<http::Request, Response = http::Response>`](::tower::Service)
 //! trait and therefore can be handed to a [`hyper` server](https://github.com/hyperium/hyper) via [`RpcV2CborService::into_make_service`]
 //! or used in AWS Lambda
 #![cfg_attr(
     feature = "aws-lambda",
     doc = " via [`LambdaHandler`](crate::server::routing::LambdaHandler)."
 )]
 #![cfg_attr(
     not(feature = "aws-lambda"),
     doc = " by enabling the `aws-lambda` feature flag and utilizing the `LambdaHandler`."

 )]
 //! The [`crate::input`], [`crate::output`], and [`crate::error`]
 //! modules provide the types used in each operation.
 //!
 //! ### Running on Hyper
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;
 //! # async fn dummy() {
 //! use rpcv2cbor_extras_no_initial_response::{RpcV2CborService, RpcV2CborServiceConfig};
 //! use rpcv2cbor_extras_no_initial_response::serve;
 //! use ::tokio::net::TcpListener;
 //!
 //! # let app = RpcV2CborService::builder(
 //! #     RpcV2CborServiceConfig::builder()
 //! #         .build()
 //! # ).build_unchecked();
 //! let server = app.into_make_service();
 //! let bind: SocketAddr = "127.0.0.1:6969".parse()
 //!     .expect("unable to parse the server bind address and port");
 //! ::hyper::Server::bind(&bind).serve(server).await.unwrap();
 //! let listener = TcpListener::bind(bind).await
 //!     .expect("failed to bind TCP listener");
 //! serve(listener, app.into_make_service()).await.unwrap();
 //! # }
 //! ```
 //!
 //! ### Running on Lambda
 //!
 //! ```rust,ignore
 //! use rpcv2cbor_extras_no_initial_response::server::routing::LambdaHandler;
 //! use rpcv2cbor_extras_no_initial_response::RpcV2CborService;
 //!
 //! # async fn dummy() {
 //! # let app = RpcV2CborService::builder(
 //! #     RpcV2CborServiceConfig::builder()
 //! #         .build()
 //! # ).build_unchecked();
 //! let handler = LambdaHandler::new(app);
 //! lambda_http::run(handler).await.unwrap();
 //! # }
 //! ```
 //!
 //! # Building the RpcV2CborService
 //!
 //! To construct [`RpcV2CborService`] we use [`RpcV2CborServiceBuilder`] returned by [`RpcV2CborService::builder`].
 //!
 //! ## Plugins
 //!
 //! The [`RpcV2CborService::builder`] method, returning [`RpcV2CborServiceBuilder`],
 //! accepts a config object on which plugins can be registered.
 //! Plugins allow you to build middleware which is aware of the operation it is being applied to.
 //!
 //! ```rust,no_run
 //! # use rpcv2cbor_extras_no_initial_response::server::plugin::IdentityPlugin as LoggingPlugin;
 //! # use rpcv2cbor_extras_no_initial_response::server::plugin::IdentityPlugin as MetricsPlugin;
 //! # use ::hyper::Body;
 //! # use ::hyper::body::Incoming;
 //! use rpcv2cbor_extras_no_initial_response::server::plugin::HttpPlugins;
 //! use rpcv2cbor_extras_no_initial_response::{RpcV2CborService, RpcV2CborServiceConfig, RpcV2CborServiceBuilder};
 //!
 //! let http_plugins = HttpPlugins::new()
 //!         .push(LoggingPlugin)
 //!         .push(MetricsPlugin);
 //! let config = RpcV2CborServiceConfig::builder().build();
 //! let builder: RpcV2CborServiceBuilder<Body, _, _, _> = RpcV2CborService::builder(config);
 //! let builder: RpcV2CborServiceBuilder<::hyper::body::Incoming, _, _, _> = RpcV2CborService::builder(config);
 //! ```
 //!
 //! Check out [`crate::server::plugin`] to learn more about plugins.
 //!
 //! ## Handlers
 //!
 //! [`RpcV2CborServiceBuilder`] provides a setter method for each operation in your Smithy model. The setter methods expect an async function as input, matching the signature for the corresponding operation in your Smithy model.
 //! We call these async functions **handlers**. This is where your application business logic lives.
 //!
 //! Every handler must take an `Input`, and optional [`extractor arguments`](crate::server::request), while returning:

↧ Expand context

 //!
 //! * A `Result<Output, Error>` if your operation has modeled errors, or
 //! * An `Output` otherwise.
 //!
 //! ```rust,no_run
 //! # struct Input;
 //! # struct Output;
 //! # struct Error;
 //! async fn infallible_handler(input: Input) -> Output { todo!() }
 //!
 //! async fn fallible_handler(input: Input) -> Result<Output, Error> { todo!() }
 //! ```
 //!
 //! Handlers can accept up to 8 extractors:
 //!
 //! ```rust,no_run
 //! # struct Input;
 //! # struct Output;
 //! # struct Error;
 //! # struct State;

@@ -135,138 +273,280 @@

↥ Expand context

 //!
 //! async fn handler_with_one_extractor(input: Input, ext: Extension<State>) -> Output {
 //!     todo!()
 //! }
 //!
 //! async fn handler_with_two_extractors(
 //!     input: Input,
 //!     ext0: Extension<State>,
 //!     ext1: ConnectInfo<SocketAddr>,
 //! ) -> Output {
 //!     todo!()
 //! }
 //! ```
 //!
 //! See the [`operation module`](crate::operation) for information on precisely what constitutes a handler.
 //!
 //! ## Build
 //!
 //! You can convert [`RpcV2CborServiceBuilder`] into [`RpcV2CborService`] using either [`RpcV2CborServiceBuilder::build`] or [`RpcV2CborServiceBuilder::build_unchecked`].
 //!

 //! [`RpcV2CborServiceBuilder::build`] requires you to provide a handler for every single operation in your Smithy model. It will return an error if that is not the case.
 //!
 //! [`RpcV2CborServiceBuilder::build_unchecked`], instead, does not require exhaustiveness. The server will automatically return 500 Internal Server Error to all requests for operations that do not have a registered handler.
 //! [`RpcV2CborServiceBuilder::build_unchecked`] is particularly useful if you are deploying your Smithy service as a collection of Lambda functions, where each Lambda is only responsible for a subset of the operations in the Smithy service (or even a single one!).
 //!
 //! # Example
 //!
 //! ```rust,no_run
 //! # use std::net::SocketAddr;
 //! use rpcv2cbor_extras_no_initial_response::{RpcV2CborService, RpcV2CborServiceConfig};
 //! use rpcv2cbor_extras_no_initial_response::serve;
 //! use ::tokio::net::TcpListener;
 //!
 //! #[::tokio::main]
 //! pub async fn main() {
 //!    let config = RpcV2CborServiceConfig::builder().build();
 //!    let app = RpcV2CborService::builder(config)
 //!        .complex_struct_operation(complex_struct_operation)
 //!        .empty_struct_operation(empty_struct_operation)
 //!        .error_serialization_operation(error_serialization_operation)
 //!        .recursive_union_operation(recursive_union_operation)
 //!        .simple_struct_operation(simple_struct_operation)
 //!        .single_member_struct_operation(single_member_struct_operation)
 //!        .streaming_operation(streaming_operation)
 //!        .streaming_operation_with_initial_data(streaming_operation_with_initial_data)
 //!        .streaming_operation_with_initial_response(streaming_operation_with_initial_response)
 //!        .streaming_operation_with_optional_data(streaming_operation_with_optional_data)
 //!        .build()
 //!        .expect("failed to build an instance of RpcV2CborService");
 //!
 //!    let bind: SocketAddr = "127.0.0.1:6969".parse()
 //!        .expect("unable to parse the server bind address and port");
 //!    let server = ::hyper::Server::bind(&bind).serve(app.into_make_service());
 //!    let listener = TcpListener::bind(bind).await
 //!        .expect("failed to bind TCP listener");
 //!    # let server = async { Ok::<_, ()>(()) };
 //!
 //!    // Run your service!
 //!    if let Err(err) = server.await {
 //!    if let Err(err) = serve(listener, app.into_make_service()).await {
 //!        eprintln!("server error: {:?}", err);
 //!    }
 //! }
 //!
 //! use rpcv2cbor_extras_no_initial_response::{input, output, error};
 //!
 //! async fn complex_struct_operation(input: input::ComplexStructOperationInput) -> Result<output::ComplexStructOperationOutput, error::ComplexStructOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn empty_struct_operation(input: input::EmptyStructOperationInput) -> output::EmptyStructOperationOutput {
 //!     todo!()
 //! }
 //!
 //! async fn error_serialization_operation(input: input::ErrorSerializationOperationInput) -> Result<output::ErrorSerializationOperationOutput, error::ErrorSerializationOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn recursive_union_operation(input: input::RecursiveUnionOperationInput) -> output::RecursiveUnionOperationOutput {
 //!     todo!()
 //! }
 //!
 //! async fn simple_struct_operation(input: input::SimpleStructOperationInput) -> Result<output::SimpleStructOperationOutput, error::SimpleStructOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn single_member_struct_operation(input: input::SingleMemberStructOperationInput) -> output::SingleMemberStructOperationOutput {
 //!     todo!()
 //! }
 //!
 //! async fn streaming_operation(input: input::StreamingOperationInput) -> Result<output::StreamingOperationOutput, error::StreamingOperationError> {
 //!     todo!()
 //! }
 //!
 //! async fn streaming_operation_with_initial_data(input: input::StreamingOperationWithInitialDataInput) -> Result<output::StreamingOperationWithInitialDataOutput, error::StreamingOperationWithInitialDataError> {
 //!     todo!()
 //! }
 //!
 //! async fn streaming_operation_with_initial_response(input: input::StreamingOperationWithInitialResponseInput) -> Result<output::StreamingOperationWithInitialResponseOutput, error::StreamingOperationWithInitialResponseError> {
 //!     todo!()
 //! }
 //!
 //! async fn streaming_operation_with_optional_data(input: input::StreamingOperationWithOptionalDataInput) -> Result<output::StreamingOperationWithOptionalDataOutput, error::StreamingOperationWithOptionalDataError> {
 //!     todo!()
 //! }
 //!
 //! ```
 //!
 //! [`serve`]: https://docs.rs/hyper/0.14.16/hyper/server/struct.Builder.html#method.serve
 //! [`serve`]: crate::serve
 //! [hyper server]: https://docs.rs/hyper/latest/hyper/server/index.html
 //! [`tower::make::MakeService`]: https://docs.rs/tower/latest/tower/make/trait.MakeService.html
 //! [HTTP binding traits]: https://smithy.io/2.0/spec/http-bindings.html
 //! [operations]: https://smithy.io/2.0/spec/service-types.html#operation
 //! [hyper server]: https://docs.rs/hyper/latest/hyper/server/index.html
 //! [Service]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html
 pub use crate::server::serve::serve;
 pub use crate::service::{
     MissingOperationsError, RpcV2CborService, RpcV2CborServiceBuilder, RpcV2CborServiceConfig,
     RpcV2CborServiceConfigBuilder,
 };
-255
 /// Contains the types that are re-exported from the `aws-smithy-http-server` crate.
 pub mod server {
     // Re-export all types from the `aws-smithy-http-server` crate.
     pub use ::aws_smithy_http_server::*;
-260
+}

↧ Expand context

-261
 /// Crate version number.
 pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");
-264
 /// Constrained types for constrained shapes.
 mod constrained;
-267
 /// All error types that operations can return. Documentation on these types is copied from the model.
 pub mod error;
-270
 /// Input structures for operations. Documentation on these types is copied from the model.
 pub mod input;
-273
 /// Data structures used by operation inputs/outputs. Documentation on these types is copied from the model.
 pub mod model;
-276
 /// All operations that this crate can perform.
 pub mod operation;
-279
 /// A collection of types representing each operation defined in the service closure.

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

@@ -4,4 +72,77 @@

↥ Expand context

     /// [`StreamingOperationWithOptionalDataInput`](crate::input::StreamingOperationWithOptionalDataInput) using modelled bindings.
     pub struct StreamingOperationWithOptionalDataInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingOperationWithOptionalDataInput, ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError>> + Send>>
-7
+    }
-8
+}
-9
 impl std::future::Future for StreamingOperationWithOptionalDataInputFuture {
     type Output = Result<
         crate::input::StreamingOperationWithOptionalDataInput,
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError,
     >;
-15
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-22
+    }
-23
+}

-24
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::StreamingOperationWithOptionalDataInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-33
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B: ::http_body_1x::Body<Data = ::bytes::Bytes>
         + ::std::marker::Send
         + ::std::marker::Sync
         + 'static,
     B::Error: Into<::aws_smithy_types::body::Error> + 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-43
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = StreamingOperationWithOptionalDataInputFuture;
-46
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_VND_AMAZON_EVENTSTREAM,
             ) && !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_CBOR,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-57
+            }

↧ Expand context

             crate::protocol_serde::shape_streaming_operation_with_optional_data::de_streaming_operation_with_optional_data_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-67
+                )
             },
         );
         StreamingOperationWithOptionalDataInputFuture {
             inner: Box::pin(fut),
-72
+        }
-73
+    }
-74
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,

@@ -106,111 +174,184 @@

↥ Expand context

     /// [`StreamingOperationWithInitialResponseInput`](crate::input::StreamingOperationWithInitialResponseInput) using modelled bindings.
     pub struct StreamingOperationWithInitialResponseInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingOperationWithInitialResponseInput, ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError>> + Send>>
-114
+    }
-115
+}
-116
 impl std::future::Future for StreamingOperationWithInitialResponseInputFuture {
     type Output = Result<
         crate::input::StreamingOperationWithInitialResponseInput,
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError,
     >;
-122
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-129
+    }
-130
+}

-131
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::StreamingOperationWithInitialResponseInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-140
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B: ::http_body_1x::Body<Data = ::bytes::Bytes>
         + ::std::marker::Send
         + ::std::marker::Sync
         + 'static,
     B::Error: Into<::aws_smithy_types::body::Error> + 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-150
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = StreamingOperationWithInitialResponseInputFuture;
-153
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_VND_AMAZON_EVENTSTREAM,
             ) && !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_CBOR,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-164
+            }

↧ Expand context

             crate::protocol_serde::shape_streaming_operation_with_initial_response::de_streaming_operation_with_initial_response_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-174
+                )
             },
         );
         StreamingOperationWithInitialResponseInputFuture {
             inner: Box::pin(fut),
-179
+        }
-180
+    }
-181
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,

@@ -208,218 +276,291 @@

↥ Expand context

     /// [`StreamingOperationWithInitialDataInput`](crate::input::StreamingOperationWithInitialDataInput) using modelled bindings.
     pub struct StreamingOperationWithInitialDataInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingOperationWithInitialDataInput, ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError>> + Send>>
-221
+    }
-222
+}
-223
 impl std::future::Future for StreamingOperationWithInitialDataInputFuture {
     type Output = Result<
         crate::input::StreamingOperationWithInitialDataInput,
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError,
     >;
-229
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-236
+    }
-237
+}

-238
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::StreamingOperationWithInitialDataInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-247
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B: ::http_body_1x::Body<Data = ::bytes::Bytes>
         + ::std::marker::Send
         + ::std::marker::Sync
         + 'static,
     B::Error: Into<::aws_smithy_types::body::Error> + 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-257
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = StreamingOperationWithInitialDataInputFuture;
-260
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_VND_AMAZON_EVENTSTREAM,
             ) && !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_CBOR,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-271
+            }

↧ Expand context

             crate::protocol_serde::shape_streaming_operation_with_initial_data::de_streaming_operation_with_initial_data_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-281
+                )
             },
         );
         StreamingOperationWithInitialDataInputFuture {
             inner: Box::pin(fut),
-286
+        }
-287
+    }
-288
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,

@@ -310,325 +378,398 @@

↥ Expand context

     /// [`StreamingOperationInput`](crate::input::StreamingOperationInput) using modelled bindings.
     pub struct StreamingOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::StreamingOperationInput, ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError>> + Send>>
-328
+    }
-329
+}
-330
 impl std::future::Future for StreamingOperationInputFuture {
     type Output = Result<
         crate::input::StreamingOperationInput,
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError,
     >;
-336
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-343
+    }
-344
+}

-345
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::StreamingOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-354
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B: ::http_body_1x::Body<Data = ::bytes::Bytes>
         + ::std::marker::Send
         + ::std::marker::Sync
         + 'static,
     B::Error: Into<::aws_smithy_types::body::Error> + 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-364
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = StreamingOperationInputFuture;
-367
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_VND_AMAZON_EVENTSTREAM,
             ) && !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_CBOR,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-378
+            }

↧ Expand context

             crate::protocol_serde::shape_streaming_operation::de_streaming_operation_http_request(
                 request,
-381
+            )
             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-390
+                )
             },
         );
         StreamingOperationInputFuture {
             inner: Box::pin(fut),
-395
+        }
-396
+    }
-397
+}
 impl

@@ -425,445 +485,505 @@

↥ Expand context

     type Output = Result<
         crate::input::RecursiveUnionOperationInput,
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError,
     >;
-449
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-456
+    }
-457
+}
-458
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::RecursiveUnionOperationInput
 where

     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-467
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-471
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = RecursiveUnionOperationInputFuture;
-474
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_CBOR,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-482
+            }
             crate::protocol_serde::shape_recursive_union_operation::de_recursive_union_operation_http_request(request)
                             .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-492
+                )
             },
         );
         RecursiveUnionOperationInputFuture {
             inner: Box::pin(fut),
-497
+        }
-498
+    }
-499
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::RecursiveUnionOperationOutput
-504
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -594,614 +988,1024 @@

↥ Expand context

                                                         ::std::option::Option::Some(
                                                             ::std::boxed::Box::new(
                                                                 crate::model::RecursiveOperationInputOutputNested2 {
                                                                     bar:
                                                                         ::std::option::Option::Some(
                                                                             "Bar2".to_owned()
-620
+                                                                        )
-621
+                                                                    ,
                                                                     recursive_member:
                                                                         ::std::option::Option::None
-624
+                                                                    ,
-625
+                                                                }
-626
+                                                            )
-627
+                                                        )
-628
+                                                    ,
-629
+                                                }
-630
+                                            )
-631
+                                        ,
-632
+                                    }
-633
+                                )

-634
+                            )
-635
+                        ,
-636
+                    }
-637
+                )
-638
+            ,
-639
+        }
-640
+        ;
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(&body, "v2ZuZXN0ZWS/Y2Zvb2RGb28xZ3ZhcmlhbnS/Z2Nob2ljZTFrT3V0ZXJDaG9pY2X/Zm5lc3RlZL9jYmFyZEJhcjFvcmVjdXJzaXZlTWVtYmVyv2Nmb29kRm9vMmd2YXJpYW50v2djaG9pY2Uyv2Nmb29kRm9vM2ZuZXN0ZWS/Y2JhcmRCYXIzb3JlY3Vyc2l2ZU1lbWJlcr9jZm9vZEZvbzRndmFyaWFudL9nY2hvaWNlMWtJbm5lckNob2ljZf//////Zm5lc3RlZL9jYmFyZEJhcjL//////w==", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
         );
-665
+    }
-666
+}
-667
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`SingleMemberStructOperationInput`](crate::input::SingleMemberStructOperationInput) using modelled bindings.
     pub struct SingleMemberStructOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SingleMemberStructOperationInput, ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError>> + Send>>
-673
+    }
-674
+}
-675
 impl std::future::Future for SingleMemberStructOperationInputFuture {
     type Output = Result<
         crate::input::SingleMemberStructOperationInput,
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError,
     >;
-681
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-688
+    }
-689
+}
-690
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::SingleMemberStructOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-699
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-703
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = SingleMemberStructOperationInputFuture;
-706
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_CBOR,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-714
+            }
             crate::protocol_serde::shape_single_member_struct_operation::de_single_member_struct_operation_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-724
+                )
             },
         );
         SingleMemberStructOperationInputFuture {
             inner: Box::pin(fut),
-729
+        }
-730
+    }
-731
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::SingleMemberStructOperationOutput
-736
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_single_member_struct_operation::ser_single_member_struct_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-743
+                        }
-744
+                    }
-745
+    }
-746
+}
-747
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod single_member_struct_operation_test {
-751
     /// When additional tokens are found past where we expect the end of the body,
     /// the request should be rejected with a serialization exception.
     /// Test ID: AdditionalTokensSingleMemberStruct
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn additional_tokens_single_member_struct_malformed_request() {
-758
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/service/RpcV2CborService/operation/SingleMemberStructOperation")
                 .method("POST")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .header("Accept", "application/cbor")
                 .header("Content-Type", "application/cbor")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "v/+//w==".as_bytes(),
                         ::aws_smithy_protocol_test::MediaType::from("unknown"),
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(
                             "v/+//w==".as_bytes(),
                             ::aws_smithy_protocol_test::MediaType::from("unknown"),
                         ),
                     )),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RpcV2CborServiceConfig::builder().build();
             let service = crate::service::RpcV2CborService::builder::<::hyper::body::Body, _, _, _>(config)
             let service = crate::service::RpcV2CborService::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .single_member_struct_operation(move |input: crate::input::SingleMemberStructOperationInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::SingleMemberStructOperationOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-785
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 ::http_1x::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let body = ::hyper::body::to_bytes(http_response.into_body())
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .expect("unable to extract body to bytes");
                 .expect("unable to collect body")
                 .to_bytes();
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
                 &body,
                 "oA==",
                 ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
             ));
-807
+        }
-808
+    }
-809
+}
-810
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`EmptyStructOperationInput`](crate::input::EmptyStructOperationInput) using modelled bindings.
     pub struct EmptyStructOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::EmptyStructOperationInput, ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError>> + Send>>
-816
+    }
-817
+}
-818
 impl std::future::Future for EmptyStructOperationInputFuture {
     type Output = Result<
         crate::input::EmptyStructOperationInput,
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError,
     >;
-824
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-831
+    }
-832
+}
-833
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::EmptyStructOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-842
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-846
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = EmptyStructOperationInputFuture;
-849
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_CBOR,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-857
+            }
             crate::protocol_serde::shape_empty_struct_operation::de_empty_struct_operation_http_request(request)
                             .await
         };
         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-867
+                )
             },
         );
         EmptyStructOperationInputFuture {
             inner: Box::pin(fut),
-872
+        }
-873
+    }
-874
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::EmptyStructOperationOutput
-879
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {
         match crate::protocol_serde::shape_empty_struct_operation::ser_empty_struct_operation_http_response(self) {
                         Ok(response) => response,
                         Err(e) => {
                             ::tracing::error!(error = %e, "failed to serialize response");
                             ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-886
+                        }
-887
+                    }
-888
+    }
-889
+}
-890
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod empty_struct_operation_test {
-894
     /// When additional tokens are found past where we expect the end of the body,
     /// the request should be rejected with a serialization exception.
     /// Test ID: AdditionalTokensEmptyStruct
     #[::tokio::test]
     #[::tracing_test::traced_test]
     #[should_panic]
     async fn additional_tokens_empty_struct_malformed_request() {
-902
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/service/RpcV2CborService/operation/EmptyStructOperation")
                 .method("POST")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .header("Accept", "application/cbor")
                 .header("Content-Type", "application/cbor")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "v/+//w==".as_bytes(),
                         ::aws_smithy_protocol_test::MediaType::from("unknown"),
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(
                             "v/+//w==".as_bytes(),
                             ::aws_smithy_protocol_test::MediaType::from("unknown"),
                         ),
                     )),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RpcV2CborServiceConfig::builder().build();
             let service = crate::service::RpcV2CborService::builder::<::hyper::body::Body, _, _, _>(config)
             let service = crate::service::RpcV2CborService::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .empty_struct_operation(move |input: crate::input::EmptyStructOperationInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as crate::output::EmptyStructOperationOutput };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-929
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 ::http_1x::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let body = ::hyper::body::to_bytes(http_response.into_body())
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .expect("unable to extract body to bytes");
                 .expect("unable to collect body")
                 .to_bytes();
             ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_body(
                 &body,
                 "oA==",
                 ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
             ));
-951
+        }
-952
+    }
-953
+}
-954
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`ComplexStructOperationInput`](crate::input::ComplexStructOperationInput) using modelled bindings.
     pub struct ComplexStructOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::ComplexStructOperationInput, ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError>> + Send>>
-960
+    }
-961
+}
-962
 impl std::future::Future for ComplexStructOperationInputFuture {
     type Output = Result<
         crate::input::ComplexStructOperationInput,
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError,
     >;
-968
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-975
+    }
-976
+}
-977
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::ComplexStructOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-986
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-990
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = ComplexStructOperationInputFuture;
-993
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_CBOR,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-1001
+            }
             crate::protocol_serde::shape_complex_struct_operation::de_complex_struct_operation_http_request(request)
                             .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-1011
+                )
             },
         );
         ComplexStructOperationInputFuture {
             inner: Box::pin(fut),
-1016
+        }
-1017
+    }
-1018
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::ComplexStructOperationOutput
-1023
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -1026,1062 +1086,1122 @@

↥ Expand context

     type Output = Result<
         crate::input::ErrorSerializationOperationInput,
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError,
     >;
-1066
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1073
+    }
-1074
+}
-1075
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::ErrorSerializationOperationInput
 where

     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1084
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1088
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = ErrorSerializationOperationInputFuture;
-1091
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_CBOR,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-1099
+            }
             crate::protocol_serde::shape_error_serialization_operation::de_error_serialization_operation_http_request(request)
                             .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-1109
+                )
             },
         );
         ErrorSerializationOperationInputFuture {
             inner: Box::pin(fut),
-1114
+        }
-1115
+    }
-1116
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::ErrorSerializationOperationOutput
-1121
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -1107,1143 +1268,1314 @@

↥ Expand context

             Err(e) => {
                 ::tracing::error!(error = %e, "failed to serialize response");
                 ::aws_smithy_http_server::response::IntoResponse::<::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor>::into_response(::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(e))
-1146
+            }
-1147
+        }
-1148
+    }
-1149
+}
-1150
 #[allow(unreachable_code, unused_variables)]
 #[cfg(test)]
 mod error_serialization_operation_test {
-1154
     /// Despite the operation output being a structure shape with the `@error` trait,
     /// `__type` field should, in a strict interpretation of the spec, not be included,
     /// because we're not serializing a server error response. However, we do, because
     /// there shouldn't™️ be any harm in doing so, and it greatly simplifies the
     /// code generator. This test just pins this behavior in case we ever modify it.
     /// Test ID: OperationOutputSerializationQuestionablyIncludesTypeField
     #[::tokio::test]
     #[::tracing_test::traced_test]

     async fn operation_output_serialization_questionably_includes_type_field_response() {
         let output = crate::output::ErrorSerializationOperationOutput {
             error_shape: ::std::option::Option::Some(crate::error::ValidationException {
                 message: "ValidationException message field".to_owned(),
                 field_list: ::std::option::Option::None,
             }),
         };
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(&body, "v2plcnJvclNoYXBlv2ZfX3R5cGV4JHNtaXRoeS5mcmFtZXdvcmsjVmFsaWRhdGlvbkV4Y2VwdGlvbmdtZXNzYWdleCFWYWxpZGF0aW9uRXhjZXB0aW9uIG1lc3NhZ2UgZmllbGT//w==", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
         );
-1186
+    }
-1187
     /// When invalid input is provided the request should be rejected with
     /// a validation exception, and a `__type` field should be included
     /// Test ID: ErrorSerializationIncludesTypeField
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn error_serialization_includes_type_field_malformed_request() {
-1194
+        {
             #[allow(unused_mut)]
             let mut http_request = http::Request::builder()
             let mut http_request = ::http_1x::Request::builder()
                 .uri("/service/RpcV2CborService/operation/ErrorSerializationOperation")
                 .method("POST")
                 .header("smithy-protocol", "rpc-v2-cbor")
                 .header("Accept", "application/cbor")
                 .header("Content-Type", "application/cbor")
                 .body(::aws_smithy_http_server::body::Body::from(
                     ::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
                         "oA==".as_bytes(),
                         ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
                 .body(::aws_smithy_http_server::body::boxed(
                     ::http_body_util::Full::new(::bytes::Bytes::copy_from_slice(
                         &::aws_smithy_protocol_test::decode_body_data(
                             "oA==".as_bytes(),
                             ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
                         ),
                     )),
                 ))
                 .unwrap();
             #[allow(unused_mut)]
             let (sender, mut receiver) = ::tokio::sync::mpsc::channel(1);
             let config = crate::service::RpcV2CborServiceConfig::builder().build();
             let service = crate::service::RpcV2CborService::builder::<::hyper::body::Body, _, _, _>(config)
             let service = crate::service::RpcV2CborService::builder::<::aws_smithy_http_server::body::BoxBody, _, _, _>(config)
                             .error_serialization_operation(move |input: crate::input::ErrorSerializationOperationInput| {
                                 let sender = sender.clone();
                                 async move {
                                     let result = { panic!("request should have been rejected, but we accepted it; we parsed operation input `{:?}`", &input) as Result<crate::output::ErrorSerializationOperationOutput, crate::error::ErrorSerializationOperationError> };
                                     sender.send(()).await.expect("receiver dropped early");
                                     result
-1221
+                                }
                             })
                             .build_unchecked();
             let http_response = ::tower::ServiceExt::oneshot(service, http_request)
                 .await
                 .expect("unable to make an HTTP request");
             ::pretty_assertions::assert_eq!(
                 http::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 ::http_1x::StatusCode::from_u16(400).expect("invalid expected HTTP status code"),
                 http_response.status()
             );
             let body = ::hyper::body::to_bytes(http_response.into_body())
             use ::http_body_util::BodyExt;
             let body = http_response
                 .into_body()
                 .collect()
                 .await
                 .expect("unable to extract body to bytes");
                 .expect("unable to collect body")
                 .to_bytes();
             ::aws_smithy_protocol_test::assert_ok(
             ::aws_smithy_protocol_test::validate_body(&body, "v2ZfX3R5cGV4JHNtaXRoeS5mcmFtZXdvcmsjVmFsaWRhdGlvbkV4Y2VwdGlvbmdtZXNzYWdleGsxIHZhbGlkYXRpb24gZXJyb3IgZGV0ZWN0ZWQuIFZhbHVlIGF0ICcvcmVxdWlyZWRCbG9iJyBmYWlsZWQgdG8gc2F0aXNmeSBjb25zdHJhaW50OiBNZW1iZXIgbXVzdCBub3QgYmUgbnVsbGlmaWVsZExpc3SBv2RwYXRobS9yZXF1aXJlZEJsb2JnbWVzc2FnZXhOVmFsdWUgYXQgJy9yZXF1aXJlZEJsb2InIGZhaWxlZCB0byBzYXRpc2Z5IGNvbnN0cmFpbnQ6IE1lbWJlciBtdXN0IG5vdCBiZSBudWxs//8=", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
             );
-1241
+        }
-1242
+    }
-1243
+}
-1244
 ::pin_project_lite::pin_project! {
     /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the
     /// [`SimpleStructOperationInput`](crate::input::SimpleStructOperationInput) using modelled bindings.
     pub struct SimpleStructOperationInputFuture {
         inner: std::pin::Pin<Box<dyn std::future::Future<Output = Result<crate::input::SimpleStructOperationInput, ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError>> + Send>>
-1250
+    }
-1251
+}
-1252
 impl std::future::Future for SimpleStructOperationInputFuture {
     type Output = Result<
         crate::input::SimpleStructOperationInput,
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError,
     >;
-1258
     fn poll(
         self: std::pin::Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> std::task::Poll<Self::Output> {
         let this = self.project();
         this.inner.as_mut().poll(cx)
-1265
+    }
-1266
+}
-1267
 impl<B>
     ::aws_smithy_http_server::request::FromRequest<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
         B,
     > for crate::input::SimpleStructOperationInput
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: 'static,
-1276
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-1280
+{
     type Rejection = ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError;
     type Future = SimpleStructOperationInputFuture;
-1283
     fn from_request(request: ::http::Request<B>) -> Self::Future {
     fn from_request(request: ::http_1x::Request<B>) -> Self::Future {
         let fut = async move {
             if !::aws_smithy_http_server::protocol::accept_header_classifier(
                 request.headers(),
                 &crate::mimes::CONTENT_TYPE_APPLICATION_CBOR,
             ) {
                 return Err(::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::NotAcceptable);
-1291
+            }
             crate::protocol_serde::shape_simple_struct_operation::de_simple_struct_operation_http_request(request)
                             .await
         };

↧ Expand context

         use ::futures_util::future::TryFutureExt;
         let fut = fut.map_err(
             |e: ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection| {
                 ::tracing::debug!(error = %e, "failed to deserialize request");
                 ::aws_smithy_http_server::protocol::rpc_v2_cbor::runtime_error::RuntimeError::from(
                     e,
-1301
+                )
             },
         );
         SimpleStructOperationInputFuture {
             inner: Box::pin(fut),
-1306
+        }
-1307
+    }
-1308
+}
 impl
     ::aws_smithy_http_server::response::IntoResponse<
         ::aws_smithy_http_server::protocol::rpc_v2_cbor::RpcV2Cbor,
     > for crate::output::SimpleStructOperationOutput
-1313
+{
     fn into_response(self) -> ::aws_smithy_http_server::response::Response {

@@ -1369,1415 +1442,1492 @@

↥ Expand context

-1415
+            ,
             required_byte:
-1417
-1418
+            ,
             required_short:
-1420
-1421
+            ,
             required_integer:
-1423
-1424
+            ,
             required_long:
-1426
-1427
+            ,
             required_float:
 .69_f32
-1430
+            ,
             required_double:
 .6969_f64
-1433
+            ,
             required_timestamp:

                 ::aws_smithy_types::DateTime::from_fractional_secs(1546300800, 0_f64)
-1436
+            ,
             required_enum:
                 "DIAMOND".parse::<crate::model::Suit>().expect("static value validated to member")
-1439
+            ,
-1440
+        }
-1441
+        ;
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(&body, "v2RibG9iS2Jsb2JieSBibG9iZ2Jvb2xlYW70ZnN0cmluZ3hwVGhlcmUgYXJlIHRocmVlIHRoaW5ncyBhbGwgd2lzZSBtZW4gZmVhcjogdGhlIHNlYSBpbiBzdG9ybSwgYSBuaWdodCB3aXRoIG5vIG1vb24sIGFuZCB0aGUgYW5nZXIgb2YgYSBnZW50bGUgbWFuLmRieXRlGEVlc2hvcnQYRmdpbnRlZ2VyGEdkbG9uZxhIZWZsb2F0+j8wo9dmZG91Ymxl+z/mTQE6kqMFaXRpbWVzdGFtcMH7QdcKq2AAAABkZW51bWdESUFNT05EbHJlcXVpcmVkQmxvYktibG9iYnkgYmxvYm9yZXF1aXJlZEJvb2xlYW70bnJlcXVpcmVkU3RyaW5neHBUaGVyZSBhcmUgdGhyZWUgdGhpbmdzIGFsbCB3aXNlIG1lbiBmZWFyOiB0aGUgc2VhIGluIHN0b3JtLCBhIG5pZ2h0IHdpdGggbm8gbW9vbiwgYW5kIHRoZSBhbmdlciBvZiBhIGdlbnRsZSBtYW4ubHJlcXVpcmVkQnl0ZRhFbXJlcXVpcmVkU2hvcnQYRm9yZXF1aXJlZEludGVnZXIYR2xyZXF1aXJlZExvbmcYSG1yZXF1aXJlZEZsb2F0+j8wo9ducmVxdWlyZWREb3VibGX7P+ZNATqSowVxcmVxdWlyZWRUaW1lc3RhbXDB+0HXCqtgAAAAbHJlcXVpcmVkRW51bWdESUFNT05E/w==", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
         );
-1466
+    }
     /// Test ID: SimpleStructWithOptionsSetToNone
     #[::tokio::test]
     #[::tracing_test::traced_test]
     async fn simple_struct_with_options_set_to_none_response() {
         let output =crate::output::SimpleStructOperationOutput {
             required_blob:

↧ Expand context

                 ::aws_smithy_types::Blob::new("blobby blob")
-1474
+            ,
             required_boolean:
                 false
-1477
+            ,
             required_string:
                 "There are three things all wise men fear: the sea in storm, a night with no moon, and the anger of a gentle man.".to_owned()
-1480
+            ,
             required_byte:
-1482
-1483
+            ,
             required_short:
-1485
-1486
+            ,
             required_integer:
-1488
-1489
+            ,
             required_long:
-1491
-1492
+            ,

@@ -1463,1513 +1511,1565 @@

↥ Expand context

-1513
+            ,
             byte:
                 ::std::option::Option::None
-1516
+            ,
             short:
                 ::std::option::Option::None
-1519
+            ,
             integer:
                 ::std::option::Option::None
-1522
+            ,
             long:
                 ::std::option::Option::None
-1525
+            ,
             float:
                 ::std::option::Option::None
-1528
+            ,
             double:
                 ::std::option::Option::None
-1531
+            ,
             timestamp:

                 ::std::option::Option::None
-1534
+            ,
             r#enum:
                 ::std::option::Option::None
-1537
+            ,
-1538
+        }
-1539
+        ;
         use ::aws_smithy_http_server::response::IntoResponse;
         let http_response = output.into_response();
         ::pretty_assertions::assert_eq!(
             http::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             ::http_1x::StatusCode::from_u16(200).expect("invalid expected HTTP status code"),
             http_response.status()
         );
         let expected_headers = [
             ("Content-Type", "application/cbor"),
             ("smithy-protocol", "rpc-v2-cbor"),
         ];
         ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(
             http_response.headers(),
             expected_headers,
         ));
         let body = ::hyper::body::to_bytes(http_response.into_body())
         use ::http_body_util::BodyExt;
         let body = http_response
             .into_body()
             .collect()
             .await
             .expect("unable to extract body to bytes");
             .expect("unable to collect body")
             .to_bytes();
         ::aws_smithy_protocol_test::assert_ok(
         ::aws_smithy_protocol_test::validate_body(&body, "v2xyZXF1aXJlZEJsb2JLYmxvYmJ5IGJsb2JvcmVxdWlyZWRCb29sZWFu9G5yZXF1aXJlZFN0cmluZ3hwVGhlcmUgYXJlIHRocmVlIHRoaW5ncyBhbGwgd2lzZSBtZW4gZmVhcjogdGhlIHNlYSBpbiBzdG9ybSwgYSBuaWdodCB3aXRoIG5vIG1vb24sIGFuZCB0aGUgYW5nZXIgb2YgYSBnZW50bGUgbWFuLmxyZXF1aXJlZEJ5dGUYRW1yZXF1aXJlZFNob3J0GEZvcmVxdWlyZWRJbnRlZ2VyGEdscmVxdWlyZWRMb25nGEhtcmVxdWlyZWRGbG9hdPo/MKPXbnJlcXVpcmVkRG91Ymxl+z/mTQE6kqMFcXJlcXVpcmVkVGltZXN0YW1wwftB1wqrYAAAAGxyZXF1aXJlZEVudW1nRElBTU9ORP8=", ::aws_smithy_protocol_test::MediaType::from("application/cbor"))
         );
-1564
+    }
-1565
+}

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/src/protocol_serde/shape_complex_struct_operation.rs

@@ -1,1 +130,133 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_complex_struct_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::ComplexStructOperationInput,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::complex_struct_operation_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let bytes = ::hyper::body::to_bytes(body).await?;
         let bytes = {
             use ::http_body_util::BodyExt;
             body.collect().await?.to_bytes()
         };
         if !bytes.is_empty() {
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/cbor"),
             )?;
             input =
                 crate::protocol_serde::shape_complex_struct_operation::de_complex_struct_operation(
                     bytes.as_ref(),
                     input,
                 )?;
-36
+        }
         input.build()?
     })
-39
+}
-40
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_complex_struct_operation_http_response(
     #[allow(unused_variables)] output: crate::output::ComplexStructOperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/cbor",
         );
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::HeaderName::from_static("smithy-protocol"),
             ::http_1x::header::HeaderName::from_static("smithy-protocol"),
             "rpc-v2-cbor",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_complex_struct_operation_output::ser_complex_struct_operation_output_output_output(&output)?
-65
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-75
+}
-76
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_complex_struct_operation_http_error(
     error: &crate::error::ComplexStructOperationError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::ComplexStructOperationError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/cbor",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("smithy-protocol"),
                     ::http_1x::header::HeaderName::from_static("smithy-protocol"),
                     "rpc-v2-cbor",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-109
+            }
-110
+        }
     })
-112
+}
-113

↧ Expand context

 pub(crate) fn de_complex_struct_operation(
     value: &[u8],
     mut builder: crate::input::complex_struct_operation_input::Builder,
 ) -> ::std::result::Result<
     crate::input::complex_struct_operation_input::Builder,
     ::aws_smithy_cbor::decode::DeserializeError,
 > {
     #[allow(clippy::match_single_binding)]
     fn pair(
         mut builder: crate::input::complex_struct_operation_input::Builder,
         decoder: &mut ::aws_smithy_cbor::Decoder,
     ) -> ::std::result::Result<
         crate::input::complex_struct_operation_input::Builder,
         ::aws_smithy_cbor::decode::DeserializeError,
     > {
         builder = match decoder.str()?.as_ref() {
             "structure" => {
                 ::aws_smithy_cbor::decode::set_optional(builder, decoder, |builder, decoder| {
                     Ok(builder.set_structure(Some(
                         crate::protocol_serde::shape_simple_struct::de_simple_struct(decoder)?,

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/src/protocol_serde/shape_empty_struct_operation.rs

@@ -1,1 +60,60 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_empty_struct_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::EmptyStructOperationInput,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::empty_struct_operation_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         input.build()
     })
-24
+}
-25
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_empty_struct_operation_http_response(
     #[allow(unused_variables)] output: crate::output::EmptyStructOperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/cbor",
         );
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::HeaderName::from_static("smithy-protocol"),
             ::http_1x::header::HeaderName::from_static("smithy-protocol"),
             "rpc-v2-cbor",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_empty_struct_operation_output::ser_empty_struct_operation_output_output_output(&output)?
-50
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-60
+}

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/src/protocol_serde/shape_error_serialization_operation.rs

@@ -1,1 +126,129 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_error_serialization_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::ErrorSerializationOperationInput,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::error_serialization_operation_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let bytes = ::hyper::body::to_bytes(body).await?;
         let bytes = {
             use ::http_body_util::BodyExt;
             body.collect().await?.to_bytes()
         };
         if !bytes.is_empty() {
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/cbor"),
             )?;
             input = crate::protocol_serde::shape_error_serialization_operation::de_error_serialization_operation(bytes.as_ref(), input)?;
-32
+        }
         input.build()?
     })
-35
+}
-36
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_error_serialization_operation_http_response(
     #[allow(unused_variables)] output: crate::output::ErrorSerializationOperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/cbor",
         );
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::HeaderName::from_static("smithy-protocol"),
             ::http_1x::header::HeaderName::from_static("smithy-protocol"),
             "rpc-v2-cbor",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_error_serialization_operation_output::ser_error_serialization_operation_output_output_output(&output)?
-61
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-71
+}
-72
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_error_serialization_operation_http_error(
     error: &crate::error::ErrorSerializationOperationError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::ErrorSerializationOperationError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/cbor",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("smithy-protocol"),
                     ::http_1x::header::HeaderName::from_static("smithy-protocol"),
                     "rpc-v2-cbor",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-105
+            }
-106
+        }
     })
-108
+}
-109

↧ Expand context

 pub(crate) fn de_error_serialization_operation(
     value: &[u8],
     mut builder: crate::input::error_serialization_operation_input::Builder,
 ) -> ::std::result::Result<
     crate::input::error_serialization_operation_input::Builder,
     ::aws_smithy_cbor::decode::DeserializeError,
 > {
     #[allow(clippy::match_single_binding)]
     fn pair(
         mut builder: crate::input::error_serialization_operation_input::Builder,
         decoder: &mut ::aws_smithy_cbor::Decoder,
     ) -> ::std::result::Result<
         crate::input::error_serialization_operation_input::Builder,
         ::aws_smithy_cbor::decode::DeserializeError,
     > {
         builder = match decoder.str()?.as_ref() {
             "blob" => {
                 ::aws_smithy_cbor::decode::set_optional(builder, decoder, |builder, decoder| {
                     Ok(builder.set_blob(Some(decoder.blob()?)))
                 })?

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/src/protocol_serde/shape_recursive_union_operation.rs

@@ -1,1 +92,95 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_recursive_union_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::RecursiveUnionOperationInput,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::recursive_union_operation_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let bytes = ::hyper::body::to_bytes(body).await?;
         let bytes = {
             use ::http_body_util::BodyExt;
             body.collect().await?.to_bytes()
         };
         if !bytes.is_empty() {
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/cbor"),
             )?;
             input = crate::protocol_serde::shape_recursive_union_operation::de_recursive_union_operation(bytes.as_ref(), input)?;
-32
+        }
         input.build()
     })
-35
+}
-36
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_recursive_union_operation_http_response(
     #[allow(unused_variables)] output: crate::output::RecursiveUnionOperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/cbor",
         );
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::HeaderName::from_static("smithy-protocol"),
             ::http_1x::header::HeaderName::from_static("smithy-protocol"),
             "rpc-v2-cbor",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_recursive_union_operation_output::ser_recursive_union_operation_output_output_output(&output)?
-61
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-71
+}
-72
 pub(crate) fn de_recursive_union_operation(
     value: &[u8],
     mut builder: crate::input::recursive_union_operation_input::Builder,

↧ Expand context

 ) -> ::std::result::Result<
     crate::input::recursive_union_operation_input::Builder,
     ::aws_smithy_cbor::decode::DeserializeError,
 > {
     #[allow(clippy::match_single_binding)]
     fn pair(
         mut builder: crate::input::recursive_union_operation_input::Builder,
         decoder: &mut ::aws_smithy_cbor::Decoder,
     ) -> ::std::result::Result<
         crate::input::recursive_union_operation_input::Builder,
         ::aws_smithy_cbor::decode::DeserializeError,
     > {
         builder = match decoder.str()?.as_ref() {
             "nested" => {
                 ::aws_smithy_cbor::decode::set_optional(builder, decoder, |builder, decoder| {
                     Ok(builder.set_nested(
                 Some(
                     crate::protocol_serde::shape_recursive_operation_input_output_nested1::de_recursive_operation_input_output_nested1(decoder)?
-94
+                )
             ))

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/src/protocol_serde/shape_simple_struct_operation.rs

@@ -1,1 +130,133 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_simple_struct_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::SimpleStructOperationInput,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::simple_struct_operation_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let bytes = ::hyper::body::to_bytes(body).await?;
         let bytes = {
             use ::http_body_util::BodyExt;
             body.collect().await?.to_bytes()
         };
         if !bytes.is_empty() {
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/cbor"),
             )?;
             input =
                 crate::protocol_serde::shape_simple_struct_operation::de_simple_struct_operation(
                     bytes.as_ref(),
                     input,
                 )?;
-36
+        }
         input.build()?
     })
-39
+}
-40
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_simple_struct_operation_http_response(
     #[allow(unused_variables)] output: crate::output::SimpleStructOperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/cbor",
         );
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::HeaderName::from_static("smithy-protocol"),
             ::http_1x::header::HeaderName::from_static("smithy-protocol"),
             "rpc-v2-cbor",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_simple_struct_operation_output::ser_simple_struct_operation_output_output_output(&output)?
-65
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-75
+}
-76
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_simple_struct_operation_http_error(
     error: &crate::error::SimpleStructOperationError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::SimpleStructOperationError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/cbor",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("smithy-protocol"),
                     ::http_1x::header::HeaderName::from_static("smithy-protocol"),
                     "rpc-v2-cbor",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-109
+            }
-110
+        }
     })
-112
+}
-113

↧ Expand context

 pub(crate) fn de_simple_struct_operation(
     value: &[u8],
     mut builder: crate::input::simple_struct_operation_input::Builder,
 ) -> ::std::result::Result<
     crate::input::simple_struct_operation_input::Builder,
     ::aws_smithy_cbor::decode::DeserializeError,
 > {
     #[allow(clippy::match_single_binding)]
     fn pair(
         mut builder: crate::input::simple_struct_operation_input::Builder,
         decoder: &mut ::aws_smithy_cbor::Decoder,
     ) -> ::std::result::Result<
         crate::input::simple_struct_operation_input::Builder,
         ::aws_smithy_cbor::decode::DeserializeError,
     > {
         builder = match decoder.str()?.as_ref() {
             "blob" => {
                 ::aws_smithy_cbor::decode::set_optional(builder, decoder, |builder, decoder| {
                     Ok(builder.set_blob(Some(decoder.blob()?)))
                 })?

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/src/protocol_serde/shape_single_member_struct_operation.rs

@@ -1,1 +92,95 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_single_member_struct_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::SingleMemberStructOperationInput,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-14
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::single_member_struct_operation_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         let bytes = ::hyper::body::to_bytes(body).await?;
         let bytes = {
             use ::http_body_util::BodyExt;
             body.collect().await?.to_bytes()
         };
         if !bytes.is_empty() {
             ::aws_smithy_http_server::protocol::content_type_header_classifier_smithy(
                 &headers,
                 Some("application/cbor"),
             )?;
             input = crate::protocol_serde::shape_single_member_struct_operation::de_single_member_struct_operation(bytes.as_ref(), input)?;
-32
+        }
         input.build()
     })
-35
+}
-36
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_single_member_struct_operation_http_response(
     #[allow(unused_variables)] output: crate::output::SingleMemberStructOperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/cbor",
         );
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::HeaderName::from_static("smithy-protocol"),
             ::http_1x::header::HeaderName::from_static("smithy-protocol"),
             "rpc-v2-cbor",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let payload =
             crate::protocol_serde::shape_single_member_struct_operation_output::ser_single_member_struct_operation_output_output_output(&output)?
-61
+        ;
         let content_length = payload.len();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_LENGTH,
             ::http_1x::header::CONTENT_LENGTH,
             content_length,
         );
         let body = ::aws_smithy_http_server::body::to_boxed(payload);
         builder.body(body)?
     })
-71
+}
-72
 pub(crate) fn de_single_member_struct_operation(
     value: &[u8],
     mut builder: crate::input::single_member_struct_operation_input::Builder,

↧ Expand context

 ) -> ::std::result::Result<
     crate::input::single_member_struct_operation_input::Builder,
     ::aws_smithy_cbor::decode::DeserializeError,
 > {
     #[allow(clippy::match_single_binding)]
     fn pair(
         mut builder: crate::input::single_member_struct_operation_input::Builder,
         decoder: &mut ::aws_smithy_cbor::Decoder,
     ) -> ::std::result::Result<
         crate::input::single_member_struct_operation_input::Builder,
         ::aws_smithy_cbor::decode::DeserializeError,
     > {
         builder = match decoder.str()?.as_ref() {
             "message" => {
                 ::aws_smithy_cbor::decode::set_optional(builder, decoder, |builder, decoder| {
                     Ok(builder.set_message(Some(decoder.string()?)))
                 })?
-93
+            }
             _ => {
                 decoder.skip()?;

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/src/protocol_serde/shape_streaming_operation.rs

@@ -1,1 +118,122 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_streaming_operation_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::StreamingOperationInput,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B: ::http_body_1x::Body<Data = ::bytes::Bytes>
         + ::std::marker::Send
         + ::std::marker::Sync
         + 'static,
     B::Error: Into<::aws_smithy_types::body::Error> + 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-20
+{
     Ok({
         #[allow(unused_mut)]
         let mut input = crate::input::streaming_operation_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         if let Some(value) = {
             let mut receiver =
                 crate::protocol_serde::shape_streaming_operation_input::de_events_payload(
                     &mut body.into().into_inner(),
                     &mut ::aws_smithy_types::body::SdkBody::from_body_1_x(body),
                 )?;
             if let Some(_initial_event) = receiver
                                                 .try_recv_initial(::aws_smithy_http::event_stream::InitialMessageType::Request)
                                                 .await
                                                 .map_err(
                                                     |ev_error| ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::ConstraintViolation(
                                                         #[allow(clippy::useless_conversion)]
                                                         format!("{ev_error}").into()
-40
+                                                    )
                                                 )? {
-42
-43
+                                            }
             Some(receiver)
         } {
             input = input.set_events(value)
-47
+        }
         input.build()?
     })
-50
+}
-51
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_streaming_operation_http_response(
     #[allow(unused_variables)] output: crate::output::StreamingOperationOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/vnd.amazon.eventstream",
         );
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::HeaderName::from_static("smithy-protocol"),
             ::http_1x::header::HeaderName::from_static("smithy-protocol"),
             "rpc-v2-cbor",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let body = ::aws_smithy_http_server::body::boxed(
             ::aws_smithy_http_server::body::Body::wrap_stream({
         let body =
             ::aws_smithy_http_server::body::boxed(::aws_smithy_http_server::body::wrap_stream({
                 let error_marshaller = crate::event_stream_serde::EventsErrorMarshaller::new();
                 let marshaller = crate::event_stream_serde::EventsMarshaller::new();
                 let signer = ::aws_smithy_eventstream::frame::NoOpSigner {};
                 output
                     .events
                     .into_body_stream(marshaller, error_marshaller, signer)
             }),
         );
             }));
         builder.body(body)?
     })
-85
+}
-86
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_streaming_operation_http_error(
     error: &crate::error::StreamingOperationError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::StreamingOperationError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/vnd.amazon.eventstream",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("smithy-protocol"),
                     ::http_1x::header::HeaderName::from_static("smithy-protocol"),
                     "rpc-v2-cbor",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-119
+            }
-120
+        }
     })
-122
+}

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/src/protocol_serde/shape_streaming_operation_with_initial_data.rs

@@ -1,1 +137,141 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_streaming_operation_with_initial_data_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::StreamingOperationWithInitialDataInput,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B: ::http_body_1x::Body<Data = ::bytes::Bytes>
         + ::std::marker::Send
         + ::std::marker::Sync
         + 'static,
     B::Error: Into<::aws_smithy_types::body::Error> + 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-20
+{
     Ok({
         #[allow(unused_mut)]
         let mut input =
             crate::input::streaming_operation_with_initial_data_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         if let Some(value) = {
             let mut receiver = crate::protocol_serde::shape_streaming_operation_with_initial_data_input::de_events_payload(&mut body.into().into_inner())?;
             let mut receiver = crate::protocol_serde::shape_streaming_operation_with_initial_data_input::de_events_payload(&mut ::aws_smithy_types::body::SdkBody::from_body_1_x(body))?;
             if let Some(_initial_event) = receiver
                                                 .try_recv_initial(::aws_smithy_http::event_stream::InitialMessageType::Request)
                                                 .await
                                                 .map_err(
                                                     |ev_error| ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::ConstraintViolation(
                                                         #[allow(clippy::useless_conversion)]
                                                         format!("{ev_error}").into()
-38
+                                                    )
                                                 )? {
                                                 input = crate::protocol_serde::shape_streaming_operation_with_initial_data::de_streaming_operation_with_initial_data(_initial_event.payload(), input)?;
-41
+                                            }
             Some(receiver)
         } {
             input = input.set_events(value)
-45
+        }
         input.build()?
     })
-48
+}
-49
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_streaming_operation_with_initial_data_http_response(
     #[allow(unused_variables)] output: crate::output::StreamingOperationWithInitialDataOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/vnd.amazon.eventstream",
         );
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::HeaderName::from_static("smithy-protocol"),
             ::http_1x::header::HeaderName::from_static("smithy-protocol"),
             "rpc-v2-cbor",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let body = ::aws_smithy_http_server::body::boxed(
             ::aws_smithy_http_server::body::Body::wrap_stream({
         let body =
             ::aws_smithy_http_server::body::boxed(::aws_smithy_http_server::body::wrap_stream({
                 let error_marshaller = crate::event_stream_serde::EventsErrorMarshaller::new();
                 let marshaller = crate::event_stream_serde::EventsMarshaller::new();
                 let signer = ::aws_smithy_eventstream::frame::NoOpSigner {};
                 output
                     .events
                     .into_body_stream(marshaller, error_marshaller, signer)
             }),
         );
             }));
         builder.body(body)?
     })
-83
+}
-84
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_streaming_operation_with_initial_data_http_error(
     error: &crate::error::StreamingOperationWithInitialDataError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::StreamingOperationWithInitialDataError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/vnd.amazon.eventstream",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("smithy-protocol"),
                     ::http_1x::header::HeaderName::from_static("smithy-protocol"),
                     "rpc-v2-cbor",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-117
+            }
-118
+        }
     })
-120
+}
-121

↧ Expand context

 pub(crate) fn de_streaming_operation_with_initial_data(
     value: &[u8],
     mut builder: crate::input::streaming_operation_with_initial_data_input::Builder,
 ) -> ::std::result::Result<
     crate::input::streaming_operation_with_initial_data_input::Builder,
     ::aws_smithy_cbor::decode::DeserializeError,
 > {
     #[allow(clippy::match_single_binding)]
     fn pair(
         mut builder: crate::input::streaming_operation_with_initial_data_input::Builder,
         decoder: &mut ::aws_smithy_cbor::Decoder,
     ) -> ::std::result::Result<
         crate::input::streaming_operation_with_initial_data_input::Builder,
         ::aws_smithy_cbor::decode::DeserializeError,
     > {
         builder = match decoder.str()?.as_ref() {
             "initialData" => builder.set_initial_data(decoder.string()?),
             _ => {
                 decoder.skip()?;
                 builder

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/src/protocol_serde/shape_streaming_operation_with_initial_response.rs

@@ -1,1 +118,122 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_streaming_operation_with_initial_response_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::StreamingOperationWithInitialResponseInput,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B: ::http_body_1x::Body<Data = ::bytes::Bytes>
         + ::std::marker::Send
         + ::std::marker::Sync
         + 'static,
     B::Error: Into<::aws_smithy_types::body::Error> + 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-20
+{
     Ok({
         #[allow(unused_mut)]
         let mut input =
             crate::input::streaming_operation_with_initial_response_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         if let Some(value) = {
             let mut receiver = crate::protocol_serde::shape_streaming_operation_with_initial_response_input::de_events_payload(&mut body.into().into_inner())?;
             let mut receiver = crate::protocol_serde::shape_streaming_operation_with_initial_response_input::de_events_payload(&mut ::aws_smithy_types::body::SdkBody::from_body_1_x(body))?;
             if let Some(_initial_event) = receiver
                                                 .try_recv_initial(::aws_smithy_http::event_stream::InitialMessageType::Request)
                                                 .await
                                                 .map_err(
                                                     |ev_error| ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::ConstraintViolation(
                                                         #[allow(clippy::useless_conversion)]
                                                         format!("{ev_error}").into()
-38
+                                                    )
                                                 )? {
-40
-41
+                                            }
             Some(receiver)
         } {
             input = input.set_events(value)
-45
+        }
         input.build()?
     })
-48
+}
-49
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_streaming_operation_with_initial_response_http_response(
     #[allow(unused_variables)] output: crate::output::StreamingOperationWithInitialResponseOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/vnd.amazon.eventstream",
         );
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::HeaderName::from_static("smithy-protocol"),
             ::http_1x::header::HeaderName::from_static("smithy-protocol"),
             "rpc-v2-cbor",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let body = ::aws_smithy_http_server::body::boxed(
             ::aws_smithy_http_server::body::Body::wrap_stream({
         let body =
             ::aws_smithy_http_server::body::boxed(::aws_smithy_http_server::body::wrap_stream({
                 let error_marshaller = crate::event_stream_serde::EventsErrorMarshaller::new();
                 let marshaller = crate::event_stream_serde::EventsMarshaller::new();
                 let signer = ::aws_smithy_eventstream::frame::NoOpSigner {};
                 output
                     .events
                     .into_body_stream(marshaller, error_marshaller, signer)
             }),
         );
             }));
         builder.body(body)?
     })
-83
+}
-84
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_streaming_operation_with_initial_response_http_error(
     error: &crate::error::StreamingOperationWithInitialResponseError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::StreamingOperationWithInitialResponseError::ValidationException(
                 output,
             ) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/vnd.amazon.eventstream",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("smithy-protocol"),
                     ::http_1x::header::HeaderName::from_static("smithy-protocol"),
                     "rpc-v2-cbor",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-119
+            }
-120
+        }
     })
-122
+}

tmp-codegen-diff/codegen-server-test/rpcv2Cbor_extras_no_initial_response/rust-server-codegen/src/protocol_serde/shape_streaming_operation_with_optional_data.rs

@@ -1,1 +137,141 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub async fn de_streaming_operation_with_optional_data_http_request<B>(
     #[allow(unused_variables)] request: ::http::Request<B>,
     #[allow(unused_variables)] request: ::http_1x::Request<B>,
 ) -> std::result::Result<
     crate::input::StreamingOperationWithOptionalDataInput,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection,
-8
+>
 where
     B: ::aws_smithy_http_server::body::HttpBody + Send,
     B: Into<::aws_smithy_types::byte_stream::ByteStream>,
     B: ::http_body_1x::Body<Data = ::bytes::Bytes>
         + ::std::marker::Send
         + ::std::marker::Sync
         + 'static,
     B::Error: Into<::aws_smithy_types::body::Error> + 'static,
-+
     B::Data: Send,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection:
         From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
-20
+{
     Ok({
         #[allow(unused_mut)]
         let mut input =
             crate::input::streaming_operation_with_optional_data_input::Builder::default();
         #[allow(unused_variables)]
         let ::aws_smithy_runtime_api::http::RequestParts {
             uri, headers, body, ..
         } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
         if let Some(value) = {
             let mut receiver = crate::protocol_serde::shape_streaming_operation_with_optional_data_input::de_events_payload(&mut body.into().into_inner())?;
             let mut receiver = crate::protocol_serde::shape_streaming_operation_with_optional_data_input::de_events_payload(&mut ::aws_smithy_types::body::SdkBody::from_body_1_x(body))?;
             if let Some(_initial_event) = receiver
                                                 .try_recv_initial(::aws_smithy_http::event_stream::InitialMessageType::Request)
                                                 .await
                                                 .map_err(
                                                     |ev_error| ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::RequestRejection::ConstraintViolation(
                                                         #[allow(clippy::useless_conversion)]
                                                         format!("{ev_error}").into()
-38
+                                                    )
                                                 )? {
                                                 input = crate::protocol_serde::shape_streaming_operation_with_optional_data::de_streaming_operation_with_optional_data(_initial_event.payload(), input)?;
-41
+                                            }
             Some(receiver)
         } {
             input = input.set_events(value)
-45
+        }
         input.build()?
     })
-48
+}
-49
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_streaming_operation_with_optional_data_http_response(
     #[allow(unused_variables)] output: crate::output::StreamingOperationWithOptionalDataOutput,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut builder = ::http::Response::builder();
         let mut builder = ::http_1x::Response::builder();
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::CONTENT_TYPE,
             ::http_1x::header::CONTENT_TYPE,
             "application/vnd.amazon.eventstream",
         );
         builder = ::aws_smithy_http::header::set_response_header_if_absent(
             builder,
             ::http::header::HeaderName::from_static("smithy-protocol"),
             ::http_1x::header::HeaderName::from_static("smithy-protocol"),
             "rpc-v2-cbor",
         );
         let http_status: u16 = 200;
         builder = builder.status(http_status);
         let body = ::aws_smithy_http_server::body::boxed(
             ::aws_smithy_http_server::body::Body::wrap_stream({
         let body =
             ::aws_smithy_http_server::body::boxed(::aws_smithy_http_server::body::wrap_stream({
                 let error_marshaller = crate::event_stream_serde::EventsErrorMarshaller::new();
                 let marshaller = crate::event_stream_serde::EventsMarshaller::new();
                 let signer = ::aws_smithy_eventstream::frame::NoOpSigner {};
                 output
                     .events
                     .into_body_stream(marshaller, error_marshaller, signer)
             }),
         );
             }));
         builder.body(body)?
     })
-83
+}
-84
 #[allow(clippy::unnecessary_wraps)]
 pub fn ser_streaming_operation_with_optional_data_http_error(
     error: &crate::error::StreamingOperationWithOptionalDataError,
 ) -> std::result::Result<
     ::aws_smithy_http_server::response::Response,
     ::aws_smithy_http_server::protocol::rpc_v2_cbor::rejection::ResponseRejection,
 > {
     Ok({
         match error {
             crate::error::StreamingOperationWithOptionalDataError::ValidationException(output) => {
                 let payload = crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(output)?;
                 #[allow(unused_mut)]
                 let mut builder = ::http::Response::builder();
                 let mut builder = ::http_1x::Response::builder();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_TYPE,
                     ::http_1x::header::CONTENT_TYPE,
                     "application/vnd.amazon.eventstream",
                 );
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::HeaderName::from_static("smithy-protocol"),
                     ::http_1x::header::HeaderName::from_static("smithy-protocol"),
                     "rpc-v2-cbor",
                 );
                 let content_length = payload.len();
                 builder = ::aws_smithy_http::header::set_response_header_if_absent(
                     builder,
                     ::http::header::CONTENT_LENGTH,
                     ::http_1x::header::CONTENT_LENGTH,
                     content_length,
                 );
                 builder
                     .status(400)
                     .body(::aws_smithy_http_server::body::to_boxed(payload))?
-117
+            }
-118
+        }
     })
-120
+}
-121

↧ Expand context

 pub(crate) fn de_streaming_operation_with_optional_data(
     value: &[u8],
     mut builder: crate::input::streaming_operation_with_optional_data_input::Builder,
 ) -> ::std::result::Result<
     crate::input::streaming_operation_with_optional_data_input::Builder,
     ::aws_smithy_cbor::decode::DeserializeError,
 > {
     #[allow(clippy::match_single_binding)]
     fn pair(
         mut builder: crate::input::streaming_operation_with_optional_data_input::Builder,
         decoder: &mut ::aws_smithy_cbor::Decoder,
     ) -> ::std::result::Result<
         crate::input::streaming_operation_with_optional_data_input::Builder,
         ::aws_smithy_cbor::decode::DeserializeError,
     > {
         builder = match decoder.str()?.as_ref() {
             "optionalData" => {
                 ::aws_smithy_cbor::decode::set_optional(builder, decoder, |builder, decoder| {
                     Ok(builder.set_optional_data(Some(decoder.string()?)))
                 })?

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208