AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/upload_multipart_part/_upload_multipart_part_input.rs

@@ -28,28 +231,288 @@
   48     48   
    "com.amazonaws.glacier.synthetic",
   49     49   
    "UploadMultipartPartInput",
   50     50   
);
   51     51   
static UPLOADMULTIPARTPARTINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.glacier.synthetic#UploadMultipartPartInput$accountId",
   54     54   
        "com.amazonaws.glacier.synthetic",
   55     55   
        "UploadMultipartPartInput",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "account_id",
          58  +
    "accountId",
   59     59   
    0,
   60     60   
)
   61     61   
.with_http_label();
   62     62   
static UPLOADMULTIPARTPARTINPUT_MEMBER_VAULT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.glacier.synthetic#UploadMultipartPartInput$vaultName",
   65     65   
        "com.amazonaws.glacier.synthetic",
   66     66   
        "UploadMultipartPartInput",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "vault_name",
          69  +
    "vaultName",
   70     70   
    1,
   71     71   
)
   72     72   
.with_http_label();
   73     73   
static UPLOADMULTIPARTPARTINPUT_MEMBER_UPLOAD_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.glacier.synthetic#UploadMultipartPartInput$uploadId",
   76     76   
        "com.amazonaws.glacier.synthetic",
   77     77   
        "UploadMultipartPartInput",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "upload_id",
          80  +
    "uploadId",
   81     81   
    2,
   82     82   
)
   83     83   
.with_http_label();
   84     84   
static UPLOADMULTIPARTPARTINPUT_MEMBER_CHECKSUM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.glacier.synthetic#UploadMultipartPartInput$checksum",
   87     87   
        "com.amazonaws.glacier.synthetic",
   88     88   
        "UploadMultipartPartInput",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::String,
   91     91   
    "checksum",
   92     92   
    3,
   93     93   
)
   94     94   
.with_http_header("x-amz-sha256-tree-hash");
   95     95   
static UPLOADMULTIPARTPARTINPUT_MEMBER_RANGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.glacier.synthetic#UploadMultipartPartInput$range",
   98     98   
        "com.amazonaws.glacier.synthetic",
   99     99   
        "UploadMultipartPartInput",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::String,
  102    102   
    "range",
  103    103   
    4,
  104    104   
)
  105    105   
.with_http_header("Content-Range");
  106    106   
static UPLOADMULTIPARTPARTINPUT_MEMBER_BODY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.glacier.synthetic#UploadMultipartPartInput$body",
  109    109   
        "com.amazonaws.glacier.synthetic",
  110    110   
        "UploadMultipartPartInput",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::Blob,
  113    113   
    "body",
  114    114   
    5,
  115    115   
)
  116    116   
.with_http_payload();
  117    117   
static UPLOADMULTIPARTPARTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  118    118   
    UPLOADMULTIPARTPARTINPUT_SCHEMA_ID,
  119    119   
    ::aws_smithy_schema::ShapeType::Structure,
  120    120   
    &[
  121    121   
        &UPLOADMULTIPARTPARTINPUT_MEMBER_ACCOUNT_ID,
  122    122   
        &UPLOADMULTIPARTPARTINPUT_MEMBER_VAULT_NAME,
  123    123   
        &UPLOADMULTIPARTPARTINPUT_MEMBER_UPLOAD_ID,
  124    124   
        &UPLOADMULTIPARTPARTINPUT_MEMBER_CHECKSUM,
  125    125   
        &UPLOADMULTIPARTPARTINPUT_MEMBER_RANGE,
  126    126   
        &UPLOADMULTIPARTPARTINPUT_MEMBER_BODY,
  127    127   
    ],
  128         -
);
         128  +
)
         129  +
.with_http(aws_smithy_schema::traits::HttpTrait::new(
         130  +
    "PUT",
         131  +
    "/{accountId}/vaults/{vaultName}/multipart-uploads/{uploadId}",
         132  +
    Some(204),
         133  +
));
  129    134   
impl UploadMultipartPartInput {
  130    135   
    /// The schema for this shape.
  131    136   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPLOADMULTIPARTPARTINPUT_SCHEMA;
  132    137   
}
  133    138   
impl ::aws_smithy_schema::serde::SerializableStruct for UploadMultipartPartInput {
  134    139   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  135    140   
    fn serialize_members(
  136    141   
        &self,
  137    142   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  138    143   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  139    144   
        if let Some(ref val) = self.account_id {
  140    145   
            ser.write_string(&UPLOADMULTIPARTPARTINPUT_MEMBER_ACCOUNT_ID, val)?;
  141    146   
        }
  142    147   
        if let Some(ref val) = self.vault_name {
  143    148   
            ser.write_string(&UPLOADMULTIPARTPARTINPUT_MEMBER_VAULT_NAME, val)?;
  144    149   
        }
  145    150   
        if let Some(ref val) = self.upload_id {
  146    151   
            ser.write_string(&UPLOADMULTIPARTPARTINPUT_MEMBER_UPLOAD_ID, val)?;
  147    152   
        }
  148    153   
        if let Some(ref val) = self.checksum {
  149    154   
            ser.write_string(&UPLOADMULTIPARTPARTINPUT_MEMBER_CHECKSUM, val)?;
  150    155   
        }
  151    156   
        if let Some(ref val) = self.range {
  152    157   
            ser.write_string(&UPLOADMULTIPARTPARTINPUT_MEMBER_RANGE, val)?;
  153    158   
        }
  154         -
        {
  155         -
            let val = &self.body;
  156         -
            // streaming blob is serialized as the HTTP body by the protocol, not the codec
  157         -
        }
  158    159   
        Ok(())
  159    160   
    }
  160    161   
}
  161    162   
impl UploadMultipartPartInput {
  162    163   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  163         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  164         -
        deserializer: &mut D,
         164  +
    pub fn deserialize(
         165  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  165    166   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  166    167   
        #[allow(unused_variables, unused_mut)]
  167    168   
        let mut builder = Self::builder();
  168    169   
        #[allow(
  169    170   
            unused_variables,
  170    171   
            unreachable_code,
  171    172   
            clippy::single_match,
  172    173   
            clippy::match_single_binding,
  173    174   
            clippy::diverging_sub_expression
  174    175   
        )]
  175         -
        deserializer.read_struct(&UPLOADMULTIPARTPARTINPUT_SCHEMA, (), |_, member, deser| {
         176  +
        deserializer.read_struct(&UPLOADMULTIPARTPARTINPUT_SCHEMA, &mut |member, deser| {
  176    177   
            match member.member_index() {
  177    178   
                Some(0) => {
  178    179   
                    builder.account_id = Some(deser.read_string(member)?);
  179    180   
                }
  180    181   
                Some(1) => {
  181    182   
                    builder.vault_name = Some(deser.read_string(member)?);
  182    183   
                }
  183    184   
                Some(2) => {
  184    185   
                    builder.upload_id = Some(deser.read_string(member)?);
  185    186   
                }
  186    187   
                Some(3) => {
  187    188   
                    builder.checksum = Some(deser.read_string(member)?);
  188    189   
                }
  189    190   
                Some(4) => {
  190    191   
                    builder.range = Some(deser.read_string(member)?);
  191    192   
                }
  192    193   
                Some(5) => {
  193    194   
                    builder.body = Some({
  194    195   
                        let _ = member;
  195    196   
                        ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
  196    197   
                    });
  197    198   
                }
  198    199   
                _ => {}
  199    200   
            }
  200    201   
            Ok(())
  201    202   
        })?;
         203  +
        builder.account_id = builder.account_id.or(Some(String::new()));
         204  +
        builder.vault_name = builder.vault_name.or(Some(String::new()));
         205  +
        builder.upload_id = builder.upload_id.or(Some(String::new()));
         206  +
        builder
         207  +
            .build()
         208  +
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
         209  +
    }
         210  +
}
         211  +
