Client Test

Client Test

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/optional_input_output/_optional_input_output_input.rs

@@ -23,23 +108,119 @@
   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.value {
   46     46   
            ser.write_string(&OPTIONALINPUTOUTPUTINPUT_MEMBER_VALUE, val)?;
   47     47   
        }
   48     48   
        Ok(())
   49     49   
    }
   50     50   
}
   51     51   
impl OptionalInputOutputInput {
   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(&OPTIONALINPUTOUTPUTINPUT_SCHEMA, (), |_, member, deser| {
          65  +
        deserializer.read_struct(&OPTIONALINPUTOUTPUTINPUT_SCHEMA, &mut |member, deser| {
   66     66   
            match member.member_index() {
   67     67   
                Some(0) => {
   68     68   
                    builder.value = Some(deser.read_string(member)?);
   69     69   
                }
   70     70   
                _ => {}
   71     71   
            }
   72     72   
            Ok(())
   73     73   
        })?;
   74     74   
        builder
   75     75   
            .build()
   76     76   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   77     77   
    }
   78     78   
}
          79  +
impl OptionalInputOutputInput {
          80  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          81  +
    pub fn deserialize_with_response(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          83  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          84  +
        _status: u16,
          85  +
        _body: &[u8],
          86  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          87  +
        Self::deserialize(deserializer)
          88  +
    }
          89  +
}
   79     90   
impl OptionalInputOutputInput {
   80     91   
    /// Creates a new builder-style object to manufacture [`OptionalInputOutputInput`](crate::operation::optional_input_output::OptionalInputOutputInput).
   81     92   
    pub fn builder() -> crate::operation::optional_input_output::builders::OptionalInputOutputInputBuilder {
   82     93   
        crate::operation::optional_input_output::builders::OptionalInputOutputInputBuilder::default()
   83     94   
    }
   84     95   
}
   85     96   
   86     97   
/// A builder for [`OptionalInputOutputInput`](crate::operation::optional_input_output::OptionalInputOutputInput).
   87     98   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88     99   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/optional_input_output/_optional_input_output_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.value {
   46     46   
            ser.write_string(&OPTIONALINPUTOUTPUTOUTPUT_MEMBER_VALUE, val)?;
   47     47   
        }
   48     48   
        Ok(())
   49     49   
    }
   50     50   
}
   51     51   
impl OptionalInputOutputOutput {
   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(&OPTIONALINPUTOUTPUTOUTPUT_SCHEMA, (), |_, member, deser| {
          65  +
        deserializer.read_struct(&OPTIONALINPUTOUTPUTOUTPUT_SCHEMA, &mut |member, deser| {
   66     66   
            match member.member_index() {
   67     67   
                Some(0) => {
   68     68   
                    builder.value = 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 OptionalInputOutputOutput {
          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 OptionalInputOutputOutput {
   78     89   
    /// Creates a new builder-style object to manufacture [`OptionalInputOutputOutput`](crate::operation::optional_input_output::OptionalInputOutputOutput).
   79     90   
    pub fn builder() -> crate::operation::optional_input_output::builders::OptionalInputOutputOutputBuilder {
   80     91   
        crate::operation::optional_input_output::builders::OptionalInputOutputOutputBuilder::default()
   81     92   
    }
   82     93   
}
   83     94   
   84     95   
/// A builder for [`OptionalInputOutputOutput`](crate::operation::optional_input_output::OptionalInputOutputOutput).
   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/rpcv2Cbor/rust-client-codegen/src/operation/recursive_shapes.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 `RecursiveShapes`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct RecursiveShapes;
    6      6   
impl RecursiveShapes {
    7      7   
    /// Creates a new `RecursiveShapes`
    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::recursive_shapes::RecursiveShapesInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::recursive_shapes::RecursiveShapesOutput::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::recursive_shapes::RecursiveShapesInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::recursive_shapes::RecursiveShapesOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::recursive_shapes::RecursiveShapesError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::recursive_shapes::RecursiveShapesError,
  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 RecursiveShapesResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RecursiveShapesResponseDeserializer {
  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_recursive_shapes::de_recursive_shapes_http_error(status, headers, body)
  146    151   
        } else {
@@ -329,334 +389,398 @@
  349    354   
            .expect("the config must have a deserializer");
  350    355   
  351    356   
        let parsed = de.deserialize_streaming(&mut http_response);
  352    357   
        let parsed = parsed.unwrap_or_else(|| {
  353    358   
            let http_response = http_response.map(|body| {
  354    359   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  355    360   
                    body.bytes().unwrap(),
  356    361   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  357    362   
                )))
  358    363   
            });
  359         -
            de.deserialize_nonstreaming(&http_response)
         364  +
            // Build a config bag with the protocol for schema-based deserialization
         365  +
            #[allow(unused_mut)]
         366  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         367  +
         368  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  360    369   
        });
  361    370   
        let parsed = parsed
  362    371   
            .expect("should be successful response")
  363    372   
            .downcast::<crate::operation::recursive_shapes::RecursiveShapesOutput>()
  364    373   
            .unwrap();
  365    374   
        ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
  366    375   
    }
  367    376   
  368    377   
    /// Deserializes recursive structures encoded using a map with definite length
  369    378   
    /// Test ID: RpcV2CborRecursiveShapesUsingDefiniteLength
@@ -393,402 +453,466 @@
  413    422   
            .expect("the config must have a deserializer");
  414    423   
  415    424   
        let parsed = de.deserialize_streaming(&mut http_response);
  416    425   
        let parsed = parsed.unwrap_or_else(|| {
  417    426   
            let http_response = http_response.map(|body| {
  418    427   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  419    428   
                    body.bytes().unwrap(),
  420    429   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  421    430   
                )))
  422    431   
            });
  423         -
            de.deserialize_nonstreaming(&http_response)
         432  +
            // Build a config bag with the protocol for schema-based deserialization
         433  +
            #[allow(unused_mut)]
         434  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         435  +
         436  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  424    437   
        });
  425    438   
        let parsed = parsed
  426    439   
            .expect("should be successful response")
  427    440   
            .downcast::<crate::operation::recursive_shapes::RecursiveShapesOutput>()
  428    441   
            .unwrap();
  429    442   
        ::pretty_assertions::assert_eq!(parsed.nested, expected_output.nested, "Unexpected value for `nested`");
  430    443   
    }
  431    444   
}
  432    445   
  433    446   
/// Error type for the `RecursiveShapesError` operation.

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/recursive_shapes/_recursive_shapes_input.rs

@@ -23,23 +108,119 @@
   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.nested {
   46     46   
            ser.write_struct(&RECURSIVESHAPESINPUT_MEMBER_NESTED, val)?;
   47     47   
        }
   48     48   
        Ok(())
   49     49   
    }
   50     50   
}
   51     51   
impl RecursiveShapesInput {
   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(&RECURSIVESHAPESINPUT_SCHEMA, (), |_, member, deser| {
          65  +
        deserializer.read_struct(&RECURSIVESHAPESINPUT_SCHEMA, &mut |member, deser| {
   66     66   
            match member.member_index() {
   67     67   
                Some(0) => {
   68     68   
                    builder.nested = Some(crate::types::RecursiveShapesInputOutputNested1::deserialize(deser)?);
   69     69   
                }
   70     70   
                _ => {}
   71     71   
            }
   72     72   
            Ok(())
   73     73   
        })?;
   74     74   
        builder
   75     75   
            .build()
   76     76   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   77     77   
    }
   78     78   
}
          79  +
impl RecursiveShapesInput {
          80  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          81  +
    pub fn deserialize_with_response(
          82  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          83  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          84  +
        _status: u16,
          85  +
        _body: &[u8],
          86  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          87  +
        Self::deserialize(deserializer)
          88  +
    }
          89  +
}
   79     90   
impl RecursiveShapesInput {
   80     91   
    /// Creates a new builder-style object to manufacture [`RecursiveShapesInput`](crate::operation::recursive_shapes::RecursiveShapesInput).
   81     92   
    pub fn builder() -> crate::operation::recursive_shapes::builders::RecursiveShapesInputBuilder {
   82     93   
        crate::operation::recursive_shapes::builders::RecursiveShapesInputBuilder::default()
   83     94   
    }
   84     95   
}
   85     96   
   86     97   
/// A builder for [`RecursiveShapesInput`](crate::operation::recursive_shapes::RecursiveShapesInput).
   87     98   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   88     99   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/recursive_shapes/_recursive_shapes_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.nested {
   46     46   
            ser.write_struct(&RECURSIVESHAPESOUTPUT_MEMBER_NESTED, val)?;
   47     47   
        }
   48     48   
        Ok(())
   49     49   
    }
   50     50   
}
   51     51   
impl RecursiveShapesOutput {
   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(&RECURSIVESHAPESOUTPUT_SCHEMA, (), |_, member, deser| {
          65  +
        deserializer.read_struct(&RECURSIVESHAPESOUTPUT_SCHEMA, &mut |member, deser| {
   66     66   
            match member.member_index() {
   67     67   
                Some(0) => {
   68     68   
                    builder.nested = Some(crate::types::RecursiveShapesInputOutputNested1::deserialize(deser)?);
   69     69   
                }
   70     70   
                _ => {}
   71     71   
            }
   72     72   
            Ok(())
   73     73   
        })?;
   74     74   
        Ok(builder.build())
   75     75   
    }
   76     76   
}
          77  +
impl RecursiveShapesOutput {
          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 RecursiveShapesOutput {
   78     89   
    /// Creates a new builder-style object to manufacture [`RecursiveShapesOutput`](crate::operation::recursive_shapes::RecursiveShapesOutput).
   79     90   
    pub fn builder() -> crate::operation::recursive_shapes::builders::RecursiveShapesOutputBuilder {
   80     91   
        crate::operation::recursive_shapes::builders::RecursiveShapesOutputBuilder::default()
   81     92   
    }
   82     93   
}
   83     94   
   84     95   
/// A builder for [`RecursiveShapesOutput`](crate::operation::recursive_shapes::RecursiveShapesOutput).
   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/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_dense_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 `RpcV2CborDenseMaps`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct RpcV2CborDenseMaps;
    6      6   
impl RpcV2CborDenseMaps {
    7      7   
    /// Creates a new `RpcV2CborDenseMaps`
    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::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsOutput::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::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsError,
  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 RpcV2CborDenseMapsResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RpcV2CborDenseMapsResponseDeserializer {
  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_rpc_v2_cbor_dense_maps::de_rpc_v2_cbor_dense_maps_http_error(status, headers, body)
  146    151   
        } else {
@@ -417,422 +477,486 @@
  437    442   
            .expect("the config must have a deserializer");
  438    443   
  439    444   
        let parsed = de.deserialize_streaming(&mut http_response);
  440    445   
        let parsed = parsed.unwrap_or_else(|| {
  441    446   
            let http_response = http_response.map(|body| {
  442    447   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  443    448   
                    body.bytes().unwrap(),
  444    449   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  445    450   
                )))
  446    451   
            });
  447         -
            de.deserialize_nonstreaming(&http_response)
         452  +
            // Build a config bag with the protocol for schema-based deserialization
         453  +
            #[allow(unused_mut)]
         454  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         455  +
         456  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  448    457   
        });
  449    458   
        let parsed = parsed
  450    459   
            .expect("should be successful response")
  451    460   
            .downcast::<crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsOutput>()
  452    461   
            .unwrap();
  453    462   
        ::pretty_assertions::assert_eq!(
  454    463   
            parsed.dense_struct_map,
  455    464   
            expected_output.dense_struct_map,
  456    465   
            "Unexpected value for `dense_struct_map`"
  457    466   
        );
@@ -495,504 +555,568 @@
  515    524   
            .expect("the config must have a deserializer");
  516    525   
  517    526   
        let parsed = de.deserialize_streaming(&mut http_response);
  518    527   
        let parsed = parsed.unwrap_or_else(|| {
  519    528   
            let http_response = http_response.map(|body| {
  520    529   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  521    530   
                    body.bytes().unwrap(),
  522    531   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  523    532   
                )))
  524    533   
            });
  525         -
            de.deserialize_nonstreaming(&http_response)
         534  +
            // Build a config bag with the protocol for schema-based deserialization
         535  +
            #[allow(unused_mut)]
         536  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         537  +
         538  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  526    539   
        });
  527    540   
        let parsed = parsed
  528    541   
            .expect("should be successful response")
  529    542   
            .downcast::<crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsOutput>()
  530    543   
            .unwrap();
  531    544   
        ::pretty_assertions::assert_eq!(
  532    545   
            parsed.dense_struct_map,
  533    546   
            expected_output.dense_struct_map,
  534    547   
            "Unexpected value for `dense_struct_map`"
  535    548   
        );
