Client Test

rev. 3c756f73b1f83a0eed4275d9d1e22df0b10b66fb

Files changed:

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_http_payload_traits.rs

@@ -7,7 +51,51 @@

 ) -> std::result::Result<crate::operation::http_payload_traits::HttpPayloadTraitsOutput, crate::operation::http_payload_traits::HttpPayloadTraitsError>
-8
+{
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::http_payload_traits::HttpPayloadTraitsError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::http_payload_traits::HttpPayloadTraitsError::generic(generic))
-14
+}
-15
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_http_payload_traits_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::http_payload_traits::HttpPayloadTraitsOutput, crate::operation::http_payload_traits::HttpPayloadTraitsError>
-22
+{
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::http_payload_traits::builders::HttpPayloadTraitsOutputBuilder::default();
         output = output.set_blob(crate::protocol_serde::shape_http_payload_traits_output::de_blob_payload(_response_body)?);

         output = output.set_foo(
             crate::protocol_serde::shape_http_payload_traits_output::de_foo_header(_response_headers)
                 .map_err(|_| crate::operation::http_payload_traits::HttpPayloadTraitsError::unhandled("Failed to parse foo from header `X-Foo"))?,
         );
         output.build()
     })
-33
+}
-34
 pub fn ser_http_payload_traits_headers(
     input: &crate::operation::http_payload_traits::HttpPayloadTraitsInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.foo {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "foo",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-46
+            )
         })?;
         builder = builder.header("X-Foo", header_value);
-49
+    }
     Ok(builder)
-51
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_http_payload_traits_with_media_type.rs

@@ -16,16 +60,60 @@

↥ Expand context

-16
+}
-17
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_http_payload_traits_with_media_type_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeOutput,
     crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeError,
 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::http_payload_traits_with_media_type::builders::HttpPayloadTraitsWithMediaTypeOutputBuilder::default();
         output = output.set_blob(crate::protocol_serde::shape_http_payload_traits_with_media_type_output::de_blob_payload(
             _response_body,
         )?);
         output = output.set_foo(
             crate::protocol_serde::shape_http_payload_traits_with_media_type_output::de_foo_header(_response_headers).map_err(|_| {
                 crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeError::unhandled(

                     "Failed to parse foo from header `X-Foo",
-37
+                )
             })?,
         );
         output.build()
     })
-42
+}
-43
 pub fn ser_http_payload_traits_with_media_type_headers(
     input: &crate::operation::http_payload_traits_with_media_type::HttpPayloadTraitsWithMediaTypeInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.foo {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "foo",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-55
+            )
         })?;
         builder = builder.header("X-Foo", header_value);
-58
+    }
     Ok(builder)
-60
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_http_prefix_headers.rs

@@ -11,11 +76,76 @@

↥ Expand context

         .map_err(crate::operation::http_prefix_headers::HttpPrefixHeadersError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::http_prefix_headers::HttpPrefixHeadersError::generic(generic))
-14
+}
-15
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_http_prefix_headers_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::http_prefix_headers::HttpPrefixHeadersOutput, crate::operation::http_prefix_headers::HttpPrefixHeadersError>
-22
+{
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::http_prefix_headers::builders::HttpPrefixHeadersOutputBuilder::default();
         output = output.set_foo(
             crate::protocol_serde::shape_http_prefix_headers_output::de_foo_header(_response_headers)
                 .map_err(|_| crate::operation::http_prefix_headers::HttpPrefixHeadersError::unhandled("Failed to parse foo from header `x-foo"))?,
         );
         output = output.set_foo_map(

             crate::protocol_serde::shape_http_prefix_headers_output::de_foo_map_prefix_header(_response_headers).map_err(|_| {
                 crate::operation::http_prefix_headers::HttpPrefixHeadersError::unhandled("Failed to parse fooMap from prefix header `x-foo-")
             })?,
         );
         output.build()
     })
-37
+}
-38
 pub fn ser_http_prefix_headers_headers(
     input: &crate::operation::http_prefix_headers::HttpPrefixHeadersInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.foo {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "foo",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-50
+            )
         })?;
         builder = builder.header("x-foo", header_value);