impl UploadMultipartPartInput {
         212  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         213  +
    /// Header-bound members are read directly from headers, avoiding runtime
         214  +
    /// member iteration overhead. Body members are read via the deserializer.
         215  +
    pub fn deserialize_with_response(
         216  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         217  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         218  +
        _status: u16,
         219  +
        _body: &[u8],
         220  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         221  +
        #[allow(unused_variables, unused_mut)]
         222  +
        let mut builder = Self::builder();
         223  +
        if let Some(val) = headers.get("x-amz-sha256-tree-hash") {
         224  +
            builder.checksum = Some(val.to_string());
         225  +
        }
         226  +
        if let Some(val) = headers.get("Content-Range") {
         227  +
            builder.range = Some(val.to_string());
         228  +
        }
         229  +
        #[allow(
         230  +
            unused_variables,
         231  +
            unreachable_code,
         232  +
            clippy::single_match,
         233  +
            clippy::match_single_binding,
         234  +
            clippy::diverging_sub_expression
         235  +
        )]
         236  +
        deserializer.read_struct(&UPLOADMULTIPARTPARTINPUT_SCHEMA, &mut |member, deser| {
         237  +
            match member.member_index() {
         238  +
                Some(0) => {
         239  +
                    builder.account_id = Some(deser.read_string(member)?);
         240  +
                }
         241  +
                Some(1) => {
         242  +
                    builder.vault_name = Some(deser.read_string(member)?);
         243  +
                }
         244  +
                Some(2) => {
         245  +
                    builder.upload_id = Some(deser.read_string(member)?);
         246  +
                }
         247  +
                Some(3) => { /* read from headers above */ }
         248  +
                Some(4) => { /* read from headers above */ }
         249  +
                Some(5) => {
         250  +
                    builder.body = Some({
         251  +
                        let _ = member;
         252  +
                        ::aws_smithy_types::byte_stream::ByteStream::new(::aws_smithy_types::body::SdkBody::empty())
         253  +
                    });
         254  +
                }
         255  +
                _ => {}
         256  +
            }
         257  +
            Ok(())
         258  +
        })?;
  202    259   
        builder
  203    260   
            .build()
  204    261   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  205    262   
    }
  206    263   
}
  207    264   
impl crate::glacier_interceptors::GlacierAccountId for UploadMultipartPartInput {
  208    265   
    fn account_id_mut(&mut self) -> &mut Option<String> {
  209    266   
        &mut self.account_id
  210    267   
    }
  211    268   
}

tmp-codegen-diff/aws-sdk/sdk/glacier/src/operation/upload_multipart_part/_upload_multipart_part_output.rs

@@ -3,3 +109,140 @@
   23     23   
    ::aws_smithy_schema::ShapeId::from_static(
   24     24   
        "com.amazonaws.glacier.synthetic#UploadMultipartPartOutput$checksum",
   25     25   
        "com.amazonaws.glacier.synthetic",
   26     26   
        "UploadMultipartPartOutput",
   27     27   
    ),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29     29   
    "checksum",
   30     30   
    0,
   31     31   
)
   32     32   
.with_http_header("x-amz-sha256-tree-hash");
          33  +
static UPLOADMULTIPARTPARTOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          34  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          35  +
    ::aws_smithy_schema::ShapeType::String,
          36  +
    "request_id",
          37  +
    1,
          38  +
)
          39  +
.with_http_header("x-amzn-requestid");
   33     40   
static UPLOADMULTIPARTPARTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     41   
    UPLOADMULTIPARTPARTOUTPUT_SCHEMA_ID,
   35     42   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    &[&UPLOADMULTIPARTPARTOUTPUT_MEMBER_CHECKSUM],
          43  +
    &[&UPLOADMULTIPARTPARTOUTPUT_MEMBER_CHECKSUM, &UPLOADMULTIPARTPARTOUTPUT_MEMBER__REQUEST_ID],
   37     44   
);
   38     45   
impl UploadMultipartPartOutput {
   39     46   
    /// The schema for this shape.
   40     47   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPLOADMULTIPARTPARTOUTPUT_SCHEMA;
   41     48   
}
   42     49   
impl ::aws_smithy_schema::serde::SerializableStruct for UploadMultipartPartOutput {
   43     50   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   44     51   
    fn serialize_members(
   45     52   
        &self,
   46     53   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   47     54   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   48     55   
        if let Some(ref val) = self.checksum {
   49     56   
            ser.write_string(&UPLOADMULTIPARTPARTOUTPUT_MEMBER_CHECKSUM, val)?;
   50     57   
        }
   51     58   
        Ok(())
   52     59   
    }
   53     60   
}
   54     61   
impl UploadMultipartPartOutput {
   55     62   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   56         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   57         -
        deserializer: &mut D,
          63  +
    pub fn deserialize(
          64  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   58     65   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   59     66   
        #[allow(unused_variables, unused_mut)]
   60     67   
        let mut builder = Self::builder();
   61     68   
        #[allow(
   62     69   
            unused_variables,
   63     70   
            unreachable_code,
   64     71   
            clippy::single_match,
   65     72   
            clippy::match_single_binding,
   66     73   
            clippy::diverging_sub_expression
   67     74   
        )]
   68         -
        deserializer.read_struct(&UPLOADMULTIPARTPARTOUTPUT_SCHEMA, (), |_, member, deser| {
          75  +
        deserializer.read_struct(&UPLOADMULTIPARTPARTOUTPUT_SCHEMA, &mut |member, deser| {
   69     76   
            match member.member_index() {
   70     77   
                Some(0) => {
   71     78   
                    builder.checksum = Some(deser.read_string(member)?);
   72     79   
                }
          80  +
                Some(1) => {
          81  +
                    builder._request_id = Some(deser.read_string(member)?);
          82  +
                }
   73     83   
                _ => {}
   74     84   
            }
   75     85   
            Ok(())
   76     86   
        })?;
   77     87   
        Ok(builder.build())
   78     88   
    }
   79     89   
}
          90  +
