Client Test

Client Test

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_blobs.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `XmlEmptyBlobs`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct XmlEmptyBlobs;
    6      6   
impl XmlEmptyBlobs {
    7      7   
    /// Creates a new `XmlEmptyBlobs`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_empty_blobs::XmlEmptyBlobsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::xml_empty_blobs::XmlEmptyBlobsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::xml_empty_blobs::XmlEmptyBlobsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::xml_empty_blobs::XmlEmptyBlobsError,
  125    129   
            >::new());
  126    130   
  127    131   
        ::std::borrow::Cow::Owned(rcb)
  128    132   
    }
  129    133   
}
  130    134   
  131    135   
#[derive(Debug)]
  132    136   
struct XmlEmptyBlobsResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for XmlEmptyBlobsResponseDeserializer {
  134         -
    fn deserialize_nonstreaming(
         138  +
    fn deserialize_nonstreaming_with_config(
  135    139   
        &self,
  136    140   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         141  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  137    142   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  138    143   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  139    144   
        let headers = response.headers();
  140    145   
        let body = response.body().bytes().expect("body loaded");
  141    146   
        #[allow(unused_mut)]
  142    147   
        let mut force_error = false;
  143    148   
  144    149   
        let parse_result = if !success && status != 200 || force_error {
  145    150   
            crate::protocol_serde::shape_xml_empty_blobs::de_xml_empty_blobs_http_error(status, headers, body)
  146    151   
        } else {
@@ -243,248 +347,360 @@
  263    268   
            .expect("the config must have a deserializer");
  264    269   
  265    270   
        let parsed = de.deserialize_streaming(&mut http_response);
  266    271   
        let parsed = parsed.unwrap_or_else(|| {
  267    272   
            let http_response = http_response.map(|body| {
  268    273   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  269    274   
                    body.bytes().unwrap(),
  270    275   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  271    276   
                )))
  272    277   
            });
  273         -
            de.deserialize_nonstreaming(&http_response)
         278  +
            // Build a config bag with the protocol for schema-based deserialization
         279  +
            #[allow(unused_mut)]
         280  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         281  +
         282  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  274    283   
        });
  275    284   
        let parsed = parsed
  276    285   
            .expect("should be successful response")
  277    286   
            .downcast::<crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput>()
  278    287   
            .unwrap();
  279    288   
        ::pretty_assertions::assert_eq!(parsed.data, expected_output.data, "Unexpected value for `data`");
  280    289   
    }
  281    290   
  282    291   
    /// Empty self closed blobs are deserialized as empty string
  283    292   
    /// Test ID: XmlEmptySelfClosedBlobs
  284    293   
    #[::tokio::test]
  285    294   
    #[::tracing_test::traced_test]
  286    295   
    async fn xml_empty_self_closed_blobs_response() {
  287    296   
        let expected_output = crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput::builder()
  288    297   
            .set_data(::std::option::Option::Some(::aws_smithy_types::Blob::new("")))
  289    298   
            .build();
  290    299   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  291    300   
            ::http_1x::response::Builder::new()
  292    301   
                .header("Content-Type", "application/xml")
  293    302   
                .status(200)
  294    303   
                .body(::aws_smithy_types::body::SdkBody::from(
  295    304   
                    "<XmlEmptyBlobsResponse>\n    <data/>\n</XmlEmptyBlobsResponse>\n",
  296    305   
                ))
  297    306   
                .unwrap(),
  298    307   
        )
  299    308   
        .unwrap();
  300    309   
        use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
  301    310   
        use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
  302    311   
  303    312   
        let op = crate::operation::xml_empty_blobs::XmlEmptyBlobs::new();
  304    313   
        let config = op.config().expect("the operation has config");
  305    314   
        let de = config
  306    315   
            .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
  307    316   
            .expect("the config must have a deserializer");
  308    317   
  309    318   
        let parsed = de.deserialize_streaming(&mut http_response);
  310    319   
        let parsed = parsed.unwrap_or_else(|| {
  311    320   
            let http_response = http_response.map(|body| {
  312    321   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  313    322   
                    body.bytes().unwrap(),
  314    323   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  315    324   
                )))
  316    325   
            });
  317         -
            de.deserialize_nonstreaming(&http_response)
         326  +
            // Build a config bag with the protocol for schema-based deserialization
         327  +
            #[allow(unused_mut)]
         328  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         329  +
         330  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  318    331   
        });
  319    332   
        let parsed = parsed
  320    333   
            .expect("should be successful response")
  321    334   
            .downcast::<crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput>()
  322    335   
            .unwrap();
  323    336   
        ::pretty_assertions::assert_eq!(parsed.data, expected_output.data, "Unexpected value for `data`");
  324    337   
    }
  325    338   
}
  326    339   
  327    340   
/// Error type for the `XmlEmptyBlobsError` operation.

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_blobs/_xml_empty_blobs_input.rs

@@ -4,4 +108,120 @@
   24     24   
        "XmlEmptyBlobsInput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::Blob,
   27     27   
    "data",
   28     28   
    0,
   29     29   
);
   30     30   
static XMLEMPTYBLOBSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   31     31   
    XMLEMPTYBLOBSINPUT_SCHEMA_ID,
   32     32   
    ::aws_smithy_schema::ShapeType::Structure,
   33     33   
    &[&XMLEMPTYBLOBSINPUT_MEMBER_DATA],
   34         -
);
          34  +
)
          35  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/XmlEmptyBlobs", None));
   35     36   
impl XmlEmptyBlobsInput {
   36     37   
    /// The schema for this shape.
   37     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLEMPTYBLOBSINPUT_SCHEMA;
   38     39   
}
   39     40   
impl ::aws_smithy_schema::serde::SerializableStruct for XmlEmptyBlobsInput {
   40     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   41     42   
    fn serialize_members(
   42     43   
        &self,
   43     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   44     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   45     46   
        if let Some(ref val) = self.data {
   46     47   
            ser.write_blob(&XMLEMPTYBLOBSINPUT_MEMBER_DATA, val)?;
   47     48   
        }
   48     49   
        Ok(())
   49     50   
    }
   50     51   
}
   51     52   
impl XmlEmptyBlobsInput {
   52     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   53         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   54         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   55     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   56     57   
        #[allow(unused_variables, unused_mut)]
   57     58   
        let mut builder = Self::builder();
   58     59   
        #[allow(
   59     60   
            unused_variables,
   60     61   
            unreachable_code,
   61     62   
            clippy::single_match,
   62     63   
            clippy::match_single_binding,
   63     64   
            clippy::diverging_sub_expression
   64     65   
        )]
   65         -
        deserializer.read_struct(&XMLEMPTYBLOBSINPUT_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&XMLEMPTYBLOBSINPUT_SCHEMA, &mut |member, deser| {
   66     67   
            match member.member_index() {
   67     68   
                Some(0) => {
   68     69   
                    builder.data = Some(deser.read_blob(member)?);
   69     70   
                }
   70     71   
                _ => {}
   71     72   
            }
   72     73   
            Ok(())
   73     74   
        })?;
   74     75   
        builder
   75     76   
            .build()
   76     77   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   77     78   
    }
   78     79   
}
          80  +
impl XmlEmptyBlobsInput {
          81  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          82  +
    pub fn deserialize_with_response(
          83  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          84  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          85  +
        _status: u16,
          86  +
        _body: &[u8],
          87  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          88  +
        Self::deserialize(deserializer)
          89  +
    }
          90  +
}
   79     91   
impl XmlEmptyBlobsInput {
   80     92   
    /// Creates a new builder-style object to manufacture [`XmlEmptyBlobsInput`](crate::operation::xml_empty_blobs::XmlEmptyBlobsInput).
   81     93   
    pub fn builder() -> crate::operation::xml_empty_blobs::builders::XmlEmptyBlobsInputBuilder {
   82     94   
        crate::operation::xml_empty_blobs::builders::XmlEmptyBlobsInputBuilder::default()
   83     95   
    }
   84     96   
}
   85     97   
   86     98   
/// A builder for [`XmlEmptyBlobsInput`](crate::operation::xml_empty_blobs::XmlEmptyBlobsInput).
   87     99   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88    100   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_blobs/_xml_empty_blobs_output.rs

@@ -23,23 +106,117 @@
   43     43   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   44     44   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   45     45   
        if let Some(ref val) = self.data {
   46     46   
            ser.write_blob(&XMLEMPTYBLOBSOUTPUT_MEMBER_DATA, val)?;
   47     47   
        }
   48     48   
        Ok(())
   49     49   
    }
   50     50   
}
   51     51   
impl XmlEmptyBlobsOutput {
   52     52   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   53         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   54         -
        deserializer: &mut D,
          53  +
    pub fn deserialize(
          54  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   55     55   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   56     56   
        #[allow(unused_variables, unused_mut)]
   57     57   
        let mut builder = Self::builder();
   58     58   
        #[allow(
   59     59   
            unused_variables,
   60     60   
            unreachable_code,
   61     61   
            clippy::single_match,
   62     62   
            clippy::match_single_binding,
   63     63   
            clippy::diverging_sub_expression
   64     64   
        )]
   65         -
        deserializer.read_struct(&XMLEMPTYBLOBSOUTPUT_SCHEMA, (), |_, member, deser| {
          65  +
        deserializer.read_struct(&XMLEMPTYBLOBSOUTPUT_SCHEMA, &mut |member, deser| {
   66     66   
            match member.member_index() {
   67     67   
                Some(0) => {
   68     68   
                    builder.data = Some(deser.read_blob(member)?);
   69     69   
                }
   70     70   
                _ => {}
   71     71   
            }
   72     72   
            Ok(())
   73     73   
        })?;
   74     74   
        Ok(builder.build())
   75     75   
    }
   76     76   
}
          77  +
impl XmlEmptyBlobsOutput {
          78  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          79  +
    pub fn deserialize_with_response(
          80  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          81  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          82  +
        _status: u16,
          83  +
        _body: &[u8],
          84  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          85  +
        Self::deserialize(deserializer)
          86  +
    }
          87  +
}
   77     88   
impl XmlEmptyBlobsOutput {
   78     89   
    /// Creates a new builder-style object to manufacture [`XmlEmptyBlobsOutput`](crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput).
   79     90   
    pub fn builder() -> crate::operation::xml_empty_blobs::builders::XmlEmptyBlobsOutputBuilder {
   80     91   
        crate::operation::xml_empty_blobs::builders::XmlEmptyBlobsOutputBuilder::default()
   81     92   
    }
   82     93   
}
   83     94   
   84     95   
/// A builder for [`XmlEmptyBlobsOutput`](crate::operation::xml_empty_blobs::XmlEmptyBlobsOutput).
   85     96   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   86     97   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_lists.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `XmlEmptyLists`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct XmlEmptyLists;
    6      6   
impl XmlEmptyLists {
    7      7   
    /// Creates a new `XmlEmptyLists`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_empty_lists::XmlEmptyListsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_empty_lists::XmlEmptyListsOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::xml_empty_lists::XmlEmptyListsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::xml_empty_lists::XmlEmptyListsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::xml_empty_lists::XmlEmptyListsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::xml_empty_lists::XmlEmptyListsError,
  125    129   
            >::new());
  126    130   
  127    131   
        ::std::borrow::Cow::Owned(rcb)
  128    132   
    }
  129    133   
}
  130    134   
  131    135   
#[derive(Debug)]
  132    136   
struct XmlEmptyListsResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for XmlEmptyListsResponseDeserializer {
  134         -
    fn deserialize_nonstreaming(
         138  +
    fn deserialize_nonstreaming_with_config(
  135    139   
        &self,
  136    140   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         141  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  137    142   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  138    143   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  139    144   
        let headers = response.headers();
  140    145   
        let body = response.body().bytes().expect("body loaded");
  141    146   
        #[allow(unused_mut)]
  142    147   
        let mut force_error = false;
  143    148   
  144    149   
        let parse_result = if !success && status != 200 || force_error {
  145    150   
            crate::protocol_serde::shape_xml_empty_lists::de_xml_empty_lists_http_error(status, headers, body)
  146    151   
        } else {
@@ -279,284 +339,348 @@
  299    304   
            .expect("the config must have a deserializer");
  300    305   
  301    306   
        let parsed = de.deserialize_streaming(&mut http_response);
  302    307   
        let parsed = parsed.unwrap_or_else(|| {
  303    308   
            let http_response = http_response.map(|body| {
  304    309   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  305    310   
                    body.bytes().unwrap(),
  306    311   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  307    312   
                )))
  308    313   
            });
  309         -
            de.deserialize_nonstreaming(&http_response)
         314  +
            // Build a config bag with the protocol for schema-based deserialization
         315  +
            #[allow(unused_mut)]
         316  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         317  +
         318  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  310    319   
        });
  311    320   
        let parsed = parsed
  312    321   
            .expect("should be successful response")
  313    322   
            .downcast::<crate::operation::xml_empty_lists::XmlEmptyListsOutput>()
  314    323   
            .unwrap();
  315    324   
        ::pretty_assertions::assert_eq!(parsed.string_list, expected_output.string_list, "Unexpected value for `string_list`");
  316    325   
        ::pretty_assertions::assert_eq!(parsed.string_set, expected_output.string_set, "Unexpected value for `string_set`");
  317    326   
        ::pretty_assertions::assert_eq!(parsed.integer_list, expected_output.integer_list, "Unexpected value for `integer_list`");
  318    327   
        ::pretty_assertions::assert_eq!(parsed.boolean_list, expected_output.boolean_list, "Unexpected value for `boolean_list`");
  319    328   
        ::pretty_assertions::assert_eq!(

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_lists/_xml_empty_lists_input.rs

@@ -111,111 +342,343 @@
  131    131   
    "aws.protocoltests.restxml.synthetic",
  132    132   
    "XmlEmptyListsInput",
  133    133   
);
  134    134   
static XMLEMPTYLISTSINPUT_MEMBER_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$stringList",
  137    137   
        "aws.protocoltests.restxml.synthetic",
  138    138   
        "XmlEmptyListsInput",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::List,
  141         -
    "string_list",
         141  +
    "stringList",
  142    142   
    0,
  143    143   
);
  144    144   