-53
+    }
     if let ::std::option::Option::Some(inner_3) = &input.foo_map {
-55
+        {
             for (k, v) in inner_3 {
                 use std::str::FromStr;
                 let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-foo-", &k)).map_err(|err| {
                 let header_name = ::http_1x::HeaderName::from_str(&format!("{}{}", "x-foo-", &k)).map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "foo_map",
                         format!("`{k}` cannot be used as a header name: {err}"),
-62
+                    )
                 })?;
                 let header_value = v.as_str();
                 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "foo_map",
                         format!("`{v}` cannot be used as a header value: {err}"),
-69
+                    )
                 })?;
                 builder = builder.header(header_name, header_value);
-72
+            }
-73
+        }
-74
+    }
     Ok(builder)

↧ Expand context

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_input_and_output_with_headers.rs

@@ -136,136 +428,428 @@

↥ Expand context

-136
+                )
             })?,
         );
         output = output.set_header_string_set(
             crate::protocol_serde::shape_input_and_output_with_headers_output::de_header_string_set_header(_response_headers).map_err(|_| {
                 crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersError::unhandled(
                     "Failed to parse headerStringSet from header `X-StringSet",
-143
+                )
             })?,
         );
         output = output.set_header_timestamp_list(
             crate::protocol_serde::shape_input_and_output_with_headers_output::de_header_timestamp_list_header(_response_headers).map_err(|_| {
                 crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersError::unhandled(
                     "Failed to parse headerTimestampList from header `X-TimestampList",
-150
+                )
             })?,
         );
         output = output.set_header_true_bool(
             crate::protocol_serde::shape_input_and_output_with_headers_output::de_header_true_bool_header(_response_headers).map_err(|_| {
                 crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersError::unhandled(

                     "Failed to parse headerTrueBool from header `X-Boolean1",
-157
+                )
             })?,
         );
         output.build()
     })
-162
+}
-163
 pub fn ser_input_and_output_with_headers_headers(
     input: &crate::operation::input_and_output_with_headers::InputAndOutputWithHeadersInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.header_string {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header_string",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-175
+            )
         })?;
         builder = builder.header("X-String", header_value);
-178
+    }
     if let ::std::option::Option::Some(inner_3) = &input.header_byte {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_3);
         let formatted_4 = encoder.encode();
         let header_value = formatted_4;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header_byte",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-187
+            )
         })?;
         builder = builder.header("X-Byte", header_value);
-190
+    }
     if let ::std::option::Option::Some(inner_5) = &input.header_short {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_5);
         let formatted_6 = encoder.encode();
         let header_value = formatted_6;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header_short",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-199
+            )
         })?;
         builder = builder.header("X-Short", header_value);
-202
+    }
     if let ::std::option::Option::Some(inner_7) = &input.header_integer {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_7);
         let formatted_8 = encoder.encode();
         let header_value = formatted_8;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header_integer",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-211
+            )
         })?;
         builder = builder.header("X-Integer", header_value);
-214
+    }
     if let ::std::option::Option::Some(inner_9) = &input.header_long {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_9);
         let formatted_10 = encoder.encode();
         let header_value = formatted_10;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header_long",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-223
+            )
         })?;
         builder = builder.header("X-Long", header_value);
-226
+    }
     if let ::std::option::Option::Some(inner_11) = &input.header_float {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_11);
         let formatted_12 = encoder.encode();
         let header_value = formatted_12;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header_float",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-235
+            )
         })?;
         builder = builder.header("X-Float", header_value);
-238
+    }
     if let ::std::option::Option::Some(inner_13) = &input.header_double {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_13);
         let formatted_14 = encoder.encode();
         let header_value = formatted_14;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header_double",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-247
+            )
         })?;
         builder = builder.header("X-Double", header_value);
-250
+    }
     if let ::std::option::Option::Some(inner_15) = &input.header_true_bool {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_15);
         let formatted_16 = encoder.encode();
         let header_value = formatted_16;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header_true_bool",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-259