impl UploadMultipartPartOutput {
          91  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          92  +
    /// Header-bound members are read directly from headers, avoiding runtime
          93  +
    /// member iteration overhead. Body members are read via the deserializer.
          94  +
    pub fn deserialize_with_response(
          95  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          96  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          97  +
        _status: u16,
          98  +
        _body: &[u8],
          99  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         100  +
        #[allow(unused_variables, unused_mut)]
         101  +
        let mut builder = Self::builder();
         102  +
        if let Some(val) = headers.get("x-amz-sha256-tree-hash") {
         103  +
            builder.checksum = Some(val.to_string());
         104  +
        }
         105  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         106  +
            builder._request_id = Some(val.to_string());
         107  +
        }
         108  +
        Ok(builder.build())
         109  +
    }
         110  +
}
   80    111   
impl ::aws_types::request_id::RequestId for UploadMultipartPartOutput {
   81    112   
    fn request_id(&self) -> Option<&str> {
   82    113   
        self._request_id.as_deref()
   83    114   
    }
   84    115   
}
   85    116   
impl UploadMultipartPartOutput {
   86    117   
    /// Creates a new builder-style object to manufacture [`UploadMultipartPartOutput`](crate::operation::upload_multipart_part::UploadMultipartPartOutput).
   87    118   
    pub fn builder() -> crate::operation::upload_multipart_part::builders::UploadMultipartPartOutputBuilder {
   88    119   
        crate::operation::upload_multipart_part::builders::UploadMultipartPartOutputBuilder::default()
   89    120   
    }

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde.rs

@@ -1,1 +224,0 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub fn parse_http_error_metadata(
           3  +
    _response_status: u16,
           4  +
    response_headers: &::aws_smithy_runtime_api::http::Headers,
           5  +
    response_body: &[u8],
           6  +
) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_json::deserialize::error::DeserializeError> {
           7  +
    crate::json_errors::parse_error_metadata(response_body, response_headers)
           8  +
}
           9  +
    2     10   
pub(crate) fn type_erase_result<O, E>(
    3     11   
    result: ::std::result::Result<O, E>,
    4     12   
) -> ::std::result::Result<
    5     13   
    ::aws_smithy_runtime_api::client::interceptors::context::Output,
    6     14   
    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError<::aws_smithy_runtime_api::client::interceptors::context::Error>,
    7     15   
>
    8     16   
where
    9     17   
    O: ::std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
   10     18   
    E: ::std::error::Error + std::fmt::Debug + ::std::marker::Send + ::std::marker::Sync + 'static,
   11     19   
{
   12     20   
    result
   13     21   
        .map(|output| ::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
   14     22   
        .map_err(|error| ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(error))
   15     23   
        .map_err(::std::convert::Into::into)
   16     24   
}
   17     25   
   18         -
pub fn parse_http_error_metadata(
   19         -
    _response_status: u16,
   20         -
    response_headers: &::aws_smithy_runtime_api::http::Headers,
   21         -
    response_body: &[u8],
   22         -
) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_json::deserialize::error::DeserializeError> {
   23         -
    crate::json_errors::parse_error_metadata(response_body, response_headers)
   24         -
}
   25         -
   26         -
pub(crate) mod shape_abort_multipart_upload;
   27         -
   28         -
pub(crate) mod shape_abort_vault_lock;
   29         -
   30         -
pub(crate) mod shape_add_tags_to_vault;
   31         -
   32         -
pub(crate) mod shape_complete_multipart_upload;
   33         -
   34         -
pub(crate) mod shape_complete_vault_lock;
   35         -
   36         -
pub(crate) mod shape_create_vault;
   37         -
   38         -
pub(crate) mod shape_delete_archive;
   39         -
   40         -
pub(crate) mod shape_delete_vault;
   41         -
   42         -
pub(crate) mod shape_delete_vault_access_policy;
   43         -
   44         -
pub(crate) mod shape_delete_vault_notifications;
   45         -
   46         -
pub(crate) mod shape_describe_job;
   47         -
   48         -
pub(crate) mod shape_describe_vault;
   49         -
   50         -
pub(crate) mod shape_get_data_retrieval_policy;
   51         -
   52     26   
pub(crate) mod shape_get_job_output;
   53     27   
   54         -
pub(crate) mod shape_get_vault_access_policy;
   55         -
   56         -
pub(crate) mod shape_get_vault_lock;
   57         -
   58         -
pub(crate) mod shape_get_vault_notifications;
   59         -
   60         -
pub(crate) mod shape_initiate_job;
   61         -
   62         -
pub fn rest_json_unset_struct_payload() -> ::std::vec::Vec<u8> {
   63         -
    b"{}"[..].into()
   64         -
}
   65         -
   66         -
pub(crate) mod shape_initiate_job_input;
   67         -
   68         -
pub(crate) mod shape_initiate_multipart_upload;
   69         -
   70         -
pub(crate) mod shape_initiate_vault_lock;
   71         -
   72         -
pub(crate) mod shape_initiate_vault_lock_input;
   73         -
   74         -
pub(crate) mod shape_list_jobs;
   75         -
   76         -
pub(crate) mod shape_list_multipart_uploads;
   77         -
   78         -
pub(crate) mod shape_list_parts;
   79         -
   80         -
pub(crate) mod shape_list_provisioned_capacity;
   81         -
   82         -
pub(crate) mod shape_list_tags_for_vault;
   83         -
   84         -
pub(crate) mod shape_list_vaults;
   85         -
   86         -
pub(crate) mod shape_purchase_provisioned_capacity;
   87         -
   88         -
pub(crate) mod shape_remove_tags_from_vault;
   89         -
   90         -
pub(crate) mod shape_set_data_retrieval_policy;
   91         -
   92         -
pub(crate) mod shape_set_vault_access_policy;
   93         -
   94         -
pub(crate) mod shape_set_vault_access_policy_input;
   95         -
   96         -
pub(crate) mod shape_set_vault_notifications;
   97         -
   98         -
pub(crate) mod shape_set_vault_notifications_input;
   99         -
  100         -
pub(crate) mod shape_upload_archive;
  101         -
  102         -
pub(crate) mod shape_upload_archive_input;
  103         -
  104         -
pub(crate) mod shape_upload_multipart_part;
  105         -
  106         -
pub(crate) mod shape_upload_multipart_part_input;
  107         -
  108         -
pub(crate) mod shape_add_tags_to_vault_input;
  109         -
  110         -
pub(crate) mod shape_complete_multipart_upload_output;
  111         -
  112         -
pub(crate) mod shape_create_vault_output;
  113         -
  114         -
pub(crate) fn or_empty_doc(data: &[u8]) -> &[u8] {
  115         -
    if data.is_empty() {
  116         -
        b"{}"
  117         -
    } else {
  118         -
        data
  119         -
    }
  120         -
}
  121         -
  122     28   
pub(crate) mod shape_get_job_output_output;
  123         -
  124         -
pub(crate) mod shape_get_vault_access_policy_output;
  125         -
  126         -
pub(crate) mod shape_get_vault_notifications_output;
  127         -
  128         -
pub(crate) mod shape_initiate_job_output;
  129         -
  130         -
pub(crate) mod shape_initiate_multipart_upload_output;
  131         -
  132         -
pub(crate) mod shape_initiate_vault_lock_output;
  133         -
  134         -
pub(crate) mod shape_insufficient_capacity_exception;
  135         -
  136         -
pub(crate) mod shape_invalid_parameter_value_exception;
  137         -
  138         -
pub(crate) mod shape_limit_exceeded_exception;
  139         -
  140         -
pub(crate) mod shape_missing_parameter_value_exception;
  141         -
  142         -
pub(crate) mod shape_policy_enforced_exception;
  143         -
  144         -
pub(crate) mod shape_purchase_provisioned_capacity_output;
  145         -
  146         -
pub(crate) mod shape_remove_tags_from_vault_input;
  147         -
  148         -
pub(crate) mod shape_request_timeout_exception;
  149         -
  150         -
pub(crate) mod shape_resource_not_found_exception;
  151         -
  152         -
pub(crate) mod shape_service_unavailable_exception;
  153         -
  154         -
pub(crate) mod shape_set_data_retrieval_policy_input;
  155         -
  156         -
pub(crate) mod shape_upload_archive_output;
  157         -
  158         -
pub(crate) mod shape_upload_multipart_part_output;
  159         -
  160         -
pub(crate) mod shape_data_retrieval_policy;
  161         -
  162         -
pub(crate) mod shape_inventory_retrieval_job_description;
  163         -
  164         -
pub(crate) mod shape_job_list;
  165         -
  166         -
pub(crate) mod shape_job_parameters;
  167         -
  168         -
pub(crate) mod shape_output_location;
  169         -
  170         -
pub(crate) mod shape_part_list;
  171         -
  172         -
pub(crate) mod shape_provisioned_capacity_list;
  173         -
  174         -
pub(crate) mod shape_select_parameters;
  175         -
  176         -
pub(crate) mod shape_tag_map;
  177         -
  178         -
pub(crate) mod shape_uploads_list;
  179         -
  180         -
pub(crate) mod shape_vault_access_policy;
  181         -
  182         -
pub(crate) mod shape_vault_list;
  183         -
  184         -
pub(crate) mod shape_vault_lock_policy;
  185         -
  186         -
pub(crate) mod shape_vault_notification_config;
  187         -
  188         -
pub(crate) mod shape_data_retrieval_rule;
  189         -
  190         -
pub(crate) mod shape_data_retrieval_rules_list;
  191         -
  192         -
pub(crate) mod shape_describe_vault_output;
  193         -
  194         -
pub(crate) mod shape_glacier_job_description;
  195         -
  196         -
pub(crate) mod shape_input_serialization;
  197         -
  198         -
pub(crate) mod shape_inventory_retrieval_job_input;
  199         -
  200         -
pub(crate) mod shape_output_serialization;
  201         -
  202         -
pub(crate) mod shape_part_list_element;
  203         -
  204         -
pub(crate) mod shape_provisioned_capacity_description;
  205         -
  206         -
pub(crate) mod shape_s3_location;
  207         -
  208         -
pub(crate) mod shape_upload_list_element;
  209         -
  210         -
pub(crate) mod shape_access_control_policy_list;
  211         -
  212         -
pub(crate) mod shape_csv_input;
  213         -
  214         -
pub(crate) mod shape_csv_output;
  215         -
  216         -
pub(crate) mod shape_encryption;
  217         -
  218         -
pub(crate) mod shape_hashmap;
  219         -
  220         -
pub(crate) mod shape_notification_event_list;
  221         -
  222         -
pub(crate) mod shape_grant;
  223         -
  224         -
pub(crate) mod shape_grantee;

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_abort_multipart_upload.rs

@@ -1,0 +109,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
#[allow(clippy::unnecessary_wraps)]
    3         -
pub fn de_abort_multipart_upload_http_error(
    4         -
    _response_status: u16,
    5         -
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
    6         -
    _response_body: &[u8],
    7         -
) -> std::result::Result<
    8         -
    crate::operation::abort_multipart_upload::AbortMultipartUploadOutput,
    9         -
    crate::operation::abort_multipart_upload::AbortMultipartUploadError,
   10         -
> {
   11         -
    #[allow(unused_mut)]
   12         -
    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
   13         -
        .map_err(crate::operation::abort_multipart_upload::AbortMultipartUploadError::unhandled)?;
   14         -
    generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
   15         -
    let generic = generic_builder.build();
   16         -
    let error_code = match generic.code() {
   17         -
        Some(code) => code,
   18         -
        None => return Err(crate::operation::abort_multipart_upload::AbortMultipartUploadError::unhandled(generic)),
   19         -
    };
   20         -
   21         -
    let _error_message = generic.message().map(|msg| msg.to_owned());
   22         -
    Err(match error_code {
   23         -
        "InvalidParameterValueException" => crate::operation::abort_multipart_upload::AbortMultipartUploadError::InvalidParameterValueException({
   24         -
            #[allow(unused_mut)]
   25         -
            let mut tmp = {
   26         -
                #[allow(unused_mut)]
   27         -
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   28         -
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   29         -
                    _response_body,
   30         -
                    output,
   31         -
                )
   32         -
                .map_err(crate::operation::abort_multipart_upload::AbortMultipartUploadError::unhandled)?;
   33         -
                let output = output.meta(generic);
   34         -
                output.build()
   35         -
            };
   36         -
            if tmp.message.is_none() {
   37         -
                tmp.message = _error_message;
   38         -
            }
   39         -
            tmp
   40         -
        }),
   41         -
        "MissingParameterValueException" => crate::operation::abort_multipart_upload::AbortMultipartUploadError::MissingParameterValueException({
   42         -
            #[allow(unused_mut)]
   43         -
            let mut tmp = {
   44         -
                #[allow(unused_mut)]
   45         -
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   46         -
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   47         -
                    _response_body,
   48         -
                    output,
   49         -
                )
   50         -
                .map_err(crate::operation::abort_multipart_upload::AbortMultipartUploadError::unhandled)?;
   51         -
                let output = output.meta(generic);
   52         -
                output.build()
   53         -
            };
   54         -
            if tmp.message.is_none() {
   55         -
                tmp.message = _error_message;
   56         -
            }
   57         -
            tmp
   58         -
        }),
   59         -
        "ResourceNotFoundException" => crate::operation::abort_multipart_upload::AbortMultipartUploadError::ResourceNotFoundException({
   60         -
            #[allow(unused_mut)]
   61         -
            let mut tmp = {
   62         -
                #[allow(unused_mut)]
   63         -
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   64         -
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   65         -
                    .map_err(crate::operation::abort_multipart_upload::AbortMultipartUploadError::unhandled)?;
   66         -
                let output = output.meta(generic);
   67         -
                output.build()
   68         -
            };
   69         -
            if tmp.message.is_none() {
   70         -
                tmp.message = _error_message;
   71         -
            }
   72         -
            tmp
   73         -
        }),
   74         -
        "ServiceUnavailableException" => crate::operation::abort_multipart_upload::AbortMultipartUploadError::ServiceUnavailableException({
   75         -
            #[allow(unused_mut)]
   76         -
            let mut tmp = {
   77         -
                #[allow(unused_mut)]
   78         -
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   79         -
                output =
   80         -
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   81         -
                        .map_err(crate::operation::abort_multipart_upload::AbortMultipartUploadError::unhandled)?;
   82         -
                let output = output.meta(generic);
   83         -
                output.build()
   84         -
            };
   85         -
            if tmp.message.is_none() {
   86         -
                tmp.message = _error_message;
   87         -
            }
   88         -
            tmp
   89         -
        }),
   90         -
        _ => crate::operation::abort_multipart_upload::AbortMultipartUploadError::generic(generic),
   91         -
    })
   92         -
}
   93         -
   94         -