@@ -567,580 +627,644 @@
  587    600   
            .expect("the config must have a deserializer");
  588    601   
  589    602   
        let parsed = de.deserialize_streaming(&mut http_response);
  590    603   
        let parsed = parsed.unwrap_or_else(|| {
  591    604   
            let http_response = http_response.map(|body| {
  592    605   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  593    606   
                    body.bytes().unwrap(),
  594    607   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  595    608   
                )))
  596    609   
            });
  597         -
            de.deserialize_nonstreaming(&http_response)
         610  +
            // Build a config bag with the protocol for schema-based deserialization
         611  +
            #[allow(unused_mut)]
         612  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         613  +
         614  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  598    615   
        });
  599    616   
        let parsed = parsed
  600    617   
            .expect("should be successful response")
  601    618   
            .downcast::<crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsOutput>()
  602    619   
            .unwrap();
  603    620   
        ::pretty_assertions::assert_eq!(
  604    621   
            parsed.dense_struct_map,
  605    622   
            expected_output.dense_struct_map,
  606    623   
            "Unexpected value for `dense_struct_map`"
  607    624   
        );
@@ -641,658 +701,722 @@
  661    678   
            .expect("the config must have a deserializer");
  662    679   
  663    680   
        let parsed = de.deserialize_streaming(&mut http_response);
  664    681   
        let parsed = parsed.unwrap_or_else(|| {
  665    682   
            let http_response = http_response.map(|body| {
  666    683   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  667    684   
                    body.bytes().unwrap(),
  668    685   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  669    686   
                )))
  670    687   
            });
  671         -
            de.deserialize_nonstreaming(&http_response)
         688  +
            // Build a config bag with the protocol for schema-based deserialization
         689  +
            #[allow(unused_mut)]
         690  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         691  +
         692  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  672    693   
        });
  673    694   
        let parsed = parsed
  674    695   
            .expect("should be successful response")
  675    696   
            .downcast::<crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsOutput>()
  676    697   
            .unwrap();
  677    698   
        ::pretty_assertions::assert_eq!(
  678    699   
            parsed.dense_struct_map,
  679    700   
            expected_output.dense_struct_map,
  680    701   
            "Unexpected value for `dense_struct_map`"
  681    702   
        );

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_dense_maps/_rpc_v2_cbor_dense_maps_input.rs

@@ -23,23 +123,123 @@
   43     43   
    "smithy.protocoltests.rpcv2Cbor.synthetic",
   44     44   
    "RpcV2CborDenseMapsInput",
   45     45   
);
   46     46   
static RPCV2CBORDENSEMAPSINPUT_MEMBER_DENSE_STRUCT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static(
   48     48   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborDenseMapsInput$denseStructMap",
   49     49   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   50     50   
        "RpcV2CborDenseMapsInput",
   51     51   
    ),
   52     52   
    ::aws_smithy_schema::ShapeType::Map,
   53         -
    "dense_struct_map",
          53  +
    "denseStructMap",
   54     54   
    0,
   55     55   
);
   56     56   
static RPCV2CBORDENSEMAPSINPUT_MEMBER_DENSE_NUMBER_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborDenseMapsInput$denseNumberMap",
   59     59   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   60     60   
        "RpcV2CborDenseMapsInput",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::Map,
   63         -
    "dense_number_map",
          63  +
    "denseNumberMap",
   64     64   
    1,
   65     65   
);
   66     66   
static RPCV2CBORDENSEMAPSINPUT_MEMBER_DENSE_BOOLEAN_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborDenseMapsInput$denseBooleanMap",
   69     69   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   70     70   
        "RpcV2CborDenseMapsInput",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::Map,
   73         -
    "dense_boolean_map",
          73  +
    "denseBooleanMap",
   74     74   
    2,
   75     75   
);
   76     76   
static RPCV2CBORDENSEMAPSINPUT_MEMBER_DENSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static(
   78     78   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborDenseMapsInput$denseStringMap",
   79     79   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   80     80   
        "RpcV2CborDenseMapsInput",
   81     81   
    ),
   82     82   
    ::aws_smithy_schema::ShapeType::Map,
   83         -
    "dense_string_map",
          83  +
    "denseStringMap",
   84     84   
    3,
   85     85   
);
   86     86   
static RPCV2CBORDENSEMAPSINPUT_MEMBER_DENSE_SET_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborDenseMapsInput$denseSetMap",
   89     89   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   90     90   
        "RpcV2CborDenseMapsInput",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::Map,
   93         -
    "dense_set_map",
          93  +
    "denseSetMap",
   94     94   
    4,
   95     95   
);
   96     96   
static RPCV2CBORDENSEMAPSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   97     97   
    RPCV2CBORDENSEMAPSINPUT_SCHEMA_ID,
   98     98   
    ::aws_smithy_schema::ShapeType::Structure,
   99     99   
    &[
  100    100   
        &RPCV2CBORDENSEMAPSINPUT_MEMBER_DENSE_STRUCT_MAP,
  101    101   
        &RPCV2CBORDENSEMAPSINPUT_MEMBER_DENSE_NUMBER_MAP,
  102    102   
        &RPCV2CBORDENSEMAPSINPUT_MEMBER_DENSE_BOOLEAN_MAP,
  103    103   
        &RPCV2CBORDENSEMAPSINPUT_MEMBER_DENSE_STRING_MAP,
@@ -141,141 +299,304 @@
  161    161   
                    Ok(())
  162    162   
                },
  163    163   
            )?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.dense_set_map {
  166    166   
            ser.write_map(
  167    167   
                &RPCV2CBORDENSEMAPSINPUT_MEMBER_DENSE_SET_MAP,
  168    168   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  169    169   
                    for (key, value) in val {
  170    170   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  171         -
                        todo!("schema: unsupported map value type");
         171  +
         172  +
                        ser.write_list(
         173  +
                            &::aws_smithy_schema::prelude::DOCUMENT,
         174  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         175  +
                                for item in value {
         176  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         177  +
                                }
         178  +
                                Ok(())
         179  +
                            },
         180  +
                        )?;
  172    181   
                    }
  173    182   
                    Ok(())
  174    183   
                },
  175    184   
            )?;
  176    185   
        }
  177    186   
        Ok(())
  178    187   
    }
  179    188   
}
  180    189   
impl RpcV2CborDenseMapsInput {
  181    190   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  182         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  183         -
        deserializer: &mut D,
         191  +
    pub fn deserialize(
         192  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  184    193   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  185    194   
        #[allow(unused_variables, unused_mut)]
  186    195   
        let mut builder = Self::builder();
  187    196   
        #[allow(
  188    197   
            unused_variables,
  189    198   
            unreachable_code,
  190    199   
            clippy::single_match,
  191    200   
            clippy::match_single_binding,
  192    201   
            clippy::diverging_sub_expression
  193    202   
        )]
  194         -
        deserializer.read_struct(&RPCV2CBORDENSEMAPSINPUT_SCHEMA, (), |_, member, deser| {
         203  +
        deserializer.read_struct(&RPCV2CBORDENSEMAPSINPUT_SCHEMA, &mut |member, deser| {
  195    204   
            match member.member_index() {
  196    205   
                Some(0) => {
  197    206   
                    builder.dense_struct_map = Some({
  198         -
                        let container = if let Some(cap) = deser.container_size() {
  199         -
                            std::collections::HashMap::with_capacity(cap)
  200         -
                        } else {
  201         -
                            std::collections::HashMap::new()
  202         -
                        };
  203         -
                        deser.read_map(member, container, |mut map, key, deser| {
  204         -
                            map.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
  205         -
                            Ok(map)
  206         -
                        })?
         207  +
                        let mut container = std::collections::HashMap::new();
         208  +
                        deser.read_map(member, &mut |key, deser| {
         209  +
                            container.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
         210  +
                            Ok(())
         211  +
                        })?;
         212  +
                        container
  207    213   
                    });
  208    214   
                }
  209    215   
                Some(1) => {
  210    216   
                    builder.dense_number_map = Some({
  211         -
                        let container = if let Some(cap) = deser.container_size() {
  212         -
                            std::collections::HashMap::with_capacity(cap)
  213         -
                        } else {
  214         -
                            std::collections::HashMap::new()
  215         -
                        };
  216         -
                        deser.read_map(member, container, |mut map, key, deser| {
  217         -
                            map.insert(key, deser.read_integer(member)?);
  218         -
                            Ok(map)
  219         -
                        })?
         217  +
                        let mut container = std::collections::HashMap::new();
         218  +
                        deser.read_map(member, &mut |key, deser| {
         219  +
                            container.insert(key, deser.read_integer(member)?);
         220  +
                            Ok(())
         221  +
                        })?;
         222  +
                        container
  220    223   
                    });
  221    224   
                }
  222    225   
                Some(2) => {
  223    226   
                    builder.dense_boolean_map = Some({
  224         -
                        let container = if let Some(cap) = deser.container_size() {
  225         -
                            std::collections::HashMap::with_capacity(cap)
  226         -
                        } else {
  227         -
                            std::collections::HashMap::new()
  228         -
                        };
  229         -
                        deser.read_map(member, container, |mut map, key, deser| {
  230         -
                            map.insert(key, deser.read_boolean(member)?);
  231         -
                            Ok(map)
  232         -
                        })?
         227  +
                        let mut container = std::collections::HashMap::new();
         228  +
                        deser.read_map(member, &mut |key, deser| {
         229  +
                            container.insert(key, deser.read_boolean(member)?);
         230  +
                            Ok(())
         231  +
                        })?;
         232  +
                        container
  233    233   
                    });
  234    234   
                }
  235    235   
                Some(3) => {
  236         -
                    builder.dense_string_map = Some({
  237         -
                        let container = if let Some(cap) = deser.container_size() {
  238         -
                            std::collections::HashMap::with_capacity(cap)
  239         -
                        } else {
  240         -
                            std::collections::HashMap::new()
  241         -
                        };
  242         -
                        deser.read_map(member, container, |mut map, key, deser| {
  243         -
                            map.insert(key, deser.read_string(member)?);
  244         -
                            Ok(map)
  245         -
                        })?
  246         -
                    });
         236  +
                    builder.dense_string_map = Some(deser.read_string_string_map(member)?);
  247    237   
                }
  248    238   
                Some(4) => {
  249    239   
                    builder.dense_set_map = Some({
  250         -
                        let container = if let Some(cap) = deser.container_size() {
  251         -
                            std::collections::HashMap::with_capacity(cap)
  252         -
                        } else {
  253         -
                            std::collections::HashMap::new()
  254         -
                        };
  255         -
                        deser.read_map(member, container, |mut map, key, deser| {
  256         -
                            map.insert(key, todo!("deserialize nested aggregate"));
  257         -
                            Ok(map)
  258         -
                        })?
         240  +
                        let mut container = std::collections::HashMap::new();
         241  +
                        deser.read_map(member, &mut |key, deser| {
         242  +
                            container.insert(key, {
         243  +
                                let mut list = Vec::new();
         244  +
                                deser.read_list(member, &mut |deser| {
         245  +
                                    list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
         246  +
                                    Ok(())
         247  +
                                })?;
         248  +
                                list
         249  +
                            });
         250  +
                            Ok(())
         251  +
                        })?;
         252  +
                        container
  259    253   
                    });
  260    254   
                }
  261    255   
                _ => {}
  262    256   
            }
  263    257   
            Ok(())
  264    258   
        })?;
  265    259   
        builder
  266    260   
            .build()
  267    261   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  268    262   
    }
  269    263   
}
         264  +
impl RpcV2CborDenseMapsInput {
         265  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         266  +
    pub fn deserialize_with_response(
         267  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         268  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         269  +
        _status: u16,
         270  +
        _body: &[u8],
         271  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         272  +
        Self::deserialize(deserializer)
         273  +
    }
         274  +
}
  270    275   
impl RpcV2CborDenseMapsInput {
  271    276   
    /// Creates a new builder-style object to manufacture [`RpcV2CborDenseMapsInput`](crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsInput).
  272    277   
    pub fn builder() -> crate::operation::rpc_v2_cbor_dense_maps::builders::RpcV2CborDenseMapsInputBuilder {
  273    278   
        crate::operation::rpc_v2_cbor_dense_maps::builders::RpcV2CborDenseMapsInputBuilder::default()
  274    279   
    }
  275    280   
}
  276    281   
  277    282   
/// A builder for [`RpcV2CborDenseMapsInput`](crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsInput).
  278    283   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  279    284   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_dense_maps/_rpc_v2_cbor_dense_maps_output.rs

@@ -23,23 +123,123 @@
   43     43   
    "smithy.protocoltests.rpcv2Cbor.synthetic",
   44     44   
    "RpcV2CborDenseMapsOutput",
   45     45   
);
   46     46   
static RPCV2CBORDENSEMAPSOUTPUT_MEMBER_DENSE_STRUCT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static(
   48     48   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborDenseMapsOutput$denseStructMap",
   49     49   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   50     50   
        "RpcV2CborDenseMapsOutput",
   51     51   
    ),
   52     52   
    ::aws_smithy_schema::ShapeType::Map,
   53         -
    "dense_struct_map",
          53  +
    "denseStructMap",
   54     54   
    0,
   55     55   
);
   56     56   
static RPCV2CBORDENSEMAPSOUTPUT_MEMBER_DENSE_NUMBER_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborDenseMapsOutput$denseNumberMap",
   59     59   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   60     60   
        "RpcV2CborDenseMapsOutput",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::Map,
   63         -
    "dense_number_map",
          63  +
    "denseNumberMap",
   64     64   
    1,
   65     65   
);
   66     66   
