aws_sdk_securityhub/protocol_serde/
shape_aws_elb_load_balancer_details.rs1pub fn ser_aws_elb_load_balancer_details(
3 object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
4 input: &crate::types::AwsElbLoadBalancerDetails,
5) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
6 if let Some(var_1) = &input.availability_zones {
7 let mut array_2 = object.key("AvailabilityZones").start_array();
8 for item_3 in var_1 {
9 {
10 array_2.value().string(item_3.as_str());
11 }
12 }
13 array_2.finish();
14 }
15 if let Some(var_4) = &input.backend_server_descriptions {
16 let mut array_5 = object.key("BackendServerDescriptions").start_array();
17 for item_6 in var_4 {
18 {
19 #[allow(unused_mut)]
20 let mut object_7 = array_5.value().start_object();
21 crate::protocol_serde::shape_aws_elb_load_balancer_backend_server_description::ser_aws_elb_load_balancer_backend_server_description(
22 &mut object_7,
23 item_6,
24 )?;
25 object_7.finish();
26 }
27 }
28 array_5.finish();
29 }
30 if let Some(var_8) = &input.canonical_hosted_zone_name {
31 object.key("CanonicalHostedZoneName").string(var_8.as_str());
32 }
33 if let Some(var_9) = &input.canonical_hosted_zone_name_id {
34 object.key("CanonicalHostedZoneNameID").string(var_9.as_str());
35 }
36 if let Some(var_10) = &input.created_time {
37 object.key("CreatedTime").string(var_10.as_str());
38 }
39 if let Some(var_11) = &input.dns_name {
40 object.key("DnsName").string(var_11.as_str());
41 }
42 if let Some(var_12) = &input.health_check {
43 #[allow(unused_mut)]
44 let mut object_13 = object.key("HealthCheck").start_object();
45 crate::protocol_serde::shape_aws_elb_load_balancer_health_check::ser_aws_elb_load_balancer_health_check(&mut object_13, var_12)?;
46 object_13.finish();
47 }
48 if let Some(var_14) = &input.instances {
49 let mut array_15 = object.key("Instances").start_array();
50 for item_16 in var_14 {
51 {
52 #[allow(unused_mut)]
53 let mut object_17 = array_15.value().start_object();
54 crate::protocol_serde::shape_aws_elb_load_balancer_instance::ser_aws_elb_load_balancer_instance(&mut object_17, item_16)?;
55 object_17.finish();
56 }
57 }
58 array_15.finish();
59 }
60 if let Some(var_18) = &input.listener_descriptions {
61 let mut array_19 = object.key("ListenerDescriptions").start_array();
62 for item_20 in var_18 {
63 {
64 #[allow(unused_mut)]
65 let mut object_21 = array_19.value().start_object();
66 crate::protocol_serde::shape_aws_elb_load_balancer_listener_description::ser_aws_elb_load_balancer_listener_description(
67 &mut object_21,
68 item_20,
69 )?;
70 object_21.finish();
71 }
72 }
73 array_19.finish();
74 }
75 if let Some(var_22) = &input.load_balancer_attributes {
76 #[allow(unused_mut)]
77 let mut object_23 = object.key("LoadBalancerAttributes").start_object();
78 crate::protocol_serde::shape_aws_elb_load_balancer_attributes::ser_aws_elb_load_balancer_attributes(&mut object_23, var_22)?;
79 object_23.finish();
80 }
81 if let Some(var_24) = &input.load_balancer_name {
82 object.key("LoadBalancerName").string(var_24.as_str());
83 }
84 if let Some(var_25) = &input.policies {
85 #[allow(unused_mut)]
86 let mut object_26 = object.key("Policies").start_object();
87 crate::protocol_serde::shape_aws_elb_load_balancer_policies::ser_aws_elb_load_balancer_policies(&mut object_26, var_25)?;
88 object_26.finish();
89 }
90 if let Some(var_27) = &input.scheme {
91 object.key("Scheme").string(var_27.as_str());
92 }
93 if let Some(var_28) = &input.security_groups {
94 let mut array_29 = object.key("SecurityGroups").start_array();
95 for item_30 in var_28 {
96 {
97 array_29.value().string(item_30.as_str());
98 }
99 }
100 array_29.finish();
101 }
102 if let Some(var_31) = &input.source_security_group {
103 #[allow(unused_mut)]
104 let mut object_32 = object.key("SourceSecurityGroup").start_object();
105 crate::protocol_serde::shape_aws_elb_load_balancer_source_security_group::ser_aws_elb_load_balancer_source_security_group(
106 &mut object_32,
107 var_31,
108 )?;
109 object_32.finish();
110 }
111 if let Some(var_33) = &input.subnets {
112 let mut array_34 = object.key("Subnets").start_array();
113 for item_35 in var_33 {
114 {
115 array_34.value().string(item_35.as_str());
116 }
117 }
118 array_34.finish();
119 }
120 if let Some(var_36) = &input.vpc_id {
121 object.key("VpcId").string(var_36.as_str());
122 }
123 Ok(())
124}
125
126pub(crate) fn de_aws_elb_load_balancer_details<'a, I>(
127 tokens: &mut ::std::iter::Peekable<I>,
128) -> ::std::result::Result<Option<crate::types::AwsElbLoadBalancerDetails>, ::aws_smithy_json::deserialize::error::DeserializeError>
129where
130 I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
131{
132 match tokens.next().transpose()? {
133 Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
134 Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
135 #[allow(unused_mut)]
136 let mut builder = crate::types::builders::AwsElbLoadBalancerDetailsBuilder::default();
137 loop {
138 match tokens.next().transpose()? {
139 Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
140 Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
141 "AvailabilityZones" => {
142 builder = builder.set_availability_zones(crate::protocol_serde::shape_string_list::de_string_list(tokens)?);
143 }
144 "BackendServerDescriptions" => {
145 builder = builder.set_backend_server_descriptions(
146 crate::protocol_serde::shape_aws_elb_load_balancer_backend_server_descriptions::de_aws_elb_load_balancer_backend_server_descriptions(tokens)?
147 );
148 }
149 "CanonicalHostedZoneName" => {
150 builder = builder.set_canonical_hosted_zone_name(
151 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
152 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
153 .transpose()?,
154 );
155 }
156 "CanonicalHostedZoneNameID" => {
157 builder = builder.set_canonical_hosted_zone_name_id(
158 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
159 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
160 .transpose()?,
161 );
162 }
163 "CreatedTime" => {
164 builder = builder.set_created_time(
165 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
166 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
167 .transpose()?,
168 );
169 }
170 "DnsName" => {
171 builder = builder.set_dns_name(
172 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
173 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
174 .transpose()?,
175 );
176 }
177 "HealthCheck" => {
178 builder = builder.set_health_check(
179 crate::protocol_serde::shape_aws_elb_load_balancer_health_check::de_aws_elb_load_balancer_health_check(tokens)?,
180 );
181 }
182 "Instances" => {
183 builder = builder.set_instances(
184 crate::protocol_serde::shape_aws_elb_load_balancer_instances::de_aws_elb_load_balancer_instances(tokens)?,
185 );
186 }
187 "ListenerDescriptions" => {
188 builder = builder.set_listener_descriptions(
189 crate::protocol_serde::shape_aws_elb_load_balancer_listener_descriptions::de_aws_elb_load_balancer_listener_descriptions(tokens)?
190 );
191 }
192 "LoadBalancerAttributes" => {
193 builder = builder.set_load_balancer_attributes(
194 crate::protocol_serde::shape_aws_elb_load_balancer_attributes::de_aws_elb_load_balancer_attributes(tokens)?,
195 );
196 }
197 "LoadBalancerName" => {
198 builder = builder.set_load_balancer_name(
199 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
200 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
201 .transpose()?,
202 );
203 }
204 "Policies" => {
205 builder = builder.set_policies(
206 crate::protocol_serde::shape_aws_elb_load_balancer_policies::de_aws_elb_load_balancer_policies(tokens)?,
207 );
208 }
209 "Scheme" => {
210 builder = builder.set_scheme(
211 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
212 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
213 .transpose()?,
214 );
215 }
216 "SecurityGroups" => {
217 builder = builder.set_security_groups(crate::protocol_serde::shape_string_list::de_string_list(tokens)?);
218 }
219 "SourceSecurityGroup" => {
220 builder = builder.set_source_security_group(
221 crate::protocol_serde::shape_aws_elb_load_balancer_source_security_group::de_aws_elb_load_balancer_source_security_group(tokens)?
222 );
223 }
224 "Subnets" => {
225 builder = builder.set_subnets(crate::protocol_serde::shape_string_list::de_string_list(tokens)?);
226 }
227 "VpcId" => {
228 builder = builder.set_vpc_id(
229 ::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?
230 .map(|s| s.to_unescaped().map(|u| u.into_owned()))
231 .transpose()?,
232 );
233 }
234 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
235 },
236 other => {
237 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
238 "expected object key or end object, found: {other:?}"
239 )))
240 }
241 }
242 }
243 Ok(Some(builder.build()))
244 }
245 _ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
246 "expected start object or null",
247 )),
248 }
249}