aws_sdk_elasticloadbalancingv2/protocol_serde/
shape_create_rule.rs1#[allow(clippy::unnecessary_wraps)]
3pub fn de_create_rule_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::create_rule::CreateRuleOutput, crate::operation::create_rule::CreateRuleError> {
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::create_rule::CreateRuleError::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::create_rule::CreateRuleError::unhandled(generic)),
16 };
17
18 let _error_message = generic.message().map(|msg| msg.to_owned());
19 Err(match error_code {
20 "IncompatibleProtocols" => crate::operation::create_rule::CreateRuleError::IncompatibleProtocolsException({
21 #[allow(unused_mut)]
22 let mut tmp = {
23 #[allow(unused_mut)]
24 let mut output = crate::types::error::builders::IncompatibleProtocolsExceptionBuilder::default();
25 output = crate::protocol_serde::shape_incompatible_protocols_exception::de_incompatible_protocols_exception_xml_err(
26 _response_body,
27 output,
28 )
29 .map_err(crate::operation::create_rule::CreateRuleError::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 "InvalidConfigurationRequest" => crate::operation::create_rule::CreateRuleError::InvalidConfigurationRequestException({
39 #[allow(unused_mut)]
40 let mut tmp = {
41 #[allow(unused_mut)]
42 let mut output = crate::types::error::builders::InvalidConfigurationRequestExceptionBuilder::default();
43 output = crate::protocol_serde::shape_invalid_configuration_request_exception::de_invalid_configuration_request_exception_xml_err(
44 _response_body,
45 output,
46 )
47 .map_err(crate::operation::create_rule::CreateRuleError::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 "InvalidLoadBalancerAction" => crate::operation::create_rule::CreateRuleError::InvalidLoadBalancerActionException({
57 #[allow(unused_mut)]
58 let mut tmp = {
59 #[allow(unused_mut)]
60 let mut output = crate::types::error::builders::InvalidLoadBalancerActionExceptionBuilder::default();
61 output = crate::protocol_serde::shape_invalid_load_balancer_action_exception::de_invalid_load_balancer_action_exception_xml_err(
62 _response_body,
63 output,
64 )
65 .map_err(crate::operation::create_rule::CreateRuleError::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 "ListenerNotFound" => crate::operation::create_rule::CreateRuleError::ListenerNotFoundException({
75 #[allow(unused_mut)]
76 let mut tmp = {
77 #[allow(unused_mut)]
78 let mut output = crate::types::error::builders::ListenerNotFoundExceptionBuilder::default();
79 output = crate::protocol_serde::shape_listener_not_found_exception::de_listener_not_found_exception_xml_err(_response_body, output)
80 .map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
81 let output = output.meta(generic);
82 output.build()
83 };
84 if tmp.message.is_none() {
85 tmp.message = _error_message;
86 }
87 tmp
88 }),
89 "PriorityInUse" => crate::operation::create_rule::CreateRuleError::PriorityInUseException({
90 #[allow(unused_mut)]
91 let mut tmp = {
92 #[allow(unused_mut)]
93 let mut output = crate::types::error::builders::PriorityInUseExceptionBuilder::default();
94 output = crate::protocol_serde::shape_priority_in_use_exception::de_priority_in_use_exception_xml_err(_response_body, output)
95 .map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
96 let output = output.meta(generic);
97 output.build()
98 };
99 if tmp.message.is_none() {
100 tmp.message = _error_message;
101 }
102 tmp
103 }),
104 "TargetGroupAssociationLimit" => crate::operation::create_rule::CreateRuleError::TargetGroupAssociationLimitException({
105 #[allow(unused_mut)]
106 let mut tmp = {
107 #[allow(unused_mut)]
108 let mut output = crate::types::error::builders::TargetGroupAssociationLimitExceptionBuilder::default();
109 output = crate::protocol_serde::shape_target_group_association_limit_exception::de_target_group_association_limit_exception_xml_err(
110 _response_body,
111 output,
112 )
113 .map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
114 let output = output.meta(generic);
115 output.build()
116 };
117 if tmp.message.is_none() {
118 tmp.message = _error_message;
119 }
120 tmp
121 }),
122 "TargetGroupNotFound" => crate::operation::create_rule::CreateRuleError::TargetGroupNotFoundException({
123 #[allow(unused_mut)]
124 let mut tmp = {
125 #[allow(unused_mut)]
126 let mut output = crate::types::error::builders::TargetGroupNotFoundExceptionBuilder::default();
127 output = crate::protocol_serde::shape_target_group_not_found_exception::de_target_group_not_found_exception_xml_err(
128 _response_body,
129 output,
130 )
131 .map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
132 let output = output.meta(generic);
133 output.build()
134 };
135 if tmp.message.is_none() {
136 tmp.message = _error_message;
137 }
138 tmp
139 }),
140 "TooManyActions" => crate::operation::create_rule::CreateRuleError::TooManyActionsException({
141 #[allow(unused_mut)]
142 let mut tmp = {
143 #[allow(unused_mut)]
144 let mut output = crate::types::error::builders::TooManyActionsExceptionBuilder::default();
145 output = crate::protocol_serde::shape_too_many_actions_exception::de_too_many_actions_exception_xml_err(_response_body, output)
146 .map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
147 let output = output.meta(generic);
148 output.build()
149 };
150 if tmp.message.is_none() {
151 tmp.message = _error_message;
152 }
153 tmp
154 }),
155 "TooManyRegistrationsForTargetId" => crate::operation::create_rule::CreateRuleError::TooManyRegistrationsForTargetIdException({
156 #[allow(unused_mut)]
157 let mut tmp = {
158 #[allow(unused_mut)]
159 let mut output = crate::types::error::builders::TooManyRegistrationsForTargetIdExceptionBuilder::default();
160 output = crate::protocol_serde::shape_too_many_registrations_for_target_id_exception::de_too_many_registrations_for_target_id_exception_xml_err(_response_body, output).map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
161 let output = output.meta(generic);
162 output.build()
163 };
164 if tmp.message.is_none() {
165 tmp.message = _error_message;
166 }
167 tmp
168 }),
169 "TooManyRules" => crate::operation::create_rule::CreateRuleError::TooManyRulesException({
170 #[allow(unused_mut)]
171 let mut tmp = {
172 #[allow(unused_mut)]
173 let mut output = crate::types::error::builders::TooManyRulesExceptionBuilder::default();
174 output = crate::protocol_serde::shape_too_many_rules_exception::de_too_many_rules_exception_xml_err(_response_body, output)
175 .map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
176 let output = output.meta(generic);
177 output.build()
178 };
179 if tmp.message.is_none() {
180 tmp.message = _error_message;
181 }
182 tmp
183 }),
184 "TooManyTags" => crate::operation::create_rule::CreateRuleError::TooManyTagsException({
185 #[allow(unused_mut)]
186 let mut tmp = {
187 #[allow(unused_mut)]
188 let mut output = crate::types::error::builders::TooManyTagsExceptionBuilder::default();
189 output = crate::protocol_serde::shape_too_many_tags_exception::de_too_many_tags_exception_xml_err(_response_body, output)
190 .map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
191 let output = output.meta(generic);
192 output.build()
193 };
194 if tmp.message.is_none() {
195 tmp.message = _error_message;
196 }
197 tmp
198 }),
199 "TooManyTargetGroups" => crate::operation::create_rule::CreateRuleError::TooManyTargetGroupsException({
200 #[allow(unused_mut)]
201 let mut tmp = {
202 #[allow(unused_mut)]
203 let mut output = crate::types::error::builders::TooManyTargetGroupsExceptionBuilder::default();
204 output = crate::protocol_serde::shape_too_many_target_groups_exception::de_too_many_target_groups_exception_xml_err(
205 _response_body,
206 output,
207 )
208 .map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
209 let output = output.meta(generic);
210 output.build()
211 };
212 if tmp.message.is_none() {
213 tmp.message = _error_message;
214 }
215 tmp
216 }),
217 "TooManyTargets" => crate::operation::create_rule::CreateRuleError::TooManyTargetsException({
218 #[allow(unused_mut)]
219 let mut tmp = {
220 #[allow(unused_mut)]
221 let mut output = crate::types::error::builders::TooManyTargetsExceptionBuilder::default();
222 output = crate::protocol_serde::shape_too_many_targets_exception::de_too_many_targets_exception_xml_err(_response_body, output)
223 .map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
224 let output = output.meta(generic);
225 output.build()
226 };
227 if tmp.message.is_none() {
228 tmp.message = _error_message;
229 }
230 tmp
231 }),
232 "TooManyUniqueTargetGroupsPerLoadBalancer" => {
233 crate::operation::create_rule::CreateRuleError::TooManyUniqueTargetGroupsPerLoadBalancerException({
234 #[allow(unused_mut)]
235 let mut tmp = {
236 #[allow(unused_mut)]
237 let mut output = crate::types::error::builders::TooManyUniqueTargetGroupsPerLoadBalancerExceptionBuilder::default();
238 output = crate::protocol_serde::shape_too_many_unique_target_groups_per_load_balancer_exception::de_too_many_unique_target_groups_per_load_balancer_exception_xml_err(_response_body, output).map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
239 let output = output.meta(generic);
240 output.build()
241 };
242 if tmp.message.is_none() {
243 tmp.message = _error_message;
244 }
245 tmp
246 })
247 }
248 "UnsupportedProtocol" => crate::operation::create_rule::CreateRuleError::UnsupportedProtocolException({
249 #[allow(unused_mut)]
250 let mut tmp = {
251 #[allow(unused_mut)]
252 let mut output = crate::types::error::builders::UnsupportedProtocolExceptionBuilder::default();
253 output =
254 crate::protocol_serde::shape_unsupported_protocol_exception::de_unsupported_protocol_exception_xml_err(_response_body, output)
255 .map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
256 let output = output.meta(generic);
257 output.build()
258 };
259 if tmp.message.is_none() {
260 tmp.message = _error_message;
261 }
262 tmp
263 }),
264 _ => crate::operation::create_rule::CreateRuleError::generic(generic),
265 })
266}
267
268#[allow(clippy::unnecessary_wraps)]
269pub fn de_create_rule_http_response(
270 _response_status: u16,
271 _response_headers: &::aws_smithy_runtime_api::http::Headers,
272 _response_body: &[u8],
273) -> std::result::Result<crate::operation::create_rule::CreateRuleOutput, crate::operation::create_rule::CreateRuleError> {
274 Ok({
275 #[allow(unused_mut)]
276 let mut output = crate::operation::create_rule::builders::CreateRuleOutputBuilder::default();
277 output = crate::protocol_serde::shape_create_rule::de_create_rule(_response_body, output)
278 .map_err(crate::operation::create_rule::CreateRuleError::unhandled)?;
279 output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
280 output.build()
281 })
282}
283
284#[allow(unused_mut)]
285pub fn de_create_rule(
286 inp: &[u8],
287 mut builder: crate::operation::create_rule::builders::CreateRuleOutputBuilder,
288) -> std::result::Result<crate::operation::create_rule::builders::CreateRuleOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
289 let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
290
291 #[allow(unused_mut)]
292 let mut decoder = doc.root_element()?;
293 #[allow(unused_variables)]
294 let start_el = decoder.start_el();
295 if !(start_el.matches("CreateRuleResponse")) {
296 return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
297 "invalid root, expected CreateRuleResponse got {:?}",
298 start_el
299 )));
300 }
301 if let Some(mut result_tag) = decoder.next_tag() {
302 let start_el = result_tag.start_el();
303 if !(start_el.matches("CreateRuleResult")) {
304 return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
305 "invalid result, expected CreateRuleResult got {:?}",
306 start_el
307 )));
308 }
309 while let Some(mut tag) = result_tag.next_tag() {
310 match tag.start_el() {
311 s if s.matches("Rules") => {
312 let var_1 =
313 Some(
314 crate::protocol_serde::shape_rules::de_rules(&mut tag)
315 ?
316 )
317 ;
318 builder = builder.set_rules(var_1);
319 }
320 ,
321 _ => {}
322 }
323 }
324 } else {
325 return Err(::aws_smithy_xml::decode::XmlDecodeError::custom("expected CreateRuleResult tag"));
326 };
327 Ok(builder)
328}