+            )
         })?;
         builder = builder.header("X-Boolean1", header_value);
-262
+    }
     if let ::std::option::Option::Some(inner_17) = &input.header_false_bool {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_17);
         let formatted_18 = encoder.encode();
         let header_value = formatted_18;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header_false_bool",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-271
+            )
         })?;
         builder = builder.header("X-Boolean2", header_value);
-274
+    }
     if let ::std::option::Option::Some(inner_19) = &input.header_string_list {
         // Empty vec in header is serialized as an empty string
         if inner_19.is_empty() {
             builder = builder.header("X-StringList", "");
         } else {
             for inner_20 in inner_19 {
                 let formatted_21 = ::aws_smithy_http::header::quote_header_value(inner_20.as_str());
                 let header_value = formatted_21;
                 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "header_string_list",
                         format!("`{}` cannot be used as a header value: {}", &header_value, err),
-287
+                    )
                 })?;
                 builder = builder.header("X-StringList", header_value);
-290
+            }
-291
+        }
-292
+    }
     if let ::std::option::Option::Some(inner_22) = &input.header_string_set {
         // Empty vec in header is serialized as an empty string
         if inner_22.is_empty() {
             builder = builder.header("X-StringSet", "");
         } else {
             for inner_23 in inner_22 {
                 let formatted_24 = ::aws_smithy_http::header::quote_header_value(inner_23.as_str());
                 let header_value = formatted_24;
                 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "header_string_set",
                         format!("`{}` cannot be used as a header value: {}", &header_value, err),
-305
+                    )
                 })?;
                 builder = builder.header("X-StringSet", header_value);
-308
+            }
-309
+        }
-310
+    }
     if let ::std::option::Option::Some(inner_25) = &input.header_integer_list {
         // Empty vec in header is serialized as an empty string
         if inner_25.is_empty() {
             builder = builder.header("X-IntegerList", "");
         } else {
             for inner_26 in inner_25 {
                 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_26);
                 let formatted_27 = encoder.encode();
                 let header_value = formatted_27;
                 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "header_integer_list",
                         format!("`{}` cannot be used as a header value: {}", &header_value, err),
-324
+                    )
                 })?;
                 builder = builder.header("X-IntegerList", header_value);
-327
+            }
-328
+        }
-329
+    }
     if let ::std::option::Option::Some(inner_28) = &input.header_boolean_list {
         // Empty vec in header is serialized as an empty string
         if inner_28.is_empty() {
             builder = builder.header("X-BooleanList", "");
         } else {
             for inner_29 in inner_28 {
                 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_29);
                 let formatted_30 = encoder.encode();
                 let header_value = formatted_30;
                 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "header_boolean_list",
                         format!("`{}` cannot be used as a header value: {}", &header_value, err),
-343
+                    )
                 })?;
                 builder = builder.header("X-BooleanList", header_value);
-346
+            }
-347
+        }
-348
+    }
     if let ::std::option::Option::Some(inner_31) = &input.header_timestamp_list {
         // Empty vec in header is serialized as an empty string
         if inner_31.is_empty() {
             builder = builder.header("X-TimestampList", "");
         } else {
             for inner_32 in inner_31 {
                 let formatted_33 = inner_32.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
                 let header_value = formatted_33;
                 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "header_timestamp_list",
                         format!("`{}` cannot be used as a header value: {}", &header_value, err),
-361
+                    )
                 })?;
                 builder = builder.header("X-TimestampList", header_value);
-364
+            }
-365
+        }
-366
+    }
     if let ::std::option::Option::Some(inner_34) = &input.header_enum {
         let formatted_35 = inner_34.as_str();
         let header_value = formatted_35;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header_enum",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-374
+            )
         })?;
         builder = builder.header("X-Enum", header_value);
-377
+    }
     if let ::std::option::Option::Some(inner_36) = &input.header_enum_list {
         // Empty vec in header is serialized as an empty string
         if inner_36.is_empty() {
             builder = builder.header("X-EnumList", "");
         } else {
             for inner_37 in inner_36 {
                 let formatted_38 = ::aws_smithy_http::header::quote_header_value(inner_37.as_str());
                 let header_value = formatted_38;
                 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "header_enum_list",
                         format!("`{}` cannot be used as a header value: {}", &header_value, err),
-390
+                    )
                 })?;
                 builder = builder.header("X-EnumList", header_value);