static XMLEMPTYLISTSINPUT_MEMBER_STRING_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$stringSet",
  147    147   
        "aws.protocoltests.restxml.synthetic",
  148    148   
        "XmlEmptyListsInput",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::List,
  151         -
    "string_set",
         151  +
    "stringSet",
  152    152   
    1,
  153    153   
);
  154    154   
static XMLEMPTYLISTSINPUT_MEMBER_INTEGER_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static(
  156    156   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$integerList",
  157    157   
        "aws.protocoltests.restxml.synthetic",
  158    158   
        "XmlEmptyListsInput",
  159    159   
    ),
  160    160   
    ::aws_smithy_schema::ShapeType::List,
  161         -
    "integer_list",
         161  +
    "integerList",
  162    162   
    2,
  163    163   
);
  164    164   
static XMLEMPTYLISTSINPUT_MEMBER_BOOLEAN_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static(
  166    166   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$booleanList",
  167    167   
        "aws.protocoltests.restxml.synthetic",
  168    168   
        "XmlEmptyListsInput",
  169    169   
    ),
  170    170   
    ::aws_smithy_schema::ShapeType::List,
  171         -
    "boolean_list",
         171  +
    "booleanList",
  172    172   
    3,
  173    173   
);
  174    174   
static XMLEMPTYLISTSINPUT_MEMBER_TIMESTAMP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  175    175   
    ::aws_smithy_schema::ShapeId::from_static(
  176    176   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$timestampList",
  177    177   
        "aws.protocoltests.restxml.synthetic",
  178    178   
        "XmlEmptyListsInput",
  179    179   
    ),
  180    180   
    ::aws_smithy_schema::ShapeType::List,
  181         -
    "timestamp_list",
         181  +
    "timestampList",
  182    182   
    4,
  183    183   
);
  184    184   
static XMLEMPTYLISTSINPUT_MEMBER_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  185    185   
    ::aws_smithy_schema::ShapeId::from_static(
  186    186   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$enumList",
  187    187   
        "aws.protocoltests.restxml.synthetic",
  188    188   
        "XmlEmptyListsInput",
  189    189   
    ),
  190    190   
    ::aws_smithy_schema::ShapeType::List,
  191         -
    "enum_list",
         191  +
    "enumList",
  192    192   
    5,
  193    193   
);
  194    194   
static XMLEMPTYLISTSINPUT_MEMBER_INT_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  195    195   
    ::aws_smithy_schema::ShapeId::from_static(
  196    196   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$intEnumList",
  197    197   
        "aws.protocoltests.restxml.synthetic",
  198    198   
        "XmlEmptyListsInput",
  199    199   
    ),
  200    200   
    ::aws_smithy_schema::ShapeType::List,
  201         -
    "int_enum_list",
         201  +
    "intEnumList",
  202    202   
    6,
  203    203   
);
  204    204   
static XMLEMPTYLISTSINPUT_MEMBER_NESTED_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  205    205   
    ::aws_smithy_schema::ShapeId::from_static(
  206    206   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$nestedStringList",
  207    207   
        "aws.protocoltests.restxml.synthetic",
  208    208   
        "XmlEmptyListsInput",
  209    209   
    ),
  210    210   
    ::aws_smithy_schema::ShapeType::List,
  211         -
    "nested_string_list",
         211  +
    "nestedStringList",
  212    212   
    7,
  213    213   
);
  214    214   
static XMLEMPTYLISTSINPUT_MEMBER_RENAMED_LIST_MEMBERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  215    215   
    ::aws_smithy_schema::ShapeId::from_static(
  216    216   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$renamedListMembers",
  217    217   
        "aws.protocoltests.restxml.synthetic",
  218    218   
        "XmlEmptyListsInput",
  219    219   
    ),
  220    220   
    ::aws_smithy_schema::ShapeType::List,
  221         -
    "renamed_list_members",
         221  +
    "renamedListMembers",
  222    222   
    8,
  223    223   
)
  224    224   
.with_xml_name("renamed");
  225    225   
static XMLEMPTYLISTSINPUT_MEMBER_FLATTENED_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  226    226   
    ::aws_smithy_schema::ShapeId::from_static(
  227    227   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$flattenedList",
  228    228   
        "aws.protocoltests.restxml.synthetic",
  229    229   
        "XmlEmptyListsInput",
  230    230   
    ),
  231    231   
    ::aws_smithy_schema::ShapeType::List,
  232         -
    "flattened_list",
         232  +
    "flattenedList",
  233    233   
    9,
  234    234   
)
  235    235   
.with_xml_flattened();
  236    236   
static XMLEMPTYLISTSINPUT_MEMBER_FLATTENED_LIST2: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  237    237   
    ::aws_smithy_schema::ShapeId::from_static(
  238    238   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$flattenedList2",
  239    239   
        "aws.protocoltests.restxml.synthetic",
  240    240   
        "XmlEmptyListsInput",
  241    241   
    ),
  242    242   
    ::aws_smithy_schema::ShapeType::List,
  243         -
    "flattened_list2",
         243  +
    "flattenedList2",
  244    244   
    10,
  245    245   
)
  246    246   
.with_xml_name("customName")
  247    247   
.with_xml_flattened();
  248    248   
static XMLEMPTYLISTSINPUT_MEMBER_FLATTENED_LIST_WITH_MEMBER_NAMESPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  249    249   
    ::aws_smithy_schema::ShapeId::from_static(
  250    250   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$flattenedListWithMemberNamespace",
  251    251   
        "aws.protocoltests.restxml.synthetic",
  252    252   
        "XmlEmptyListsInput",
  253    253   
    ),
  254    254   
    ::aws_smithy_schema::ShapeType::List,
  255         -
    "flattened_list_with_member_namespace",
         255  +
    "flattenedListWithMemberNamespace",
  256    256   
    11,
  257    257   
)
  258    258   
.with_xml_flattened();
  259    259   
static XMLEMPTYLISTSINPUT_MEMBER_FLATTENED_LIST_WITH_NAMESPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  260    260   
    ::aws_smithy_schema::ShapeId::from_static(
  261    261   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$flattenedListWithNamespace",
  262    262   
        "aws.protocoltests.restxml.synthetic",
  263    263   
        "XmlEmptyListsInput",
  264    264   
    ),
  265    265   
    ::aws_smithy_schema::ShapeType::List,
  266         -
    "flattened_list_with_namespace",
         266  +
    "flattenedListWithNamespace",
  267    267   
    12,
  268    268   
)
  269    269   
.with_xml_flattened();
  270    270   
static XMLEMPTYLISTSINPUT_MEMBER_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  271    271   
    ::aws_smithy_schema::ShapeId::from_static(
  272    272   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$structureList",
  273    273   
        "aws.protocoltests.restxml.synthetic",
  274    274   
        "XmlEmptyListsInput",
  275    275   
    ),
  276    276   
    ::aws_smithy_schema::ShapeType::List,
  277         -
    "structure_list",
         277  +
    "structureList",
  278    278   
    13,
  279    279   
)
  280    280   
.with_xml_name("myStructureList");
  281    281   
static XMLEMPTYLISTSINPUT_MEMBER_FLATTENED_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  282    282   
    ::aws_smithy_schema::ShapeId::from_static(
  283    283   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsInput$flattenedStructureList",
  284    284   
        "aws.protocoltests.restxml.synthetic",
  285    285   
        "XmlEmptyListsInput",
  286    286   
    ),
  287    287   
    ::aws_smithy_schema::ShapeType::List,
  288         -
    "flattened_structure_list",
         288  +
    "flattenedStructureList",
  289    289   
    14,
  290    290   
)
  291    291   
.with_xml_flattened();
  292    292   
static XMLEMPTYLISTSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  293    293   
    XMLEMPTYLISTSINPUT_SCHEMA_ID,
  294    294   
    ::aws_smithy_schema::ShapeType::Structure,
  295    295   
    &[
  296    296   
        &XMLEMPTYLISTSINPUT_MEMBER_STRING_LIST,
  297    297   
        &XMLEMPTYLISTSINPUT_MEMBER_STRING_SET,
  298    298   
        &XMLEMPTYLISTSINPUT_MEMBER_INTEGER_LIST,
  299    299   
        &XMLEMPTYLISTSINPUT_MEMBER_BOOLEAN_LIST,
  300    300   
        &XMLEMPTYLISTSINPUT_MEMBER_TIMESTAMP_LIST,
  301    301   
        &XMLEMPTYLISTSINPUT_MEMBER_ENUM_LIST,
  302    302   
        &XMLEMPTYLISTSINPUT_MEMBER_INT_ENUM_LIST,
  303    303   
        &XMLEMPTYLISTSINPUT_MEMBER_NESTED_STRING_LIST,
  304    304   
        &XMLEMPTYLISTSINPUT_MEMBER_RENAMED_LIST_MEMBERS,
  305    305   
        &XMLEMPTYLISTSINPUT_MEMBER_FLATTENED_LIST,
  306    306   
        &XMLEMPTYLISTSINPUT_MEMBER_FLATTENED_LIST2,
  307    307   
        &XMLEMPTYLISTSINPUT_MEMBER_FLATTENED_LIST_WITH_MEMBER_NAMESPACE,
  308    308   
        &XMLEMPTYLISTSINPUT_MEMBER_FLATTENED_LIST_WITH_NAMESPACE,
  309    309   
        &XMLEMPTYLISTSINPUT_MEMBER_STRUCTURE_LIST,
  310    310   
        &XMLEMPTYLISTSINPUT_MEMBER_FLATTENED_STRUCTURE_LIST,
  311    311   
    ],
  312         -
);
         312  +
)
         313  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/XmlEmptyLists", None));
  313    314   
impl XmlEmptyListsInput {
  314    315   
    /// The schema for this shape.
  315    316   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLEMPTYLISTSINPUT_SCHEMA;
  316    317   
}
  317    318   
impl ::aws_smithy_schema::serde::SerializableStruct for XmlEmptyListsInput {
  318    319   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  319    320   
    fn serialize_members(
  320    321   
        &self,
  321    322   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  322    323   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
@@ -375,376 +435,444 @@
  395    396   
                    }
  396    397   
                    Ok(())
  397    398   
                },
  398    399   
            )?;
  399    400   
        }
  400    401   
        if let Some(ref val) = self.nested_string_list {
  401    402   
            ser.write_list(
  402    403   
                &XMLEMPTYLISTSINPUT_MEMBER_NESTED_STRING_LIST,
  403    404   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  404    405   
                    for item in val {
  405         -
                        todo!("schema: unsupported list element type");
         406  +
                        ser.write_list(
         407  +
                            &::aws_smithy_schema::prelude::DOCUMENT,
         408  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         409  +
                                for item in item {
         410  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         411  +
                                }
         412  +
                                Ok(())
         413  +
                            },
         414  +
                        )?;
  406    415   
                    }
  407    416   
                    Ok(())
  408    417   
                },
  409    418   
            )?;
  410    419   
        }
  411    420   
        if let Some(ref val) = self.renamed_list_members {
  412    421   
            ser.write_list(
  413    422   
                &XMLEMPTYLISTSINPUT_MEMBER_RENAMED_LIST_MEMBERS,
  414    423   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  415    424   
                    for item in val {
@@ -463,472 +740,659 @@
  483    492   
                    }
  484    493   
                    Ok(())
  485    494   
                },
  486    495   
            )?;
  487    496   
        }
  488    497   
        Ok(())
  489    498   
    }
  490    499   
}
  491    500   