#[allow(clippy::unnecessary_wraps)]
   95         -
pub fn de_abort_multipart_upload_http_response(
   96         -
    _response_status: u16,
   97         -
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
   98         -
    _response_body: &[u8],
   99         -
) -> std::result::Result<
  100         -
    crate::operation::abort_multipart_upload::AbortMultipartUploadOutput,
  101         -
    crate::operation::abort_multipart_upload::AbortMultipartUploadError,
  102         -
> {
  103         -
    Ok({
  104         -
        #[allow(unused_mut)]
  105         -
        let mut output = crate::operation::abort_multipart_upload::builders::AbortMultipartUploadOutputBuilder::default();
  106         -
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  107         -
        output.build()
  108         -
    })
  109         -
}

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_abort_vault_lock.rs

@@ -1,0 +103,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
#[allow(clippy::unnecessary_wraps)]
    3         -
pub fn de_abort_vault_lock_http_error(
    4         -
    _response_status: u16,
    5         -
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
    6         -
    _response_body: &[u8],
    7         -
) -> std::result::Result<crate::operation::abort_vault_lock::AbortVaultLockOutput, crate::operation::abort_vault_lock::AbortVaultLockError> {
    8         -
    #[allow(unused_mut)]
    9         -
    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
   10         -
        .map_err(crate::operation::abort_vault_lock::AbortVaultLockError::unhandled)?;
   11         -
    generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
   12         -
    let generic = generic_builder.build();
   13         -
    let error_code = match generic.code() {
   14         -
        Some(code) => code,
   15         -
        None => return Err(crate::operation::abort_vault_lock::AbortVaultLockError::unhandled(generic)),
   16         -
    };
   17         -
   18         -
    let _error_message = generic.message().map(|msg| msg.to_owned());
   19         -
    Err(match error_code {
   20         -
        "InvalidParameterValueException" => crate::operation::abort_vault_lock::AbortVaultLockError::InvalidParameterValueException({
   21         -
            #[allow(unused_mut)]
   22         -
            let mut tmp = {
   23         -
                #[allow(unused_mut)]
   24         -
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25         -
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26         -
                    _response_body,
   27         -
                    output,
   28         -
                )
   29         -
                .map_err(crate::operation::abort_vault_lock::AbortVaultLockError::unhandled)?;
   30         -
                let output = output.meta(generic);
   31         -
                output.build()
   32         -
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36         -
            tmp
   37         -
        }),
   38         -
        "MissingParameterValueException" => crate::operation::abort_vault_lock::AbortVaultLockError::MissingParameterValueException({
   39         -
            #[allow(unused_mut)]
   40         -
            let mut tmp = {
   41         -
                #[allow(unused_mut)]
   42         -
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   43         -
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   44         -
                    _response_body,
   45         -
                    output,
   46         -
                )
   47         -
                .map_err(crate::operation::abort_vault_lock::AbortVaultLockError::unhandled)?;
   48         -
                let output = output.meta(generic);
   49         -
                output.build()
   50         -
            };
   51         -
            if tmp.message.is_none() {
   52         -
                tmp.message = _error_message;
   53         -
            }
   54         -
            tmp
   55         -
        }),
   56         -
        "ResourceNotFoundException" => crate::operation::abort_vault_lock::AbortVaultLockError::ResourceNotFoundException({
   57         -
            #[allow(unused_mut)]
   58         -
            let mut tmp = {
   59         -
                #[allow(unused_mut)]
   60         -
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   61         -
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   62         -
                    .map_err(crate::operation::abort_vault_lock::AbortVaultLockError::unhandled)?;
   63         -
                let output = output.meta(generic);
   64         -
                output.build()
   65         -
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69         -
            tmp
   70         -
        }),
   71         -
        "ServiceUnavailableException" => crate::operation::abort_vault_lock::AbortVaultLockError::ServiceUnavailableException({
   72         -
            #[allow(unused_mut)]
   73         -
            let mut tmp = {
   74         -
                #[allow(unused_mut)]
   75         -
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   76         -
                output =
   77         -
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   78         -
                        .map_err(crate::operation::abort_vault_lock::AbortVaultLockError::unhandled)?;
   79         -
                let output = output.meta(generic);
   80         -
                output.build()
   81         -
            };
   82         -
            if tmp.message.is_none() {
   83         -
                tmp.message = _error_message;
   84         -
            }
   85         -
            tmp
   86         -
        }),
   87         -
        _ => crate::operation::abort_vault_lock::AbortVaultLockError::generic(generic),
   88         -
    })
   89         -
}
   90         -
   91         -