-393
+            }
-394
+        }
-395
+    }
     if let ::std::option::Option::Some(inner_39) = &input.header_integer_enum {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_39);
         let formatted_40 = encoder.encode();
         let header_value = formatted_40;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header_integer_enum",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-404
+            )
         })?;
         builder = builder.header("X-IntegerEnum", header_value);
-407
+    }
     if let ::std::option::Option::Some(inner_41) = &input.header_integer_enum_list {
         // Empty vec in header is serialized as an empty string
         if inner_41.is_empty() {
             builder = builder.header("X-IntegerEnumList", "");
         } else {
             for inner_42 in inner_41 {
                 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_42);
                 let formatted_43 = encoder.encode();
                 let header_value = formatted_43;
                 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
                 let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
                     ::aws_smithy_types::error::operation::BuildError::invalid_field(
                         "header_integer_enum_list",
                         format!("`{}` cannot be used as a header value: {}", &header_value, err),
-421
+                    )
                 })?;
                 builder = builder.header("X-IntegerEnumList", header_value);
-424
+            }
-425
+        }
-426
+    }
     Ok(builder)

↧ Expand context

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_boolean.rs

@@ -1,1 +55,55 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_boolean_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::malformed_boolean::MalformedBooleanOutput, crate::operation::malformed_boolean::MalformedBooleanError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_boolean::MalformedBooleanError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_boolean::MalformedBooleanError::generic(generic))
-13
+}
-14
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_boolean_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],

 ) -> std::result::Result<crate::operation::malformed_boolean::MalformedBooleanOutput, crate::operation::malformed_boolean::MalformedBooleanError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_boolean::builders::MalformedBooleanOutputBuilder::default();
         output.build()
     })
-26
+}
-27
 pub fn ser_malformed_boolean_headers(
     input: &crate::operation::malformed_boolean::MalformedBooleanInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.boolean_in_header {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
         let formatted_2 = encoder.encode();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "boolean_in_header",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-40
+            )
         })?;
         builder = builder.header("booleanInHeader", header_value);
-43
+    }
     Ok(builder)
-45
+}
-46

↧ Expand context

 pub fn ser_malformed_boolean_input(
     input: &crate::operation::malformed_boolean::MalformedBooleanInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_malformed_boolean_input::ser_malformed_boolean_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))
-55
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_byte.rs

@@ -1,1 +55,55 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_byte_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::malformed_byte::MalformedByteOutput, crate::operation::malformed_byte::MalformedByteError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_byte::MalformedByteError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_byte::MalformedByteError::generic(generic))
-13
+}
-14
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_byte_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],

 ) -> std::result::Result<crate::operation::malformed_byte::MalformedByteOutput, crate::operation::malformed_byte::MalformedByteError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_byte::builders::MalformedByteOutputBuilder::default();
         output.build()
     })
-26
+}
-27
 pub fn ser_malformed_byte_headers(
     input: &crate::operation::malformed_byte::MalformedByteInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.byte_in_header {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
         let formatted_2 = encoder.encode();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "byte_in_header",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-40
+            )
         })?;
         builder = builder.header("byteInHeader", header_value);
-43
+    }
     Ok(builder)
-45
+}
-46

↧ Expand context

 pub fn ser_malformed_byte_input(
     input: &crate::operation::malformed_byte::MalformedByteInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_malformed_byte_input::ser_malformed_byte_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))
-55
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_content_type_without_body_empty_input.rs

@@ -6,6 +50,50 @@

↥ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::malformed_content_type_without_body_empty_input::MalformedContentTypeWithoutBodyEmptyInputOutput,
     crate::operation::malformed_content_type_without_body_empty_input::MalformedContentTypeWithoutBodyEmptyInputError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_content_type_without_body_empty_input::MalformedContentTypeWithoutBodyEmptyInputError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_content_type_without_body_empty_input::MalformedContentTypeWithoutBodyEmptyInputError::generic(generic))