impl XmlEmptyListsInput {
  492    501   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  493         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  494         -
        deserializer: &mut D,
         502  +
    pub fn deserialize(
         503  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  495    504   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  496    505   
        #[allow(unused_variables, unused_mut)]
  497    506   
        let mut builder = Self::builder();
  498    507   
        #[allow(
  499    508   
            unused_variables,
  500    509   
            unreachable_code,
  501    510   
            clippy::single_match,
  502    511   
            clippy::match_single_binding,
  503    512   
            clippy::diverging_sub_expression
  504    513   
        )]
  505         -
        deserializer.read_struct(&XMLEMPTYLISTSINPUT_SCHEMA, (), |_, member, deser| {
         514  +
        deserializer.read_struct(&XMLEMPTYLISTSINPUT_SCHEMA, &mut |member, deser| {
  506    515   
            match member.member_index() {
  507    516   
                Some(0) => {
  508         -
                    builder.string_list = Some({
  509         -
                        let container = if let Some(cap) = deser.container_size() {
  510         -
                            Vec::with_capacity(cap)
  511         -
                        } else {
  512         -
                            Vec::new()
  513         -
                        };
  514         -
                        deser.read_list(member, container, |mut list, deser| {
  515         -
                            list.push(deser.read_string(member)?);
  516         -
                            Ok(list)
  517         -
                        })?
  518         -
                    });
         517  +
                    builder.string_list = Some(deser.read_string_list(member)?);
  519    518   
                }
  520    519   
                Some(1) => {
  521         -
                    builder.string_set = Some({
  522         -
                        let container = if let Some(cap) = deser.container_size() {
  523         -
                            Vec::with_capacity(cap)
  524         -
                        } else {
  525         -
                            Vec::new()
  526         -
                        };
  527         -
                        deser.read_list(member, container, |mut list, deser| {
  528         -
                            list.push(deser.read_string(member)?);
  529         -
                            Ok(list)
  530         -
                        })?
  531         -
                    });
         520  +
                    builder.string_set = Some(deser.read_string_list(member)?);
  532    521   
                }
  533    522   
                Some(2) => {
  534         -
                    builder.integer_list = Some({
  535         -
                        let container = if let Some(cap) = deser.container_size() {
  536         -
                            Vec::with_capacity(cap)
  537         -
                        } else {
  538         -
                            Vec::new()
  539         -
                        };
  540         -
                        deser.read_list(member, container, |mut list, deser| {
  541         -
                            list.push(deser.read_integer(member)?);
  542         -
                            Ok(list)
  543         -
                        })?
  544         -
                    });
         523  +
                    builder.integer_list = Some(deser.read_integer_list(member)?);
  545    524   
                }
  546    525   
                Some(3) => {
  547    526   
                    builder.boolean_list = Some({
  548         -
                        let container = if let Some(cap) = deser.container_size() {
  549         -
                            Vec::with_capacity(cap)
  550         -
                        } else {
  551         -
                            Vec::new()
  552         -
                        };
  553         -
                        deser.read_list(member, container, |mut list, deser| {
  554         -
                            list.push(deser.read_boolean(member)?);
  555         -
                            Ok(list)
  556         -
                        })?
         527  +
                        let mut container = Vec::new();
         528  +
                        deser.read_list(member, &mut |deser| {
         529  +
                            container.push(deser.read_boolean(member)?);
         530  +
                            Ok(())
         531  +
                        })?;
         532  +
                        container
  557    533   
                    });
  558    534   
                }
  559    535   
                Some(4) => {
  560    536   
                    builder.timestamp_list = Some({
  561         -
                        let container = if let Some(cap) = deser.container_size() {
  562         -
                            Vec::with_capacity(cap)
  563         -
                        } else {
  564         -
                            Vec::new()
  565         -
                        };
  566         -
                        deser.read_list(member, container, |mut list, deser| {
  567         -
                            list.push(deser.read_timestamp(member)?);
  568         -
                            Ok(list)
  569         -
                        })?
         537  +
                        let mut container = Vec::new();
         538  +
                        deser.read_list(member, &mut |deser| {
         539  +
                            container.push(deser.read_timestamp(member)?);
         540  +
                            Ok(())
         541  +
                        })?;
         542  +
                        container
  570    543   
                    });
  571    544   
                }
  572    545   
                Some(5) => {
  573    546   
                    builder.enum_list = Some({
  574         -
                        let container = if let Some(cap) = deser.container_size() {
  575         -
                            Vec::with_capacity(cap)
  576         -
                        } else {
  577         -
                            Vec::new()
  578         -
                        };
  579         -
                        deser.read_list(member, container, |mut list, deser| {
  580         -
                            list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  581         -
                            Ok(list)
  582         -
                        })?
         547  +
                        let mut container = Vec::new();
         548  +
                        deser.read_list(member, &mut |deser| {
         549  +
                            container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
         550  +
                            Ok(())
         551  +
                        })?;
         552  +
                        container
  583    553   
                    });
  584    554   
                }
  585    555   
                Some(6) => {
  586         -
                    builder.int_enum_list = Some({
  587         -
                        let container = if let Some(cap) = deser.container_size() {
  588         -
                            Vec::with_capacity(cap)
  589         -
                        } else {
  590         -
                            Vec::new()
  591         -
                        };
  592         -
                        deser.read_list(member, container, |mut list, deser| {
  593         -
                            list.push(deser.read_integer(member)?);
  594         -
                            Ok(list)
  595         -
                        })?
  596         -
                    });
         556  +
                    builder.int_enum_list = Some(deser.read_integer_list(member)?);
  597    557   
                }
  598    558   
                Some(7) => {
  599    559   
                    builder.nested_string_list = Some({
  600         -
                        let container = if let Some(cap) = deser.container_size() {
  601         -
                            Vec::with_capacity(cap)
  602         -
                        } else {
  603         -
                            Vec::new()
  604         -
                        };
  605         -
                        deser.read_list(member, container, |mut list, deser| {
  606         -
                            list.push(todo!("deserialize nested aggregate"));
  607         -
                            Ok(list)
  608         -
                        })?
         560  +
                        let mut container = Vec::new();
         561  +
                        deser.read_list(member, &mut |deser| {
         562  +
                            container.push({
         563  +
                                let mut list = Vec::new();
         564  +
                                deser.read_list(member, &mut |deser| {
         565  +
                                    list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
         566  +
                                    Ok(())
         567  +
                                })?;
         568  +
                                list
         569  +
                            });
         570  +
                            Ok(())
         571  +
                        })?;
         572  +
                        container
  609    573   
                    });
  610    574   
                }
  611    575   
                Some(8) => {
  612         -
                    builder.renamed_list_members = Some({
  613         -
                        let container = if let Some(cap) = deser.container_size() {
  614         -
                            Vec::with_capacity(cap)
  615         -
                        } else {
  616         -
                            Vec::new()
  617         -
                        };
  618         -
                        deser.read_list(member, container, |mut list, deser| {
  619         -
                            list.push(deser.read_string(member)?);
  620         -
                            Ok(list)
  621         -
                        })?
  622         -
                    });
         576  +
                    builder.renamed_list_members = Some(deser.read_string_list(member)?);
  623    577   
                }
  624    578   
                Some(9) => {
  625         -
                    builder.flattened_list = Some({
  626         -
                        let container = if let Some(cap) = deser.container_size() {
  627         -
                            Vec::with_capacity(cap)
  628         -
                        } else {
  629         -
                            Vec::new()
  630         -
                        };
  631         -
                        deser.read_list(member, container, |mut list, deser| {
  632         -
                            list.push(deser.read_string(member)?);
  633         -
                            Ok(list)
  634         -
                        })?
  635         -
                    });
         579  +
                    builder.flattened_list = Some(deser.read_string_list(member)?);
  636    580   
                }
  637    581   
                Some(10) => {
  638         -
                    builder.flattened_list2 = Some({
  639         -
                        let container = if let Some(cap) = deser.container_size() {
  640         -
                            Vec::with_capacity(cap)
  641         -
                        } else {
  642         -
                            Vec::new()
  643         -
                        };
  644         -
                        deser.read_list(member, container, |mut list, deser| {
  645         -
                            list.push(deser.read_string(member)?);
  646         -
                            Ok(list)
  647         -
                        })?
  648         -
                    });
         582  +
                    builder.flattened_list2 = Some(deser.read_string_list(member)?);
  649    583   
                }
  650    584   
                Some(11) => {
  651         -
                    builder.flattened_list_with_member_namespace = Some({
  652         -
                        let container = if let Some(cap) = deser.container_size() {
  653         -
                            Vec::with_capacity(cap)
  654         -
                        } else {
  655         -
                            Vec::new()
  656         -
                        };
  657         -
                        deser.read_list(member, container, |mut list, deser| {
  658         -
                            list.push(deser.read_string(member)?);
  659         -
                            Ok(list)
  660         -
                        })?
  661         -
                    });
         585  +
                    builder.flattened_list_with_member_namespace = Some(deser.read_string_list(member)?);
  662    586   
                }
  663    587   
                Some(12) => {
  664         -
                    builder.flattened_list_with_namespace = Some({
  665         -
                        let container = if let Some(cap) = deser.container_size() {
  666         -
                            Vec::with_capacity(cap)
  667         -
                        } else {
  668         -
                            Vec::new()
  669         -
                        };
  670         -
                        deser.read_list(member, container, |mut list, deser| {
  671         -
                            list.push(deser.read_string(member)?);
  672         -
                            Ok(list)
  673         -
                        })?
  674         -
                    });
         588  +
                    builder.flattened_list_with_namespace = Some(deser.read_string_list(member)?);
  675    589   
                }
  676    590   
                Some(13) => {
  677    591   
                    builder.structure_list = Some({
  678         -
                        let container = if let Some(cap) = deser.container_size() {
  679         -
                            Vec::with_capacity(cap)
  680         -
                        } else {
  681         -
                            Vec::new()
  682         -
                        };
  683         -
                        deser.read_list(member, container, |mut list, deser| {
  684         -
                            list.push(crate::types::StructureListMember::deserialize(deser)?);
  685         -
                            Ok(list)
  686         -
                        })?
         592  +
                        let mut container = Vec::new();
         593  +
                        deser.read_list(member, &mut |deser| {
         594  +
                            container.push(crate::types::StructureListMember::deserialize(deser)?);
         595  +
                            Ok(())
         596  +
                        })?;
         597  +
                        container
  687    598   
                    });
  688    599   
                }
  689    600   
                Some(14) => {
  690    601   
                    builder.flattened_structure_list = Some({
  691         -
                        let container = if let Some(cap) = deser.container_size() {
  692         -
                            Vec::with_capacity(cap)
  693         -
                        } else {
  694         -
                            Vec::new()
  695         -
                        };
  696         -
                        deser.read_list(member, container, |mut list, deser| {
  697         -
                            list.push(crate::types::StructureListMember::deserialize(deser)?);
  698         -
                            Ok(list)
  699         -
                        })?
         602  +
                        let mut container = Vec::new();
         603  +
                        deser.read_list(member, &mut |deser| {
         604  +
                            container.push(crate::types::StructureListMember::deserialize(deser)?);
         605  +
                            Ok(())
         606  +
                        })?;
         607  +
                        container
  700    608   
                    });
  701    609   
                }
  702    610   
                _ => {}
  703    611   
            }
  704    612   
            Ok(())
  705    613   
        })?;
  706    614   
        builder
  707    615   
            .build()
  708    616   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  709    617   
    }
  710    618   
}
         619  +
impl XmlEmptyListsInput {
         620  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         621  +
    pub fn deserialize_with_response(
         622  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         623  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         624  +
        _status: u16,
         625  +
        _body: &[u8],
         626  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         627  +
        Self::deserialize(deserializer)
         628  +
    }
         629  +
}
  711    630   
impl XmlEmptyListsInput {
  712    631   
    /// Creates a new builder-style object to manufacture [`XmlEmptyListsInput`](crate::operation::xml_empty_lists::XmlEmptyListsInput).
  713    632   
    pub fn builder() -> crate::operation::xml_empty_lists::builders::XmlEmptyListsInputBuilder {
  714    633   
        crate::operation::xml_empty_lists::builders::XmlEmptyListsInputBuilder::default()
  715    634   
    }
  716    635   
}
  717    636   
  718    637   
/// A builder for [`XmlEmptyListsInput`](crate::operation::xml_empty_lists::XmlEmptyListsInput).
  719    638   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  720    639   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_lists/_xml_empty_lists_output.rs

@@ -111,111 +318,318 @@
  131    131   
    "aws.protocoltests.restxml.synthetic",
  132    132   
    "XmlEmptyListsOutput",
  133    133   
);
  134    134   
static XMLEMPTYLISTSOUTPUT_MEMBER_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$stringList",
  137    137   
        "aws.protocoltests.restxml.synthetic",
  138    138   
        "XmlEmptyListsOutput",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::List,
  141         -
    "string_list",
         141  +
    "stringList",
  142    142   
    0,
  143    143   
);
  144    144   
static XMLEMPTYLISTSOUTPUT_MEMBER_STRING_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$stringSet",
  147    147   
        "aws.protocoltests.restxml.synthetic",
  148    148   
        "XmlEmptyListsOutput",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::List,
  151         -
    "string_set",
         151  +
    "stringSet",
  152    152   
    1,
  153    153   
);
  154    154   
static XMLEMPTYLISTSOUTPUT_MEMBER_INTEGER_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static(
  156    156   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$integerList",
  157    157   
        "aws.protocoltests.restxml.synthetic",
  158    158   
        "XmlEmptyListsOutput",
  159    159   
    ),
  160    160   
    ::aws_smithy_schema::ShapeType::List,
  161         -
    "integer_list",
         161  +
    "integerList",
  162    162   
    2,
  163    163   
);
  164    164   
static XMLEMPTYLISTSOUTPUT_MEMBER_BOOLEAN_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static(
  166    166   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$booleanList",
  167    167   
        "aws.protocoltests.restxml.synthetic",
  168    168   
        "XmlEmptyListsOutput",
  169    169   
    ),
  170    170   
    ::aws_smithy_schema::ShapeType::List,
  171         -
    "boolean_list",
         171  +
    "booleanList",
  172    172   
    3,
  173    173   
);
  174    174   
static XMLEMPTYLISTSOUTPUT_MEMBER_TIMESTAMP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  175    175   
    ::aws_smithy_schema::ShapeId::from_static(
  176    176   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$timestampList",
  177    177   
        "aws.protocoltests.restxml.synthetic",
  178    178   
        "XmlEmptyListsOutput",
  179    179   
    ),
  180    180   
    ::aws_smithy_schema::ShapeType::List,
  181         -
    "timestamp_list",
         181  +
    "timestampList",
  182    182   
    4,
  183    183   
);
  184    184   
static XMLEMPTYLISTSOUTPUT_MEMBER_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  185    185   
    ::aws_smithy_schema::ShapeId::from_static(
  186    186   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$enumList",
  187    187   
        "aws.protocoltests.restxml.synthetic",
  188    188   
        "XmlEmptyListsOutput",
  189    189   
    ),
  190    190   
    ::aws_smithy_schema::ShapeType::List,
  191         -
    "enum_list",
         191  +
    "enumList",
  192    192   
    5,
  193    193   
);
  194    194   
static XMLEMPTYLISTSOUTPUT_MEMBER_INT_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  195    195   
    ::aws_smithy_schema::ShapeId::from_static(
  196    196   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$intEnumList",
  197    197   
        "aws.protocoltests.restxml.synthetic",
  198    198   
        "XmlEmptyListsOutput",
  199    199   
    ),
  200    200   
    ::aws_smithy_schema::ShapeType::List,
  201         -
    "int_enum_list",
         201  +
    "intEnumList",
  202    202   
    6,
  203    203   
);
  204    204   
static XMLEMPTYLISTSOUTPUT_MEMBER_NESTED_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  205    205   
    ::aws_smithy_schema::ShapeId::from_static(
  206    206   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$nestedStringList",
  207    207   
        "aws.protocoltests.restxml.synthetic",
  208    208   
        "XmlEmptyListsOutput",
  209    209   
    ),
  210    210   
    ::aws_smithy_schema::ShapeType::List,
  211         -
    "nested_string_list",
         211  +
    "nestedStringList",
  212    212   
    7,
  213    213   
);
  214    214   
static XMLEMPTYLISTSOUTPUT_MEMBER_RENAMED_LIST_MEMBERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  215    215   
    ::aws_smithy_schema::ShapeId::from_static(
  216    216   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$renamedListMembers",
  217    217   
        "aws.protocoltests.restxml.synthetic",
  218    218   
        "XmlEmptyListsOutput",
  219    219   
    ),
  220    220   
    ::aws_smithy_schema::ShapeType::List,
  221         -
    "renamed_list_members",
         221  +
    "renamedListMembers",
  222    222   
    8,
  223    223   
)
  224    224   