#[allow(clippy::unnecessary_wraps)]
   92         -
pub fn de_abort_vault_lock_http_response(
   93         -
    _response_status: u16,
   94         -
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
   95         -
    _response_body: &[u8],
   96         -
) -> std::result::Result<crate::operation::abort_vault_lock::AbortVaultLockOutput, crate::operation::abort_vault_lock::AbortVaultLockError> {
   97         -
    Ok({
   98         -
        #[allow(unused_mut)]
   99         -
        let mut output = crate::operation::abort_vault_lock::builders::AbortVaultLockOutputBuilder::default();
  100         -
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  101         -
        output.build()
  102         -
    })
  103         -
}

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_access_control_policy_list.rs

@@ -1,0 +37,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
pub(crate) fn de_access_control_policy_list<'a, I>(
    3         -
    tokens: &mut ::std::iter::Peekable<I>,
    4         -
    _value: &'a [u8],
    5         -
) -> ::std::result::Result<Option<::std::vec::Vec<crate::types::Grant>>, ::aws_smithy_json::deserialize::error::DeserializeError>
    6         -
where
    7         -
    I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
    8         -
{
    9         -
    match tokens.next().transpose()? {
   10         -
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
   11         -
        Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
   12         -
            let mut items = Vec::new();
   13         -
            loop {
   14         -
                match tokens.peek() {
   15         -
                    Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
   16         -
                        tokens.next().transpose().unwrap();
   17         -
                        break;
   18         -
                    }
   19         -
                    _ => {
   20         -
                        let value = crate::protocol_serde::shape_grant::de_grant(tokens, _value)?;
   21         -
                        if let Some(value) = value {
   22         -
                            items.push(value);
   23         -
                        } else {
   24         -
                            return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
   25         -
                                "dense list cannot contain null values",
   26         -
                            ));
   27         -
                        }
   28         -
                    }
   29         -
                }
   30         -
            }
   31         -
            Ok(Some(items))
   32         -
        }
   33         -
        _ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
   34         -
            "expected start array or null",
   35         -
        )),
   36         -
    }
   37         -
}

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_add_tags_to_vault.rs