-16
+}
-17
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_content_type_without_body_empty_input_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::malformed_content_type_without_body_empty_input::MalformedContentTypeWithoutBodyEmptyInputOutput,
     crate::operation::malformed_content_type_without_body_empty_input::MalformedContentTypeWithoutBodyEmptyInputError,

 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_content_type_without_body_empty_input::builders::MalformedContentTypeWithoutBodyEmptyInputOutputBuilder::default();
         output.build()
     })
-32
+}
-33
 pub fn ser_malformed_content_type_without_body_empty_input_headers(
     input: &crate::operation::malformed_content_type_without_body_empty_input::MalformedContentTypeWithoutBodyEmptyInputInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.header {
         let formatted_2 = inner_1.as_str();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "header",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-45
+            )
         })?;
         builder = builder.header("header", header_value);
-48
+    }
     Ok(builder)
-50
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_double.rs

@@ -1,1 +55,55 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_double_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::malformed_double::MalformedDoubleOutput, crate::operation::malformed_double::MalformedDoubleError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_double::MalformedDoubleError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_double::MalformedDoubleError::generic(generic))
-13
+}
-14
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_double_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],

 ) -> std::result::Result<crate::operation::malformed_double::MalformedDoubleOutput, crate::operation::malformed_double::MalformedDoubleError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_double::builders::MalformedDoubleOutputBuilder::default();
         output.build()
     })
-26
+}
-27
 pub fn ser_malformed_double_headers(
     input: &crate::operation::malformed_double::MalformedDoubleInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.double_in_header {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
         let formatted_2 = encoder.encode();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "double_in_header",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-40
+            )
         })?;
         builder = builder.header("doubleInHeader", header_value);
-43
+    }
     Ok(builder)
-45
+}
-46

↧ Expand context

 pub fn ser_malformed_double_input(
     input: &crate::operation::malformed_double::MalformedDoubleInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_malformed_double_input::ser_malformed_double_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))
-55
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_float.rs

@@ -1,1 +55,55 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_float_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::malformed_float::MalformedFloatOutput, crate::operation::malformed_float::MalformedFloatError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_float::MalformedFloatError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_float::MalformedFloatError::generic(generic))
-13
+}
-14
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_float_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],

 ) -> std::result::Result<crate::operation::malformed_float::MalformedFloatOutput, crate::operation::malformed_float::MalformedFloatError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_float::builders::MalformedFloatOutputBuilder::default();
         output.build()
     })
-26
+}
-27
 pub fn ser_malformed_float_headers(
     input: &crate::operation::malformed_float::MalformedFloatInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.float_in_header {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
         let formatted_2 = encoder.encode();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "float_in_header",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-40
+            )
         })?;
         builder = builder.header("floatInHeader", header_value);
-43
+    }
     Ok(builder)
-45
+}
-46

↧ Expand context

 pub fn ser_malformed_float_input(
     input: &crate::operation::malformed_float::MalformedFloatInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_malformed_float_input::ser_malformed_float_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))
-55
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_integer.rs

@@ -1,1 +55,55 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_integer_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::malformed_integer::MalformedIntegerOutput, crate::operation::malformed_integer::MalformedIntegerError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_integer::MalformedIntegerError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_integer::MalformedIntegerError::generic(generic))
-13
+}
-14
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_integer_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],

 ) -> std::result::Result<crate::operation::malformed_integer::MalformedIntegerOutput, crate::operation::malformed_integer::MalformedIntegerError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_integer::builders::MalformedIntegerOutputBuilder::default();
         output.build()
     })
-26
+}
-27
 pub fn ser_malformed_integer_headers(
     input: &crate::operation::malformed_integer::MalformedIntegerInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.integer_in_header {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
         let formatted_2 = encoder.encode();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "integer_in_header",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-40
+            )
         })?;
         builder = builder.header("integerInHeader", header_value);
-43
+    }
     Ok(builder)
-45
+}
-46