static RPCV2CBORDENSEMAPSOUTPUT_MEMBER_DENSE_BOOLEAN_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborDenseMapsOutput$denseBooleanMap",
   69     69   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   70     70   
        "RpcV2CborDenseMapsOutput",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::Map,
   73         -
    "dense_boolean_map",
          73  +
    "denseBooleanMap",
   74     74   
    2,
   75     75   
);
   76     76   
static RPCV2CBORDENSEMAPSOUTPUT_MEMBER_DENSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static(
   78     78   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborDenseMapsOutput$denseStringMap",
   79     79   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   80     80   
        "RpcV2CborDenseMapsOutput",
   81     81   
    ),
   82     82   
    ::aws_smithy_schema::ShapeType::Map,
   83         -
    "dense_string_map",
          83  +
    "denseStringMap",
   84     84   
    3,
   85     85   
);
   86     86   
static RPCV2CBORDENSEMAPSOUTPUT_MEMBER_DENSE_SET_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborDenseMapsOutput$denseSetMap",
   89     89   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   90     90   
        "RpcV2CborDenseMapsOutput",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::Map,
   93         -
    "dense_set_map",
          93  +
    "denseSetMap",
   94     94   
    4,
   95     95   
);
   96     96   
static RPCV2CBORDENSEMAPSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   97     97   
    RPCV2CBORDENSEMAPSOUTPUT_SCHEMA_ID,
   98     98   
    ::aws_smithy_schema::ShapeType::Structure,
   99     99   
    &[
  100    100   
        &RPCV2CBORDENSEMAPSOUTPUT_MEMBER_DENSE_STRUCT_MAP,
  101    101   
        &RPCV2CBORDENSEMAPSOUTPUT_MEMBER_DENSE_NUMBER_MAP,
  102    102   
        &RPCV2CBORDENSEMAPSOUTPUT_MEMBER_DENSE_BOOLEAN_MAP,
  103    103   
        &RPCV2CBORDENSEMAPSOUTPUT_MEMBER_DENSE_STRING_MAP,
@@ -141,141 +297,302 @@
  161    161   
                    Ok(())
  162    162   
                },
  163    163   
            )?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.dense_set_map {
  166    166   
            ser.write_map(
  167    167   
                &RPCV2CBORDENSEMAPSOUTPUT_MEMBER_DENSE_SET_MAP,
  168    168   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  169    169   
                    for (key, value) in val {
  170    170   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  171         -
                        todo!("schema: unsupported map value type");
         171  +
         172  +
                        ser.write_list(
         173  +
                            &::aws_smithy_schema::prelude::DOCUMENT,
         174  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         175  +
                                for item in value {
         176  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         177  +
                                }
         178  +
                                Ok(())
         179  +
                            },
         180  +
                        )?;
  172    181   
                    }
  173    182   
                    Ok(())
  174    183   
                },
  175    184   
            )?;
  176    185   
        }
  177    186   
        Ok(())
  178    187   
    }
  179    188   
}
  180    189   
impl RpcV2CborDenseMapsOutput {
  181    190   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  182         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  183         -
        deserializer: &mut D,
         191  +
    pub fn deserialize(
         192  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  184    193   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  185    194   
        #[allow(unused_variables, unused_mut)]
  186    195   
        let mut builder = Self::builder();
  187    196   
        #[allow(
  188    197   
            unused_variables,
  189    198   
            unreachable_code,
  190    199   
            clippy::single_match,
  191    200   
            clippy::match_single_binding,
  192    201   
            clippy::diverging_sub_expression
  193    202   
        )]
  194         -
        deserializer.read_struct(&RPCV2CBORDENSEMAPSOUTPUT_SCHEMA, (), |_, member, deser| {
         203  +
        deserializer.read_struct(&RPCV2CBORDENSEMAPSOUTPUT_SCHEMA, &mut |member, deser| {
  195    204   
            match member.member_index() {
  196    205   
                Some(0) => {
  197    206   
                    builder.dense_struct_map = Some({
  198         -
                        let container = if let Some(cap) = deser.container_size() {
  199         -
                            std::collections::HashMap::with_capacity(cap)
  200         -
                        } else {
  201         -
                            std::collections::HashMap::new()
  202         -
                        };
  203         -
                        deser.read_map(member, container, |mut map, key, deser| {
  204         -
                            map.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
  205         -
                            Ok(map)
  206         -
                        })?
         207  +
                        let mut container = std::collections::HashMap::new();
         208  +
                        deser.read_map(member, &mut |key, deser| {
         209  +
                            container.insert(key, crate::types::GreetingStruct::deserialize(deser)?);
         210  +
                            Ok(())
         211  +
                        })?;
         212  +
                        container
  207    213   
                    });
  208    214   
                }
  209    215   
                Some(1) => {
  210    216   
                    builder.dense_number_map = Some({
  211         -
                        let container = if let Some(cap) = deser.container_size() {
  212         -
                            std::collections::HashMap::with_capacity(cap)
  213         -
                        } else {
  214         -
                            std::collections::HashMap::new()
  215         -
                        };
  216         -
                        deser.read_map(member, container, |mut map, key, deser| {
  217         -
                            map.insert(key, deser.read_integer(member)?);
  218         -
                            Ok(map)
  219         -
                        })?
         217  +
                        let mut container = std::collections::HashMap::new();
         218  +
                        deser.read_map(member, &mut |key, deser| {
         219  +
                            container.insert(key, deser.read_integer(member)?);
         220  +
                            Ok(())
         221  +
                        })?;
         222  +
                        container
  220    223   
                    });
  221    224   
                }
  222    225   
                Some(2) => {
  223    226   
                    builder.dense_boolean_map = Some({
  224         -
                        let container = if let Some(cap) = deser.container_size() {
  225         -
                            std::collections::HashMap::with_capacity(cap)
  226         -
                        } else {
  227         -
                            std::collections::HashMap::new()
  228         -
                        };
  229         -
                        deser.read_map(member, container, |mut map, key, deser| {
  230         -
                            map.insert(key, deser.read_boolean(member)?);
  231         -
                            Ok(map)
  232         -
                        })?
         227  +
                        let mut container = std::collections::HashMap::new();
         228  +
                        deser.read_map(member, &mut |key, deser| {
         229  +
                            container.insert(key, deser.read_boolean(member)?);
         230  +
                            Ok(())
         231  +
                        })?;
         232  +
                        container
  233    233   
                    });
  234    234   
                }
  235    235   
                Some(3) => {
  236         -
                    builder.dense_string_map = Some({
  237         -
                        let container = if let Some(cap) = deser.container_size() {
  238         -
                            std::collections::HashMap::with_capacity(cap)
  239         -
                        } else {
  240         -
                            std::collections::HashMap::new()
  241         -
                        };
  242         -
                        deser.read_map(member, container, |mut map, key, deser| {
  243         -
                            map.insert(key, deser.read_string(member)?);
  244         -
                            Ok(map)
  245         -
                        })?
  246         -
                    });
         236  +
                    builder.dense_string_map = Some(deser.read_string_string_map(member)?);
  247    237   
                }
  248    238   
                Some(4) => {
  249    239   
                    builder.dense_set_map = Some({
  250         -
                        let container = if let Some(cap) = deser.container_size() {
  251         -
                            std::collections::HashMap::with_capacity(cap)
  252         -
                        } else {
  253         -
                            std::collections::HashMap::new()
  254         -
                        };
  255         -
                        deser.read_map(member, container, |mut map, key, deser| {
  256         -
                            map.insert(key, todo!("deserialize nested aggregate"));
  257         -
                            Ok(map)
  258         -
                        })?
         240  +
                        let mut container = std::collections::HashMap::new();
         241  +
                        deser.read_map(member, &mut |key, deser| {
         242  +
                            container.insert(key, {
         243  +
                                let mut list = Vec::new();
         244  +
                                deser.read_list(member, &mut |deser| {
         245  +
                                    list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
         246  +
                                    Ok(())
         247  +
                                })?;
         248  +
                                list
         249  +
                            });
         250  +
                            Ok(())
         251  +
                        })?;
         252  +
                        container
  259    253   
                    });
  260    254   
                }
  261    255   
                _ => {}
  262    256   
            }
  263    257   
            Ok(())
  264    258   
        })?;
  265    259   
        Ok(builder.build())
  266    260   
    }
  267    261   
}
         262  +
impl RpcV2CborDenseMapsOutput {
         263  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         264  +
    pub fn deserialize_with_response(
         265  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         266  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         267  +
        _status: u16,
         268  +
        _body: &[u8],
         269  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         270  +
        Self::deserialize(deserializer)
         271  +
    }
         272  +
}
  268    273   
impl RpcV2CborDenseMapsOutput {
  269    274   
    /// Creates a new builder-style object to manufacture [`RpcV2CborDenseMapsOutput`](crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsOutput).
  270    275   
    pub fn builder() -> crate::operation::rpc_v2_cbor_dense_maps::builders::RpcV2CborDenseMapsOutputBuilder {
  271    276   
        crate::operation::rpc_v2_cbor_dense_maps::builders::RpcV2CborDenseMapsOutputBuilder::default()
  272    277   
    }
  273    278   
}
  274    279   
  275    280   
/// A builder for [`RpcV2CborDenseMapsOutput`](crate::operation::rpc_v2_cbor_dense_maps::RpcV2CborDenseMapsOutput).
  276    281   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  277    282   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_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 `RpcV2CborLists`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct RpcV2CborLists;
    6      6   
