AWS SDK for C++

AWS SDK for C++ Version 1.11.932

Loading...
Searching...
No Matches
FieldToMatch.h
1
6#pragma once
7#include <aws/wafv2/WAFV2_EXPORTS.h>
8#include <aws/wafv2/model/AllQueryArguments.h>
9#include <aws/wafv2/model/Body.h>
10#include <aws/wafv2/model/Cookies.h>
11#include <aws/wafv2/model/HeaderOrder.h>
12#include <aws/wafv2/model/Headers.h>
13#include <aws/wafv2/model/JA3Fingerprint.h>
14#include <aws/wafv2/model/JA4Fingerprint.h>
15#include <aws/wafv2/model/JsonBody.h>
16#include <aws/wafv2/model/Method.h>
17#include <aws/wafv2/model/QueryString.h>
18#include <aws/wafv2/model/SingleHeader.h>
19#include <aws/wafv2/model/SingleQueryArgument.h>
20#include <aws/wafv2/model/UriFragment.h>
21#include <aws/wafv2/model/UriPath.h>
22
23#include <utility>
24
25namespace Aws {
26namespace Utils {
27namespace Json {
28class JsonValue;
29class JsonView;
30} // namespace Json
31} // namespace Utils
32namespace WAFV2 {
33namespace Model {
34
65 public:
66 AWS_WAFV2_API FieldToMatch() = default;
67 AWS_WAFV2_API FieldToMatch(Aws::Utils::Json::JsonView jsonValue);
69 AWS_WAFV2_API Aws::Utils::Json::JsonValue Jsonize() const;
70
72
79 inline const SingleHeader& GetSingleHeader() const { return m_singleHeader; }
80 inline bool SingleHeaderHasBeenSet() const { return m_singleHeaderHasBeenSet; }
81 template <typename SingleHeaderT = SingleHeader>
82 void SetSingleHeader(SingleHeaderT&& value) {
83 m_singleHeaderHasBeenSet = true;
84 m_singleHeader = std::forward<SingleHeaderT>(value);
85 }
86 template <typename SingleHeaderT = SingleHeader>
87 FieldToMatch& WithSingleHeader(SingleHeaderT&& value) {
88 SetSingleHeader(std::forward<SingleHeaderT>(value));
89 return *this;
90 }
92
94
100 inline const SingleQueryArgument& GetSingleQueryArgument() const { return m_singleQueryArgument; }
101 inline bool SingleQueryArgumentHasBeenSet() const { return m_singleQueryArgumentHasBeenSet; }
102 template <typename SingleQueryArgumentT = SingleQueryArgument>
103 void SetSingleQueryArgument(SingleQueryArgumentT&& value) {
104 m_singleQueryArgumentHasBeenSet = true;
105 m_singleQueryArgument = std::forward<SingleQueryArgumentT>(value);
106 }
107 template <typename SingleQueryArgumentT = SingleQueryArgument>
108 FieldToMatch& WithSingleQueryArgument(SingleQueryArgumentT&& value) {
109 SetSingleQueryArgument(std::forward<SingleQueryArgumentT>(value));
110 return *this;
111 }
113
115
118 inline const AllQueryArguments& GetAllQueryArguments() const { return m_allQueryArguments; }
119 inline bool AllQueryArgumentsHasBeenSet() const { return m_allQueryArgumentsHasBeenSet; }
120 template <typename AllQueryArgumentsT = AllQueryArguments>
121 void SetAllQueryArguments(AllQueryArgumentsT&& value) {
122 m_allQueryArgumentsHasBeenSet = true;
123 m_allQueryArguments = std::forward<AllQueryArgumentsT>(value);
124 }
125 template <typename AllQueryArgumentsT = AllQueryArguments>
126 FieldToMatch& WithAllQueryArguments(AllQueryArgumentsT&& value) {
127 SetAllQueryArguments(std::forward<AllQueryArgumentsT>(value));
128 return *this;
129 }
131
133
137 inline const UriPath& GetUriPath() const { return m_uriPath; }
138 inline bool UriPathHasBeenSet() const { return m_uriPathHasBeenSet; }
139 template <typename UriPathT = UriPath>
140 void SetUriPath(UriPathT&& value) {
141 m_uriPathHasBeenSet = true;
142 m_uriPath = std::forward<UriPathT>(value);
143 }
144 template <typename UriPathT = UriPath>
145 FieldToMatch& WithUriPath(UriPathT&& value) {
146 SetUriPath(std::forward<UriPathT>(value));
147 return *this;
148 }
150
152
156 inline const QueryString& GetQueryString() const { return m_queryString; }
157 inline bool QueryStringHasBeenSet() const { return m_queryStringHasBeenSet; }
158 template <typename QueryStringT = QueryString>
159 void SetQueryString(QueryStringT&& value) {
160 m_queryStringHasBeenSet = true;
161 m_queryString = std::forward<QueryStringT>(value);
162 }
163 template <typename QueryStringT = QueryString>
164 FieldToMatch& WithQueryString(QueryStringT&& value) {
165 SetQueryString(std::forward<QueryStringT>(value));
166 return *this;
167 }
169
171
188 inline const Body& GetBody() const { return m_body; }
189 inline bool BodyHasBeenSet() const { return m_bodyHasBeenSet; }
190 template <typename BodyT = Body>
191 void SetBody(BodyT&& value) {
192 m_bodyHasBeenSet = true;
193 m_body = std::forward<BodyT>(value);
194 }
195 template <typename BodyT = Body>
196 FieldToMatch& WithBody(BodyT&& value) {
197 SetBody(std::forward<BodyT>(value));
198 return *this;
199 }
201
203
207 inline const Method& GetMethod() const { return m_method; }
208 inline bool MethodHasBeenSet() const { return m_methodHasBeenSet; }
209 template <typename MethodT = Method>
210 void SetMethod(MethodT&& value) {
211 m_methodHasBeenSet = true;
212 m_method = std::forward<MethodT>(value);
213 }
214 template <typename MethodT = Method>
215 FieldToMatch& WithMethod(MethodT&& value) {
216 SetMethod(std::forward<MethodT>(value));
217 return *this;
218 }
220
222
239 inline const JsonBody& GetJsonBody() const { return m_jsonBody; }
240 inline bool JsonBodyHasBeenSet() const { return m_jsonBodyHasBeenSet; }
241 template <typename JsonBodyT = JsonBody>
242 void SetJsonBody(JsonBodyT&& value) {
243 m_jsonBodyHasBeenSet = true;
244 m_jsonBody = std::forward<JsonBodyT>(value);
245 }
246 template <typename JsonBodyT = JsonBody>
247 FieldToMatch& WithJsonBody(JsonBodyT&& value) {
248 SetJsonBody(std::forward<JsonBodyT>(value));
249 return *this;
250 }
252
254
264 inline const Headers& GetHeaders() const { return m_headers; }
265 inline bool HeadersHasBeenSet() const { return m_headersHasBeenSet; }
266 template <typename HeadersT = Headers>
267 void SetHeaders(HeadersT&& value) {
268 m_headersHasBeenSet = true;
269 m_headers = std::forward<HeadersT>(value);
270 }
271 template <typename HeadersT = Headers>
272 FieldToMatch& WithHeaders(HeadersT&& value) {
273 SetHeaders(std::forward<HeadersT>(value));
274 return *this;
275 }
277
279
289 inline const Cookies& GetCookies() const { return m_cookies; }
290 inline bool CookiesHasBeenSet() const { return m_cookiesHasBeenSet; }
291 template <typename CookiesT = Cookies>
292 void SetCookies(CookiesT&& value) {
293 m_cookiesHasBeenSet = true;
294 m_cookies = std::forward<CookiesT>(value);
295 }
296 template <typename CookiesT = Cookies>
297 FieldToMatch& WithCookies(CookiesT&& value) {
298 SetCookies(std::forward<CookiesT>(value));
299 return *this;
300 }
302
304
312 inline const HeaderOrder& GetHeaderOrder() const { return m_headerOrder; }
313 inline bool HeaderOrderHasBeenSet() const { return m_headerOrderHasBeenSet; }
314 template <typename HeaderOrderT = HeaderOrder>
315 void SetHeaderOrder(HeaderOrderT&& value) {
316 m_headerOrderHasBeenSet = true;
317 m_headerOrder = std::forward<HeaderOrderT>(value);
318 }
319 template <typename HeaderOrderT = HeaderOrder>
320 FieldToMatch& WithHeaderOrder(HeaderOrderT&& value) {
321 SetHeaderOrder(std::forward<HeaderOrderT>(value));
322 return *this;
323 }
325
327
348 inline const JA3Fingerprint& GetJA3Fingerprint() const { return m_jA3Fingerprint; }
349 inline bool JA3FingerprintHasBeenSet() const { return m_jA3FingerprintHasBeenSet; }
350 template <typename JA3FingerprintT = JA3Fingerprint>
351 void SetJA3Fingerprint(JA3FingerprintT&& value) {
352 m_jA3FingerprintHasBeenSet = true;
353 m_jA3Fingerprint = std::forward<JA3FingerprintT>(value);
354 }
355 template <typename JA3FingerprintT = JA3Fingerprint>
356 FieldToMatch& WithJA3Fingerprint(JA3FingerprintT&& value) {
357 SetJA3Fingerprint(std::forward<JA3FingerprintT>(value));
358 return *this;
359 }
361
363
384 inline const JA4Fingerprint& GetJA4Fingerprint() const { return m_jA4Fingerprint; }
385 inline bool JA4FingerprintHasBeenSet() const { return m_jA4FingerprintHasBeenSet; }
386 template <typename JA4FingerprintT = JA4Fingerprint>
387 void SetJA4Fingerprint(JA4FingerprintT&& value) {
388 m_jA4FingerprintHasBeenSet = true;
389 m_jA4Fingerprint = std::forward<JA4FingerprintT>(value);
390 }
391 template <typename JA4FingerprintT = JA4Fingerprint>
392 FieldToMatch& WithJA4Fingerprint(JA4FingerprintT&& value) {
393 SetJA4Fingerprint(std::forward<JA4FingerprintT>(value));
394 return *this;
395 }
397
399
409 inline const UriFragment& GetUriFragment() const { return m_uriFragment; }
410 inline bool UriFragmentHasBeenSet() const { return m_uriFragmentHasBeenSet; }
411 template <typename UriFragmentT = UriFragment>
412 void SetUriFragment(UriFragmentT&& value) {
413 m_uriFragmentHasBeenSet = true;
414 m_uriFragment = std::forward<UriFragmentT>(value);
415 }
416 template <typename UriFragmentT = UriFragment>
417 FieldToMatch& WithUriFragment(UriFragmentT&& value) {
418 SetUriFragment(std::forward<UriFragmentT>(value));
419 return *this;
420 }
422 private:
423 SingleHeader m_singleHeader;
424
425 SingleQueryArgument m_singleQueryArgument;
426
427 AllQueryArguments m_allQueryArguments;
428
429 UriPath m_uriPath;
430
431 QueryString m_queryString;
432
433 Body m_body;
434
435 Method m_method;
436
437 JsonBody m_jsonBody;
438
439 Headers m_headers;
440
441 Cookies m_cookies;
442
443 HeaderOrder m_headerOrder;
444
445 JA3Fingerprint m_jA3Fingerprint;
446
447 JA4Fingerprint m_jA4Fingerprint;
448
449 UriFragment m_uriFragment;
450 bool m_singleHeaderHasBeenSet = false;
451 bool m_singleQueryArgumentHasBeenSet = false;
452 bool m_allQueryArgumentsHasBeenSet = false;
453 bool m_uriPathHasBeenSet = false;
454 bool m_queryStringHasBeenSet = false;
455 bool m_bodyHasBeenSet = false;
456 bool m_methodHasBeenSet = false;
457 bool m_jsonBodyHasBeenSet = false;
458 bool m_headersHasBeenSet = false;
459 bool m_cookiesHasBeenSet = false;
460 bool m_headerOrderHasBeenSet = false;
461 bool m_jA3FingerprintHasBeenSet = false;
462 bool m_jA4FingerprintHasBeenSet = false;
463 bool m_uriFragmentHasBeenSet = false;
464};
465
466} // namespace Model
467} // namespace WAFV2
468} // namespace Aws
void SetMethod(MethodT &&value)
const UriFragment & GetUriFragment() const
FieldToMatch & WithSingleQueryArgument(SingleQueryArgumentT &&value)
FieldToMatch & WithMethod(MethodT &&value)
void SetAllQueryArguments(AllQueryArgumentsT &&value)
FieldToMatch & WithBody(BodyT &&value)
const Headers & GetHeaders() const
const JsonBody & GetJsonBody() const
void SetSingleQueryArgument(SingleQueryArgumentT &&value)
FieldToMatch & WithAllQueryArguments(AllQueryArgumentsT &&value)
void SetHeaders(HeadersT &&value)
FieldToMatch & WithQueryString(QueryStringT &&value)
void SetQueryString(QueryStringT &&value)
FieldToMatch & WithSingleHeader(SingleHeaderT &&value)
const SingleHeader & GetSingleHeader() const
const JA3Fingerprint & GetJA3Fingerprint() const
const HeaderOrder & GetHeaderOrder() const
AWS_WAFV2_API FieldToMatch(Aws::Utils::Json::JsonView jsonValue)
FieldToMatch & WithJsonBody(JsonBodyT &&value)
void SetHeaderOrder(HeaderOrderT &&value)
const Method & GetMethod() const
AWS_WAFV2_API Aws::Utils::Json::JsonValue Jsonize() const
void SetJsonBody(JsonBodyT &&value)
const QueryString & GetQueryString() const
void SetCookies(CookiesT &&value)
const Cookies & GetCookies() const
AWS_WAFV2_API FieldToMatch()=default
FieldToMatch & WithJA4Fingerprint(JA4FingerprintT &&value)
FieldToMatch & WithUriPath(UriPathT &&value)
FieldToMatch & WithHeaderOrder(HeaderOrderT &&value)
void SetJA4Fingerprint(JA4FingerprintT &&value)
void SetUriPath(UriPathT &&value)
FieldToMatch & WithHeaders(HeadersT &&value)
const UriPath & GetUriPath() const
const AllQueryArguments & GetAllQueryArguments() const
void SetSingleHeader(SingleHeaderT &&value)
FieldToMatch & WithJA3Fingerprint(JA3FingerprintT &&value)
void SetUriFragment(UriFragmentT &&value)
const SingleQueryArgument & GetSingleQueryArgument() const
FieldToMatch & WithUriFragment(UriFragmentT &&value)
void SetJA3Fingerprint(JA3FingerprintT &&value)
AWS_WAFV2_API FieldToMatch & operator=(Aws::Utils::Json::JsonView jsonValue)
const Body & GetBody() const
const JA4Fingerprint & GetJA4Fingerprint() const
FieldToMatch & WithCookies(CookiesT &&value)
Aws::Utils::Json::JsonValue JsonValue