↧ Expand context

 pub fn ser_malformed_integer_input(
     input: &crate::operation::malformed_integer::MalformedIntegerInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_malformed_integer_input::ser_malformed_integer_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))
-55
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_long.rs

@@ -1,1 +55,55 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_long_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::malformed_long::MalformedLongOutput, crate::operation::malformed_long::MalformedLongError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_long::MalformedLongError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_long::MalformedLongError::generic(generic))
-13
+}
-14
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_long_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],

 ) -> std::result::Result<crate::operation::malformed_long::MalformedLongOutput, crate::operation::malformed_long::MalformedLongError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_long::builders::MalformedLongOutputBuilder::default();
         output.build()
     })
-26
+}
-27
 pub fn ser_malformed_long_headers(
     input: &crate::operation::malformed_long::MalformedLongInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.long_in_header {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
         let formatted_2 = encoder.encode();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "long_in_header",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-40
+            )
         })?;
         builder = builder.header("longInHeader", header_value);
-43
+    }
     Ok(builder)
-45
+}
-46

↧ Expand context

 pub fn ser_malformed_long_input(
     input: &crate::operation::malformed_long::MalformedLongInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_malformed_long_input::ser_malformed_long_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))
-55
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_short.rs

@@ -1,1 +55,55 @@

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_short_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::malformed_short::MalformedShortOutput, crate::operation::malformed_short::MalformedShortError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_short::MalformedShortError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_short::MalformedShortError::generic(generic))
-13
+}
-14
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_short_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],

 ) -> std::result::Result<crate::operation::malformed_short::MalformedShortOutput, crate::operation::malformed_short::MalformedShortError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_short::builders::MalformedShortOutputBuilder::default();
         output.build()
     })
-26
+}
-27
 pub fn ser_malformed_short_headers(
     input: &crate::operation::malformed_short::MalformedShortInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.short_in_header {
         let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_1);
         let formatted_2 = encoder.encode();
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "short_in_header",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-40
+            )
         })?;
         builder = builder.header("shortInHeader", header_value);
-43
+    }
     Ok(builder)
-45
+}
-46

↧ Expand context

 pub fn ser_malformed_short_input(
     input: &crate::operation::malformed_short::MalformedShortInput,
 ) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
     let mut out = String::new();
     let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
     crate::protocol_serde::shape_malformed_short_input::ser_malformed_short_input_input(&mut object, input)?;
     object.finish();
     Ok(::aws_smithy_types::body::SdkBody::from(out))
-55
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_string.rs

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

↥ Expand context

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_string_http_error(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<crate::operation::malformed_string::MalformedStringOutput, crate::operation::malformed_string::MalformedStringError> {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_string::MalformedStringError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_string::MalformedStringError::generic(generic))
-13
+}
-14
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_string_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],

 ) -> std::result::Result<crate::operation::malformed_string::MalformedStringOutput, crate::operation::malformed_string::MalformedStringError> {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_string::builders::MalformedStringOutputBuilder::default();
         output.build()
     })
-26
+}
-27
 pub fn ser_malformed_string_headers(
     input: &crate::operation::malformed_string::MalformedStringInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.blob {
         let formatted_2 = ::aws_smithy_types::base64::encode(inner_1);
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "blob",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-39
+            )
         })?;
         builder = builder.header("amz-media-typed-header", header_value);
-42
+    }
     Ok(builder)
-44
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_timestamp_header_date_time.rs

@@ -6,6 +50,50 @@

↥ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::malformed_timestamp_header_date_time::MalformedTimestampHeaderDateTimeOutput,
     crate::operation::malformed_timestamp_header_date_time::MalformedTimestampHeaderDateTimeError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_timestamp_header_date_time::MalformedTimestampHeaderDateTimeError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_timestamp_header_date_time::MalformedTimestampHeaderDateTimeError::generic(generic))
-16
+}
-17
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_timestamp_header_date_time_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::malformed_timestamp_header_date_time::MalformedTimestampHeaderDateTimeOutput,
     crate::operation::malformed_timestamp_header_date_time::MalformedTimestampHeaderDateTimeError,

 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_timestamp_header_date_time::builders::MalformedTimestampHeaderDateTimeOutputBuilder::default();
         output.build()
     })