impl RpcV2CborLists {
    7      7   
    /// Creates a new `RpcV2CborLists`
    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::rpc_v2_cbor_lists::RpcV2CborListsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::rpc_v2_cbor_lists::RpcV2CborListsOutput::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::rpc_v2_cbor_lists::RpcV2CborListsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::rpc_v2_cbor_lists::RpcV2CborListsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::rpc_v2_cbor_lists::RpcV2CborListsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::rpc_v2_cbor_lists::RpcV2CborListsError,
  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 RpcV2CborListsResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RpcV2CborListsResponseDeserializer {
  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_rpc_v2_cbor_lists::de_rpc_v2_cbor_lists_http_error(status, headers, body)
  146    151   
        } else {
@@ -425,430 +485,494 @@
  445    450   
            .expect("the config must have a deserializer");
  446    451   
  447    452   
        let parsed = de.deserialize_streaming(&mut http_response);
  448    453   
        let parsed = parsed.unwrap_or_else(|| {
  449    454   
            let http_response = http_response.map(|body| {
  450    455   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  451    456   
                    body.bytes().unwrap(),
  452    457   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  453    458   
                )))
  454    459   
            });
  455         -
            de.deserialize_nonstreaming(&http_response)
         460  +
            // Build a config bag with the protocol for schema-based deserialization
         461  +
            #[allow(unused_mut)]
         462  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         463  +
         464  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  456    465   
        });
  457    466   
        let parsed = parsed
  458    467   
            .expect("should be successful response")
  459    468   
            .downcast::<crate::operation::rpc_v2_cbor_lists::RpcV2CborListsOutput>()
  460    469   
            .unwrap();
  461    470   
        ::pretty_assertions::assert_eq!(parsed.string_list, expected_output.string_list, "Unexpected value for `string_list`");
  462    471   
        ::pretty_assertions::assert_eq!(parsed.string_set, expected_output.string_set, "Unexpected value for `string_set`");
  463    472   
        ::pretty_assertions::assert_eq!(parsed.integer_list, expected_output.integer_list, "Unexpected value for `integer_list`");
  464    473   
        ::pretty_assertions::assert_eq!(parsed.boolean_list, expected_output.boolean_list, "Unexpected value for `boolean_list`");
  465    474   
        ::pretty_assertions::assert_eq!(
@@ -493,502 +553,566 @@
  513    522   
            .expect("the config must have a deserializer");
  514    523   
  515    524   
        let parsed = de.deserialize_streaming(&mut http_response);
  516    525   
        let parsed = parsed.unwrap_or_else(|| {
  517    526   
            let http_response = http_response.map(|body| {
  518    527   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  519    528   
                    body.bytes().unwrap(),
  520    529   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  521    530   
                )))
  522    531   
            });
  523         -
            de.deserialize_nonstreaming(&http_response)
         532  +
            // Build a config bag with the protocol for schema-based deserialization
         533  +
            #[allow(unused_mut)]
         534  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         535  +
         536  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  524    537   
        });
  525    538   
        let parsed = parsed
  526    539   
            .expect("should be successful response")
  527    540   
            .downcast::<crate::operation::rpc_v2_cbor_lists::RpcV2CborListsOutput>()
  528    541   
            .unwrap();
  529    542   
        ::pretty_assertions::assert_eq!(parsed.string_list, expected_output.string_list, "Unexpected value for `string_list`");
  530    543   
        ::pretty_assertions::assert_eq!(parsed.string_set, expected_output.string_set, "Unexpected value for `string_set`");
  531    544   
        ::pretty_assertions::assert_eq!(parsed.integer_list, expected_output.integer_list, "Unexpected value for `integer_list`");
  532    545   
        ::pretty_assertions::assert_eq!(parsed.boolean_list, expected_output.boolean_list, "Unexpected value for `boolean_list`");
  533    546   
        ::pretty_assertions::assert_eq!(
@@ -563,576 +623,640 @@
  583    596   
            .expect("the config must have a deserializer");
  584    597   
  585    598   
        let parsed = de.deserialize_streaming(&mut http_response);
  586    599   
        let parsed = parsed.unwrap_or_else(|| {
  587    600   
            let http_response = http_response.map(|body| {
  588    601   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  589    602   
                    body.bytes().unwrap(),
  590    603   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  591    604   
                )))
  592    605   
            });
  593         -
            de.deserialize_nonstreaming(&http_response)
         606  +
            // Build a config bag with the protocol for schema-based deserialization
         607  +
            #[allow(unused_mut)]
         608  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         609  +
         610  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  594    611   
        });
  595    612   
        let parsed = parsed
  596    613   
            .expect("should be successful response")
  597    614   
            .downcast::<crate::operation::rpc_v2_cbor_lists::RpcV2CborListsOutput>()
  598    615   
            .unwrap();
  599    616   
        ::pretty_assertions::assert_eq!(parsed.string_list, expected_output.string_list, "Unexpected value for `string_list`");
  600    617   
        ::pretty_assertions::assert_eq!(parsed.string_set, expected_output.string_set, "Unexpected value for `string_set`");
  601    618   
        ::pretty_assertions::assert_eq!(parsed.integer_list, expected_output.integer_list, "Unexpected value for `integer_list`");
  602    619   
        ::pretty_assertions::assert_eq!(parsed.boolean_list, expected_output.boolean_list, "Unexpected value for `boolean_list`");
  603    620   
        ::pretty_assertions::assert_eq!(
@@ -633,650 +693,714 @@
  653    670   
            .expect("the config must have a deserializer");
  654    671   
  655    672   
        let parsed = de.deserialize_streaming(&mut http_response);
  656    673   
        let parsed = parsed.unwrap_or_else(|| {
  657    674   
            let http_response = http_response.map(|body| {
  658    675   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  659    676   
                    body.bytes().unwrap(),
  660    677   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  661    678   
                )))
  662    679   
            });
  663         -
            de.deserialize_nonstreaming(&http_response)
         680  +
            // Build a config bag with the protocol for schema-based deserialization
         681  +
            #[allow(unused_mut)]
         682  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         683  +
         684  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  664    685   
        });
  665    686   
        let parsed = parsed
  666    687   
            .expect("should be successful response")
  667    688   
            .downcast::<crate::operation::rpc_v2_cbor_lists::RpcV2CborListsOutput>()
  668    689   
            .unwrap();
  669    690   
        ::pretty_assertions::assert_eq!(parsed.string_list, expected_output.string_list, "Unexpected value for `string_list`");
  670    691   
        ::pretty_assertions::assert_eq!(parsed.string_set, expected_output.string_set, "Unexpected value for `string_set`");
  671    692   
        ::pretty_assertions::assert_eq!(parsed.integer_list, expected_output.integer_list, "Unexpected value for `integer_list`");
  672    693   
        ::pretty_assertions::assert_eq!(parsed.boolean_list, expected_output.boolean_list, "Unexpected value for `boolean_list`");
  673    694   
        ::pretty_assertions::assert_eq!(

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_lists/_rpc_v2_cbor_lists_input.rs

@@ -71,71 +221,221 @@
   91     91   
    "smithy.protocoltests.rpcv2Cbor.synthetic",
   92     92   
    "RpcV2CborListsInput",
   93     93   
);
   94     94   
static RPCV2CBORLISTSINPUT_MEMBER_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static(
   96     96   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsInput$stringList",
   97     97   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   98     98   
        "RpcV2CborListsInput",
   99     99   
    ),
  100    100   
    ::aws_smithy_schema::ShapeType::List,
  101         -
    "string_list",
         101  +
    "stringList",
  102    102   
    0,
  103    103   
);
  104    104   
static RPCV2CBORLISTSINPUT_MEMBER_STRING_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static(
  106    106   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsInput$stringSet",
  107    107   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  108    108   
        "RpcV2CborListsInput",
  109    109   
    ),
  110    110   
    ::aws_smithy_schema::ShapeType::List,
  111         -
    "string_set",
         111  +
    "stringSet",
  112    112   
    1,
  113    113   
);
  114    114   
static RPCV2CBORLISTSINPUT_MEMBER_INTEGER_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsInput$integerList",
  117    117   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  118    118   
        "RpcV2CborListsInput",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::List,
  121         -
    "integer_list",
         121  +
    "integerList",
  122    122   
    2,
  123    123   
);
  124    124   
static RPCV2CBORLISTSINPUT_MEMBER_BOOLEAN_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsInput$booleanList",
  127    127   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  128    128   
        "RpcV2CborListsInput",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::List,
  131         -
    "boolean_list",
         131  +
    "booleanList",
  132    132   
    3,
  133    133   
);
  134    134   
static RPCV2CBORLISTSINPUT_MEMBER_TIMESTAMP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsInput$timestampList",
  137    137   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  138    138   
        "RpcV2CborListsInput",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::List,
  141         -
    "timestamp_list",
         141  +
    "timestampList",
  142    142   
    4,
  143    143   
);
  144    144   
static RPCV2CBORLISTSINPUT_MEMBER_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsInput$enumList",
  147    147   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  148    148   
        "RpcV2CborListsInput",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::List,
  151         -
    "enum_list",
         151  +
    "enumList",
  152    152   
    5,
  153    153   
);
  154    154   
static RPCV2CBORLISTSINPUT_MEMBER_INT_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static(
  156    156   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsInput$intEnumList",
  157    157   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  158    158   
        "RpcV2CborListsInput",
  159    159   
    ),
  160    160   
    ::aws_smithy_schema::ShapeType::List,
  161         -
    "int_enum_list",
         161  +
    "intEnumList",
  162    162   
    6,
  163    163   
);
  164    164   
static RPCV2CBORLISTSINPUT_MEMBER_NESTED_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static(
  166    166   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsInput$nestedStringList",
  167    167   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  168    168   
        "RpcV2CborListsInput",
  169    169   
    ),
  170    170   
    ::aws_smithy_schema::ShapeType::List,
  171         -
    "nested_string_list",
         171  +
    "nestedStringList",
  172    172   
    7,
  173    173   
);
  174    174   
static RPCV2CBORLISTSINPUT_MEMBER_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  175    175   
    ::aws_smithy_schema::ShapeId::from_static(
  176    176   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsInput$structureList",
  177    177   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  178    178   
        "RpcV2CborListsInput",
  179    179   
    ),
  180    180   
    ::aws_smithy_schema::ShapeType::List,
  181         -
    "structure_list",
         181  +
    "structureList",
  182    182   
    8,
  183    183   
);
  184    184   
static RPCV2CBORLISTSINPUT_MEMBER_BLOB_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  185    185   
    ::aws_smithy_schema::ShapeId::from_static(
  186    186   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsInput$blobList",
  187    187   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  188    188   
        "RpcV2CborListsInput",
  189    189   
    ),
  190    190   
    ::aws_smithy_schema::ShapeType::List,
  191         -
    "blob_list",
         191  +
    "blobList",
  192    192   
    9,
  193    193   
);
  194    194   
static RPCV2CBORLISTSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  195    195   
    RPCV2CBORLISTSINPUT_SCHEMA_ID,
  196    196   
    ::aws_smithy_schema::ShapeType::Structure,
  197    197   
    &[
  198    198   
        &RPCV2CBORLISTSINPUT_MEMBER_STRING_LIST,
  199    199   
        &RPCV2CBORLISTSINPUT_MEMBER_STRING_SET,
  200    200   
        &RPCV2CBORLISTSINPUT_MEMBER_INTEGER_LIST,
  201    201   
        &RPCV2CBORLISTSINPUT_MEMBER_BOOLEAN_LIST,
@@ -272,272 +517,478 @@
  292    292   
                    }
  293    293   
                    Ok(())
  294    294   
                },
  295    295   
            )?;
  296    296   
        }
  297    297   
        if let Some(ref val) = self.nested_string_list {
  298    298   
            ser.write_list(
  299    299   
                &RPCV2CBORLISTSINPUT_MEMBER_NESTED_STRING_LIST,
  300    300   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  301    301   
                    for item in val {
  302         -
                        todo!("schema: unsupported list element type");
         302  +
                        ser.write_list(
         303  +
                            &::aws_smithy_schema::prelude::DOCUMENT,
         304  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         305  +
                                for item in item {
         306  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         307  +
                                }
         308  +
                                Ok(())
         309  +
                            },
         310  +
                        )?;
  303    311   
                    }
  304    312   
                    Ok(())
  305    313   
                },
  306    314   
            )?;
  307    315   
        }
  308    316   
        if let Some(ref val) = self.structure_list {
  309    317   
            ser.write_list(
  310    318   
                &RPCV2CBORLISTSINPUT_MEMBER_STRUCTURE_LIST,
  311    319   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  312    320   
                    for item in val {
  313    321   
                        ser.write_struct(crate::types::StructureListMember::SCHEMA, item)?;
  314    322   
                    }
  315    323   
                    Ok(())
  316    324   
                },
  317    325   
            )?;
  318    326   
        }
  319    327   
        if let Some(ref val) = self.blob_list {
  320    328   
            ser.write_list(
  321    329   
                &RPCV2CBORLISTSINPUT_MEMBER_BLOB_LIST,
  322    330   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  323    331   
                    for item in val {
  324    332   
                        ser.write_blob(&aws_smithy_schema::prelude::BLOB, item)?;
  325    333   
                    }
  326    334   
                    Ok(())
  327    335   
                },
  328    336   
            )?;
  329    337   
        }
  330    338   
        Ok(())
  331    339   
    }
  332    340   
}
  333    341   