@@ -1,0 +128,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
#[allow(clippy::unnecessary_wraps)]
    3         -
pub fn de_add_tags_to_vault_http_error(
    4         -
    _response_status: u16,
    5         -
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
    6         -
    _response_body: &[u8],
    7         -
) -> std::result::Result<crate::operation::add_tags_to_vault::AddTagsToVaultOutput, crate::operation::add_tags_to_vault::AddTagsToVaultError> {
    8         -
    #[allow(unused_mut)]
    9         -
    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
   10         -
        .map_err(crate::operation::add_tags_to_vault::AddTagsToVaultError::unhandled)?;
   11         -
    generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
   12         -
    let generic = generic_builder.build();
   13         -
    let error_code = match generic.code() {
   14         -
        Some(code) => code,
   15         -
        None => return Err(crate::operation::add_tags_to_vault::AddTagsToVaultError::unhandled(generic)),
   16         -
    };
   17         -
   18         -
    let _error_message = generic.message().map(|msg| msg.to_owned());
   19         -
    Err(match error_code {
   20         -
        "InvalidParameterValueException" => crate::operation::add_tags_to_vault::AddTagsToVaultError::InvalidParameterValueException({
   21         -
            #[allow(unused_mut)]
   22         -
            let mut tmp = {
   23         -
                #[allow(unused_mut)]
   24         -
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   25         -
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   26         -
                    _response_body,
   27         -
                    output,
   28         -
                )
   29         -
                .map_err(crate::operation::add_tags_to_vault::AddTagsToVaultError::unhandled)?;
   30         -
                let output = output.meta(generic);
   31         -
                output.build()
   32         -
            };
   33         -
            if tmp.message.is_none() {
   34         -
                tmp.message = _error_message;
   35         -
            }
   36         -
            tmp
   37         -
        }),
   38         -
        "LimitExceededException" => crate::operation::add_tags_to_vault::AddTagsToVaultError::LimitExceededException({
   39         -
            #[allow(unused_mut)]
   40         -
            let mut tmp = {
   41         -
                #[allow(unused_mut)]
   42         -
                let mut output = crate::types::error::builders::LimitExceededExceptionBuilder::default();
   43         -
                output = crate::protocol_serde::shape_limit_exceeded_exception::de_limit_exceeded_exception_json_err(_response_body, output)
   44         -
                    .map_err(crate::operation::add_tags_to_vault::AddTagsToVaultError::unhandled)?;
   45         -
                let output = output.meta(generic);
   46         -
                output.build()
   47         -
            };
   48         -
            if tmp.message.is_none() {
   49         -
                tmp.message = _error_message;
   50         -
            }
   51         -
            tmp
   52         -
        }),
   53         -
        "MissingParameterValueException" => crate::operation::add_tags_to_vault::AddTagsToVaultError::MissingParameterValueException({
   54         -
            #[allow(unused_mut)]
   55         -
            let mut tmp = {
   56         -
                #[allow(unused_mut)]
   57         -
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   58         -
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   59         -
                    _response_body,
   60         -
                    output,
   61         -
                )
   62         -
                .map_err(crate::operation::add_tags_to_vault::AddTagsToVaultError::unhandled)?;
   63         -
                let output = output.meta(generic);
   64         -
                output.build()
   65         -
            };
   66         -
            if tmp.message.is_none() {
   67         -
                tmp.message = _error_message;
   68         -
            }
   69         -
            tmp
   70         -
        }),
   71         -
        "ResourceNotFoundException" => crate::operation::add_tags_to_vault::AddTagsToVaultError::ResourceNotFoundException({
   72         -
            #[allow(unused_mut)]
   73         -
            let mut tmp = {
   74         -
                #[allow(unused_mut)]
   75         -
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   76         -
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   77         -
                    .map_err(crate::operation::add_tags_to_vault::AddTagsToVaultError::unhandled)?;
   78         -
                let output = output.meta(generic);
   79         -
                output.build()
   80         -
            };
   81         -
            if tmp.message.is_none() {
   82         -
                tmp.message = _error_message;
   83         -
            }
   84         -
            tmp
   85         -
        }),
   86         -
        "ServiceUnavailableException" => crate::operation::add_tags_to_vault::AddTagsToVaultError::ServiceUnavailableException({
   87         -
            #[allow(unused_mut)]
   88         -
            let mut tmp = {
   89         -
                #[allow(unused_mut)]
   90         -
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   91         -
                output =
   92         -
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   93         -
                        .map_err(crate::operation::add_tags_to_vault::AddTagsToVaultError::unhandled)?;
   94         -
                let output = output.meta(generic);
   95         -
                output.build()
   96         -
            };
   97         -
            if tmp.message.is_none() {
   98         -
                tmp.message = _error_message;
   99         -
            }
  100         -
            tmp
  101         -
        }),
  102         -
        _ => crate::operation::add_tags_to_vault::AddTagsToVaultError::generic(generic),
  103         -
    })
  104         -
}
  105         -
  106         -
#[allow(clippy::unnecessary_wraps)]
  107         -
pub fn de_add_tags_to_vault_http_response(
  108         -
    _response_status: u16,
  109         -
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
  110         -
    _response_body: &[u8],
  111         -
) -> std::result::Result<crate::operation::add_tags_to_vault::AddTagsToVaultOutput, crate::operation::add_tags_to_vault::AddTagsToVaultError> {
  112         -
    Ok({
  113         -
        #[allow(unused_mut)]
  114         -
        let mut output = crate::operation::add_tags_to_vault::builders::AddTagsToVaultOutputBuilder::default();
  115         -
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  116         -
        output.build()
  117         -
    })
  118         -
}
  119         -
  120         -
pub fn ser_add_tags_to_vault_input(
  121         -
    input: &crate::operation::add_tags_to_vault::AddTagsToVaultInput,
  122         -
) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
  123         -
    let mut out = String::new();
  124         -
    let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
  125         -
    crate::protocol_serde::shape_add_tags_to_vault_input::ser_add_tags_to_vault_input_input(&mut object, input)?;
  126         -
    object.finish();
  127         -
    Ok(::aws_smithy_types::body::SdkBody::from(out))
  128         -
}

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_add_tags_to_vault_input.rs

@@ -1,0 +17,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
pub fn ser_add_tags_to_vault_input_input(
    3         -
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
    4         -
    input: &crate::operation::add_tags_to_vault::AddTagsToVaultInput,
    5         -
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
    6         -
    if let Some(var_1) = &input.tags {
    7         -
        #[allow(unused_mut)]
    8         -
        let mut object_2 = object.key("Tags").start_object();
    9         -
        for (key_3, value_4) in var_1 {
   10         -
            {
   11         -
                object_2.key(key_3.as_str()).string(value_4.as_str());
   12         -
            }
   13         -
        }
   14         -
        object_2.finish();
   15         -
    }
   16         -
    Ok(())
   17         -
}

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_complete_multipart_upload.rs