.with_xml_name("renamed");
  225    225   
static XMLEMPTYLISTSOUTPUT_MEMBER_FLATTENED_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  226    226   
    ::aws_smithy_schema::ShapeId::from_static(
  227    227   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$flattenedList",
  228    228   
        "aws.protocoltests.restxml.synthetic",
  229    229   
        "XmlEmptyListsOutput",
  230    230   
    ),
  231    231   
    ::aws_smithy_schema::ShapeType::List,
  232         -
    "flattened_list",
         232  +
    "flattenedList",
  233    233   
    9,
  234    234   
)
  235    235   
.with_xml_flattened();
  236    236   
static XMLEMPTYLISTSOUTPUT_MEMBER_FLATTENED_LIST2: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  237    237   
    ::aws_smithy_schema::ShapeId::from_static(
  238    238   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$flattenedList2",
  239    239   
        "aws.protocoltests.restxml.synthetic",
  240    240   
        "XmlEmptyListsOutput",
  241    241   
    ),
  242    242   
    ::aws_smithy_schema::ShapeType::List,
  243         -
    "flattened_list2",
         243  +
    "flattenedList2",
  244    244   
    10,
  245    245   
)
  246    246   
.with_xml_name("customName")
  247    247   
.with_xml_flattened();
  248    248   
static XMLEMPTYLISTSOUTPUT_MEMBER_FLATTENED_LIST_WITH_MEMBER_NAMESPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  249    249   
    ::aws_smithy_schema::ShapeId::from_static(
  250    250   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$flattenedListWithMemberNamespace",
  251    251   
        "aws.protocoltests.restxml.synthetic",
  252    252   
        "XmlEmptyListsOutput",
  253    253   
    ),
  254    254   
    ::aws_smithy_schema::ShapeType::List,
  255         -
    "flattened_list_with_member_namespace",
         255  +
    "flattenedListWithMemberNamespace",
  256    256   
    11,
  257    257   
)
  258    258   
.with_xml_flattened();
  259    259   
static XMLEMPTYLISTSOUTPUT_MEMBER_FLATTENED_LIST_WITH_NAMESPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  260    260   
    ::aws_smithy_schema::ShapeId::from_static(
  261    261   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$flattenedListWithNamespace",
  262    262   
        "aws.protocoltests.restxml.synthetic",
  263    263   
        "XmlEmptyListsOutput",
  264    264   
    ),
  265    265   
    ::aws_smithy_schema::ShapeType::List,
  266         -
    "flattened_list_with_namespace",
         266  +
    "flattenedListWithNamespace",
  267    267   
    12,
  268    268   
)
  269    269   
.with_xml_flattened();
  270    270   
static XMLEMPTYLISTSOUTPUT_MEMBER_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  271    271   
    ::aws_smithy_schema::ShapeId::from_static(
  272    272   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$structureList",
  273    273   
        "aws.protocoltests.restxml.synthetic",
  274    274   
        "XmlEmptyListsOutput",
  275    275   
    ),
  276    276   
    ::aws_smithy_schema::ShapeType::List,
  277         -
    "structure_list",
         277  +
    "structureList",
  278    278   
    13,
  279    279   
)
  280    280   
.with_xml_name("myStructureList");
  281    281   
static XMLEMPTYLISTSOUTPUT_MEMBER_FLATTENED_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  282    282   
    ::aws_smithy_schema::ShapeId::from_static(
  283    283   
        "aws.protocoltests.restxml.synthetic#XmlEmptyListsOutput$flattenedStructureList",
  284    284   
        "aws.protocoltests.restxml.synthetic",
  285    285   
        "XmlEmptyListsOutput",
  286    286   
    ),
  287    287   
    ::aws_smithy_schema::ShapeType::List,
  288         -
    "flattened_structure_list",
         288  +
    "flattenedStructureList",
  289    289   
    14,
  290    290   
)
  291    291   
.with_xml_flattened();
  292    292   
static XMLEMPTYLISTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  293    293   
    XMLEMPTYLISTSOUTPUT_SCHEMA_ID,
  294    294   
    ::aws_smithy_schema::ShapeType::Structure,
  295    295   
    &[
  296    296   
        &XMLEMPTYLISTSOUTPUT_MEMBER_STRING_LIST,
  297    297   
        &XMLEMPTYLISTSOUTPUT_MEMBER_STRING_SET,
  298    298   
        &XMLEMPTYLISTSOUTPUT_MEMBER_INTEGER_LIST,
@@ -375,375 +435,443 @@
  395    395   
                    }
  396    396   
                    Ok(())
  397    397   
                },
  398    398   
            )?;
  399    399   
        }
  400    400   
        if let Some(ref val) = self.nested_string_list {
  401    401   
            ser.write_list(
  402    402   
                &XMLEMPTYLISTSOUTPUT_MEMBER_NESTED_STRING_LIST,
  403    403   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  404    404   
                    for item in val {
  405         -
                        todo!("schema: unsupported list element type");
         405  +
                        ser.write_list(
         406  +
                            &::aws_smithy_schema::prelude::DOCUMENT,
         407  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         408  +
                                for item in item {
         409  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         410  +
                                }
         411  +
                                Ok(())
         412  +
                            },
         413  +
                        )?;
  406    414   
                    }
  407    415   
                    Ok(())
  408    416   
                },
  409    417   
            )?;
  410    418   
        }
  411    419   
        if let Some(ref val) = self.renamed_list_members {
  412    420   
            ser.write_list(
  413    421   
                &XMLEMPTYLISTSOUTPUT_MEMBER_RENAMED_LIST_MEMBERS,
  414    422   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  415    423   
                    for item in val {
@@ -463,471 +738,656 @@
  483    491   
                    }
  484    492   
                    Ok(())
  485    493   
                },
  486    494   
            )?;
  487    495   
        }
  488    496   
        Ok(())
  489    497   
    }
  490    498   
}
  491    499   
impl XmlEmptyListsOutput {
  492    500   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  493         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  494         -
        deserializer: &mut D,
         501  +
    pub fn deserialize(
         502  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  495    503   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  496    504   
        #[allow(unused_variables, unused_mut)]
  497    505   
        let mut builder = Self::builder();
  498    506   
        #[allow(
  499    507   
            unused_variables,
  500    508   
            unreachable_code,
  501    509   
            clippy::single_match,
  502    510   
            clippy::match_single_binding,
  503    511   
            clippy::diverging_sub_expression
  504    512   
        )]
  505         -
        deserializer.read_struct(&XMLEMPTYLISTSOUTPUT_SCHEMA, (), |_, member, deser| {
         513  +
        deserializer.read_struct(&XMLEMPTYLISTSOUTPUT_SCHEMA, &mut |member, deser| {
  506    514   
            match member.member_index() {
  507    515   
                Some(0) => {
  508         -
                    builder.string_list = Some({
  509         -
                        let container = if let Some(cap) = deser.container_size() {
  510         -
                            Vec::with_capacity(cap)
  511         -
                        } else {
  512         -
                            Vec::new()
  513         -
                        };
  514         -
                        deser.read_list(member, container, |mut list, deser| {
  515         -
                            list.push(deser.read_string(member)?);
  516         -
                            Ok(list)
  517         -
                        })?
  518         -
                    });
         516  +
                    builder.string_list = Some(deser.read_string_list(member)?);
  519    517   
                }
  520    518   
                Some(1) => {
  521         -
                    builder.string_set = Some({
  522         -
                        let container = if let Some(cap) = deser.container_size() {
  523         -
                            Vec::with_capacity(cap)
  524         -
                        } else {
  525         -
                            Vec::new()
  526         -
                        };
  527         -
                        deser.read_list(member, container, |mut list, deser| {
  528         -
                            list.push(deser.read_string(member)?);
  529         -
                            Ok(list)
  530         -
                        })?
  531         -
                    });
         519  +
                    builder.string_set = Some(deser.read_string_list(member)?);
  532    520   
                }
  533    521   
                Some(2) => {
  534         -
                    builder.integer_list = Some({
  535         -
                        let container = if let Some(cap) = deser.container_size() {
  536         -
                            Vec::with_capacity(cap)
  537         -
                        } else {
  538         -
                            Vec::new()
  539         -
                        };
  540         -
                        deser.read_list(member, container, |mut list, deser| {
  541         -
                            list.push(deser.read_integer(member)?);
  542         -
                            Ok(list)
  543         -
                        })?
  544         -
                    });
         522  +
                    builder.integer_list = Some(deser.read_integer_list(member)?);
  545    523   
                }
  546    524   
                Some(3) => {
  547    525   
                    builder.boolean_list = Some({
  548         -
                        let container = if let Some(cap) = deser.container_size() {
  549         -
                            Vec::with_capacity(cap)
  550         -
                        } else {
  551         -
                            Vec::new()
  552         -
                        };
  553         -
                        deser.read_list(member, container, |mut list, deser| {
  554         -
                            list.push(deser.read_boolean(member)?);
  555         -
                            Ok(list)
  556         -
                        })?
         526  +
                        let mut container = Vec::new();
         527  +
                        deser.read_list(member, &mut |deser| {
         528  +
                            container.push(deser.read_boolean(member)?);
         529  +
                            Ok(())
         530  +
                        })?;
         531  +
                        container
  557    532   
                    });
  558    533   
                }
  559    534   
                Some(4) => {
  560    535   
                    builder.timestamp_list = Some({
  561         -
                        let container = if let Some(cap) = deser.container_size() {
  562         -
                            Vec::with_capacity(cap)
  563         -
                        } else {
  564         -
                            Vec::new()
  565         -
                        };
  566         -
                        deser.read_list(member, container, |mut list, deser| {
  567         -
                            list.push(deser.read_timestamp(member)?);
  568         -
                            Ok(list)
  569         -
                        })?
         536  +
                        let mut container = Vec::new();
         537  +
                        deser.read_list(member, &mut |deser| {
         538  +
                            container.push(deser.read_timestamp(member)?);
         539  +
                            Ok(())
         540  +
                        })?;
         541  +
                        container
  570    542   
                    });
  571    543   
                }
  572    544   
                Some(5) => {
  573    545   
                    builder.enum_list = Some({
  574         -
                        let container = if let Some(cap) = deser.container_size() {
  575         -
                            Vec::with_capacity(cap)
  576         -
                        } else {
  577         -
                            Vec::new()
  578         -
                        };
  579         -
                        deser.read_list(member, container, |mut list, deser| {
  580         -
                            list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  581         -
                            Ok(list)
  582         -
                        })?
         546  +
                        let mut container = Vec::new();
         547  +
                        deser.read_list(member, &mut |deser| {
         548  +
                            container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
         549  +
                            Ok(())
         550  +
                        })?;
         551  +
                        container
  583    552   
                    });
  584    553   
                }
  585    554   
                Some(6) => {
  586         -
                    builder.int_enum_list = Some({
  587         -
                        let container = if let Some(cap) = deser.container_size() {
  588         -
                            Vec::with_capacity(cap)
  589         -
                        } else {
  590         -
                            Vec::new()
  591         -
                        };
  592         -
                        deser.read_list(member, container, |mut list, deser| {
  593         -
                            list.push(deser.read_integer(member)?);
  594         -
                            Ok(list)
  595         -
                        })?
  596         -
                    });
         555  +
                    builder.int_enum_list = Some(deser.read_integer_list(member)?);
  597    556   
                }
  598    557   
                Some(7) => {
  599    558   
                    builder.nested_string_list = Some({
  600         -
                        let container = if let Some(cap) = deser.container_size() {
  601         -
                            Vec::with_capacity(cap)
  602         -
                        } else {
  603         -
                            Vec::new()
  604         -
                        };
  605         -
                        deser.read_list(member, container, |mut list, deser| {
  606         -
                            list.push(todo!("deserialize nested aggregate"));
  607         -
                            Ok(list)
  608         -
                        })?
         559  +
                        let mut container = Vec::new();
         560  +
                        deser.read_list(member, &mut |deser| {
         561  +
                            container.push({
         562  +
                                let mut list = Vec::new();
         563  +
                                deser.read_list(member, &mut |deser| {
         564  +
                                    list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
         565  +
                                    Ok(())
         566  +
                                })?;
         567  +
                                list
         568  +
                            });
         569  +
                            Ok(())
         570  +
                        })?;
         571  +
                        container
  609    572   
                    });
  610    573   
                }
  611    574   
                Some(8) => {
  612         -
                    builder.renamed_list_members = Some({
  613         -
                        let container = if let Some(cap) = deser.container_size() {
  614         -
                            Vec::with_capacity(cap)
  615         -
                        } else {
  616         -
                            Vec::new()
  617         -
                        };
  618         -
                        deser.read_list(member, container, |mut list, deser| {
  619         -
                            list.push(deser.read_string(member)?);
  620         -
                            Ok(list)
  621         -
                        })?
  622         -
                    });
         575  +
                    builder.renamed_list_members = Some(deser.read_string_list(member)?);
  623    576   
                }
  624    577   
                Some(9) => {
  625         -
                    builder.flattened_list = Some({
  626         -
                        let container = if let Some(cap) = deser.container_size() {
  627         -
                            Vec::with_capacity(cap)
  628         -
                        } else {
  629         -
                            Vec::new()
  630         -
                        };
  631         -
                        deser.read_list(member, container, |mut list, deser| {
  632         -
                            list.push(deser.read_string(member)?);
  633         -
                            Ok(list)
  634         -
                        })?
  635         -
                    });
         578  +
                    builder.flattened_list = Some(deser.read_string_list(member)?);
  636    579   
                }
  637    580   
                Some(10) => {
  638         -
                    builder.flattened_list2 = Some({
  639         -
                        let container = if let Some(cap) = deser.container_size() {
  640         -
                            Vec::with_capacity(cap)
  641         -
                        } else {
  642         -
                            Vec::new()
  643         -
                        };
  644         -
                        deser.read_list(member, container, |mut list, deser| {
  645         -
                            list.push(deser.read_string(member)?);
  646         -
                            Ok(list)
  647         -
                        })?
  648         -
                    });
         581  +
                    builder.flattened_list2 = Some(deser.read_string_list(member)?);
  649    582   
                }
  650    583   
                Some(11) => {
  651         -
                    builder.flattened_list_with_member_namespace = Some({
  652         -
                        let container = if let Some(cap) = deser.container_size() {
  653         -
                            Vec::with_capacity(cap)
  654         -
                        } else {
  655         -
                            Vec::new()
  656         -
                        };
  657         -
                        deser.read_list(member, container, |mut list, deser| {
  658         -
                            list.push(deser.read_string(member)?);
  659         -
                            Ok(list)
  660         -
                        })?
  661         -
                    });
         584  +
                    builder.flattened_list_with_member_namespace = Some(deser.read_string_list(member)?);
  662    585   
                }
  663    586   
                Some(12) => {
  664         -
                    builder.flattened_list_with_namespace = Some({
  665         -
                        let container = if let Some(cap) = deser.container_size() {
  666         -
                            Vec::with_capacity(cap)
  667         -
                        } else {
  668         -
                            Vec::new()
  669         -
                        };
  670         -
                        deser.read_list(member, container, |mut list, deser| {
  671         -
                            list.push(deser.read_string(member)?);
  672         -
                            Ok(list)
  673         -
                        })?
  674         -
                    });
         587  +
                    builder.flattened_list_with_namespace = Some(deser.read_string_list(member)?);
  675    588   
                }
  676    589   
                Some(13) => {
  677    590   
                    builder.structure_list = Some({
  678         -
                        let container = if let Some(cap) = deser.container_size() {
  679         -
                            Vec::with_capacity(cap)
  680         -
                        } else {
  681         -
                            Vec::new()
  682         -
                        };
  683         -
                        deser.read_list(member, container, |mut list, deser| {
  684         -
                            list.push(crate::types::StructureListMember::deserialize(deser)?);
  685         -
                            Ok(list)
  686         -
                        })?
         591  +
                        let mut container = Vec::new();
         592  +
                        deser.read_list(member, &mut |deser| {
         593  +
                            container.push(crate::types::StructureListMember::deserialize(deser)?);
         594  +
                            Ok(())
         595  +
                        })?;
         596  +
                        container
  687    597   
                    });
  688    598   
                }
  689    599   
                Some(14) => {
  690    600   
                    builder.flattened_structure_list = Some({
  691         -
                        let container = if let Some(cap) = deser.container_size() {
  692         -
                            Vec::with_capacity(cap)
  693         -
                        } else {
  694         -
                            Vec::new()
  695         -
                        };
  696         -
                        deser.read_list(member, container, |mut list, deser| {
  697         -
                            list.push(crate::types::StructureListMember::deserialize(deser)?);
  698         -
                            Ok(list)
  699         -
                        })?
         601  +
                        let mut container = Vec::new();
         602  +
                        deser.read_list(member, &mut |deser| {
         603  +
                            container.push(crate::types::StructureListMember::deserialize(deser)?);
         604  +
                            Ok(())
         605  +
                        })?;
         606  +
                        container
  700    607   
                    });
  701    608   
                }
  702    609   
                _ => {}
  703    610   
            }
  704    611   
            Ok(())
  705    612   
        })?;
  706    613   
        Ok(builder.build())
  707    614   
    }
  708    615   
}
         616  +