impl RpcV2CborListsInput {
  334    342   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  335         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  336         -
        deserializer: &mut D,
         343  +
    pub fn deserialize(
         344  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  337    345   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  338    346   
        #[allow(unused_variables, unused_mut)]
  339    347   
        let mut builder = Self::builder();
  340    348   
        #[allow(
  341    349   
            unused_variables,
  342    350   
            unreachable_code,
  343    351   
            clippy::single_match,
  344    352   
            clippy::match_single_binding,
  345    353   
            clippy::diverging_sub_expression
  346    354   
        )]
  347         -
        deserializer.read_struct(&RPCV2CBORLISTSINPUT_SCHEMA, (), |_, member, deser| {
         355  +
        deserializer.read_struct(&RPCV2CBORLISTSINPUT_SCHEMA, &mut |member, deser| {
  348    356   
            match member.member_index() {
  349    357   
                Some(0) => {
  350         -
                    builder.string_list = Some({
  351         -
                        let container = if let Some(cap) = deser.container_size() {
  352         -
                            Vec::with_capacity(cap)
  353         -
                        } else {
  354         -
                            Vec::new()
  355         -
                        };
  356         -
                        deser.read_list(member, container, |mut list, deser| {
  357         -
                            list.push(deser.read_string(member)?);
  358         -
                            Ok(list)
  359         -
                        })?
  360         -
                    });
         358  +
                    builder.string_list = Some(deser.read_string_list(member)?);
  361    359   
                }
  362    360   
                Some(1) => {
  363         -
                    builder.string_set = Some({
  364         -
                        let container = if let Some(cap) = deser.container_size() {
  365         -
                            Vec::with_capacity(cap)
  366         -
                        } else {
  367         -
                            Vec::new()
  368         -
                        };
  369         -
                        deser.read_list(member, container, |mut list, deser| {
  370         -
                            list.push(deser.read_string(member)?);
  371         -
                            Ok(list)
  372         -
                        })?
  373         -
                    });
         361  +
                    builder.string_set = Some(deser.read_string_list(member)?);
  374    362   
                }
  375    363   
                Some(2) => {
  376         -
                    builder.integer_list = Some({
  377         -
                        let container = if let Some(cap) = deser.container_size() {
  378         -
                            Vec::with_capacity(cap)
  379         -
                        } else {
  380         -
                            Vec::new()
  381         -
                        };
  382         -
                        deser.read_list(member, container, |mut list, deser| {
  383         -
                            list.push(deser.read_integer(member)?);
  384         -
                            Ok(list)
  385         -
                        })?
  386         -
                    });
         364  +
                    builder.integer_list = Some(deser.read_integer_list(member)?);
  387    365   
                }
  388    366   
                Some(3) => {
  389    367   
                    builder.boolean_list = Some({
  390         -
                        let container = if let Some(cap) = deser.container_size() {
  391         -
                            Vec::with_capacity(cap)
  392         -
                        } else {
  393         -
                            Vec::new()
  394         -
                        };
  395         -
                        deser.read_list(member, container, |mut list, deser| {
  396         -
                            list.push(deser.read_boolean(member)?);
  397         -
                            Ok(list)
  398         -
                        })?
         368  +
                        let mut container = Vec::new();
         369  +
                        deser.read_list(member, &mut |deser| {
         370  +
                            container.push(deser.read_boolean(member)?);
         371  +
                            Ok(())
         372  +
                        })?;
         373  +
                        container
  399    374   
                    });
  400    375   
                }
  401    376   
                Some(4) => {
  402    377   
                    builder.timestamp_list = Some({
  403         -
                        let container = if let Some(cap) = deser.container_size() {
  404         -
                            Vec::with_capacity(cap)
  405         -
                        } else {
  406         -
                            Vec::new()
  407         -
                        };
  408         -
                        deser.read_list(member, container, |mut list, deser| {
  409         -
                            list.push(deser.read_timestamp(member)?);
  410         -
                            Ok(list)
  411         -
                        })?
         378  +
                        let mut container = Vec::new();
         379  +
                        deser.read_list(member, &mut |deser| {
         380  +
                            container.push(deser.read_timestamp(member)?);
         381  +
                            Ok(())
         382  +
                        })?;
         383  +
                        container
  412    384   
                    });
  413    385   
                }
  414    386   
                Some(5) => {
  415    387   
                    builder.enum_list = Some({
  416         -
                        let container = if let Some(cap) = deser.container_size() {
  417         -
                            Vec::with_capacity(cap)
  418         -
                        } else {
  419         -
                            Vec::new()
  420         -
                        };
  421         -
                        deser.read_list(member, container, |mut list, deser| {
  422         -
                            list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  423         -
                            Ok(list)
  424         -
                        })?
         388  +
                        let mut container = Vec::new();
         389  +
                        deser.read_list(member, &mut |deser| {
         390  +
                            container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
         391  +
                            Ok(())
         392  +
                        })?;
         393  +
                        container
  425    394   
                    });
  426    395   
                }
  427    396   
                Some(6) => {
  428         -
                    builder.int_enum_list = Some({
  429         -
                        let container = if let Some(cap) = deser.container_size() {
  430         -
                            Vec::with_capacity(cap)
  431         -
                        } else {
  432         -
                            Vec::new()
  433         -
                        };
  434         -
                        deser.read_list(member, container, |mut list, deser| {
  435         -
                            list.push(deser.read_integer(member)?);
  436         -
                            Ok(list)
  437         -
                        })?
  438         -
                    });
         397  +
                    builder.int_enum_list = Some(deser.read_integer_list(member)?);
  439    398   
                }
  440    399   
                Some(7) => {
  441    400   
                    builder.nested_string_list = Some({
  442         -
                        let container = if let Some(cap) = deser.container_size() {
  443         -
                            Vec::with_capacity(cap)
  444         -
                        } else {
  445         -
                            Vec::new()
  446         -
                        };
  447         -
                        deser.read_list(member, container, |mut list, deser| {
  448         -
                            list.push(todo!("deserialize nested aggregate"));
  449         -
                            Ok(list)
  450         -
                        })?
         401  +
                        let mut container = Vec::new();
         402  +
                        deser.read_list(member, &mut |deser| {
         403  +
                            container.push({
         404  +
                                let mut list = Vec::new();
         405  +
                                deser.read_list(member, &mut |deser| {
         406  +
                                    list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
         407  +
                                    Ok(())
         408  +
                                })?;
         409  +
                                list
         410  +
                            });
         411  +
                            Ok(())
         412  +
                        })?;
         413  +
                        container
  451    414   
                    });
  452    415   
                }
  453    416   
                Some(8) => {
  454    417   
                    builder.structure_list = Some({
  455         -
                        let container = if let Some(cap) = deser.container_size() {
  456         -
                            Vec::with_capacity(cap)
  457         -
                        } else {
  458         -
                            Vec::new()
  459         -
                        };
  460         -
                        deser.read_list(member, container, |mut list, deser| {
  461         -
                            list.push(crate::types::StructureListMember::deserialize(deser)?);
  462         -
                            Ok(list)
  463         -
                        })?
         418  +
                        let mut container = Vec::new();
         419  +
                        deser.read_list(member, &mut |deser| {
         420  +
                            container.push(crate::types::StructureListMember::deserialize(deser)?);
         421  +
                            Ok(())
         422  +
                        })?;
         423  +
                        container
  464    424   
                    });
  465    425   
                }
  466    426   
                Some(9) => {
  467         -
                    builder.blob_list = Some({
  468         -
                        let container = if let Some(cap) = deser.container_size() {
  469         -
                            Vec::with_capacity(cap)
  470         -
                        } else {
  471         -
                            Vec::new()
  472         -
                        };
  473         -
                        deser.read_list(member, container, |mut list, deser| {
  474         -
                            list.push(deser.read_blob(member)?);
  475         -
                            Ok(list)
  476         -
                        })?
  477         -
                    });
         427  +
                    builder.blob_list = Some(deser.read_blob_list(member)?);
  478    428   
                }
  479    429   
                _ => {}
  480    430   
            }
  481    431   
            Ok(())
  482    432   
        })?;
  483    433   
        builder
  484    434   
            .build()
  485    435   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  486    436   
    }
  487    437   
}
         438  +
impl RpcV2CborListsInput {
         439  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         440  +
    pub fn deserialize_with_response(
         441  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         442  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         443  +
        _status: u16,
         444  +
        _body: &[u8],
         445  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         446  +
        Self::deserialize(deserializer)
         447  +
    }
         448  +
}
  488    449   
impl RpcV2CborListsInput {
  489    450   
    /// Creates a new builder-style object to manufacture [`RpcV2CborListsInput`](crate::operation::rpc_v2_cbor_lists::RpcV2CborListsInput).
  490    451   
    pub fn builder() -> crate::operation::rpc_v2_cbor_lists::builders::RpcV2CborListsInputBuilder {
  491    452   
        crate::operation::rpc_v2_cbor_lists::builders::RpcV2CborListsInputBuilder::default()
  492    453   
    }
  493    454   
}
  494    455   
  495    456   
/// A builder for [`RpcV2CborListsInput`](crate::operation::rpc_v2_cbor_lists::RpcV2CborListsInput).
  496    457   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  497    458   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_lists/_rpc_v2_cbor_lists_output.rs

@@ -71,71 +221,221 @@
   91     91   
    "smithy.protocoltests.rpcv2Cbor.synthetic",
   92     92   
    "RpcV2CborListsOutput",
   93     93   
);
   94     94   
static RPCV2CBORLISTSOUTPUT_MEMBER_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   95     95   
    ::aws_smithy_schema::ShapeId::from_static(
   96     96   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$stringList",
   97     97   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   98     98   
        "RpcV2CborListsOutput",
   99     99   
    ),
  100    100   
    ::aws_smithy_schema::ShapeType::List,
  101         -
    "string_list",
         101  +
    "stringList",
  102    102   
    0,
  103    103   
);
  104    104   
static RPCV2CBORLISTSOUTPUT_MEMBER_STRING_SET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  105    105   
    ::aws_smithy_schema::ShapeId::from_static(
  106    106   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$stringSet",
  107    107   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  108    108   
        "RpcV2CborListsOutput",
  109    109   
    ),
  110    110   
    ::aws_smithy_schema::ShapeType::List,
  111         -
    "string_set",
         111  +
    "stringSet",
  112    112   
    1,
  113    113   
);
  114    114   
static RPCV2CBORLISTSOUTPUT_MEMBER_INTEGER_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$integerList",
  117    117   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  118    118   
        "RpcV2CborListsOutput",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::List,
  121         -
    "integer_list",
         121  +
    "integerList",
  122    122   
    2,
  123    123   
);
  124    124   
static RPCV2CBORLISTSOUTPUT_MEMBER_BOOLEAN_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$booleanList",
  127    127   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  128    128   
        "RpcV2CborListsOutput",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::List,
  131         -
    "boolean_list",
         131  +
    "booleanList",
  132    132   
    3,
  133    133   
);
  134    134   
static RPCV2CBORLISTSOUTPUT_MEMBER_TIMESTAMP_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$timestampList",
  137    137   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  138    138   
        "RpcV2CborListsOutput",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::List,
  141         -
    "timestamp_list",
         141  +
    "timestampList",
  142    142   
    4,
  143    143   
);
  144    144   
static RPCV2CBORLISTSOUTPUT_MEMBER_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$enumList",
  147    147   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  148    148   
        "RpcV2CborListsOutput",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::List,
  151         -
    "enum_list",
         151  +
    "enumList",
  152    152   
    5,
  153    153   
);
  154    154   
static RPCV2CBORLISTSOUTPUT_MEMBER_INT_ENUM_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static(
  156    156   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$intEnumList",
  157    157   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  158    158   
        "RpcV2CborListsOutput",
  159    159   
    ),
  160    160   
    ::aws_smithy_schema::ShapeType::List,
  161         -
    "int_enum_list",
         161  +
    "intEnumList",
  162    162   
    6,
  163    163   
);
  164    164   
static RPCV2CBORLISTSOUTPUT_MEMBER_NESTED_STRING_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static(
  166    166   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$nestedStringList",
  167    167   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  168    168   
        "RpcV2CborListsOutput",
  169    169   
    ),
  170    170   
    ::aws_smithy_schema::ShapeType::List,
  171         -
    "nested_string_list",
         171  +
    "nestedStringList",
  172    172   
    7,
  173    173   
);
  174    174   
static RPCV2CBORLISTSOUTPUT_MEMBER_STRUCTURE_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  175    175   
    ::aws_smithy_schema::ShapeId::from_static(
  176    176   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$structureList",
  177    177   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  178    178   
        "RpcV2CborListsOutput",
  179    179   
    ),
  180    180   
    ::aws_smithy_schema::ShapeType::List,
  181         -
    "structure_list",
         181  +
    "structureList",
  182    182   
    8,
  183    183   
);
  184    184   
static RPCV2CBORLISTSOUTPUT_MEMBER_BLOB_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  185    185   
    ::aws_smithy_schema::ShapeId::from_static(
  186    186   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborListsOutput$blobList",
  187    187   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
  188    188   
        "RpcV2CborListsOutput",
  189    189   
    ),
  190    190   
    ::aws_smithy_schema::ShapeType::List,
  191         -
    "blob_list",
         191  +
    "blobList",
  192    192   
    9,
  193    193   
);
  194    194   
static RPCV2CBORLISTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  195    195   
    RPCV2CBORLISTSOUTPUT_SCHEMA_ID,
  196    196   
    ::aws_smithy_schema::ShapeType::Structure,
  197    197   
    &[
  198    198   
        &RPCV2CBORLISTSOUTPUT_MEMBER_STRING_LIST,
  199    199   
        &RPCV2CBORLISTSOUTPUT_MEMBER_STRING_SET,
  200    200   
        &RPCV2CBORLISTSOUTPUT_MEMBER_INTEGER_LIST,
  201    201   
        &RPCV2CBORLISTSOUTPUT_MEMBER_BOOLEAN_LIST,
@@ -272,272 +515,476 @@
  292    292   
                    }
  293    293   
                    Ok(())
  294    294   
                },
  295    295   
            )?;
  296    296   
        }
  297    297   
        if let Some(ref val) = self.nested_string_list {
  298    298   
            ser.write_list(
  299    299   
                &RPCV2CBORLISTSOUTPUT_MEMBER_NESTED_STRING_LIST,
  300    300   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  301    301   
                    for item in val {
  302         -
                        todo!("schema: unsupported list element type");
         302  +
                        ser.write_list(
         303  +
                            &::aws_smithy_schema::prelude::DOCUMENT,
         304  +
                            &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         305  +
                                for item in item {
         306  +
                                    ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         307  +
                                }
         308  +
                                Ok(())
         309  +
                            },
         310  +
                        )?;
  303    311   
                    }
  304    312   
                    Ok(())
  305    313   
                },
  306    314   
            )?;
  307    315   
        }
  308    316   
        if let Some(ref val) = self.structure_list {
  309    317   
            ser.write_list(
  310    318   
                &RPCV2CBORLISTSOUTPUT_MEMBER_STRUCTURE_LIST,
  311    319   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  312    320   
                    for item in val {
  313    321   
                        ser.write_struct(crate::types::StructureListMember::SCHEMA, item)?;
  314    322   
                    }
  315    323   
                    Ok(())
  316    324   
                },
  317    325   
            )?;
  318    326   
        }
  319    327   
        if let Some(ref val) = self.blob_list {
  320    328   
            ser.write_list(
  321    329   
                &RPCV2CBORLISTSOUTPUT_MEMBER_BLOB_LIST,
  322    330   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  323    331   
                    for item in val {
  324    332   
                        ser.write_blob(&aws_smithy_schema::prelude::BLOB, item)?;
  325    333   
                    }
  326    334   
                    Ok(())
  327    335   
                },
  328    336   
            )?;
  329    337   
        }
  330    338   
        Ok(())
  331    339   
    }
  332    340   
}
  333    341   