@@ -1,0 +165,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
#[allow(clippy::unnecessary_wraps)]
    3         -
pub fn de_complete_multipart_upload_http_error(
    4         -
    _response_status: u16,
    5         -
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
    6         -
    _response_body: &[u8],
    7         -
) -> std::result::Result<
    8         -
    crate::operation::complete_multipart_upload::CompleteMultipartUploadOutput,
    9         -
    crate::operation::complete_multipart_upload::CompleteMultipartUploadError,
   10         -
> {
   11         -
    #[allow(unused_mut)]
   12         -
    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
   13         -
        .map_err(crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled)?;
   14         -
    generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
   15         -
    let generic = generic_builder.build();
   16         -
    let error_code = match generic.code() {
   17         -
        Some(code) => code,
   18         -
        None => {
   19         -
            return Err(crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
   20         -
                generic,
   21         -
            ))
   22         -
        }
   23         -
    };
   24         -
   25         -
    let _error_message = generic.message().map(|msg| msg.to_owned());
   26         -
    Err(match error_code {
   27         -
        "InvalidParameterValueException" => {
   28         -
            crate::operation::complete_multipart_upload::CompleteMultipartUploadError::InvalidParameterValueException({
   29         -
                #[allow(unused_mut)]
   30         -
                let mut tmp = {
   31         -
                    #[allow(unused_mut)]
   32         -
                    let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   33         -
                    output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   34         -
                        _response_body,
   35         -
                        output,
   36         -
                    )
   37         -
                    .map_err(crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled)?;
   38         -
                    let output = output.meta(generic);
   39         -
                    output.build()
   40         -
                };
   41         -
                if tmp.message.is_none() {
   42         -
                    tmp.message = _error_message;
   43         -
                }
   44         -
                tmp
   45         -
            })
   46         -
        }
   47         -
        "MissingParameterValueException" => {
   48         -
            crate::operation::complete_multipart_upload::CompleteMultipartUploadError::MissingParameterValueException({
   49         -
                #[allow(unused_mut)]
   50         -
                let mut tmp = {
   51         -
                    #[allow(unused_mut)]
   52         -
                    let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   53         -
                    output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   54         -
                        _response_body,
   55         -
                        output,
   56         -
                    )
   57         -
                    .map_err(crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled)?;
   58         -
                    let output = output.meta(generic);
   59         -
                    output.build()
   60         -
                };
   61         -
                if tmp.message.is_none() {
   62         -
                    tmp.message = _error_message;
   63         -
                }
   64         -
                tmp
   65         -
            })
   66         -
        }
   67         -
        "ResourceNotFoundException" => crate::operation::complete_multipart_upload::CompleteMultipartUploadError::ResourceNotFoundException({
   68         -
            #[allow(unused_mut)]
   69         -
            let mut tmp = {
   70         -
                #[allow(unused_mut)]
   71         -
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   72         -
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   73         -
                    .map_err(crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled)?;
   74         -
                let output = output.meta(generic);
   75         -
                output.build()
   76         -
            };
   77         -
            if tmp.message.is_none() {
   78         -
                tmp.message = _error_message;
   79         -
            }
   80         -
            tmp
   81         -
        }),
   82         -
        "ServiceUnavailableException" => crate::operation::complete_multipart_upload::CompleteMultipartUploadError::ServiceUnavailableException({
   83         -
            #[allow(unused_mut)]
   84         -
            let mut tmp = {
   85         -
                #[allow(unused_mut)]
   86         -
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   87         -
                output =
   88         -
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   89         -
                        .map_err(crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled)?;
   90         -
                let output = output.meta(generic);
   91         -
                output.build()
   92         -
            };
   93         -
            if tmp.message.is_none() {
   94         -
                tmp.message = _error_message;
   95         -
            }
   96         -
            tmp
   97         -
        }),
   98         -
        _ => crate::operation::complete_multipart_upload::CompleteMultipartUploadError::generic(generic),
   99         -
    })
  100         -
}
  101         -
  102         -
#[allow(clippy::unnecessary_wraps)]
  103         -
pub fn de_complete_multipart_upload_http_response(
  104         -
    _response_status: u16,
  105         -
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
  106         -
    _response_body: &[u8],
  107         -
) -> std::result::Result<
  108         -
    crate::operation::complete_multipart_upload::CompleteMultipartUploadOutput,
  109         -
    crate::operation::complete_multipart_upload::CompleteMultipartUploadError,
  110         -
> {
  111         -
    Ok({
  112         -
        #[allow(unused_mut)]
  113         -
        let mut output = crate::operation::complete_multipart_upload::builders::CompleteMultipartUploadOutputBuilder::default();
  114         -
        output = output.set_archive_id(
  115         -
            crate::protocol_serde::shape_complete_multipart_upload_output::de_archive_id_header(_response_headers).map_err(|_| {
  116         -
                crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
  117         -
                    "Failed to parse archiveId from header `x-amz-archive-id",
  118         -
                )
  119         -
            })?,
  120         -
        );
  121         -
        output = output.set_checksum(
  122         -
            crate::protocol_serde::shape_complete_multipart_upload_output::de_checksum_header(_response_headers).map_err(|_| {
  123         -
                crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
  124         -
                    "Failed to parse checksum from header `x-amz-sha256-tree-hash",
  125         -
                )
  126         -
            })?,
  127         -
        );
  128         -
        output = output.set_location(
  129         -
            crate::protocol_serde::shape_complete_multipart_upload_output::de_location_header(_response_headers).map_err(|_| {
  130         -
                crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled("Failed to parse location from header `Location")
  131         -
            })?,
  132         -
        );
  133         -
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  134         -
        output.build()
  135         -
    })
  136         -
}
  137         -
  138         -
pub fn ser_complete_multipart_upload_headers(
  139         -
    input: &crate::operation::complete_multipart_upload::CompleteMultipartUploadInput,
  140         -
    mut builder: ::http_1x::request::Builder,
  141         -
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  142         -
    if let ::std::option::Option::Some(inner_1) = &input.archive_size {
  143         -
        let formatted_2 = inner_1.as_str();
  144         -
        let header_value = formatted_2;
  145         -
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  146         -
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  147         -
                "archive_size",
  148         -
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  149         -
            )
  150         -
        })?;
  151         -
        builder = builder.header("x-amz-archive-size", header_value);
  152         -
    }
  153         -
    if let ::std::option::Option::Some(inner_3) = &input.checksum {
  154         -
        let formatted_4 = inner_3.as_str();
  155         -
        let header_value = formatted_4;
  156         -
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  157         -
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  158         -
                "checksum",
  159         -
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  160         -
            )
  161         -
        })?;
  162         -
        builder = builder.header("x-amz-sha256-tree-hash", header_value);
  163         -
    }
  164         -
    Ok(builder)
  165         -
}

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_complete_multipart_upload_output.rs