impl XmlEmptyListsOutput {
         617  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         618  +
    pub fn deserialize_with_response(
         619  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         620  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         621  +
        _status: u16,
         622  +
        _body: &[u8],
         623  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         624  +
        Self::deserialize(deserializer)
         625  +
    }
         626  +
}
  709    627   
impl XmlEmptyListsOutput {
  710    628   
    /// Creates a new builder-style object to manufacture [`XmlEmptyListsOutput`](crate::operation::xml_empty_lists::XmlEmptyListsOutput).
  711    629   
    pub fn builder() -> crate::operation::xml_empty_lists::builders::XmlEmptyListsOutputBuilder {
  712    630   
        crate::operation::xml_empty_lists::builders::XmlEmptyListsOutputBuilder::default()
  713    631   
    }
  714    632   
}
  715    633   
  716    634   
/// A builder for [`XmlEmptyListsOutput`](crate::operation::xml_empty_lists::XmlEmptyListsOutput).
  717    635   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  718    636   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_maps.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `XmlEmptyMaps`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct XmlEmptyMaps;
    6      6   
impl XmlEmptyMaps {
    7      7   
    /// Creates a new `XmlEmptyMaps`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_empty_maps::XmlEmptyMapsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_empty_maps::XmlEmptyMapsOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::xml_empty_maps::XmlEmptyMapsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::xml_empty_maps::XmlEmptyMapsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::xml_empty_maps::XmlEmptyMapsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::xml_empty_maps::XmlEmptyMapsError,
  125    129   
            >::new());
  126    130   
  127    131   
        ::std::borrow::Cow::Owned(rcb)
  128    132   
    }
  129    133   
}
  130    134   
  131    135   
#[derive(Debug)]
  132    136   
struct XmlEmptyMapsResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for XmlEmptyMapsResponseDeserializer {
  134         -
    fn deserialize_nonstreaming(
         138  +
    fn deserialize_nonstreaming_with_config(
  135    139   
        &self,
  136    140   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         141  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  137    142   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  138    143   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  139    144   
        let headers = response.headers();
  140    145   
        let body = response.body().bytes().expect("body loaded");
  141    146   
        #[allow(unused_mut)]
  142    147   
        let mut force_error = false;
  143    148   
  144    149   
        let parse_result = if !success && status != 200 || force_error {
  145    150   
            crate::protocol_serde::shape_xml_empty_maps::de_xml_empty_maps_http_error(status, headers, body)
  146    151   
        } else {
@@ -277,282 +381,394 @@
  297    302   
            .expect("the config must have a deserializer");
  298    303   
  299    304   
        let parsed = de.deserialize_streaming(&mut http_response);
  300    305   
        let parsed = parsed.unwrap_or_else(|| {
  301    306   
            let http_response = http_response.map(|body| {
  302    307   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  303    308   
                    body.bytes().unwrap(),
  304    309   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  305    310   
                )))
  306    311   
            });
  307         -
            de.deserialize_nonstreaming(&http_response)
         312  +
            // Build a config bag with the protocol for schema-based deserialization
         313  +
            #[allow(unused_mut)]
         314  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         315  +
         316  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  308    317   
        });
  309    318   
        let parsed = parsed
  310    319   
            .expect("should be successful response")
  311    320   
            .downcast::<crate::operation::xml_empty_maps::XmlEmptyMapsOutput>()
  312    321   
            .unwrap();
  313    322   
        ::pretty_assertions::assert_eq!(parsed.my_map, expected_output.my_map, "Unexpected value for `my_map`");
  314    323   
    }
  315    324   
  316    325   
    /// Deserializes Empty Self-closed XML maps
  317    326   
    /// Test ID: XmlEmptySelfClosedMaps
  318    327   
    #[::tokio::test]
  319    328   
    #[::tracing_test::traced_test]
  320    329   
    async fn xml_empty_self_closed_maps_response() {
  321    330   
        let expected_output = crate::operation::xml_empty_maps::XmlEmptyMapsOutput::builder()
  322    331   
            .set_my_map(::std::option::Option::Some(::std::collections::HashMap::new()))
  323    332   
            .build();
  324    333   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  325    334   
            ::http_1x::response::Builder::new()
  326    335   
                .header("Content-Type", "application/xml")
  327    336   
                .status(200)
  328    337   
                .body(::aws_smithy_types::body::SdkBody::from(
  329    338   
                    "<XmlEmptyMapsResponse>\n    <myMap/>\n</XmlEmptyMapsResponse>\n",
  330    339   
                ))
  331    340   
                .unwrap(),
  332    341   
        )
  333    342   
        .unwrap();
  334    343   
        use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
  335    344   
        use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
  336    345   
  337    346   
        let op = crate::operation::xml_empty_maps::XmlEmptyMaps::new();
  338    347   
        let config = op.config().expect("the operation has config");
  339    348   
        let de = config
  340    349   
            .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
  341    350   
            .expect("the config must have a deserializer");
  342    351   
  343    352   
        let parsed = de.deserialize_streaming(&mut http_response);
  344    353   
        let parsed = parsed.unwrap_or_else(|| {
  345    354   
            let http_response = http_response.map(|body| {
  346    355   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  347    356   
                    body.bytes().unwrap(),
  348    357   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  349    358   
                )))
  350    359   
            });
  351         -
            de.deserialize_nonstreaming(&http_response)
         360  +
            // Build a config bag with the protocol for schema-based deserialization
         361  +
            #[allow(unused_mut)]
         362  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         363  +
         364  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  352    365   
        });
  353    366   
        let parsed = parsed
  354    367   
            .expect("should be successful response")
  355    368   
            .downcast::<crate::operation::xml_empty_maps::XmlEmptyMapsOutput>()
  356    369   
            .unwrap();
  357    370   
        ::pretty_assertions::assert_eq!(parsed.my_map, expected_output.my_map, "Unexpected value for `my_map`");
  358    371   
    }
  359    372   
}
  360    373   
  361    374   
/// Error type for the `XmlEmptyMapsError` operation.

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_maps/_xml_empty_maps_input.rs

@@ -1,1 +127,136 @@
   17     17   
    "aws.protocoltests.restxml.synthetic",
   18     18   
    "XmlEmptyMapsInput",
   19     19   
);
   20     20   
static XMLEMPTYMAPSINPUT_MEMBER_MY_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static(
   22     22   
        "aws.protocoltests.restxml.synthetic#XmlEmptyMapsInput$myMap",
   23     23   
        "aws.protocoltests.restxml.synthetic",
   24     24   
        "XmlEmptyMapsInput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::Map,
   27         -
    "my_map",
          27  +
    "myMap",
   28     28   
    0,
   29     29   
);
   30     30   
static XMLEMPTYMAPSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   31     31   
    XMLEMPTYMAPSINPUT_SCHEMA_ID,
   32     32   
    ::aws_smithy_schema::ShapeType::Structure,
   33     33   
    &[&XMLEMPTYMAPSINPUT_MEMBER_MY_MAP],
   34         -
);
          34  +
)
          35  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("POST", "/XmlEmptyMaps", None));
   35     36   
impl XmlEmptyMapsInput {
   36     37   
    /// The schema for this shape.
   37     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLEMPTYMAPSINPUT_SCHEMA;
   38     39   
}
   39     40   
impl ::aws_smithy_schema::serde::SerializableStruct for XmlEmptyMapsInput {
   40     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   41     42   
    fn serialize_members(
   42     43   
        &self,
   43     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   44     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   45     46   
        if let Some(ref val) = self.my_map {
   46     47   
            ser.write_map(
   47     48   
                &XMLEMPTYMAPSINPUT_MEMBER_MY_MAP,
   48     49   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   49     50   
                    for (key, value) in val {
   50     51   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   51     52   
                        ser.write_struct(crate::types::GreetingStruct::SCHEMA, value)?;
   52     53   
                    }
   53     54   
                    Ok(())
   54     55   
                },
   55     56   
            )?;
   56     57   
        }
   57     58   
        Ok(())
   58     59   
    }
   59     60   
}
   60     61   
impl XmlEmptyMapsInput {
   61     62   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   62         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   63         -
        deserializer: &mut D,
          63  +
    pub fn deserialize(
          64  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   64     65   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   65     66   
        #[allow(unused_variables, unused_mut)]
   66     67   
        let mut builder = Self::builder();
   67     68   
        #[allow(
   68     69   
            unused_variables,
   69     70   
            unreachable_code,
   70     71   
            clippy::single_match,
   71     72   
            clippy::match_single_binding,
   72     73   
            clippy::diverging_sub_expression
   73     74   
        )]
   74         -
        deserializer.read_struct(&XMLEMPTYMAPSINPUT_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&XMLEMPTYMAPSINPUT_SCHEMA, &mut |member, deser| {
   75     76   
            match member.member_index() {
   76     77   
                Some(0) => {
   77     78   
                    builder.my_map = Some({
   78         -
                        let container = if let Some(cap) = deser.container_size() {
   79         -
                            std::collections::HashMap::with_capacity(cap)
   80         -
                        } else {
   81         -
                            std::collections::HashMap::new()
   82         -
                        };
   83         -
                        deser.read_map(member, container, |mut map, key, deser| {
   84         -
                            map.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
   85         -
                            Ok(map)
   86         -
                        })?
          79  +
                        let mut container = std::collections::HashMap::new();
          80  +
                        deser.read_map(member, &mut |key, deser| {
          81  +
                            container.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
          82  +
                            Ok(())
          83  +
                        })?;
          84  +
                        container
   87     85   
                    });
   88     86   
                }
   89     87   
                _ => {}
   90     88   
            }
   91     89   
            Ok(())
   92     90   
        })?;
   93     91   
        builder
   94     92   
            .build()
   95     93   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   96     94   
    }
   97     95   
}
          96  +
impl XmlEmptyMapsInput {
          97  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          98  +
    pub fn deserialize_with_response(
          99  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         100  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         101  +
        _status: u16,
         102  +
        _body: &[u8],
         103  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         104  +
        Self::deserialize(deserializer)
         105  +
    }
         106  +
}
   98    107   
impl XmlEmptyMapsInput {
   99    108   
    /// Creates a new builder-style object to manufacture [`XmlEmptyMapsInput`](crate::operation::xml_empty_maps::XmlEmptyMapsInput).
  100    109   
    pub fn builder() -> crate::operation::xml_empty_maps::builders::XmlEmptyMapsInputBuilder {
  101    110   
        crate::operation::xml_empty_maps::builders::XmlEmptyMapsInputBuilder::default()
  102    111   
    }
  103    112   
}
  104    113   
  105    114   
/// A builder for [`XmlEmptyMapsInput`](crate::operation::xml_empty_maps::XmlEmptyMapsInput).
  106    115   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  107    116   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_maps/_xml_empty_maps_output.rs

@@ -1,1 +125,133 @@
   17     17   
    "aws.protocoltests.restxml.synthetic",
   18     18   
    "XmlEmptyMapsOutput",
   19     19   
);
   20     20   
