aws_sdk_codecommit/protocol_serde/
shape_get_pull_request_approval_states.rs1#[allow(clippy::unnecessary_wraps)]
3pub fn de_get_pull_request_approval_states_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::get_pull_request_approval_states::GetPullRequestApprovalStatesOutput,
9    crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError,
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::get_pull_request_approval_states::GetPullRequestApprovalStatesError::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::get_pull_request_approval_states::GetPullRequestApprovalStatesError::unhandled(generic)),
19    };
20
21    let _error_message = generic.message().map(|msg| msg.to_owned());
22    Err(match error_code {
23        "EncryptionIntegrityChecksFailedException" => {
24            crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::EncryptionIntegrityChecksFailedException({
25                #[allow(unused_mut)]
26                let mut tmp = {
27                    #[allow(unused_mut)]
28                    let mut output = crate::types::error::builders::EncryptionIntegrityChecksFailedExceptionBuilder::default();
29                    output = crate::protocol_serde::shape_encryption_integrity_checks_failed_exception::de_encryption_integrity_checks_failed_exception_json_err(_response_body, output).map_err(crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::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        }
39        "EncryptionKeyAccessDeniedException" => {
40            crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::EncryptionKeyAccessDeniedException({
41                #[allow(unused_mut)]
42                let mut tmp = {
43                    #[allow(unused_mut)]
44                    let mut output = crate::types::error::builders::EncryptionKeyAccessDeniedExceptionBuilder::default();
45                    output = crate::protocol_serde::shape_encryption_key_access_denied_exception::de_encryption_key_access_denied_exception_json_err(
46                        _response_body,
47                        output,
48                    )
49                    .map_err(crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::unhandled)?;
50                    let output = output.meta(generic);
51                    output.build()
52                };
53                if tmp.message.is_none() {
54                    tmp.message = _error_message;
55                }
56                tmp
57            })
58        }
59        "EncryptionKeyDisabledException" => {
60            crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::EncryptionKeyDisabledException({
61                #[allow(unused_mut)]
62                let mut tmp = {
63                    #[allow(unused_mut)]
64                    let mut output = crate::types::error::builders::EncryptionKeyDisabledExceptionBuilder::default();
65                    output = crate::protocol_serde::shape_encryption_key_disabled_exception::de_encryption_key_disabled_exception_json_err(
66                        _response_body,
67                        output,
68                    )
69                    .map_err(crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::unhandled)?;
70                    let output = output.meta(generic);
71                    output.build()
72                };
73                if tmp.message.is_none() {
74                    tmp.message = _error_message;
75                }
76                tmp
77            })
78        }
79        "EncryptionKeyNotFoundException" => {
80            crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::EncryptionKeyNotFoundException({
81                #[allow(unused_mut)]
82                let mut tmp = {
83                    #[allow(unused_mut)]
84                    let mut output = crate::types::error::builders::EncryptionKeyNotFoundExceptionBuilder::default();
85                    output = crate::protocol_serde::shape_encryption_key_not_found_exception::de_encryption_key_not_found_exception_json_err(
86                        _response_body,
87                        output,
88                    )
89                    .map_err(crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::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        }
99        "EncryptionKeyUnavailableException" => {
100            crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::EncryptionKeyUnavailableException({
101                #[allow(unused_mut)]
102                let mut tmp = {
103                    #[allow(unused_mut)]
104                    let mut output = crate::types::error::builders::EncryptionKeyUnavailableExceptionBuilder::default();
105                    output = crate::protocol_serde::shape_encryption_key_unavailable_exception::de_encryption_key_unavailable_exception_json_err(
106                        _response_body,
107                        output,
108                    )
109                    .map_err(crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::unhandled)?;
110                    let output = output.meta(generic);
111                    output.build()
112                };
113                if tmp.message.is_none() {
114                    tmp.message = _error_message;
115                }
116                tmp
117            })
118        }
119        "InvalidPullRequestIdException" => {
120            crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::InvalidPullRequestIdException({
121                #[allow(unused_mut)]
122                let mut tmp = {
123                    #[allow(unused_mut)]
124                    let mut output = crate::types::error::builders::InvalidPullRequestIdExceptionBuilder::default();
125                    output = crate::protocol_serde::shape_invalid_pull_request_id_exception::de_invalid_pull_request_id_exception_json_err(
126                        _response_body,
127                        output,
128                    )
129                    .map_err(crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::unhandled)?;
130                    let output = output.meta(generic);
131                    output.build()
132                };
133                if tmp.message.is_none() {
134                    tmp.message = _error_message;
135                }
136                tmp
137            })
138        }
139        "InvalidRevisionIdException" => {
140            crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::InvalidRevisionIdException({
141                #[allow(unused_mut)]
142                let mut tmp = {
143                    #[allow(unused_mut)]
144                    let mut output = crate::types::error::builders::InvalidRevisionIdExceptionBuilder::default();
145                    output =
146                        crate::protocol_serde::shape_invalid_revision_id_exception::de_invalid_revision_id_exception_json_err(_response_body, output)
147                            .map_err(crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::unhandled)?;
148                    let output = output.meta(generic);
149                    output.build()
150                };
151                if tmp.message.is_none() {
152                    tmp.message = _error_message;
153                }
154                tmp
155            })
156        }
157        "PullRequestDoesNotExistException" => {
158            crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::PullRequestDoesNotExistException({
159                #[allow(unused_mut)]
160                let mut tmp = {
161                    #[allow(unused_mut)]
162                    let mut output = crate::types::error::builders::PullRequestDoesNotExistExceptionBuilder::default();
163                    output = crate::protocol_serde::shape_pull_request_does_not_exist_exception::de_pull_request_does_not_exist_exception_json_err(
164                        _response_body,
165                        output,
166                    )
167                    .map_err(crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::unhandled)?;
168                    let output = output.meta(generic);
169                    output.build()
170                };
171                if tmp.message.is_none() {
172                    tmp.message = _error_message;
173                }
174                tmp
175            })
176        }
177        "PullRequestIdRequiredException" => {
178            crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::PullRequestIdRequiredException({
179                #[allow(unused_mut)]
180                let mut tmp = {
181                    #[allow(unused_mut)]
182                    let mut output = crate::types::error::builders::PullRequestIdRequiredExceptionBuilder::default();
183                    output = crate::protocol_serde::shape_pull_request_id_required_exception::de_pull_request_id_required_exception_json_err(
184                        _response_body,
185                        output,
186                    )
187                    .map_err(crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::unhandled)?;
188                    let output = output.meta(generic);
189                    output.build()
190                };
191                if tmp.message.is_none() {
192                    tmp.message = _error_message;
193                }
194                tmp
195            })
196        }
197        "RevisionIdRequiredException" => {
198            crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::RevisionIdRequiredException({
199                #[allow(unused_mut)]
200                let mut tmp = {
201                    #[allow(unused_mut)]
202                    let mut output = crate::types::error::builders::RevisionIdRequiredExceptionBuilder::default();
203                    output = crate::protocol_serde::shape_revision_id_required_exception::de_revision_id_required_exception_json_err(
204                        _response_body,
205                        output,
206                    )
207                    .map_err(crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::unhandled)?;
208                    let output = output.meta(generic);
209                    output.build()
210                };
211                if tmp.message.is_none() {
212                    tmp.message = _error_message;
213                }
214                tmp
215            })
216        }
217        _ => crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::generic(generic),
218    })
219}
220
221#[allow(clippy::unnecessary_wraps)]
222pub fn de_get_pull_request_approval_states_http_response(
223    _response_status: u16,
224    _response_headers: &::aws_smithy_runtime_api::http::Headers,
225    _response_body: &[u8],
226) -> std::result::Result<
227    crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesOutput,
228    crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError,
229> {
230    Ok({
231        #[allow(unused_mut)]
232        let mut output = crate::operation::get_pull_request_approval_states::builders::GetPullRequestApprovalStatesOutputBuilder::default();
233        output = crate::protocol_serde::shape_get_pull_request_approval_states::de_get_pull_request_approval_states(_response_body, output)
234            .map_err(crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesError::unhandled)?;
235        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
236        output.build()
237    })
238}
239
240pub fn ser_get_pull_request_approval_states_input(
241    input: &crate::operation::get_pull_request_approval_states::GetPullRequestApprovalStatesInput,
242) -> ::std::result::Result<::aws_smithy_types::body::SdkBody, ::aws_smithy_types::error::operation::SerializationError> {
243    let mut out = String::new();
244    let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
245    crate::protocol_serde::shape_get_pull_request_approval_states_input::ser_get_pull_request_approval_states_input_input(&mut object, input)?;
246    object.finish();
247    Ok(::aws_smithy_types::body::SdkBody::from(out))
248}
249
250pub(crate) fn de_get_pull_request_approval_states(
251    value: &[u8],
252    mut builder: crate::operation::get_pull_request_approval_states::builders::GetPullRequestApprovalStatesOutputBuilder,
253) -> ::std::result::Result<
254    crate::operation::get_pull_request_approval_states::builders::GetPullRequestApprovalStatesOutputBuilder,
255    ::aws_smithy_json::deserialize::error::DeserializeError,
256> {
257    let mut tokens_owned = ::aws_smithy_json::deserialize::json_token_iter(crate::protocol_serde::or_empty_doc(value)).peekable();
258    let tokens = &mut tokens_owned;
259    ::aws_smithy_json::deserialize::token::expect_start_object(tokens.next())?;
260    loop {
261        match tokens.next().transpose()? {
262            Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
263            Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
264                "approvals" => {
265                    builder = builder.set_approvals(crate::protocol_serde::shape_approval_list::de_approval_list(tokens)?);
266                }
267                _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
268            },
269            other => {
270                return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
271                    "expected object key or end object, found: {other:?}"
272                )))
273            }
274        }
275    }
276    if tokens.next().is_some() {
277        return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
278            "found more JSON tokens after completing parsing",
279        ));
280    }
281    Ok(builder)
282}