@@ -1,0 +21,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
pub(crate) fn de_archive_id_header(
    3         -
    header_map: &::aws_smithy_runtime_api::http::Headers,
    4         -
) -> ::std::result::Result<::std::option::Option<::std::string::String>, ::aws_smithy_http::header::ParseError> {
    5         -
    let headers = header_map.get_all("x-amz-archive-id");
    6         -
    ::aws_smithy_http::header::one_or_none(headers)
    7         -
}
    8         -
    9         -
pub(crate) fn de_checksum_header(
   10         -
    header_map: &::aws_smithy_runtime_api::http::Headers,
   11         -
) -> ::std::result::Result<::std::option::Option<::std::string::String>, ::aws_smithy_http::header::ParseError> {
   12         -
    let headers = header_map.get_all("x-amz-sha256-tree-hash");
   13         -
    ::aws_smithy_http::header::one_or_none(headers)
   14         -
}
   15         -
   16         -
pub(crate) fn de_location_header(
   17         -
    header_map: &::aws_smithy_runtime_api::http::Headers,
   18         -
) -> ::std::result::Result<::std::option::Option<::std::string::String>, ::aws_smithy_http::header::ParseError> {
   19         -
    let headers = header_map.get_all("Location");
   20         -
    ::aws_smithy_http::header::one_or_none(headers)
   21         -
}

tmp-codegen-diff/aws-sdk/sdk/glacier/src/protocol_serde/shape_complete_vault_lock.rs

@@ -1,0 +105,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
#[allow(clippy::unnecessary_wraps)]
    3         -
pub fn de_complete_vault_lock_http_error(
    4         -
    _response_status: u16,
    5         -
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
    6         -
    _response_body: &[u8],
    7         -
) -> std::result::Result<crate::operation::complete_vault_lock::CompleteVaultLockOutput, crate::operation::complete_vault_lock::CompleteVaultLockError>
    8         -
{
    9         -
    #[allow(unused_mut)]
   10         -
    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
   11         -
        .map_err(crate::operation::complete_vault_lock::CompleteVaultLockError::unhandled)?;
   12         -
    generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
   13         -
    let generic = generic_builder.build();
   14         -
    let error_code = match generic.code() {
   15         -
        Some(code) => code,
   16         -
        None => return Err(crate::operation::complete_vault_lock::CompleteVaultLockError::unhandled(generic)),
   17         -
    };
   18         -
   19         -
    let _error_message = generic.message().map(|msg| msg.to_owned());
   20         -
    Err(match error_code {
   21         -
        "InvalidParameterValueException" => crate::operation::complete_vault_lock::CompleteVaultLockError::InvalidParameterValueException({
   22         -
            #[allow(unused_mut)]
   23         -
            let mut tmp = {
   24         -
                #[allow(unused_mut)]
   25         -
                let mut output = crate::types::error::builders::InvalidParameterValueExceptionBuilder::default();
   26         -
                output = crate::protocol_serde::shape_invalid_parameter_value_exception::de_invalid_parameter_value_exception_json_err(
   27         -
                    _response_body,
   28         -
                    output,
   29         -
                )
   30         -
                .map_err(crate::operation::complete_vault_lock::CompleteVaultLockError::unhandled)?;
   31         -
                let output = output.meta(generic);
   32         -
                output.build()
   33         -
            };
   34         -
            if tmp.message.is_none() {
   35         -
                tmp.message = _error_message;
   36         -
            }
   37         -
            tmp
   38         -
        }),
   39         -
        "MissingParameterValueException" => crate::operation::complete_vault_lock::CompleteVaultLockError::MissingParameterValueException({
   40         -
            #[allow(unused_mut)]
   41         -
            let mut tmp = {
   42         -
                #[allow(unused_mut)]
   43         -
                let mut output = crate::types::error::builders::MissingParameterValueExceptionBuilder::default();
   44         -
                output = crate::protocol_serde::shape_missing_parameter_value_exception::de_missing_parameter_value_exception_json_err(
   45         -
                    _response_body,
   46         -
                    output,
   47         -
                )
   48         -
                .map_err(crate::operation::complete_vault_lock::CompleteVaultLockError::unhandled)?;
   49         -
                let output = output.meta(generic);
   50         -
                output.build()
   51         -
            };
   52         -
            if tmp.message.is_none() {
   53         -
                tmp.message = _error_message;
   54         -
            }
   55         -
            tmp
   56         -
        }),
   57         -
        "ResourceNotFoundException" => crate::operation::complete_vault_lock::CompleteVaultLockError::ResourceNotFoundException({
   58         -
            #[allow(unused_mut)]
   59         -
            let mut tmp = {
   60         -
                #[allow(unused_mut)]
   61         -
                let mut output = crate::types::error::builders::ResourceNotFoundExceptionBuilder::default();
   62         -
                output = crate::protocol_serde::shape_resource_not_found_exception::de_resource_not_found_exception_json_err(_response_body, output)
   63         -
                    .map_err(crate::operation::complete_vault_lock::CompleteVaultLockError::unhandled)?;
   64         -
                let output = output.meta(generic);
   65         -
                output.build()
   66         -
            };
   67         -
            if tmp.message.is_none() {
   68         -
                tmp.message = _error_message;
   69         -
            }
   70         -
            tmp
   71         -
        }),
   72         -
        "ServiceUnavailableException" => crate::operation::complete_vault_lock::CompleteVaultLockError::ServiceUnavailableException({
   73         -
            #[allow(unused_mut)]
   74         -
            let mut tmp = {
   75         -
                #[allow(unused_mut)]
   76         -
                let mut output = crate::types::error::builders::ServiceUnavailableExceptionBuilder::default();
   77         -
                output =
   78         -
                    crate::protocol_serde::shape_service_unavailable_exception::de_service_unavailable_exception_json_err(_response_body, output)
   79         -
                        .map_err(crate::operation::complete_vault_lock::CompleteVaultLockError::unhandled)?;
   80         -
                let output = output.meta(generic);
   81         -
                output.build()
   82         -
            };
   83         -
            if tmp.message.is_none() {
   84         -
                tmp.message = _error_message;
   85         -
            }
   86         -
            tmp
   87         -
        }),
   88         -
        _ => crate::operation::complete_vault_lock::CompleteVaultLockError::generic(generic),
   89         -
    })
   90         -
}
   91         -
   92         -
#[allow(clippy::unnecessary_wraps)]
   93         -
pub fn de_complete_vault_lock_http_response(
   94         -
    _response_status: u16,
   95         -
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
   96         -
    _response_body: &[u8],
   97         -
) -> std::result::Result<crate::operation::complete_vault_lock::CompleteVaultLockOutput, crate::operation::complete_vault_lock::CompleteVaultLockError>
   98         -
{
   99         -
    Ok({
  100         -
        #[allow(unused_mut)]
  101         -
        let mut output = crate::operation::complete_vault_lock::builders::CompleteVaultLockOutputBuilder::default();
  102         -
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  103         -
        output.build()
  104         -
    })
  105         -
}