-32
+}
-33
 pub fn ser_malformed_timestamp_header_date_time_headers(
     input: &crate::operation::malformed_timestamp_header_date_time::MalformedTimestampHeaderDateTimeInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.timestamp {
         let formatted_2 = inner_1.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "timestamp",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-45
+            )
         })?;
         builder = builder.header("timestamp", header_value);
-48
+    }
     Ok(builder)
-50
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_timestamp_header_default.rs

@@ -6,6 +50,50 @@

↥ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::malformed_timestamp_header_default::MalformedTimestampHeaderDefaultOutput,
     crate::operation::malformed_timestamp_header_default::MalformedTimestampHeaderDefaultError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_timestamp_header_default::MalformedTimestampHeaderDefaultError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_timestamp_header_default::MalformedTimestampHeaderDefaultError::generic(generic))
-16
+}
-17
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_timestamp_header_default_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::malformed_timestamp_header_default::MalformedTimestampHeaderDefaultOutput,
     crate::operation::malformed_timestamp_header_default::MalformedTimestampHeaderDefaultError,

 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_timestamp_header_default::builders::MalformedTimestampHeaderDefaultOutputBuilder::default();
         output.build()
     })
-32
+}
-33
 pub fn ser_malformed_timestamp_header_default_headers(
     input: &crate::operation::malformed_timestamp_header_default::MalformedTimestampHeaderDefaultInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.timestamp {
         let formatted_2 = inner_1.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "timestamp",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-45
+            )
         })?;
         builder = builder.header("timestamp", header_value);
-48
+    }
     Ok(builder)
-50
+}

tmp-codegen-diff/codegen-client-test/rest_json/rust-client-codegen/src/protocol_serde/shape_malformed_timestamp_header_epoch.rs

@@ -6,6 +50,50 @@

↥ Expand context

     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::malformed_timestamp_header_epoch::MalformedTimestampHeaderEpochOutput,
     crate::operation::malformed_timestamp_header_epoch::MalformedTimestampHeaderEpochError,
 > {
     #[allow(unused_mut)]
     let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
         .map_err(crate::operation::malformed_timestamp_header_epoch::MalformedTimestampHeaderEpochError::unhandled)?;
     let generic = generic_builder.build();
     Err(crate::operation::malformed_timestamp_header_epoch::MalformedTimestampHeaderEpochError::generic(generic))
-16
+}
-17
 #[allow(clippy::unnecessary_wraps)]
 pub fn de_malformed_timestamp_header_epoch_http_response(
     _response_status: u16,
     _response_headers: &::aws_smithy_runtime_api::http::Headers,
     _response_body: &[u8],
 ) -> std::result::Result<
     crate::operation::malformed_timestamp_header_epoch::MalformedTimestampHeaderEpochOutput,
     crate::operation::malformed_timestamp_header_epoch::MalformedTimestampHeaderEpochError,

 > {
     Ok({
         #[allow(unused_mut)]
         let mut output = crate::operation::malformed_timestamp_header_epoch::builders::MalformedTimestampHeaderEpochOutputBuilder::default();
         output.build()
     })
-32
+}
-33
 pub fn ser_malformed_timestamp_header_epoch_headers(
     input: &crate::operation::malformed_timestamp_header_epoch::MalformedTimestampHeaderEpochInput,
     mut builder: ::http::request::Builder,
 ) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     mut builder: ::http_1x::request::Builder,
 ) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
     if let ::std::option::Option::Some(inner_1) = &input.timestamp {
         let formatted_2 = inner_1.fmt(::aws_smithy_types::date_time::Format::EpochSeconds)?;
         let header_value = formatted_2;
         let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
             ::aws_smithy_types::error::operation::BuildError::invalid_field(
                 "timestamp",
                 format!("`{}` cannot be used as a header value: {}", &header_value, err),
-45
+            )
         })?;
         builder = builder.header("timestamp", header_value);
-48
+    }
     Ok(builder)
-50
+}

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