impl RpcV2CborListsOutput {
  334    342   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  335         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  336         -
        deserializer: &mut D,
         343  +
    pub fn deserialize(
         344  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  337    345   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  338    346   
        #[allow(unused_variables, unused_mut)]
  339    347   
        let mut builder = Self::builder();
  340    348   
        #[allow(
  341    349   
            unused_variables,
  342    350   
            unreachable_code,
  343    351   
            clippy::single_match,
  344    352   
            clippy::match_single_binding,
  345    353   
            clippy::diverging_sub_expression
  346    354   
        )]
  347         -
        deserializer.read_struct(&RPCV2CBORLISTSOUTPUT_SCHEMA, (), |_, member, deser| {
         355  +
        deserializer.read_struct(&RPCV2CBORLISTSOUTPUT_SCHEMA, &mut |member, deser| {
  348    356   
            match member.member_index() {
  349    357   
                Some(0) => {
  350         -
                    builder.string_list = Some({
  351         -
                        let container = if let Some(cap) = deser.container_size() {
  352         -
                            Vec::with_capacity(cap)
  353         -
                        } else {
  354         -
                            Vec::new()
  355         -
                        };
  356         -
                        deser.read_list(member, container, |mut list, deser| {
  357         -
                            list.push(deser.read_string(member)?);
  358         -
                            Ok(list)
  359         -
                        })?
  360         -
                    });
         358  +
                    builder.string_list = Some(deser.read_string_list(member)?);
  361    359   
                }
  362    360   
                Some(1) => {
  363         -
                    builder.string_set = Some({
  364         -
                        let container = if let Some(cap) = deser.container_size() {
  365         -
                            Vec::with_capacity(cap)
  366         -
                        } else {
  367         -
                            Vec::new()
  368         -
                        };
  369         -
                        deser.read_list(member, container, |mut list, deser| {
  370         -
                            list.push(deser.read_string(member)?);
  371         -
                            Ok(list)
  372         -
                        })?
  373         -
                    });
         361  +
                    builder.string_set = Some(deser.read_string_list(member)?);
  374    362   
                }
  375    363   
                Some(2) => {
  376         -
                    builder.integer_list = Some({
  377         -
                        let container = if let Some(cap) = deser.container_size() {
  378         -
                            Vec::with_capacity(cap)
  379         -
                        } else {
  380         -
                            Vec::new()
  381         -
                        };
  382         -
                        deser.read_list(member, container, |mut list, deser| {
  383         -
                            list.push(deser.read_integer(member)?);
  384         -
                            Ok(list)
  385         -
                        })?
  386         -
                    });
         364  +
                    builder.integer_list = Some(deser.read_integer_list(member)?);
  387    365   
                }
  388    366   
                Some(3) => {
  389    367   
                    builder.boolean_list = Some({
  390         -
                        let container = if let Some(cap) = deser.container_size() {
  391         -
                            Vec::with_capacity(cap)
  392         -
                        } else {
  393         -
                            Vec::new()
  394         -
                        };
  395         -
                        deser.read_list(member, container, |mut list, deser| {
  396         -
                            list.push(deser.read_boolean(member)?);
  397         -
                            Ok(list)
  398         -
                        })?
         368  +
                        let mut container = Vec::new();
         369  +
                        deser.read_list(member, &mut |deser| {
         370  +
                            container.push(deser.read_boolean(member)?);
         371  +
                            Ok(())
         372  +
                        })?;
         373  +
                        container
  399    374   
                    });
  400    375   
                }
  401    376   
                Some(4) => {
  402    377   
                    builder.timestamp_list = Some({
  403         -
                        let container = if let Some(cap) = deser.container_size() {
  404         -
                            Vec::with_capacity(cap)
  405         -
                        } else {
  406         -
                            Vec::new()
  407         -
                        };
  408         -
                        deser.read_list(member, container, |mut list, deser| {
  409         -
                            list.push(deser.read_timestamp(member)?);
  410         -
                            Ok(list)
  411         -
                        })?
         378  +
                        let mut container = Vec::new();
         379  +
                        deser.read_list(member, &mut |deser| {
         380  +
                            container.push(deser.read_timestamp(member)?);
         381  +
                            Ok(())
         382  +
                        })?;
         383  +
                        container
  412    384   
                    });
  413    385   
                }
  414    386   
                Some(5) => {
  415    387   
                    builder.enum_list = Some({
  416         -
                        let container = if let Some(cap) = deser.container_size() {
  417         -
                            Vec::with_capacity(cap)
  418         -
                        } else {
  419         -
                            Vec::new()
  420         -
                        };
  421         -
                        deser.read_list(member, container, |mut list, deser| {
  422         -
                            list.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
  423         -
                            Ok(list)
  424         -
                        })?
         388  +
                        let mut container = Vec::new();
         389  +
                        deser.read_list(member, &mut |deser| {
         390  +
                            container.push(crate::types::FooEnum::from(deser.read_string(member)?.as_str()));
         391  +
                            Ok(())
         392  +
                        })?;
         393  +
                        container
  425    394   
                    });
  426    395   
                }
  427    396   
                Some(6) => {
  428         -
                    builder.int_enum_list = Some({
  429         -
                        let container = if let Some(cap) = deser.container_size() {
  430         -
                            Vec::with_capacity(cap)
  431         -
                        } else {
  432         -
                            Vec::new()
  433         -
                        };
  434         -
                        deser.read_list(member, container, |mut list, deser| {
  435         -
                            list.push(deser.read_integer(member)?);
  436         -
                            Ok(list)
  437         -
                        })?
  438         -
                    });
         397  +
                    builder.int_enum_list = Some(deser.read_integer_list(member)?);
  439    398   
                }
  440    399   
                Some(7) => {
  441    400   
                    builder.nested_string_list = Some({
  442         -
                        let container = if let Some(cap) = deser.container_size() {
  443         -
                            Vec::with_capacity(cap)
  444         -
                        } else {
  445         -
                            Vec::new()
  446         -
                        };
  447         -
                        deser.read_list(member, container, |mut list, deser| {
  448         -
                            list.push(todo!("deserialize nested aggregate"));
  449         -
                            Ok(list)
  450         -
                        })?
         401  +
                        let mut container = Vec::new();
         402  +
                        deser.read_list(member, &mut |deser| {
         403  +
                            container.push({
         404  +
                                let mut list = Vec::new();
         405  +
                                deser.read_list(member, &mut |deser| {
         406  +
                                    list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
         407  +
                                    Ok(())
         408  +
                                })?;
         409  +
                                list
         410  +
                            });
         411  +
                            Ok(())
         412  +
                        })?;
         413  +
                        container
  451    414   
                    });
  452    415   
                }
  453    416   
                Some(8) => {
  454    417   
                    builder.structure_list = Some({
  455         -
                        let container = if let Some(cap) = deser.container_size() {
  456         -
                            Vec::with_capacity(cap)
  457         -
                        } else {
  458         -
                            Vec::new()
  459         -
                        };
  460         -
                        deser.read_list(member, container, |mut list, deser| {
  461         -
                            list.push(crate::types::StructureListMember::deserialize(deser)?);
  462         -
                            Ok(list)
  463         -
                        })?
         418  +
                        let mut container = Vec::new();
         419  +
                        deser.read_list(member, &mut |deser| {
         420  +
                            container.push(crate::types::StructureListMember::deserialize(deser)?);
         421  +
                            Ok(())
         422  +
                        })?;
         423  +
                        container
  464    424   
                    });
  465    425   
                }
  466    426   
                Some(9) => {
  467         -
                    builder.blob_list = Some({
  468         -
                        let container = if let Some(cap) = deser.container_size() {
  469         -
                            Vec::with_capacity(cap)
  470         -
                        } else {
  471         -
                            Vec::new()
  472         -
                        };
  473         -
                        deser.read_list(member, container, |mut list, deser| {
  474         -
                            list.push(deser.read_blob(member)?);
  475         -
                            Ok(list)
  476         -
                        })?
  477         -
                    });
         427  +
                    builder.blob_list = Some(deser.read_blob_list(member)?);
  478    428   
                }
  479    429   
                _ => {}
  480    430   
            }
  481    431   
            Ok(())
  482    432   
        })?;
  483    433   
        Ok(builder.build())
  484    434   
    }
  485    435   
}
         436  +
impl RpcV2CborListsOutput {
         437  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         438  +
    pub fn deserialize_with_response(
         439  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         440  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         441  +
        _status: u16,
         442  +
        _body: &[u8],
         443  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         444  +
        Self::deserialize(deserializer)
         445  +
    }
         446  +
}
  486    447   
impl RpcV2CborListsOutput {
  487    448   
    /// Creates a new builder-style object to manufacture [`RpcV2CborListsOutput`](crate::operation::rpc_v2_cbor_lists::RpcV2CborListsOutput).
  488    449   
    pub fn builder() -> crate::operation::rpc_v2_cbor_lists::builders::RpcV2CborListsOutputBuilder {
  489    450   
        crate::operation::rpc_v2_cbor_lists::builders::RpcV2CborListsOutputBuilder::default()
  490    451   
    }
  491    452   
}
  492    453   
  493    454   
/// A builder for [`RpcV2CborListsOutput`](crate::operation::rpc_v2_cbor_lists::RpcV2CborListsOutput).
  494    455   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  495    456   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_sparse_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 `RpcV2CborSparseMaps`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct RpcV2CborSparseMaps;
    6      6   
impl RpcV2CborSparseMaps {
    7      7   
    /// Creates a new `RpcV2CborSparseMaps`
    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::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput::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::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -104,108 +166,171 @@
  124    128   
                crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsError,
  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 RpcV2CborSparseMapsResponseDeserializer;
  133    137   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RpcV2CborSparseMapsResponseDeserializer {
  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_rpc_v2_cbor_sparse_maps::de_rpc_v2_cbor_sparse_maps_http_error(status, headers, body)
  146    151   
        } else {
@@ -530,535 +590,599 @@
  550    555   
            .expect("the config must have a deserializer");
  551    556   
  552    557   
        let parsed = de.deserialize_streaming(&mut http_response);
  553    558   
        let parsed = parsed.unwrap_or_else(|| {
  554    559   
            let http_response = http_response.map(|body| {
  555    560   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  556    561   
                    body.bytes().unwrap(),
  557    562   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  558    563   
                )))
  559    564   
            });
  560         -
            de.deserialize_nonstreaming(&http_response)
         565  +
            // Build a config bag with the protocol for schema-based deserialization
         566  +
            #[allow(unused_mut)]
         567  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         568  +
         569  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  561    570   
        });
  562    571   
        let parsed = parsed
  563    572   
            .expect("should be successful response")
  564    573   
            .downcast::<crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput>()
  565    574   
            .unwrap();
  566    575   
        ::pretty_assertions::assert_eq!(
  567    576   
            parsed.sparse_struct_map,
  568    577   
            expected_output.sparse_struct_map,
  569    578   
            "Unexpected value for `sparse_struct_map`"
  570    579   
        );
@@ -618,627 +678,691 @@
  638    647   
            .expect("the config must have a deserializer");
  639    648   
  640    649   
        let parsed = de.deserialize_streaming(&mut http_response);
  641    650   
        let parsed = parsed.unwrap_or_else(|| {
  642    651   
            let http_response = http_response.map(|body| {
  643    652   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  644    653   
                    body.bytes().unwrap(),
  645    654   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  646    655   
                )))
  647    656   
            });
  648         -
            de.deserialize_nonstreaming(&http_response)
         657  +
            // Build a config bag with the protocol for schema-based deserialization
         658  +
            #[allow(unused_mut)]
         659  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         660  +
         661  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  649    662   
        });
  650    663   
        let parsed = parsed
  651    664   
            .expect("should be successful response")
  652    665   
            .downcast::<crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput>()
  653    666   
            .unwrap();
  654    667   
        ::pretty_assertions::assert_eq!(
  655    668   
            parsed.sparse_struct_map,
  656    669   
            expected_output.sparse_struct_map,
  657    670   
            "Unexpected value for `sparse_struct_map`"
  658    671   
        );
@@ -690,703 +750,767 @@
  710    723   
            .expect("the config must have a deserializer");
  711    724   
  712    725   
        let parsed = de.deserialize_streaming(&mut http_response);
  713    726   
        let parsed = parsed.unwrap_or_else(|| {
  714    727   
            let http_response = http_response.map(|body| {
  715    728   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  716    729   
                    body.bytes().unwrap(),
  717    730   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  718    731   
                )))
  719    732   
            });
  720         -
            de.deserialize_nonstreaming(&http_response)
         733  +
            // Build a config bag with the protocol for schema-based deserialization
         734  +
            #[allow(unused_mut)]
         735  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         736  +
         737  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  721    738   
        });
  722    739   
        let parsed = parsed
  723    740   
            .expect("should be successful response")
  724    741   
            .downcast::<crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput>()
  725    742   
            .unwrap();
  726    743   
        ::pretty_assertions::assert_eq!(
  727    744   
            parsed.sparse_struct_map,
  728    745   
            expected_output.sparse_struct_map,
  729    746   
            "Unexpected value for `sparse_struct_map`"
  730    747   
        );
