aws_sdk_elasticloadbalancingv2/protocol_serde/
shape_create_load_balancer.rs1#[allow(clippy::unnecessary_wraps)]
3pub fn de_create_load_balancer_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::create_load_balancer::CreateLoadBalancerOutput,
9 crate::operation::create_load_balancer::CreateLoadBalancerError,
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::create_load_balancer::CreateLoadBalancerError::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::create_load_balancer::CreateLoadBalancerError::unhandled(generic)),
19 };
20
21 let _error_message = generic.message().map(|msg| msg.to_owned());
22 Err(match error_code {
23 "AllocationIdNotFound" => crate::operation::create_load_balancer::CreateLoadBalancerError::AllocationIdNotFoundException({
24 #[allow(unused_mut)]
25 let mut tmp = {
26 #[allow(unused_mut)]
27 let mut output = crate::types::error::builders::AllocationIdNotFoundExceptionBuilder::default();
28 output = crate::protocol_serde::shape_allocation_id_not_found_exception::de_allocation_id_not_found_exception_xml_err(
29 _response_body,
30 output,
31 )
32 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::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 "AvailabilityZoneNotSupported" => crate::operation::create_load_balancer::CreateLoadBalancerError::AvailabilityZoneNotSupportedException({
42 #[allow(unused_mut)]
43 let mut tmp = {
44 #[allow(unused_mut)]
45 let mut output = crate::types::error::builders::AvailabilityZoneNotSupportedExceptionBuilder::default();
46 output =
47 crate::protocol_serde::shape_availability_zone_not_supported_exception::de_availability_zone_not_supported_exception_xml_err(
48 _response_body,
49 output,
50 )
51 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
52 let output = output.meta(generic);
53 output.build()
54 };
55 if tmp.message.is_none() {
56 tmp.message = _error_message;
57 }
58 tmp
59 }),
60 "DuplicateLoadBalancerName" => crate::operation::create_load_balancer::CreateLoadBalancerError::DuplicateLoadBalancerNameException({
61 #[allow(unused_mut)]
62 let mut tmp = {
63 #[allow(unused_mut)]
64 let mut output = crate::types::error::builders::DuplicateLoadBalancerNameExceptionBuilder::default();
65 output = crate::protocol_serde::shape_duplicate_load_balancer_name_exception::de_duplicate_load_balancer_name_exception_xml_err(
66 _response_body,
67 output,
68 )
69 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::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 "DuplicateTagKeys" => crate::operation::create_load_balancer::CreateLoadBalancerError::DuplicateTagKeysException({
79 #[allow(unused_mut)]
80 let mut tmp = {
81 #[allow(unused_mut)]
82 let mut output = crate::types::error::builders::DuplicateTagKeysExceptionBuilder::default();
83 output = crate::protocol_serde::shape_duplicate_tag_keys_exception::de_duplicate_tag_keys_exception_xml_err(_response_body, output)
84 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
85 let output = output.meta(generic);
86 output.build()
87 };
88 if tmp.message.is_none() {
89 tmp.message = _error_message;
90 }
91 tmp
92 }),
93 "InvalidConfigurationRequest" => crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidConfigurationRequestException({
94 #[allow(unused_mut)]
95 let mut tmp = {
96 #[allow(unused_mut)]
97 let mut output = crate::types::error::builders::InvalidConfigurationRequestExceptionBuilder::default();
98 output = crate::protocol_serde::shape_invalid_configuration_request_exception::de_invalid_configuration_request_exception_xml_err(
99 _response_body,
100 output,
101 )
102 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
103 let output = output.meta(generic);
104 output.build()
105 };
106 if tmp.message.is_none() {
107 tmp.message = _error_message;
108 }
109 tmp
110 }),
111 "InvalidScheme" => crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidSchemeException({
112 #[allow(unused_mut)]
113 let mut tmp = {
114 #[allow(unused_mut)]
115 let mut output = crate::types::error::builders::InvalidSchemeExceptionBuilder::default();
116 output = crate::protocol_serde::shape_invalid_scheme_exception::de_invalid_scheme_exception_xml_err(_response_body, output)
117 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
118 let output = output.meta(generic);
119 output.build()
120 };
121 if tmp.message.is_none() {
122 tmp.message = _error_message;
123 }
124 tmp
125 }),
126 "InvalidSecurityGroup" => crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidSecurityGroupException({
127 #[allow(unused_mut)]
128 let mut tmp = {
129 #[allow(unused_mut)]
130 let mut output = crate::types::error::builders::InvalidSecurityGroupExceptionBuilder::default();
131 output = crate::protocol_serde::shape_invalid_security_group_exception::de_invalid_security_group_exception_xml_err(
132 _response_body,
133 output,
134 )
135 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
136 let output = output.meta(generic);
137 output.build()
138 };
139 if tmp.message.is_none() {
140 tmp.message = _error_message;
141 }
142 tmp
143 }),
144 "InvalidSubnet" => crate::operation::create_load_balancer::CreateLoadBalancerError::InvalidSubnetException({
145 #[allow(unused_mut)]
146 let mut tmp = {
147 #[allow(unused_mut)]
148 let mut output = crate::types::error::builders::InvalidSubnetExceptionBuilder::default();
149 output = crate::protocol_serde::shape_invalid_subnet_exception::de_invalid_subnet_exception_xml_err(_response_body, output)
150 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
151 let output = output.meta(generic);
152 output.build()
153 };
154 if tmp.message.is_none() {
155 tmp.message = _error_message;
156 }
157 tmp
158 }),
159 "OperationNotPermitted" => crate::operation::create_load_balancer::CreateLoadBalancerError::OperationNotPermittedException({
160 #[allow(unused_mut)]
161 let mut tmp = {
162 #[allow(unused_mut)]
163 let mut output = crate::types::error::builders::OperationNotPermittedExceptionBuilder::default();
164 output = crate::protocol_serde::shape_operation_not_permitted_exception::de_operation_not_permitted_exception_xml_err(
165 _response_body,
166 output,
167 )
168 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
169 let output = output.meta(generic);
170 output.build()
171 };
172 if tmp.message.is_none() {
173 tmp.message = _error_message;
174 }
175 tmp
176 }),
177 "ResourceInUse" => crate::operation::create_load_balancer::CreateLoadBalancerError::ResourceInUseException({
178 #[allow(unused_mut)]
179 let mut tmp = {
180 #[allow(unused_mut)]
181 let mut output = crate::types::error::builders::ResourceInUseExceptionBuilder::default();
182 output = crate::protocol_serde::shape_resource_in_use_exception::de_resource_in_use_exception_xml_err(_response_body, output)
183 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
184 let output = output.meta(generic);
185 output.build()
186 };
187 if tmp.message.is_none() {
188 tmp.message = _error_message;
189 }
190 tmp
191 }),
192 "SubnetNotFound" => crate::operation::create_load_balancer::CreateLoadBalancerError::SubnetNotFoundException({
193 #[allow(unused_mut)]
194 let mut tmp = {
195 #[allow(unused_mut)]
196 let mut output = crate::types::error::builders::SubnetNotFoundExceptionBuilder::default();
197 output = crate::protocol_serde::shape_subnet_not_found_exception::de_subnet_not_found_exception_xml_err(_response_body, output)
198 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
199 let output = output.meta(generic);
200 output.build()
201 };
202 if tmp.message.is_none() {
203 tmp.message = _error_message;
204 }
205 tmp
206 }),
207 "TooManyLoadBalancers" => crate::operation::create_load_balancer::CreateLoadBalancerError::TooManyLoadBalancersException({
208 #[allow(unused_mut)]
209 let mut tmp = {
210 #[allow(unused_mut)]
211 let mut output = crate::types::error::builders::TooManyLoadBalancersExceptionBuilder::default();
212 output = crate::protocol_serde::shape_too_many_load_balancers_exception::de_too_many_load_balancers_exception_xml_err(
213 _response_body,
214 output,
215 )
216 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
217 let output = output.meta(generic);
218 output.build()
219 };
220 if tmp.message.is_none() {
221 tmp.message = _error_message;
222 }
223 tmp
224 }),
225 "TooManyTags" => crate::operation::create_load_balancer::CreateLoadBalancerError::TooManyTagsException({
226 #[allow(unused_mut)]
227 let mut tmp = {
228 #[allow(unused_mut)]
229 let mut output = crate::types::error::builders::TooManyTagsExceptionBuilder::default();
230 output = crate::protocol_serde::shape_too_many_tags_exception::de_too_many_tags_exception_xml_err(_response_body, output)
231 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
232 let output = output.meta(generic);
233 output.build()
234 };
235 if tmp.message.is_none() {
236 tmp.message = _error_message;
237 }
238 tmp
239 }),
240 _ => crate::operation::create_load_balancer::CreateLoadBalancerError::generic(generic),
241 })
242}
243
244#[allow(clippy::unnecessary_wraps)]
245pub fn de_create_load_balancer_http_response(
246 _response_status: u16,
247 _response_headers: &::aws_smithy_runtime_api::http::Headers,
248 _response_body: &[u8],
249) -> std::result::Result<
250 crate::operation::create_load_balancer::CreateLoadBalancerOutput,
251 crate::operation::create_load_balancer::CreateLoadBalancerError,
252> {
253 Ok({
254 #[allow(unused_mut)]
255 let mut output = crate::operation::create_load_balancer::builders::CreateLoadBalancerOutputBuilder::default();
256 output = crate::protocol_serde::shape_create_load_balancer::de_create_load_balancer(_response_body, output)
257 .map_err(crate::operation::create_load_balancer::CreateLoadBalancerError::unhandled)?;
258 output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
259 output.build()
260 })
261}
262
263#[allow(unused_mut)]
264pub fn de_create_load_balancer(
265 inp: &[u8],
266 mut builder: crate::operation::create_load_balancer::builders::CreateLoadBalancerOutputBuilder,
267) -> std::result::Result<crate::operation::create_load_balancer::builders::CreateLoadBalancerOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError>
268{
269 let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
270
271 #[allow(unused_mut)]
272 let mut decoder = doc.root_element()?;
273 #[allow(unused_variables)]
274 let start_el = decoder.start_el();
275 if !(start_el.matches("CreateLoadBalancerResponse")) {
276 return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
277 "invalid root, expected CreateLoadBalancerResponse got {:?}",
278 start_el
279 )));
280 }
281 if let Some(mut result_tag) = decoder.next_tag() {
282 let start_el = result_tag.start_el();
283 if !(start_el.matches("CreateLoadBalancerResult")) {
284 return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
285 "invalid result, expected CreateLoadBalancerResult got {:?}",
286 start_el
287 )));
288 }
289 while let Some(mut tag) = result_tag.next_tag() {
290 match tag.start_el() {
291 s if s.matches("LoadBalancers") => {
292 let var_1 =
293 Some(
294 crate::protocol_serde::shape_load_balancers::de_load_balancers(&mut tag)
295 ?
296 )
297 ;
298 builder = builder.set_load_balancers(var_1);
299 }
300 ,
301 _ => {}
302 }
303 }
304 } else {
305 return Err(::aws_smithy_xml::decode::XmlDecodeError::custom("expected CreateLoadBalancerResult tag"));
306 };
307 Ok(builder)
308}