static XMLEMPTYMAPSOUTPUT_MEMBER_MY_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static(
   22     22   
        "aws.protocoltests.restxml.synthetic#XmlEmptyMapsOutput$myMap",
   23     23   
        "aws.protocoltests.restxml.synthetic",
   24     24   
        "XmlEmptyMapsOutput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::Map,
   27         -
    "my_map",
          27  +
    "myMap",
   28     28   
    0,
   29     29   
);
   30     30   
static XMLEMPTYMAPSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   31     31   
    XMLEMPTYMAPSOUTPUT_SCHEMA_ID,
   32     32   
    ::aws_smithy_schema::ShapeType::Structure,
   33     33   
    &[&XMLEMPTYMAPSOUTPUT_MEMBER_MY_MAP],
   34     34   
);
   35     35   
impl XmlEmptyMapsOutput {
   36     36   
    /// The schema for this shape.
   37     37   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLEMPTYMAPSOUTPUT_SCHEMA;
   38     38   
}
   39     39   
impl ::aws_smithy_schema::serde::SerializableStruct for XmlEmptyMapsOutput {
   40     40   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   41     41   
    fn serialize_members(
   42     42   
        &self,
   43     43   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   44     44   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   45     45   
        if let Some(ref val) = self.my_map {
   46     46   
            ser.write_map(
   47     47   
                &XMLEMPTYMAPSOUTPUT_MEMBER_MY_MAP,
   48     48   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   49     49   
                    for (key, value) in val {
   50     50   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
   51     51   
                        ser.write_struct(crate::types::GreetingStruct::SCHEMA, value)?;
   52     52   
                    }
   53     53   
                    Ok(())
   54     54   
                },
   55     55   
            )?;
   56     56   
        }
   57     57   
        Ok(())
   58     58   
    }
   59     59   
}
   60     60   
impl XmlEmptyMapsOutput {
   61     61   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   62         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   63         -
        deserializer: &mut D,
          62  +
    pub fn deserialize(
          63  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   64     64   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   65     65   
        #[allow(unused_variables, unused_mut)]
   66     66   
        let mut builder = Self::builder();
   67     67   
        #[allow(
   68     68   
            unused_variables,
   69     69   
            unreachable_code,
   70     70   
            clippy::single_match,
   71     71   
            clippy::match_single_binding,
   72     72   
            clippy::diverging_sub_expression
   73     73   
        )]
   74         -
        deserializer.read_struct(&XMLEMPTYMAPSOUTPUT_SCHEMA, (), |_, member, deser| {
          74  +
        deserializer.read_struct(&XMLEMPTYMAPSOUTPUT_SCHEMA, &mut |member, deser| {
   75     75   
            match member.member_index() {
   76     76   
                Some(0) => {
   77     77   
                    builder.my_map = Some({
   78         -
                        let container = if let Some(cap) = deser.container_size() {
   79         -
                            std::collections::HashMap::with_capacity(cap)
   80         -
                        } else {
   81         -
                            std::collections::HashMap::new()
   82         -
                        };
   83         -
                        deser.read_map(member, container, |mut map, key, deser| {
   84         -
                            map.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
   85         -
                            Ok(map)
   86         -
                        })?
          78  +
                        let mut container = std::collections::HashMap::new();
          79  +
                        deser.read_map(member, &mut |key, deser| {
          80  +
                            container.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
          81  +
                            Ok(())
          82  +
                        })?;
          83  +
                        container
   87     84   
                    });
   88     85   
                }
   89     86   
                _ => {}
   90     87   
            }
   91     88   
            Ok(())
   92     89   
        })?;
   93     90   
        Ok(builder.build())
   94     91   
    }
   95     92   
}
          93  +
impl XmlEmptyMapsOutput {
          94  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          95  +
    pub fn deserialize_with_response(
          96  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          97  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          98  +
        _status: u16,
          99  +
        _body: &[u8],
         100  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         101  +
        Self::deserialize(deserializer)
         102  +
    }
         103  +
}
   96    104   
impl XmlEmptyMapsOutput {
   97    105   
    /// Creates a new builder-style object to manufacture [`XmlEmptyMapsOutput`](crate::operation::xml_empty_maps::XmlEmptyMapsOutput).
   98    106   
    pub fn builder() -> crate::operation::xml_empty_maps::builders::XmlEmptyMapsOutputBuilder {
   99    107   
        crate::operation::xml_empty_maps::builders::XmlEmptyMapsOutputBuilder::default()
  100    108   
    }
  101    109   
}
  102    110   
  103    111   
/// A builder for [`XmlEmptyMapsOutput`](crate::operation::xml_empty_maps::XmlEmptyMapsOutput).
  104    112   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  105    113   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_strings.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `XmlEmptyStrings`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct XmlEmptyStrings;
    6      6   
impl XmlEmptyStrings {
    7      7   
    /// Creates a new `XmlEmptyStrings`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_empty_strings::XmlEmptyStringsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_empty_strings::XmlEmptyStringsOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::xml_empty_strings::XmlEmptyStringsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::xml_empty_strings::XmlEmptyStringsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::xml_empty_strings::XmlEmptyStringsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::xml_empty_strings::XmlEmptyStringsError,
  125    129   
            >::new());
  126    130   
  127    131   
        ::std::borrow::Cow::Owned(rcb)
  128    132   
    }
  129    133   
}
  130    134   
  131    135   
#[derive(Debug)]
  132    136   
struct XmlEmptyStringsResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for XmlEmptyStringsResponseDeserializer {
  134         -
    fn deserialize_nonstreaming(
         138  +
    fn deserialize_nonstreaming_with_config(
  135    139   
        &self,
  136    140   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         141  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  137    142   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  138    143   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  139    144   
        let headers = response.headers();
  140    145   
        let body = response.body().bytes().expect("body loaded");
  141    146   
        #[allow(unused_mut)]
  142    147   
        let mut force_error = false;
  143    148   
  144    149   
        let parse_result = if !success && status != 200 || force_error {
  145    150   
            crate::protocol_serde::shape_xml_empty_strings::de_xml_empty_strings_http_error(status, headers, body)
  146    151   
        } else {
@@ -277,282 +381,394 @@
  297    302   
            .expect("the config must have a deserializer");
  298    303   
  299    304   
        let parsed = de.deserialize_streaming(&mut http_response);
  300    305   
        let parsed = parsed.unwrap_or_else(|| {
  301    306   
            let http_response = http_response.map(|body| {
  302    307   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  303    308   
                    body.bytes().unwrap(),
  304    309   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  305    310   
                )))
  306    311   
            });
  307         -
            de.deserialize_nonstreaming(&http_response)
         312  +
            // Build a config bag with the protocol for schema-based deserialization
         313  +
            #[allow(unused_mut)]
         314  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         315  +
         316  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  308    317   
        });
  309    318   
        let parsed = parsed
  310    319   
            .expect("should be successful response")
  311    320   
            .downcast::<crate::operation::xml_empty_strings::XmlEmptyStringsOutput>()
  312    321   
            .unwrap();
  313    322   
        ::pretty_assertions::assert_eq!(parsed.empty_string, expected_output.empty_string, "Unexpected value for `empty_string`");
  314    323   
    }
  315    324   
  316    325   
    /// Empty self closed string are deserialized as empty string
  317    326   
    /// Test ID: XmlEmptySelfClosedStrings
  318    327   
    #[::tokio::test]
  319    328   
    #[::tracing_test::traced_test]
  320    329   
    async fn xml_empty_self_closed_strings_response() {
  321    330   
        let expected_output = crate::operation::xml_empty_strings::XmlEmptyStringsOutput::builder()
  322    331   
            .set_empty_string(::std::option::Option::Some("".to_owned()))
  323    332   
            .build();
  324    333   
        let mut http_response = ::aws_smithy_runtime_api::http::Response::try_from(
  325    334   
            ::http_1x::response::Builder::new()
  326    335   
                .header("Content-Type", "application/xml")
  327    336   
                .status(200)
  328    337   
                .body(::aws_smithy_types::body::SdkBody::from(
  329    338   
                    "<XmlEmptyStringsResponse>\n    <emptyString/>\n</XmlEmptyStringsResponse>\n",
  330    339   
                ))
  331    340   
                .unwrap(),
  332    341   
        )
  333    342   
        .unwrap();
  334    343   
        use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
  335    344   
        use ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse;
  336    345   
  337    346   
        let op = crate::operation::xml_empty_strings::XmlEmptyStrings::new();
  338    347   
        let config = op.config().expect("the operation has config");
  339    348   
        let de = config
  340    349   
            .load::<::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer>()
  341    350   
            .expect("the config must have a deserializer");
  342    351   
  343    352   
        let parsed = de.deserialize_streaming(&mut http_response);
  344    353   
        let parsed = parsed.unwrap_or_else(|| {
  345    354   
            let http_response = http_response.map(|body| {
  346    355   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  347    356   
                    body.bytes().unwrap(),
  348    357   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  349    358   
                )))
  350    359   
            });
  351         -
            de.deserialize_nonstreaming(&http_response)
         360  +
            // Build a config bag with the protocol for schema-based deserialization
         361  +
            #[allow(unused_mut)]
         362  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         363  +
         364  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  352    365   
        });
  353    366   
        let parsed = parsed
  354    367   
            .expect("should be successful response")
  355    368   
            .downcast::<crate::operation::xml_empty_strings::XmlEmptyStringsOutput>()
  356    369   
            .unwrap();
  357    370   
        ::pretty_assertions::assert_eq!(parsed.empty_string, expected_output.empty_string, "Unexpected value for `empty_string`");
  358    371   
    }
  359    372   
}
  360    373   
  361    374   
/// Error type for the `XmlEmptyStringsError` operation.

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_strings/_xml_empty_strings_input.rs

@@ -1,1 +108,120 @@
   17     17   
    "aws.protocoltests.restxml.synthetic",
   18     18   
    "XmlEmptyStringsInput",
   19     19   
);
   20     20   
static XMLEMPTYSTRINGSINPUT_MEMBER_EMPTY_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static(
   22     22   
        "aws.protocoltests.restxml.synthetic#XmlEmptyStringsInput$emptyString",
   23     23   
        "aws.protocoltests.restxml.synthetic",
   24     24   
        "XmlEmptyStringsInput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "empty_string",
          27  +
    "emptyString",
   28     28   
    0,
   29     29   
);
   30     30   
static XMLEMPTYSTRINGSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   31     31   
    XMLEMPTYSTRINGSINPUT_SCHEMA_ID,
   32     32   
    ::aws_smithy_schema::ShapeType::Structure,
   33     33   
    &[&XMLEMPTYSTRINGSINPUT_MEMBER_EMPTY_STRING],
   34         -
);
          34  +
)
          35  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/XmlEmptyStrings", None));
   35     36   
impl XmlEmptyStringsInput {
   36     37   
    /// The schema for this shape.
   37     38   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLEMPTYSTRINGSINPUT_SCHEMA;
   38     39   
}
   39     40   
impl ::aws_smithy_schema::serde::SerializableStruct for XmlEmptyStringsInput {
   40     41   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   41     42   
    fn serialize_members(
   42     43   
        &self,
   43     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   44     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   45     46   
        if let Some(ref val) = self.empty_string {
   46     47   
            ser.write_string(&XMLEMPTYSTRINGSINPUT_MEMBER_EMPTY_STRING, val)?;
   47     48   
        }
   48     49   
        Ok(())
   49     50   
    }
   50     51   
}
   51     52   
impl XmlEmptyStringsInput {
   52     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   53         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   54         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   55     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   56     57   
        #[allow(unused_variables, unused_mut)]
   57     58   
        let mut builder = Self::builder();
   58     59   
        #[allow(
   59     60   
            unused_variables,
   60     61   
            unreachable_code,
   61     62   
            clippy::single_match,
   62     63   
            clippy::match_single_binding,
   63     64   
            clippy::diverging_sub_expression
   64     65   
        )]
   65         -
        deserializer.read_struct(&XMLEMPTYSTRINGSINPUT_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&XMLEMPTYSTRINGSINPUT_SCHEMA, &mut |member, deser| {
   66     67   
            match member.member_index() {
   67     68   
                Some(0) => {
   68     69   
                    builder.empty_string = Some(deser.read_string(member)?);
   69     70   
                }
   70     71   
                _ => {}
   71     72   
            }
   72     73   
            Ok(())
   73     74   
        })?;
   74     75   
        builder
   75     76   
            .build()
   76     77   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   77     78   
    }
   78     79   
}
          80  +
impl XmlEmptyStringsInput {
          81  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          82  +
    pub fn deserialize_with_response(
          83  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          84  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          85  +
        _status: u16,
          86  +
        _body: &[u8],
          87  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          88  +
        Self::deserialize(deserializer)
          89  +
    }
          90  +
}
   79     91   
impl XmlEmptyStringsInput {
   80     92   
    /// Creates a new builder-style object to manufacture [`XmlEmptyStringsInput`](crate::operation::xml_empty_strings::XmlEmptyStringsInput).
   81     93   
    pub fn builder() -> crate::operation::xml_empty_strings::builders::XmlEmptyStringsInputBuilder {
   82     94   
        crate::operation::xml_empty_strings::builders::XmlEmptyStringsInputBuilder::default()
   83     95   
    }
   84     96   
}
   85     97   
   86     98   
/// A builder for [`XmlEmptyStringsInput`](crate::operation::xml_empty_strings::XmlEmptyStringsInput).
   87     99   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88    100   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_empty_strings/_xml_empty_strings_output.rs

@@ -1,1 +106,117 @@
   17     17   
    "aws.protocoltests.restxml.synthetic",
   18     18   
    "XmlEmptyStringsOutput",
   19     19   
);
   20     20   
static XMLEMPTYSTRINGSOUTPUT_MEMBER_EMPTY_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   21     21   
    ::aws_smithy_schema::ShapeId::from_static(
   22     22   
        "aws.protocoltests.restxml.synthetic#XmlEmptyStringsOutput$emptyString",
   23     23   
        "aws.protocoltests.restxml.synthetic",
   24     24   
        "XmlEmptyStringsOutput",
   25     25   
    ),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "empty_string",
          27  +
    "emptyString",
   28     28   
    0,
   29     29   
);
   30     30   
static XMLEMPTYSTRINGSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   31     31   
    XMLEMPTYSTRINGSOUTPUT_SCHEMA_ID,
   32     32   
    ::aws_smithy_schema::ShapeType::Structure,
   33     33   
    &[&XMLEMPTYSTRINGSOUTPUT_MEMBER_EMPTY_STRING],
   34     34   
);
   35     35   
impl XmlEmptyStringsOutput {
   36     36   
    /// The schema for this shape.
   37     37   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLEMPTYSTRINGSOUTPUT_SCHEMA;
   38     38   
}
   39     39   
impl ::aws_smithy_schema::serde::SerializableStruct for XmlEmptyStringsOutput {
   40     40   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   41     41   
    fn serialize_members(
   42     42   
        &self,
   43     43   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   44     44   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   45     45   
        if let Some(ref val) = self.empty_string {
   46     46   
            ser.write_string(&XMLEMPTYSTRINGSOUTPUT_MEMBER_EMPTY_STRING, val)?;
   47     47   
        }
   48     48   
        Ok(())
   49     49   
    }
   50     50   
}
   51     51   
impl XmlEmptyStringsOutput {
   52     52   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   53         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   54         -
        deserializer: &mut D,
          53  +
    pub fn deserialize(
          54  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   55     55   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   56     56   
        #[allow(unused_variables, unused_mut)]
   57     57   
        let mut builder = Self::builder();
   58     58   
        #[allow(
   59     59   
            unused_variables,
   60     60   
            unreachable_code,
   61     61   
            clippy::single_match,
   62     62   
            clippy::match_single_binding,
   63     63   
            clippy::diverging_sub_expression
   64     64   
        )]
   65         -
        deserializer.read_struct(&XMLEMPTYSTRINGSOUTPUT_SCHEMA, (), |_, member, deser| {
          65  +
        deserializer.read_struct(&XMLEMPTYSTRINGSOUTPUT_SCHEMA, &mut |member, deser| {
   66     66   
            match member.member_index() {
   67     67   
                Some(0) => {
   68     68   
                    builder.empty_string = Some(deser.read_string(member)?);
   69     69   
                }
   70     70   
                _ => {}
   71     71   
            }
   72     72   
            Ok(())
   73     73   
        })?;
   74     74   
        Ok(builder.build())
   75     75   
    }
   76     76   
}
          77  +
impl XmlEmptyStringsOutput {
          78  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          79  +
    pub fn deserialize_with_response(
          80  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          81  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          82  +
        _status: u16,
          83  +
        _body: &[u8],
          84  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          85  +
        Self::deserialize(deserializer)
          86  +
    }
          87  +
}
   77     88   
impl XmlEmptyStringsOutput {
   78     89   
    /// Creates a new builder-style object to manufacture [`XmlEmptyStringsOutput`](crate::operation::xml_empty_strings::XmlEmptyStringsOutput).
   79     90   
    pub fn builder() -> crate::operation::xml_empty_strings::builders::XmlEmptyStringsOutputBuilder {
   80     91   
        crate::operation::xml_empty_strings::builders::XmlEmptyStringsOutputBuilder::default()
   81     92   
    }
   82     93   
}
   83     94   
   84     95   
/// A builder for [`XmlEmptyStringsOutput`](crate::operation::xml_empty_strings::XmlEmptyStringsOutput).
   85     96   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   86     97   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_enums.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `XmlEnums`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct XmlEnums;
    6      6   
impl XmlEnums {
    7      7   
    /// Creates a new `XmlEnums`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_enums::XmlEnumsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_enums::XmlEnumsOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::xml_enums::XmlEnumsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::xml_enums::XmlEnumsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::xml_enums::XmlEnumsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -100,104 +162,167 @@
  120    124   
                crate::operation::xml_enums::XmlEnumsError,
  121    125   
            >::new());
  122    126   
  123    127   
        ::std::borrow::Cow::Owned(rcb)
  124    128   
    }
  125    129   
}
  126    130   
  127    131   
#[derive(Debug)]
  128    132   
struct XmlEnumsResponseDeserializer;
  129    133   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for XmlEnumsResponseDeserializer {
  130         -
    fn deserialize_nonstreaming(
         134  +
    fn deserialize_nonstreaming_with_config(
  131    135   
        &self,
  132    136   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         137  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  133    138   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  134    139   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  135    140   
        let headers = response.headers();
  136    141   
        let body = response.body().bytes().expect("body loaded");
  137    142   
        #[allow(unused_mut)]
  138    143   
        let mut force_error = false;
  139    144   
  140    145   
        let parse_result = if !success && status != 200 || force_error {
  141    146   
            crate::protocol_serde::shape_xml_enums::de_xml_enums_http_error(status, headers, body)
  142    147   
        } else {
@@ -321,326 +381,390 @@
  341    346   
            .expect("the config must have a deserializer");
  342    347   
  343    348   
        let parsed = de.deserialize_streaming(&mut http_response);
  344    349   
        let parsed = parsed.unwrap_or_else(|| {
  345    350   
            let http_response = http_response.map(|body| {
  346    351   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  347    352   
                    body.bytes().unwrap(),
  348    353   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  349    354   
                )))
  350    355   
            });
  351         -
            de.deserialize_nonstreaming(&http_response)
         356  +
            // Build a config bag with the protocol for schema-based deserialization
         357  +
            #[allow(unused_mut)]
         358  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         359  +
         360  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  352    361   
        });
  353    362   
        let parsed = parsed
  354    363   
            .expect("should be successful response")
  355    364   
            .downcast::<crate::operation::xml_enums::XmlEnumsOutput>()
  356    365   
            .unwrap();
  357    366   
        ::pretty_assertions::assert_eq!(parsed.foo_enum1, expected_output.foo_enum1, "Unexpected value for `foo_enum1`");
  358    367   
        ::pretty_assertions::assert_eq!(parsed.foo_enum2, expected_output.foo_enum2, "Unexpected value for `foo_enum2`");
  359    368   
        ::pretty_assertions::assert_eq!(parsed.foo_enum3, expected_output.foo_enum3, "Unexpected value for `foo_enum3`");
  360    369   
        ::pretty_assertions::assert_eq!(
  361    370   
            parsed.foo_enum_list,

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_enums/_xml_enums_input.rs

@@ -31,31 +284,287 @@
   51     51   
    "aws.protocoltests.restxml.synthetic",
   52     52   
    "XmlEnumsInput",
   53     53   
);
   54     54   
static XMLENUMSINPUT_MEMBER_FOO_ENUM1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static(
   56     56   
        "aws.protocoltests.restxml.synthetic#XmlEnumsInput$fooEnum1",
   57     57   
        "aws.protocoltests.restxml.synthetic",
   58     58   
        "XmlEnumsInput",
   59     59   
    ),
   60     60   
    ::aws_smithy_schema::ShapeType::String,
   61         -
    "foo_enum1",
          61  +
    "fooEnum1",
   62     62   
    0,
   63     63   
);
   64     64   
static XMLENUMSINPUT_MEMBER_FOO_ENUM2: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static(
   66     66   
        "aws.protocoltests.restxml.synthetic#XmlEnumsInput$fooEnum2",
   67     67   
        "aws.protocoltests.restxml.synthetic",
   68     68   
        "XmlEnumsInput",
   69     69   
    ),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "foo_enum2",
          71  +
    "fooEnum2",
   72     72   
    1,
   73     73   
);
   74     74   
static XMLENUMSINPUT_MEMBER_FOO_ENUM3: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "aws.protocoltests.restxml.synthetic#XmlEnumsInput$fooEnum3",
   77     77   
        "aws.protocoltests.restxml.synthetic",
   78     78   
        "XmlEnumsInput",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "foo_enum3",
          81  +
    "fooEnum3",
   82     82   
    2,
   83     83   
);
   84     84   
static XMLENUMSINPUT_MEMBER_FOO_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "aws.protocoltests.restxml.synthetic#XmlEnumsInput$fooEnumList",
   87     87   
        "aws.protocoltests.restxml.synthetic",
   88     88   
        "XmlEnumsInput",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::List,
   91         -
    "foo_enum_list",
          91  +
    "fooEnumList",
   92     92   
    3,
   93     93   
);
   94     94   
static XMLENUMSINPUT_MEMBER_FOO_ENUM_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static(
   96     96   
        "aws.protocoltests.restxml.synthetic#XmlEnumsInput$fooEnumSet",
   97     97   
        "aws.protocoltests.restxml.synthetic",
   98     98   
        "XmlEnumsInput",
   99     99   
    ),
  100    100   
    ::aws_smithy_schema::ShapeType::List,
  101         -
    "foo_enum_set",
         101  +
    "fooEnumSet",
  102    102   
    4,
  103    103   
);
  104    104   
static XMLENUMSINPUT_MEMBER_FOO_ENUM_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static(
  106    106   
        "aws.protocoltests.restxml.synthetic#XmlEnumsInput$fooEnumMap",
  107    107   
        "aws.protocoltests.restxml.synthetic",
  108    108   
        "XmlEnumsInput",
  109    109   
    ),
  110    110   
    ::aws_smithy_schema::ShapeType::Map,
  111         -
    "foo_enum_map",
         111  +
    "fooEnumMap",
  112    112   
    5,
  113    113   
);
  114    114   
static XMLENUMSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  115    115   
    XMLENUMSINPUT_SCHEMA_ID,
  116    116   
    ::aws_smithy_schema::ShapeType::Structure,
  117    117   
    &[
  118    118   
        &XMLENUMSINPUT_MEMBER_FOO_ENUM1,
  119    119   
        &XMLENUMSINPUT_MEMBER_FOO_ENUM2,
  120    120   
        &XMLENUMSINPUT_MEMBER_FOO_ENUM3,
  121    121   
        &XMLENUMSINPUT_MEMBER_FOO_ENUM_LIST,
  122    122   
        &XMLENUMSINPUT_MEMBER_FOO_ENUM_SET,
  123    123   
        &XMLENUMSINPUT_MEMBER_FOO_ENUM_MAP,
  124    124   
    ],
  125         -
);
         125  +
)
         126  +
.with_http(aws_smithy_schema::traits::HttpTrait::new("PUT", "/XmlEnums", None));
  126    127   
impl XmlEnumsInput {
  127    128   
    /// The schema for this shape.
  128    129   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &XMLENUMSINPUT_SCHEMA;
  129    130   
}
  130    131   
impl ::aws_smithy_schema::serde::SerializableStruct for XmlEnumsInput {
  131    132   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  132    133   
    fn serialize_members(
  133    134   
        &self,
  134    135   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  135    136   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  136    137   
        if let Some(ref val) = self.foo_enum1 {
  137    138   
            ser.write_string(&XMLENUMSINPUT_MEMBER_FOO_ENUM1, val.as_str())?;
  138    139   
        }
  139    140   
        if let Some(ref val) = self.foo_enum2 {
  140    141   
            ser.write_string(&XMLENUMSINPUT_MEMBER_FOO_ENUM2, val.as_str())?;
  141    142   
        }
  142    143   
        if let Some(ref val) = self.foo_enum3 {
  143    144   
            ser.write_string(&XMLENUMSINPUT_MEMBER_FOO_ENUM3, val.as_str())?;
  144    145   
        }
  145    146   
        if let Some(ref val) = self.foo_enum_list {
  146    147   
            ser.write_list(
  147    148   
                &XMLENUMSINPUT_MEMBER_FOO_ENUM_LIST,
  148    149   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  149    150   
                    for item in val {
  150    151   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
  151    152   
                    }
  152    153   
                    Ok(())
  153    154   
                },
  154    155   
            )?;
  155    156   
        }
  156    157   
        if let Some(ref val) = self.foo_enum_set {
  157    158   
            ser.write_list(
  158    159   
                &XMLENUMSINPUT_MEMBER_FOO_ENUM_SET,
  159    160   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  160    161   
                    for item in val {
  161    162   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item.as_str())?;
  162    163   
                    }
  163    164   
                    Ok(())
  164    165   
                },
  165    166   
            )?;
  166    167   
        }
  167    168   
        if let Some(ref val) = self.foo_enum_map {
  168    169   
            ser.write_map(
  169    170   
                &XMLENUMSINPUT_MEMBER_FOO_ENUM_MAP,
  170    171   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  171    172   
                    for (key, value) in val {
  172    173   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  173    174   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value.as_str())?;
  174    175   
                    }
  175    176   
                    Ok(())
  176    177   
                },
  177    178   
            )?;
  178    179   
        }
  179    180   
        Ok(())
  180    181   
    }
  181    182   
}
  182    183   