@@ -763,780 +823,844 @@
  783    800   
            .expect("the config must have a deserializer");
  784    801   
  785    802   
        let parsed = de.deserialize_streaming(&mut http_response);
  786    803   
        let parsed = parsed.unwrap_or_else(|| {
  787    804   
            let http_response = http_response.map(|body| {
  788    805   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  789    806   
                    body.bytes().unwrap(),
  790    807   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  791    808   
                )))
  792    809   
            });
  793         -
            de.deserialize_nonstreaming(&http_response)
         810  +
            // Build a config bag with the protocol for schema-based deserialization
         811  +
            #[allow(unused_mut)]
         812  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         813  +
         814  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  794    815   
        });
  795    816   
        let parsed = parsed
  796    817   
            .expect("should be successful response")
  797    818   
            .downcast::<crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput>()
  798    819   
            .unwrap();
  799    820   
        ::pretty_assertions::assert_eq!(
  800    821   
            parsed.sparse_struct_map,
  801    822   
            expected_output.sparse_struct_map,
  802    823   
            "Unexpected value for `sparse_struct_map`"
  803    824   
        );
@@ -841,862 +901,926 @@
  861    882   
            .expect("the config must have a deserializer");
  862    883   
  863    884   
        let parsed = de.deserialize_streaming(&mut http_response);
  864    885   
        let parsed = parsed.unwrap_or_else(|| {
  865    886   
            let http_response = http_response.map(|body| {
  866    887   
                ::aws_smithy_types::body::SdkBody::from(::bytes::Bytes::copy_from_slice(&::aws_smithy_protocol_test::decode_body_data(
  867    888   
                    body.bytes().unwrap(),
  868    889   
                    ::aws_smithy_protocol_test::MediaType::from("application/cbor"),
  869    890   
                )))
  870    891   
            });
  871         -
            de.deserialize_nonstreaming(&http_response)
         892  +
            // Build a config bag with the protocol for schema-based deserialization
         893  +
            #[allow(unused_mut)]
         894  +
            let mut test_cfg = ::aws_smithy_types::config_bag::ConfigBag::base();
         895  +
         896  +
            de.deserialize_nonstreaming_with_config(&http_response, &test_cfg)
  872    897   
        });
  873    898   
        let parsed = parsed
  874    899   
            .expect("should be successful response")
  875    900   
            .downcast::<crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput>()
  876    901   
            .unwrap();
  877    902   
        ::pretty_assertions::assert_eq!(
  878    903   
            parsed.sparse_struct_map,
  879    904   
            expected_output.sparse_struct_map,
  880    905   
            "Unexpected value for `sparse_struct_map`"
  881    906   
        );

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_sparse_maps/_rpc_v2_cbor_sparse_maps_input.rs

@@ -30,30 +130,130 @@
   50     50   
    "smithy.protocoltests.rpcv2Cbor.synthetic",
   51     51   
    "RpcV2CborSparseMapsInput",
   52     52   
);
   53     53   
static RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_STRUCT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsInput$sparseStructMap",
   56     56   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   57     57   
        "RpcV2CborSparseMapsInput",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Map,
   60         -
    "sparse_struct_map",
          60  +
    "sparseStructMap",
   61     61   
    0,
   62     62   
);
   63     63   
static RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_NUMBER_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsInput$sparseNumberMap",
   66     66   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   67     67   
        "RpcV2CborSparseMapsInput",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::Map,
   70         -
    "sparse_number_map",
          70  +
    "sparseNumberMap",
   71     71   
    1,
   72     72   
);
   73     73   
static RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_BOOLEAN_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsInput$sparseBooleanMap",
   76     76   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   77     77   
        "RpcV2CborSparseMapsInput",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Map,
   80         -
    "sparse_boolean_map",
          80  +
    "sparseBooleanMap",
   81     81   
    2,
   82     82   
);
   83     83   
static RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsInput$sparseStringMap",
   86     86   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   87     87   
        "RpcV2CborSparseMapsInput",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::Map,
   90         -
    "sparse_string_map",
          90  +
    "sparseStringMap",
   91     91   
    3,
   92     92   
);
   93     93   
static RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_SET_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsInput$sparseSetMap",
   96     96   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   97     97   
        "RpcV2CborSparseMapsInput",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::Map,
  100         -
    "sparse_set_map",
         100  +
    "sparseSetMap",
  101    101   
    4,
  102    102   
);
  103    103   
static RPCV2CBORSPARSEMAPSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  104    104   
    RPCV2CBORSPARSEMAPSINPUT_SCHEMA_ID,
  105    105   
    ::aws_smithy_schema::ShapeType::Structure,
  106    106   
    &[
  107    107   
        &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_STRUCT_MAP,
  108    108   
        &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_NUMBER_MAP,
  109    109   
        &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_BOOLEAN_MAP,
  110    110   
        &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_STRING_MAP,
@@ -178,178 +381,392 @@
  198    198   
            )?;
  199    199   
        }
  200    200   
        if let Some(ref val) = self.sparse_set_map {
  201    201   
            ser.write_map(
  202    202   
                &RPCV2CBORSPARSEMAPSINPUT_MEMBER_SPARSE_SET_MAP,
  203    203   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  204    204   
                    for (key, value) in val {
  205    205   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  206    206   
                        match value {
  207    207   
                            Some(value) => {
  208         -
                                todo!("schema: unsupported map value type");
         208  +
                                ser.write_list(
         209  +
                                    &::aws_smithy_schema::prelude::DOCUMENT,
         210  +
                                    &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         211  +
                                        for item in value {
         212  +
                                            ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         213  +
                                        }
         214  +
                                        Ok(())
         215  +
                                    },
         216  +
                                )?;
  209    217   
                            }
  210    218   
                            None => {
  211    219   
                                ser.write_null(&::aws_smithy_schema::prelude::STRING)?;
  212    220   
                            }
  213    221   
                        }
  214    222   
                    }
  215    223   
                    Ok(())
  216    224   
                },
  217    225   
            )?;
  218    226   
        }
  219    227   
        Ok(())
  220    228   
    }
  221    229   
}
  222    230   
impl RpcV2CborSparseMapsInput {
  223    231   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  224         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  225         -
        deserializer: &mut D,
         232  +
    pub fn deserialize(
         233  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  226    234   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  227    235   
        #[allow(unused_variables, unused_mut)]
  228    236   
        let mut builder = Self::builder();
  229    237   
        #[allow(
  230    238   
            unused_variables,
  231    239   
            unreachable_code,
  232    240   
            clippy::single_match,
  233    241   
            clippy::match_single_binding,
  234    242   
            clippy::diverging_sub_expression
  235    243   
        )]
  236         -
        deserializer.read_struct(&RPCV2CBORSPARSEMAPSINPUT_SCHEMA, (), |_, member, deser| {
         244  +
        deserializer.read_struct(&RPCV2CBORSPARSEMAPSINPUT_SCHEMA, &mut |member, deser| {
  237    245   
            match member.member_index() {
  238    246   
                Some(0) => {
  239    247   
                    builder.sparse_struct_map = Some({
  240         -
                        let container = if let Some(cap) = deser.container_size() {
  241         -
                            std::collections::HashMap::with_capacity(cap)
  242         -
                        } else {
  243         -
                            std::collections::HashMap::new()
  244         -
                        };
  245         -
                        deser.read_map(member, container, |mut map, key, deser| {
  246         -
                            map.insert(
         248  +
                        let mut container = std::collections::HashMap::new();
         249  +
                        deser.read_map(member, &mut |key, deser| {
         250  +
                            container.insert(
  247    251   
                                key,
  248    252   
                                if deser.is_null() {
  249         -
                                    deser.read_string(member).ok();
         253  +
                                    deser.read_null()?;
  250    254   
                                    None
  251    255   
                                } else {
  252    256   
                                    Some(crate::types::GreetingStruct::deserialize(deser)?)
  253    257   
                                },
  254    258   
                            );
  255         -
                            Ok(map)
  256         -
                        })?
         259  +
                            Ok(())
         260  +
                        })?;
         261  +
                        container
  257    262   
                    });
  258    263   
                }
  259    264   
                Some(1) => {
  260    265   
                    builder.sparse_number_map = Some({
  261         -
                        let container = if let Some(cap) = deser.container_size() {
  262         -
                            std::collections::HashMap::with_capacity(cap)
  263         -
                        } else {
  264         -
                            std::collections::HashMap::new()
  265         -
                        };
  266         -
                        deser.read_map(member, container, |mut map, key, deser| {
  267         -
                            map.insert(
         266  +
                        let mut container = std::collections::HashMap::new();
         267  +
                        deser.read_map(member, &mut |key, deser| {
         268  +
                            container.insert(
  268    269   
                                key,
  269    270   
                                if deser.is_null() {
  270         -
                                    deser.read_string(member).ok();
         271  +
                                    deser.read_null()?;
  271    272   
                                    None
  272    273   
                                } else {
  273    274   
                                    Some(deser.read_integer(member)?)
  274    275   
                                },
  275    276   
                            );
  276         -
                            Ok(map)
  277         -
                        })?
         277  +
                            Ok(())
         278  +
                        })?;
         279  +
                        container
  278    280   
                    });
  279    281   
                }
  280    282   
                Some(2) => {
  281    283   
                    builder.sparse_boolean_map = Some({
  282         -
                        let container = if let Some(cap) = deser.container_size() {
  283         -
                            std::collections::HashMap::with_capacity(cap)
  284         -
                        } else {
  285         -
                            std::collections::HashMap::new()
  286         -
                        };
  287         -
                        deser.read_map(member, container, |mut map, key, deser| {
  288         -
                            map.insert(
         284  +
                        let mut container = std::collections::HashMap::new();
         285  +
                        deser.read_map(member, &mut |key, deser| {
         286  +
                            container.insert(
  289    287   
                                key,
  290    288   
                                if deser.is_null() {
  291         -
                                    deser.read_string(member).ok();
         289  +
                                    deser.read_null()?;
  292    290   
                                    None
  293    291   
                                } else {
  294    292   
                                    Some(deser.read_boolean(member)?)
  295    293   
                                },
  296    294   
                            );
  297         -
                            Ok(map)
  298         -
                        })?
         295  +
                            Ok(())
         296  +
                        })?;
         297  +
                        container
  299    298   
                    });
  300    299   
                }
  301    300   
                Some(3) => {
  302    301   
                    builder.sparse_string_map = Some({
  303         -
                        let container = if let Some(cap) = deser.container_size() {
  304         -
                            std::collections::HashMap::with_capacity(cap)
  305         -
                        } else {
  306         -
                            std::collections::HashMap::new()
  307         -
                        };
  308         -
                        deser.read_map(member, container, |mut map, key, deser| {
  309         -
                            map.insert(
         302  +
                        let mut container = std::collections::HashMap::new();
         303  +
                        deser.read_map(member, &mut |key, deser| {
         304  +
                            container.insert(
  310    305   
                                key,
  311    306   
                                if deser.is_null() {
  312         -
                                    deser.read_string(member).ok();
         307  +
                                    deser.read_null()?;
  313    308   
                                    None
  314    309   
                                } else {
  315    310   
                                    Some(deser.read_string(member)?)
  316    311   
                                },
  317    312   
                            );
  318         -
                            Ok(map)
  319         -
                        })?
         313  +
                            Ok(())
         314  +
                        })?;
         315  +
                        container
  320    316   
                    });
  321    317   
                }
  322    318   
                Some(4) => {
  323    319   
                    builder.sparse_set_map = Some({
  324         -
                        let container = if let Some(cap) = deser.container_size() {
  325         -
                            std::collections::HashMap::with_capacity(cap)
  326         -
                        } else {
  327         -
                            std::collections::HashMap::new()
  328         -
                        };
  329         -
                        deser.read_map(member, container, |mut map, key, deser| {
  330         -
                            map.insert(
         320  +
                        let mut container = std::collections::HashMap::new();
         321  +
                        deser.read_map(member, &mut |key, deser| {
         322  +
                            container.insert(
  331    323   
                                key,
  332    324   
                                if deser.is_null() {
  333         -
                                    deser.read_string(member).ok();
         325  +
                                    deser.read_null()?;
  334    326   
                                    None
  335    327   
                                } else {
  336         -
                                    Some(todo!("deserialize nested aggregate"))
         328  +
                                    Some({
         329  +
                                        let mut list = Vec::new();
         330  +
                                        deser.read_list(member, &mut |deser| {
         331  +
                                            list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
         332  +
                                            Ok(())
         333  +
                                        })?;
         334  +
                                        list
         335  +
                                    })
  337    336   
                                },
  338    337   
                            );
  339         -
                            Ok(map)
  340         -
                        })?
         338  +
                            Ok(())
         339  +
                        })?;
         340  +
                        container
  341    341   
                    });
  342    342   
                }
  343    343   
                _ => {}
  344    344   
            }
  345    345   
            Ok(())
  346    346   
        })?;
  347    347   
        builder
  348    348   
            .build()
  349    349   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  350    350   
    }
  351    351   
}
         352  +
impl RpcV2CborSparseMapsInput {
         353  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         354  +
    pub fn deserialize_with_response(
         355  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         356  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         357  +
        _status: u16,
         358  +
        _body: &[u8],
         359  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         360  +
        Self::deserialize(deserializer)
         361  +
    }
         362  +
}
  352    363   
impl RpcV2CborSparseMapsInput {
  353    364   
    /// Creates a new builder-style object to manufacture [`RpcV2CborSparseMapsInput`](crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput).
  354    365   
    pub fn builder() -> crate::operation::rpc_v2_cbor_sparse_maps::builders::RpcV2CborSparseMapsInputBuilder {
  355    366   
        crate::operation::rpc_v2_cbor_sparse_maps::builders::RpcV2CborSparseMapsInputBuilder::default()
  356    367   
    }
  357    368   
}
  358    369   
  359    370   
/// A builder for [`RpcV2CborSparseMapsInput`](crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsInput).
  360    371   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  361    372   
#[non_exhaustive]

tmp-codegen-diff/codegen-client-test/rpcv2Cbor/rust-client-codegen/src/operation/rpc_v2_cbor_sparse_maps/_rpc_v2_cbor_sparse_maps_output.rs

@@ -30,30 +130,130 @@
   50     50   
    "smithy.protocoltests.rpcv2Cbor.synthetic",
   51     51   
    "RpcV2CborSparseMapsOutput",
   52     52   
);
   53     53   
static RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_STRUCT_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsOutput$sparseStructMap",
   56     56   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   57     57   
        "RpcV2CborSparseMapsOutput",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::Map,
   60         -
    "sparse_struct_map",
          60  +
    "sparseStructMap",
   61     61   
    0,
   62     62   
);
   63     63   
static RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_NUMBER_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static(
   65     65   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsOutput$sparseNumberMap",
   66     66   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   67     67   
        "RpcV2CborSparseMapsOutput",
   68     68   
    ),
   69     69   
    ::aws_smithy_schema::ShapeType::Map,
   70         -
    "sparse_number_map",
          70  +
    "sparseNumberMap",
   71     71   
    1,
   72     72   
);
   73     73   
static RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_BOOLEAN_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsOutput$sparseBooleanMap",
   76     76   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   77     77   
        "RpcV2CborSparseMapsOutput",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Map,
   80         -
    "sparse_boolean_map",
          80  +
    "sparseBooleanMap",
   81     81   
    2,
   82     82   
);
   83     83   
static RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_STRING_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   84     84   
    ::aws_smithy_schema::ShapeId::from_static(
   85     85   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsOutput$sparseStringMap",
   86     86   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   87     87   
        "RpcV2CborSparseMapsOutput",
   88     88   
    ),
   89     89   
    ::aws_smithy_schema::ShapeType::Map,
   90         -
    "sparse_string_map",
          90  +
    "sparseStringMap",
   91     91   
    3,
   92     92   
);
   93     93   
static RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_SET_MAP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "smithy.protocoltests.rpcv2Cbor.synthetic#RpcV2CborSparseMapsOutput$sparseSetMap",
   96     96   
        "smithy.protocoltests.rpcv2Cbor.synthetic",
   97     97   
        "RpcV2CborSparseMapsOutput",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::Map,
  100         -
    "sparse_set_map",
         100  +
    "sparseSetMap",
  101    101   
    4,
  102    102   
);
  103    103   
static RPCV2CBORSPARSEMAPSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  104    104   
    RPCV2CBORSPARSEMAPSOUTPUT_SCHEMA_ID,
  105    105   
    ::aws_smithy_schema::ShapeType::Structure,
  106    106   
    &[
  107    107   
        &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_STRUCT_MAP,
  108    108   
        &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_NUMBER_MAP,
  109    109   
        &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_BOOLEAN_MAP,
  110    110   
        &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_STRING_MAP,
@@ -178,178 +379,390 @@
  198    198   
            )?;
  199    199   
        }
  200    200   
        if let Some(ref val) = self.sparse_set_map {
  201    201   
            ser.write_map(
  202    202   
                &RPCV2CBORSPARSEMAPSOUTPUT_MEMBER_SPARSE_SET_MAP,
  203    203   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  204    204   
                    for (key, value) in val {
  205    205   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  206    206   
                        match value {
  207    207   
                            Some(value) => {
  208         -
                                todo!("schema: unsupported map value type");
         208  +
                                ser.write_list(
         209  +
                                    &::aws_smithy_schema::prelude::DOCUMENT,
         210  +
                                    &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         211  +
                                        for item in value {
         212  +
                                            ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         213  +
                                        }
         214  +
                                        Ok(())
         215  +
                                    },
         216  +
                                )?;
  209    217   
                            }
  210    218   
                            None => {
  211    219   
                                ser.write_null(&::aws_smithy_schema::prelude::STRING)?;
  212    220   
                            }
  213    221   
                        }
  214    222   
                    }
  215    223   
                    Ok(())
  216    224   
                },
  217    225   
            )?;
  218    226   
        }
  219    227   
        Ok(())
  220    228   
    }
  221    229   
}
  222    230   
impl RpcV2CborSparseMapsOutput {
  223    231   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  224         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  225         -
        deserializer: &mut D,
         232  +
    pub fn deserialize(
         233  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  226    234   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  227    235   
        #[allow(unused_variables, unused_mut)]
  228    236   
        let mut builder = Self::builder();
  229    237   
        #[allow(
  230    238   
            unused_variables,
  231    239   
            unreachable_code,
  232    240   
            clippy::single_match,
  233    241   
            clippy::match_single_binding,
  234    242   
            clippy::diverging_sub_expression
  235    243   
        )]
  236         -
        deserializer.read_struct(&RPCV2CBORSPARSEMAPSOUTPUT_SCHEMA, (), |_, member, deser| {
         244  +
        deserializer.read_struct(&RPCV2CBORSPARSEMAPSOUTPUT_SCHEMA, &mut |member, deser| {
  237    245   
            match member.member_index() {
  238    246   
                Some(0) => {
  239    247   
                    builder.sparse_struct_map = Some({
  240         -
                        let container = if let Some(cap) = deser.container_size() {
  241         -
                            std::collections::HashMap::with_capacity(cap)
  242         -
                        } else {
  243         -
                            std::collections::HashMap::new()
  244         -
                        };
  245         -
                        deser.read_map(member, container, |mut map, key, deser| {
  246         -
                            map.insert(
         248  +
                        let mut container = std::collections::HashMap::new();
         249  +
                        deser.read_map(member, &mut |key, deser| {
         250  +
                            container.insert(
  247    251   
                                key,
  248    252   
                                if deser.is_null() {
  249         -
                                    deser.read_string(member).ok();
         253  +
                                    deser.read_null()?;
  250    254   
                                    None
  251    255   
                                } else {
  252    256   
                                    Some(crate::types::GreetingStruct::deserialize(deser)?)
  253    257   
                                },
  254    258   
                            );
  255         -
                            Ok(map)
  256         -
                        })?
         259  +
                            Ok(())
         260  +
                        })?;
         261  +
                        container
  257    262   
                    });
  258    263   
                }
  259    264   
                Some(1) => {
  260    265   
                    builder.sparse_number_map = Some({
  261         -
                        let container = if let Some(cap) = deser.container_size() {
  262         -
                            std::collections::HashMap::with_capacity(cap)
  263         -
                        } else {
  264         -
                            std::collections::HashMap::new()
  265         -
                        };
  266         -
                        deser.read_map(member, container, |mut map, key, deser| {
  267         -
                            map.insert(
         266  +
                        let mut container = std::collections::HashMap::new();
         267  +
                        deser.read_map(member, &mut |key, deser| {
         268  +
                            container.insert(
  268    269   
                                key,
  269    270   
                                if deser.is_null() {
  270         -
                                    deser.read_string(member).ok();
         271  +
                                    deser.read_null()?;
  271    272   
                                    None
  272    273   
                                } else {
  273    274   
                                    Some(deser.read_integer(member)?)
  274    275   
                                },
  275    276   
                            );
  276         -
                            Ok(map)
  277         -
                        })?
         277  +
                            Ok(())
         278  +
                        })?;
         279  +
                        container
  278    280   
                    });
  279    281   
                }
  280    282   
                Some(2) => {
  281    283   
                    builder.sparse_boolean_map = Some({
  282         -
                        let container = if let Some(cap) = deser.container_size() {
  283         -
                            std::collections::HashMap::with_capacity(cap)
  284         -
                        } else {
  285         -
                            std::collections::HashMap::new()
  286         -
                        };
  287         -
                        deser.read_map(member, container, |mut map, key, deser| {
  288         -
                            map.insert(
         284  +
                        let mut container = std::collections::HashMap::new();
         285  +
                        deser.read_map(member, &mut |key, deser| {
         286  +
                            container.insert(
  289    287   
                                key,
  290    288   
                                if deser.is_null() {
  291         -
                                    deser.read_string(member).ok();
         289  +
                                    deser.read_null()?;
  292    290   
                                    None
  293    291   
                                } else {
  294    292   
                                    Some(deser.read_boolean(member)?)
  295    293   
                                },
  296    294   
                            );
  297         -
                            Ok(map)
  298         -
                        })?
         295  +
                            Ok(())
         296  +
                        })?;
         297  +
                        container
  299    298   
                    });
  300    299   
                }
  301    300   
                Some(3) => {
  302    301   
                    builder.sparse_string_map = Some({
  303         -
                        let container = if let Some(cap) = deser.container_size() {
  304         -
                            std::collections::HashMap::with_capacity(cap)
  305         -
                        } else {
  306         -
                            std::collections::HashMap::new()
  307         -
                        };
  308         -
                        deser.read_map(member, container, |mut map, key, deser| {
  309         -
                            map.insert(
         302  +
                        let mut container = std::collections::HashMap::new();
         303  +
                        deser.read_map(member, &mut |key, deser| {
         304  +
                            container.insert(
  310    305   
                                key,
  311    306   
                                if deser.is_null() {
  312         -
                                    deser.read_string(member).ok();
         307  +
                                    deser.read_null()?;
  313    308   
                                    None
  314    309   
                                } else {
  315    310   
                                    Some(deser.read_string(member)?)
  316    311   
                                },
  317    312   
                            );
  318         -
                            Ok(map)
  319         -
                        })?
         313  +
                            Ok(())
         314  +
                        })?;
         315  +
                        container
  320    316   
                    });
  321    317   
                }
  322    318   
                Some(4) => {
  323    319   
                    builder.sparse_set_map = Some({
  324         -
                        let container = if let Some(cap) = deser.container_size() {
  325         -
                            std::collections::HashMap::with_capacity(cap)
  326         -
                        } else {
  327         -
                            std::collections::HashMap::new()
  328         -
                        };
  329         -
                        deser.read_map(member, container, |mut map, key, deser| {
  330         -
                            map.insert(
         320  +
                        let mut container = std::collections::HashMap::new();
         321  +
                        deser.read_map(member, &mut |key, deser| {
         322  +
                            container.insert(
  331    323   
                                key,
  332    324   
                                if deser.is_null() {
  333         -
                                    deser.read_string(member).ok();
         325  +
                                    deser.read_null()?;
  334    326   
                                    None
  335    327   
                                } else {
  336         -
                                    Some(todo!("deserialize nested aggregate"))
         328  +
                                    Some({
         329  +
                                        let mut list = Vec::new();
         330  +
                                        deser.read_list(member, &mut |deser| {
         331  +
                                            list.push(deser.read_string(&::aws_smithy_schema::prelude::DOCUMENT)?);
         332  +
                                            Ok(())
         333  +
                                        })?;
         334  +
                                        list
         335  +
                                    })
  337    336   
                                },
  338    337   
                            );
  339         -
                            Ok(map)
  340         -
                        })?
         338  +
                            Ok(())
         339  +
                        })?;
         340  +
                        container
  341    341   
                    });
  342    342   
                }
  343    343   
                _ => {}
  344    344   
            }
  345    345   
            Ok(())
  346    346   
        })?;
  347    347   
        Ok(builder.build())
  348    348   
    }
  349    349   
}
         350  +
impl RpcV2CborSparseMapsOutput {
         351  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         352  +
    pub fn deserialize_with_response(
         353  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         354  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         355  +
        _status: u16,
         356  +
        _body: &[u8],
         357  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         358  +
        Self::deserialize(deserializer)
         359  +
    }
         360  +
}
  350    361   
impl RpcV2CborSparseMapsOutput {
  351    362   
    /// Creates a new builder-style object to manufacture [`RpcV2CborSparseMapsOutput`](crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput).
  352    363   
    pub fn builder() -> crate::operation::rpc_v2_cbor_sparse_maps::builders::RpcV2CborSparseMapsOutputBuilder {
  353    364   
        crate::operation::rpc_v2_cbor_sparse_maps::builders::RpcV2CborSparseMapsOutputBuilder::default()
  354    365   
    }
  355    366   
}
  356    367   
  357    368   
/// A builder for [`RpcV2CborSparseMapsOutput`](crate::operation::rpc_v2_cbor_sparse_maps::RpcV2CborSparseMapsOutput).
  358    369   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  359    370   
#[non_exhaustive]