aws_sdk_wafv2/protocol_serde/
shape_statement.rs1pub fn ser_statement(
3 object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
4 input: &crate::types::Statement,
5) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
6 if let Some(var_1) = &input.byte_match_statement {
7 #[allow(unused_mut)]
8 let mut object_2 = object.key("ByteMatchStatement").start_object();
9 crate::protocol_serde::shape_byte_match_statement::ser_byte_match_statement(&mut object_2, var_1)?;
10 object_2.finish();
11 }
12 if let Some(var_3) = &input.sqli_match_statement {
13 #[allow(unused_mut)]
14 let mut object_4 = object.key("SqliMatchStatement").start_object();
15 crate::protocol_serde::shape_sqli_match_statement::ser_sqli_match_statement(&mut object_4, var_3)?;
16 object_4.finish();
17 }
18 if let Some(var_5) = &input.xss_match_statement {
19 #[allow(unused_mut)]
20 let mut object_6 = object.key("XssMatchStatement").start_object();
21 crate::protocol_serde::shape_xss_match_statement::ser_xss_match_statement(&mut object_6, var_5)?;
22 object_6.finish();
23 }
24 if let Some(var_7) = &input.size_constraint_statement {
25 #[allow(unused_mut)]
26 let mut object_8 = object.key("SizeConstraintStatement").start_object();
27 crate::protocol_serde::shape_size_constraint_statement::ser_size_constraint_statement(&mut object_8, var_7)?;
28 object_8.finish();
29 }
30 if let Some(var_9) = &input.geo_match_statement {
31 #[allow(unused_mut)]
32 let mut object_10 = object.key("GeoMatchStatement").start_object();
33 crate::protocol_serde::shape_geo_match_statement::ser_geo_match_statement(&mut object_10, var_9)?;
34 object_10.finish();
35 }
36 if let Some(var_11) = &input.rule_group_reference_statement {
37 #[allow(unused_mut)]
38 let mut object_12 = object.key("RuleGroupReferenceStatement").start_object();
39 crate::protocol_serde::shape_rule_group_reference_statement::ser_rule_group_reference_statement(&mut object_12, var_11)?;
40 object_12.finish();
41 }
42 if let Some(var_13) = &input.ip_set_reference_statement {
43 #[allow(unused_mut)]
44 let mut object_14 = object.key("IPSetReferenceStatement").start_object();
45 crate::protocol_serde::shape_ip_set_reference_statement::ser_ip_set_reference_statement(&mut object_14, var_13)?;
46 object_14.finish();
47 }
48 if let Some(var_15) = &input.regex_pattern_set_reference_statement {
49 #[allow(unused_mut)]
50 let mut object_16 = object.key("RegexPatternSetReferenceStatement").start_object();
51 crate::protocol_serde::shape_regex_pattern_set_reference_statement::ser_regex_pattern_set_reference_statement(&mut object_16, var_15)?;
52 object_16.finish();
53 }
54 if let Some(var_17) = &input.rate_based_statement {
55 #[allow(unused_mut)]
56 let mut object_18 = object.key("RateBasedStatement").start_object();
57 crate::protocol_serde::shape_rate_based_statement::ser_rate_based_statement(&mut object_18, var_17)?;
58 object_18.finish();
59 }
60 if let Some(var_19) = &input.and_statement {
61 #[allow(unused_mut)]
62 let mut object_20 = object.key("AndStatement").start_object();
63 crate::protocol_serde::shape_and_statement::ser_and_statement(&mut object_20, var_19)?;
64 object_20.finish();
65 }
66 if let Some(var_21) = &input.or_statement {
67 #[allow(unused_mut)]
68 let mut object_22 = object.key("OrStatement").start_object();
69 crate::protocol_serde::shape_or_statement::ser_or_statement(&mut object_22, var_21)?;
70 object_22.finish();
71 }
72 if let Some(var_23) = &input.not_statement {
73 #[allow(unused_mut)]
74 let mut object_24 = object.key("NotStatement").start_object();
75 crate::protocol_serde::shape_not_statement::ser_not_statement(&mut object_24, var_23)?;
76 object_24.finish();
77 }
78 if let Some(var_25) = &input.managed_rule_group_statement {
79 #[allow(unused_mut)]
80 let mut object_26 = object.key("ManagedRuleGroupStatement").start_object();
81 crate::protocol_serde::shape_managed_rule_group_statement::ser_managed_rule_group_statement(&mut object_26, var_25)?;
82 object_26.finish();
83 }
84 if let Some(var_27) = &input.label_match_statement {
85 #[allow(unused_mut)]
86 let mut object_28 = object.key("LabelMatchStatement").start_object();
87 crate::protocol_serde::shape_label_match_statement::ser_label_match_statement(&mut object_28, var_27)?;
88 object_28.finish();
89 }
90 if let Some(var_29) = &input.regex_match_statement {
91 #[allow(unused_mut)]
92 let mut object_30 = object.key("RegexMatchStatement").start_object();
93 crate::protocol_serde::shape_regex_match_statement::ser_regex_match_statement(&mut object_30, var_29)?;
94 object_30.finish();
95 }
96 if let Some(var_31) = &input.asn_match_statement {
97 #[allow(unused_mut)]
98 let mut object_32 = object.key("AsnMatchStatement").start_object();
99 crate::protocol_serde::shape_asn_match_statement::ser_asn_match_statement(&mut object_32, var_31)?;
100 object_32.finish();
101 }
102 Ok(())
103}
104
105pub(crate) fn de_statement<'a, I>(
106 tokens: &mut ::std::iter::Peekable<I>,
107) -> ::std::result::Result<Option<crate::types::Statement>, ::aws_smithy_json::deserialize::error::DeserializeError>
108where
109 I: Iterator<Item = Result<::aws_smithy_json::deserialize::Token<'a>, ::aws_smithy_json::deserialize::error::DeserializeError>>,
110{
111 match tokens.next().transpose()? {
112 Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
113 Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
114 #[allow(unused_mut)]
115 let mut builder = crate::types::builders::StatementBuilder::default();
116 loop {
117 match tokens.next().transpose()? {
118 Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
119 Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => match key.to_unescaped()?.as_ref() {
120 "ByteMatchStatement" => {
121 builder =
122 builder.set_byte_match_statement(crate::protocol_serde::shape_byte_match_statement::de_byte_match_statement(tokens)?);
123 }
124 "SqliMatchStatement" => {
125 builder =
126 builder.set_sqli_match_statement(crate::protocol_serde::shape_sqli_match_statement::de_sqli_match_statement(tokens)?);
127 }
128 "XssMatchStatement" => {
129 builder =
130 builder.set_xss_match_statement(crate::protocol_serde::shape_xss_match_statement::de_xss_match_statement(tokens)?);
131 }
132 "SizeConstraintStatement" => {
133 builder = builder.set_size_constraint_statement(
134 crate::protocol_serde::shape_size_constraint_statement::de_size_constraint_statement(tokens)?,
135 );
136 }
137 "GeoMatchStatement" => {
138 builder =
139 builder.set_geo_match_statement(crate::protocol_serde::shape_geo_match_statement::de_geo_match_statement(tokens)?);
140 }
141 "RuleGroupReferenceStatement" => {
142 builder = builder.set_rule_group_reference_statement(
143 crate::protocol_serde::shape_rule_group_reference_statement::de_rule_group_reference_statement(tokens)?,
144 );
145 }
146 "IPSetReferenceStatement" => {
147 builder = builder.set_ip_set_reference_statement(
148 crate::protocol_serde::shape_ip_set_reference_statement::de_ip_set_reference_statement(tokens)?,
149 );
150 }
151 "RegexPatternSetReferenceStatement" => {
152 builder = builder.set_regex_pattern_set_reference_statement(
153 crate::protocol_serde::shape_regex_pattern_set_reference_statement::de_regex_pattern_set_reference_statement(tokens)?,
154 );
155 }
156 "RateBasedStatement" => {
157 builder =
158 builder.set_rate_based_statement(crate::protocol_serde::shape_rate_based_statement::de_rate_based_statement(tokens)?);
159 }
160 "AndStatement" => {
161 builder = builder.set_and_statement(crate::protocol_serde::shape_and_statement::de_and_statement(tokens)?);
162 }
163 "OrStatement" => {
164 builder = builder.set_or_statement(crate::protocol_serde::shape_or_statement::de_or_statement(tokens)?);
165 }
166 "NotStatement" => {
167 builder = builder.set_not_statement(crate::protocol_serde::shape_not_statement::de_not_statement(tokens)?);
168 }
169 "ManagedRuleGroupStatement" => {
170 builder = builder.set_managed_rule_group_statement(
171 crate::protocol_serde::shape_managed_rule_group_statement::de_managed_rule_group_statement(tokens)?,
172 );
173 }
174 "LabelMatchStatement" => {
175 builder = builder
176 .set_label_match_statement(crate::protocol_serde::shape_label_match_statement::de_label_match_statement(tokens)?);
177 }
178 "RegexMatchStatement" => {
179 builder = builder
180 .set_regex_match_statement(crate::protocol_serde::shape_regex_match_statement::de_regex_match_statement(tokens)?);
181 }
182 "AsnMatchStatement" => {
183 builder =
184 builder.set_asn_match_statement(crate::protocol_serde::shape_asn_match_statement::de_asn_match_statement(tokens)?);
185 }
186 _ => ::aws_smithy_json::deserialize::token::skip_value(tokens)?,
187 },
188 other => {
189 return Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
190 "expected object key or end object, found: {:?}",
191 other
192 )))
193 }
194 }
195 }
196 Ok(Some(builder.build()))
197 }
198 _ => Err(::aws_smithy_json::deserialize::error::DeserializeError::custom(
199 "expected start object or null",
200 )),
201 }
202}