impl XmlEnumsInput {
  183    184   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  184         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  185         -
        deserializer: &mut D,
         185  +
    pub fn deserialize(
         186  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  186    187   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  187    188   
        #[allow(unused_variables, unused_mut)]
  188    189   
        let mut builder = Self::builder();
  189    190   
        #[allow(
  190    191   
            unused_variables,
  191    192   
            unreachable_code,
  192    193   
            clippy::single_match,
  193    194   
            clippy::match_single_binding,
  194    195   
            clippy::diverging_sub_expression
  195    196   
        )]
  196         -
        deserializer.read_struct(&XMLENUMSINPUT_SCHEMA, (), |_, member, deser| {
         197  +
        deserializer.read_struct(&XMLENUMSINPUT_SCHEMA, &mut |member, deser| {
  197    198   
            match member.member_index() {
  198    199   
                Some(0) => {
  199    200   
                    builder.foo_enum1 = Some(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  200    201   
                }
  201    202   
                Some(1) => {
  202    203   
                    builder.foo_enum2 = Some(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  203    204   
                }
  204    205   
                Some(2) => {
  205    206   
                    builder.foo_enum3 = Some(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  206    207   
                }
  207    208   
                Some(3) => {
  208    209   
                    builder.foo_enum_list = Some({
  209         -
                        let container = if let Some(cap) = deser.container_size() {
  210         -
                            Vec::with_capacity(cap)
  211         -
                        } else {
  212         -
                            Vec::new()
  213         -
                        };
  214         -
                        deser.read_list(member, container, |mut list, deser| {
  215         -
                            list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  216         -
                            Ok(list)
  217         -
                        })?
         210  +
                        let mut container = Vec::new();
         211  +
                        deser.read_list(member, &mut |deser| {
         212  +
                            container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
         213  +
                            Ok(())
         214  +
                        })?;
         215  +
                        container
  218    216   
                    });
  219    217   
                }
  220    218   
                Some(4) => {
  221    219   
                    builder.foo_enum_set = Some({
  222         -
                        let container = if let Some(cap) = deser.container_size() {
  223         -
                            Vec::with_capacity(cap)
  224         -
                        } else {
  225         -
                            Vec::new()
  226         -
                        };
  227         -
                        deser.read_list(member, container, |mut list, deser| {
  228         -
                            list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  229         -
                            Ok(list)
  230         -
                        })?
         220  +
                        let mut container = Vec::new();
         221  +
                        deser.read_list(member, &mut |deser| {
         222  +
                            container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
         223  +
                            Ok(())
         224  +
                        })?;
         225  +
                        container
  231    226   
                    });
  232    227   
                }
  233    228   
                Some(5) => {
  234    229   
                    builder.foo_enum_map = Some({
  235         -
                        let container = if let Some(cap) = deser.container_size() {
  236         -
                            std::collections::HashMap::with_capacity(cap)
  237         -
                        } else {
  238         -
                            std::collections::HashMap::new()
  239         -
                        };
  240         -
                        deser.read_map(member, container, |mut map, key, deser| {
  241         -
                            map.insert(key, crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  242         -
                            Ok(map)
  243         -
                        })?
         230  +
                        let mut container = std::collections::HashMap::new();
         231  +
                        deser.read_map(member, &mut |key, deser| {
         232  +
                            container.insert(key, crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
         233  +
                            Ok(())
         234  +
                        })?;
         235  +
                        container
  244    236   
                    });
  245    237   
                }
  246    238   
                _ => {}
  247    239   
            }
  248    240   
            Ok(())
  249    241   
        })?;
  250    242   
        builder
  251    243   
            .build()
  252    244   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  253    245   
    }
  254    246   
}
         247  +
impl XmlEnumsInput {
         248  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         249  +
    pub fn deserialize_with_response(
         250  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         251  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         252  +
        _status: u16,
         253  +
        _body: &[u8],
         254  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         255  +
        Self::deserialize(deserializer)
         256  +
    }
         257  +
}
  255    258   
impl XmlEnumsInput {
  256    259   
    /// Creates a new builder-style object to manufacture [`XmlEnumsInput`](crate::operation::xml_enums::XmlEnumsInput).
  257    260   
    pub fn builder() -> crate::operation::xml_enums::builders::XmlEnumsInputBuilder {
  258    261   
        crate::operation::xml_enums::builders::XmlEnumsInputBuilder::default()
  259    262   
    }
  260    263   
}
  261    264   
  262    265   
/// A builder for [`XmlEnumsInput`](crate::operation::xml_enums::XmlEnumsInput).
  263    266   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  264    267   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_enums/_xml_enums_output.rs

@@ -31,31 +141,141 @@
   51     51   
    "aws.protocoltests.restxml.synthetic",
   52     52   
    "XmlEnumsOutput",
   53     53   
);
   54     54   
static XMLENUMSOUTPUT_MEMBER_FOO_ENUM1: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static(
   56     56   
        "aws.protocoltests.restxml.synthetic#XmlEnumsOutput$fooEnum1",
   57     57   
        "aws.protocoltests.restxml.synthetic",
   58     58   
        "XmlEnumsOutput",
   59     59   
    ),
   60     60   
    ::aws_smithy_schema::ShapeType::String,
   61         -
    "foo_enum1",
          61  +
    "fooEnum1",
   62     62   
    0,
   63     63   
);
   64     64   
static XMLENUMSOUTPUT_MEMBER_FOO_ENUM2: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static(
   66     66   
        "aws.protocoltests.restxml.synthetic#XmlEnumsOutput$fooEnum2",
   67     67   
        "aws.protocoltests.restxml.synthetic",
   68     68   
        "XmlEnumsOutput",
   69     69   
    ),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "foo_enum2",
          71  +
    "fooEnum2",
   72     72   
    1,
   73     73   
);
   74     74   
static XMLENUMSOUTPUT_MEMBER_FOO_ENUM3: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "aws.protocoltests.restxml.synthetic#XmlEnumsOutput$fooEnum3",
   77     77   
        "aws.protocoltests.restxml.synthetic",
   78     78   
        "XmlEnumsOutput",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "foo_enum3",
          81  +
    "fooEnum3",
   82     82   
    2,
   83     83   
);
   84     84   
static XMLENUMSOUTPUT_MEMBER_FOO_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "aws.protocoltests.restxml.synthetic#XmlEnumsOutput$fooEnumList",
   87     87   
        "aws.protocoltests.restxml.synthetic",
   88     88   
        "XmlEnumsOutput",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::List,
   91         -
    "foo_enum_list",
          91  +
    "fooEnumList",
   92     92   
    3,
   93     93   
);
   94     94   
static XMLENUMSOUTPUT_MEMBER_FOO_ENUM_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static(
   96     96   
        "aws.protocoltests.restxml.synthetic#XmlEnumsOutput$fooEnumSet",
   97     97   
        "aws.protocoltests.restxml.synthetic",
   98     98   
        "XmlEnumsOutput",
   99     99   
    ),
  100    100   
    ::aws_smithy_schema::ShapeType::List,
  101         -
    "foo_enum_set",
         101  +
    "fooEnumSet",
  102    102   
    4,
  103    103   
);
  104    104   
static XMLENUMSOUTPUT_MEMBER_FOO_ENUM_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static(
  106    106   
        "aws.protocoltests.restxml.synthetic#XmlEnumsOutput$fooEnumMap",
  107    107   
        "aws.protocoltests.restxml.synthetic",
  108    108   
        "XmlEnumsOutput",
  109    109   
    ),
  110    110   
    ::aws_smithy_schema::ShapeType::Map,
  111         -
    "foo_enum_map",
         111  +
    "fooEnumMap",
  112    112   
    5,
  113    113   
);
  114    114   
static XMLENUMSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  115    115   
    XMLENUMSOUTPUT_SCHEMA_ID,
  116    116   
    ::aws_smithy_schema::ShapeType::Structure,
  117    117   
    &[
  118    118   
        &XMLENUMSOUTPUT_MEMBER_FOO_ENUM1,
  119    119   
        &XMLENUMSOUTPUT_MEMBER_FOO_ENUM2,
  120    120   
        &XMLENUMSOUTPUT_MEMBER_FOO_ENUM3,
  121    121   
        &XMLENUMSOUTPUT_MEMBER_FOO_ENUM_LIST,
@@ -154,154 +282,284 @@
  174    174   
                    }
  175    175   
                    Ok(())
  176    176   
                },
  177    177   
            )?;
  178    178   
        }
  179    179   
        Ok(())
  180    180   
    }
  181    181   
}
  182    182   
impl XmlEnumsOutput {
  183    183   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  184         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  185         -
        deserializer: &mut D,
         184  +
    pub fn deserialize(
         185  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  186    186   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  187    187   
        #[allow(unused_variables, unused_mut)]
  188    188   
        let mut builder = Self::builder();
  189    189   
        #[allow(
  190    190   
            unused_variables,
  191    191   
            unreachable_code,
  192    192   
            clippy::single_match,
  193    193   
            clippy::match_single_binding,
  194    194   
            clippy::diverging_sub_expression
  195    195   
        )]
  196         -
        deserializer.read_struct(&XMLENUMSOUTPUT_SCHEMA, (), |_, member, deser| {
         196  +
        deserializer.read_struct(&XMLENUMSOUTPUT_SCHEMA, &mut |member, deser| {
  197    197   
            match member.member_index() {
  198    198   
                Some(0) => {
  199    199   
                    builder.foo_enum1 = Some(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  200    200   
                }
  201    201   
                Some(1) => {
  202    202   
                    builder.foo_enum2 = Some(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  203    203   
                }
  204    204   
                Some(2) => {
  205    205   
                    builder.foo_enum3 = Some(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  206    206   
                }
  207    207   
                Some(3) => {
  208    208   
                    builder.foo_enum_list = Some({
  209         -
                        let container = if let Some(cap) = deser.container_size() {
  210         -
                            Vec::with_capacity(cap)
  211         -
                        } else {
  212         -
                            Vec::new()
  213         -
                        };
  214         -
                        deser.read_list(member, container, |mut list, deser| {
  215         -
                            list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  216         -
                            Ok(list)
  217         -
                        })?
         209  +
                        let mut container = Vec::new();
         210  +
                        deser.read_list(member, &mut |deser| {
         211  +
                            container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
         212  +
                            Ok(())
         213  +
                        })?;
         214  +
                        container
  218    215   
                    });
  219    216   
                }
  220    217   
                Some(4) => {
  221    218   
                    builder.foo_enum_set = Some({
  222         -
                        let container = if let Some(cap) = deser.container_size() {
  223         -
                            Vec::with_capacity(cap)
  224         -
                        } else {
  225         -
                            Vec::new()
  226         -
                        };
  227         -
                        deser.read_list(member, container, |mut list, deser| {
  228         -
                            list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  229         -
                            Ok(list)
  230         -
                        })?
         219  +
                        let mut container = Vec::new();
         220  +
                        deser.read_list(member, &mut |deser| {
         221  +
                            container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
         222  +
                            Ok(())
         223  +
                        })?;
         224  +
                        container
  231    225   
                    });
  232    226   
                }
  233    227   
                Some(5) => {
  234    228   
                    builder.foo_enum_map = Some({
  235         -
                        let container = if let Some(cap) = deser.container_size() {
  236         -
                            std::collections::HashMap::with_capacity(cap)
  237         -
                        } else {
  238         -
                            std::collections::HashMap::new()
  239         -
                        };
  240         -
                        deser.read_map(member, container, |mut map, key, deser| {
  241         -
                            map.insert(key, crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  242         -
                            Ok(map)
  243         -
                        })?
         229  +
                        let mut container = std::collections::HashMap::new();
         230  +
                        deser.read_map(member, &mut |key, deser| {
         231  +
                            container.insert(key, crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
         232  +
                            Ok(())
         233  +
                        })?;
         234  +
                        container
  244    235   
                    });
  245    236   
                }
  246    237   
                _ => {}
  247    238   
            }
  248    239   
            Ok(())
  249    240   
        })?;
  250    241   
        Ok(builder.build())
  251    242   
    }
  252    243   
}
         244  +
impl XmlEnumsOutput {
         245  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         246  +
    pub fn deserialize_with_response(
         247  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         248  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         249  +
        _status: u16,
         250  +
        _body: &[u8],
         251  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         252  +
        Self::deserialize(deserializer)
         253  +
    }
         254  +
}
  253    255   
impl XmlEnumsOutput {
  254    256   
    /// Creates a new builder-style object to manufacture [`XmlEnumsOutput`](crate::operation::xml_enums::XmlEnumsOutput).
  255    257   
    pub fn builder() -> crate::operation::xml_enums::builders::XmlEnumsOutputBuilder {
  256    258   
        crate::operation::xml_enums::builders::XmlEnumsOutputBuilder::default()
  257    259   
    }
  258    260   
}
  259    261   
  260    262   
/// A builder for [`XmlEnumsOutput`](crate::operation::xml_enums::XmlEnumsOutput).
  261    263   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  262    264   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rest_xml/rust-client-codegen/src/operation/xml_int_enums.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `XmlIntEnums`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct XmlIntEnums;
    6      6   
impl XmlIntEnums {
    7      7   
    /// Creates a new `XmlIntEnums`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_int_enums::XmlIntEnumsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::xml_int_enums::XmlIntEnumsOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::xml_int_enums::XmlIntEnumsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::xml_int_enums::XmlIntEnumsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::xml_int_enums::XmlIntEnumsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::xml_int_enums::XmlIntEnumsError,
  125    129   
            >::new());
  126    130   
  127    131   
        ::std::borrow::Cow::Owned(rcb)
  128    132   
    }
  129    133   
}
  130    134   
  131    135   
#[derive(Debug)]
  132    136   
struct XmlIntEnumsResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for XmlIntEnumsResponseDeserializer {
  134         -
    fn deserialize_nonstreaming(
         138  +
    fn deserialize_nonstreaming_with_config(
  135    139   
        &self,
  136    140   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         141  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  137    142   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  138    143   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  139    144   
        let headers = response.headers();
  140    145   
        let body = response.body().bytes().expect("body loaded");
  141    146   
        #[allow(unused_mut)]
  142    147   
        let mut force_error = false;
  143    148   
  144    149   
        let parse_result = if !success && status != 200 || force_error {
  145    150   
            crate::protocol_serde::shape_xml_int_enums::de_xml_int_enums_http_error(status, headers, body)
  146    151   
        } else {
@@ -291,296 +351,360 @@
  311    316   
            .expect("the config must have a deserializer");
  312    317   
  313    318   
        let parsed = de.deserialize_streaming(&mut http_response);
  314    319   
        let parsed = parsed.unwrap_or_else(|| {
  315    320   
            let http_response = http_response.map(|body| {
  316    321   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  317    322   
                    body.bytes().unwrap(),
  318    323   
                    ::aws_smithy_protocol_test::MediaType::from("application/xml"),
  319    324   
                )))
  320    325   
            });
  321         -
            de.deserialize_nonstreaming(&http_response)
         326  +
            // Build a config bag with the protocol for schema-based deserialization
         327  +
            #[allow(unused_mut)]
         328  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         329  +
         330  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  322    331   
        });
  323    332   
        let parsed = parsed
  324    333   
            .expect("should be successful response")
  325    334   
            .downcast::<crate::operation::xml_int_enums::XmlIntEnumsOutput>()
  326    335   
            .unwrap();
  327    336   
        ::pretty_assertions::assert_eq!(parsed.int_enum1, expected_output.int_enum1, "Unexpected value for `int_enum1`");
  328    337   
        ::pretty_assertions::assert_eq!(parsed.int_enum2, expected_output.int_enum2, "Unexpected value for `int_enum2`");
  329    338   
        ::pretty_assertions::assert_eq!(parsed.int_enum3, expected_output.int_enum3, "Unexpected value for `int_enum3`");
  330    339   
        ::pretty_assertions::assert_eq!(
  331    340   
            parsed.int_enum_list,