1 /**
2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
3 * SPDX-License-Identifier: Apache-2.0.
4 */
5
6 #include <aws/core/utils/Outcome.h>
7 #include <aws/core/auth/AWSAuthSigner.h>
8 #include <aws/core/client/CoreErrors.h>
9 #include <aws/core/client/RetryStrategy.h>
10 #include <aws/core/http/HttpClient.h>
11 #include <aws/core/http/HttpResponse.h>
12 #include <aws/core/http/HttpClientFactory.h>
13 #include <aws/core/auth/AWSCredentialsProviderChain.h>
14 #include <aws/core/utils/json/JsonSerializer.h>
15 #include <aws/core/utils/memory/stl/AWSStringStream.h>
16 #include <aws/core/utils/threading/Executor.h>
17 #include <aws/core/utils/DNS.h>
18 #include <aws/core/utils/logging/LogMacros.h>
19
20 #include <aws/route53resolver/Route53ResolverClient.h>
21 #include <aws/route53resolver/Route53ResolverEndpoint.h>
22 #include <aws/route53resolver/Route53ResolverErrorMarshaller.h>
23 #include <aws/route53resolver/model/AssociateFirewallRuleGroupRequest.h>
24 #include <aws/route53resolver/model/AssociateResolverEndpointIpAddressRequest.h>
25 #include <aws/route53resolver/model/AssociateResolverQueryLogConfigRequest.h>
26 #include <aws/route53resolver/model/AssociateResolverRuleRequest.h>
27 #include <aws/route53resolver/model/CreateFirewallDomainListRequest.h>
28 #include <aws/route53resolver/model/CreateFirewallRuleRequest.h>
29 #include <aws/route53resolver/model/CreateFirewallRuleGroupRequest.h>
30 #include <aws/route53resolver/model/CreateResolverEndpointRequest.h>
31 #include <aws/route53resolver/model/CreateResolverQueryLogConfigRequest.h>
32 #include <aws/route53resolver/model/CreateResolverRuleRequest.h>
33 #include <aws/route53resolver/model/DeleteFirewallDomainListRequest.h>
34 #include <aws/route53resolver/model/DeleteFirewallRuleRequest.h>
35 #include <aws/route53resolver/model/DeleteFirewallRuleGroupRequest.h>
36 #include <aws/route53resolver/model/DeleteResolverEndpointRequest.h>
37 #include <aws/route53resolver/model/DeleteResolverQueryLogConfigRequest.h>
38 #include <aws/route53resolver/model/DeleteResolverRuleRequest.h>
39 #include <aws/route53resolver/model/DisassociateFirewallRuleGroupRequest.h>
40 #include <aws/route53resolver/model/DisassociateResolverEndpointIpAddressRequest.h>
41 #include <aws/route53resolver/model/DisassociateResolverQueryLogConfigRequest.h>
42 #include <aws/route53resolver/model/DisassociateResolverRuleRequest.h>
43 #include <aws/route53resolver/model/GetFirewallConfigRequest.h>
44 #include <aws/route53resolver/model/GetFirewallDomainListRequest.h>
45 #include <aws/route53resolver/model/GetFirewallRuleGroupRequest.h>
46 #include <aws/route53resolver/model/GetFirewallRuleGroupAssociationRequest.h>
47 #include <aws/route53resolver/model/GetFirewallRuleGroupPolicyRequest.h>
48 #include <aws/route53resolver/model/GetResolverDnssecConfigRequest.h>
49 #include <aws/route53resolver/model/GetResolverEndpointRequest.h>
50 #include <aws/route53resolver/model/GetResolverQueryLogConfigRequest.h>
51 #include <aws/route53resolver/model/GetResolverQueryLogConfigAssociationRequest.h>
52 #include <aws/route53resolver/model/GetResolverQueryLogConfigPolicyRequest.h>
53 #include <aws/route53resolver/model/GetResolverRuleRequest.h>
54 #include <aws/route53resolver/model/GetResolverRuleAssociationRequest.h>
55 #include <aws/route53resolver/model/GetResolverRulePolicyRequest.h>
56 #include <aws/route53resolver/model/ImportFirewallDomainsRequest.h>
57 #include <aws/route53resolver/model/ListFirewallConfigsRequest.h>
58 #include <aws/route53resolver/model/ListFirewallDomainListsRequest.h>
59 #include <aws/route53resolver/model/ListFirewallDomainsRequest.h>
60 #include <aws/route53resolver/model/ListFirewallRuleGroupAssociationsRequest.h>
61 #include <aws/route53resolver/model/ListFirewallRuleGroupsRequest.h>
62 #include <aws/route53resolver/model/ListFirewallRulesRequest.h>
63 #include <aws/route53resolver/model/ListResolverDnssecConfigsRequest.h>
64 #include <aws/route53resolver/model/ListResolverEndpointIpAddressesRequest.h>
65 #include <aws/route53resolver/model/ListResolverEndpointsRequest.h>
66 #include <aws/route53resolver/model/ListResolverQueryLogConfigAssociationsRequest.h>
67 #include <aws/route53resolver/model/ListResolverQueryLogConfigsRequest.h>
68 #include <aws/route53resolver/model/ListResolverRuleAssociationsRequest.h>
69 #include <aws/route53resolver/model/ListResolverRulesRequest.h>
70 #include <aws/route53resolver/model/ListTagsForResourceRequest.h>
71 #include <aws/route53resolver/model/PutFirewallRuleGroupPolicyRequest.h>
72 #include <aws/route53resolver/model/PutResolverQueryLogConfigPolicyRequest.h>
73 #include <aws/route53resolver/model/PutResolverRulePolicyRequest.h>
74 #include <aws/route53resolver/model/TagResourceRequest.h>
75 #include <aws/route53resolver/model/UntagResourceRequest.h>
76 #include <aws/route53resolver/model/UpdateFirewallConfigRequest.h>
77 #include <aws/route53resolver/model/UpdateFirewallDomainsRequest.h>
78 #include <aws/route53resolver/model/UpdateFirewallRuleRequest.h>
79 #include <aws/route53resolver/model/UpdateFirewallRuleGroupAssociationRequest.h>
80 #include <aws/route53resolver/model/UpdateResolverDnssecConfigRequest.h>
81 #include <aws/route53resolver/model/UpdateResolverEndpointRequest.h>
82 #include <aws/route53resolver/model/UpdateResolverRuleRequest.h>
83
84 using namespace Aws;
85 using namespace Aws::Auth;
86 using namespace Aws::Client;
87 using namespace Aws::Route53Resolver;
88 using namespace Aws::Route53Resolver::Model;
89 using namespace Aws::Http;
90 using namespace Aws::Utils::Json;
91
92 static const char* SERVICE_NAME = "route53resolver";
93 static const char* ALLOCATION_TAG = "Route53ResolverClient";
94
95
Route53ResolverClient(const Client::ClientConfiguration & clientConfiguration)96 Route53ResolverClient::Route53ResolverClient(const Client::ClientConfiguration& clientConfiguration) :
97 BASECLASS(clientConfiguration,
98 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
99 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
100 Aws::MakeShared<Route53ResolverErrorMarshaller>(ALLOCATION_TAG)),
101 m_executor(clientConfiguration.executor)
102 {
103 init(clientConfiguration);
104 }
105
Route53ResolverClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)106 Route53ResolverClient::Route53ResolverClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
107 BASECLASS(clientConfiguration,
108 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
109 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
110 Aws::MakeShared<Route53ResolverErrorMarshaller>(ALLOCATION_TAG)),
111 m_executor(clientConfiguration.executor)
112 {
113 init(clientConfiguration);
114 }
115
Route53ResolverClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)116 Route53ResolverClient::Route53ResolverClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
117 const Client::ClientConfiguration& clientConfiguration) :
118 BASECLASS(clientConfiguration,
119 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
120 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
121 Aws::MakeShared<Route53ResolverErrorMarshaller>(ALLOCATION_TAG)),
122 m_executor(clientConfiguration.executor)
123 {
124 init(clientConfiguration);
125 }
126
~Route53ResolverClient()127 Route53ResolverClient::~Route53ResolverClient()
128 {
129 }
130
init(const Client::ClientConfiguration & config)131 void Route53ResolverClient::init(const Client::ClientConfiguration& config)
132 {
133 SetServiceClientName("Route53Resolver");
134 m_configScheme = SchemeMapper::ToString(config.scheme);
135 if (config.endpointOverride.empty())
136 {
137 m_uri = m_configScheme + "://" + Route53ResolverEndpoint::ForRegion(config.region, config.useDualStack);
138 }
139 else
140 {
141 OverrideEndpoint(config.endpointOverride);
142 }
143 }
144
OverrideEndpoint(const Aws::String & endpoint)145 void Route53ResolverClient::OverrideEndpoint(const Aws::String& endpoint)
146 {
147 if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
148 {
149 m_uri = endpoint;
150 }
151 else
152 {
153 m_uri = m_configScheme + "://" + endpoint;
154 }
155 }
156
AssociateFirewallRuleGroup(const AssociateFirewallRuleGroupRequest & request) const157 AssociateFirewallRuleGroupOutcome Route53ResolverClient::AssociateFirewallRuleGroup(const AssociateFirewallRuleGroupRequest& request) const
158 {
159 Aws::Http::URI uri = m_uri;
160 return AssociateFirewallRuleGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
161 }
162
AssociateFirewallRuleGroupCallable(const AssociateFirewallRuleGroupRequest & request) const163 AssociateFirewallRuleGroupOutcomeCallable Route53ResolverClient::AssociateFirewallRuleGroupCallable(const AssociateFirewallRuleGroupRequest& request) const
164 {
165 auto task = Aws::MakeShared< std::packaged_task< AssociateFirewallRuleGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateFirewallRuleGroup(request); } );
166 auto packagedFunction = [task]() { (*task)(); };
167 m_executor->Submit(packagedFunction);
168 return task->get_future();
169 }
170
AssociateFirewallRuleGroupAsync(const AssociateFirewallRuleGroupRequest & request,const AssociateFirewallRuleGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const171 void Route53ResolverClient::AssociateFirewallRuleGroupAsync(const AssociateFirewallRuleGroupRequest& request, const AssociateFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
172 {
173 m_executor->Submit( [this, request, handler, context](){ this->AssociateFirewallRuleGroupAsyncHelper( request, handler, context ); } );
174 }
175
AssociateFirewallRuleGroupAsyncHelper(const AssociateFirewallRuleGroupRequest & request,const AssociateFirewallRuleGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const176 void Route53ResolverClient::AssociateFirewallRuleGroupAsyncHelper(const AssociateFirewallRuleGroupRequest& request, const AssociateFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
177 {
178 handler(this, request, AssociateFirewallRuleGroup(request), context);
179 }
180
AssociateResolverEndpointIpAddress(const AssociateResolverEndpointIpAddressRequest & request) const181 AssociateResolverEndpointIpAddressOutcome Route53ResolverClient::AssociateResolverEndpointIpAddress(const AssociateResolverEndpointIpAddressRequest& request) const
182 {
183 Aws::Http::URI uri = m_uri;
184 return AssociateResolverEndpointIpAddressOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
185 }
186
AssociateResolverEndpointIpAddressCallable(const AssociateResolverEndpointIpAddressRequest & request) const187 AssociateResolverEndpointIpAddressOutcomeCallable Route53ResolverClient::AssociateResolverEndpointIpAddressCallable(const AssociateResolverEndpointIpAddressRequest& request) const
188 {
189 auto task = Aws::MakeShared< std::packaged_task< AssociateResolverEndpointIpAddressOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateResolverEndpointIpAddress(request); } );
190 auto packagedFunction = [task]() { (*task)(); };
191 m_executor->Submit(packagedFunction);
192 return task->get_future();
193 }
194
AssociateResolverEndpointIpAddressAsync(const AssociateResolverEndpointIpAddressRequest & request,const AssociateResolverEndpointIpAddressResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const195 void Route53ResolverClient::AssociateResolverEndpointIpAddressAsync(const AssociateResolverEndpointIpAddressRequest& request, const AssociateResolverEndpointIpAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
196 {
197 m_executor->Submit( [this, request, handler, context](){ this->AssociateResolverEndpointIpAddressAsyncHelper( request, handler, context ); } );
198 }
199
AssociateResolverEndpointIpAddressAsyncHelper(const AssociateResolverEndpointIpAddressRequest & request,const AssociateResolverEndpointIpAddressResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const200 void Route53ResolverClient::AssociateResolverEndpointIpAddressAsyncHelper(const AssociateResolverEndpointIpAddressRequest& request, const AssociateResolverEndpointIpAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
201 {
202 handler(this, request, AssociateResolverEndpointIpAddress(request), context);
203 }
204
AssociateResolverQueryLogConfig(const AssociateResolverQueryLogConfigRequest & request) const205 AssociateResolverQueryLogConfigOutcome Route53ResolverClient::AssociateResolverQueryLogConfig(const AssociateResolverQueryLogConfigRequest& request) const
206 {
207 Aws::Http::URI uri = m_uri;
208 return AssociateResolverQueryLogConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
209 }
210
AssociateResolverQueryLogConfigCallable(const AssociateResolverQueryLogConfigRequest & request) const211 AssociateResolverQueryLogConfigOutcomeCallable Route53ResolverClient::AssociateResolverQueryLogConfigCallable(const AssociateResolverQueryLogConfigRequest& request) const
212 {
213 auto task = Aws::MakeShared< std::packaged_task< AssociateResolverQueryLogConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateResolverQueryLogConfig(request); } );
214 auto packagedFunction = [task]() { (*task)(); };
215 m_executor->Submit(packagedFunction);
216 return task->get_future();
217 }
218
AssociateResolverQueryLogConfigAsync(const AssociateResolverQueryLogConfigRequest & request,const AssociateResolverQueryLogConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const219 void Route53ResolverClient::AssociateResolverQueryLogConfigAsync(const AssociateResolverQueryLogConfigRequest& request, const AssociateResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
220 {
221 m_executor->Submit( [this, request, handler, context](){ this->AssociateResolverQueryLogConfigAsyncHelper( request, handler, context ); } );
222 }
223
AssociateResolverQueryLogConfigAsyncHelper(const AssociateResolverQueryLogConfigRequest & request,const AssociateResolverQueryLogConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const224 void Route53ResolverClient::AssociateResolverQueryLogConfigAsyncHelper(const AssociateResolverQueryLogConfigRequest& request, const AssociateResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
225 {
226 handler(this, request, AssociateResolverQueryLogConfig(request), context);
227 }
228
AssociateResolverRule(const AssociateResolverRuleRequest & request) const229 AssociateResolverRuleOutcome Route53ResolverClient::AssociateResolverRule(const AssociateResolverRuleRequest& request) const
230 {
231 Aws::Http::URI uri = m_uri;
232 return AssociateResolverRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
233 }
234
AssociateResolverRuleCallable(const AssociateResolverRuleRequest & request) const235 AssociateResolverRuleOutcomeCallable Route53ResolverClient::AssociateResolverRuleCallable(const AssociateResolverRuleRequest& request) const
236 {
237 auto task = Aws::MakeShared< std::packaged_task< AssociateResolverRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateResolverRule(request); } );
238 auto packagedFunction = [task]() { (*task)(); };
239 m_executor->Submit(packagedFunction);
240 return task->get_future();
241 }
242
AssociateResolverRuleAsync(const AssociateResolverRuleRequest & request,const AssociateResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const243 void Route53ResolverClient::AssociateResolverRuleAsync(const AssociateResolverRuleRequest& request, const AssociateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
244 {
245 m_executor->Submit( [this, request, handler, context](){ this->AssociateResolverRuleAsyncHelper( request, handler, context ); } );
246 }
247
AssociateResolverRuleAsyncHelper(const AssociateResolverRuleRequest & request,const AssociateResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const248 void Route53ResolverClient::AssociateResolverRuleAsyncHelper(const AssociateResolverRuleRequest& request, const AssociateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
249 {
250 handler(this, request, AssociateResolverRule(request), context);
251 }
252
CreateFirewallDomainList(const CreateFirewallDomainListRequest & request) const253 CreateFirewallDomainListOutcome Route53ResolverClient::CreateFirewallDomainList(const CreateFirewallDomainListRequest& request) const
254 {
255 Aws::Http::URI uri = m_uri;
256 return CreateFirewallDomainListOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
257 }
258
CreateFirewallDomainListCallable(const CreateFirewallDomainListRequest & request) const259 CreateFirewallDomainListOutcomeCallable Route53ResolverClient::CreateFirewallDomainListCallable(const CreateFirewallDomainListRequest& request) const
260 {
261 auto task = Aws::MakeShared< std::packaged_task< CreateFirewallDomainListOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateFirewallDomainList(request); } );
262 auto packagedFunction = [task]() { (*task)(); };
263 m_executor->Submit(packagedFunction);
264 return task->get_future();
265 }
266
CreateFirewallDomainListAsync(const CreateFirewallDomainListRequest & request,const CreateFirewallDomainListResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const267 void Route53ResolverClient::CreateFirewallDomainListAsync(const CreateFirewallDomainListRequest& request, const CreateFirewallDomainListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
268 {
269 m_executor->Submit( [this, request, handler, context](){ this->CreateFirewallDomainListAsyncHelper( request, handler, context ); } );
270 }
271
CreateFirewallDomainListAsyncHelper(const CreateFirewallDomainListRequest & request,const CreateFirewallDomainListResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const272 void Route53ResolverClient::CreateFirewallDomainListAsyncHelper(const CreateFirewallDomainListRequest& request, const CreateFirewallDomainListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
273 {
274 handler(this, request, CreateFirewallDomainList(request), context);
275 }
276
CreateFirewallRule(const CreateFirewallRuleRequest & request) const277 CreateFirewallRuleOutcome Route53ResolverClient::CreateFirewallRule(const CreateFirewallRuleRequest& request) const
278 {
279 Aws::Http::URI uri = m_uri;
280 return CreateFirewallRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
281 }
282
CreateFirewallRuleCallable(const CreateFirewallRuleRequest & request) const283 CreateFirewallRuleOutcomeCallable Route53ResolverClient::CreateFirewallRuleCallable(const CreateFirewallRuleRequest& request) const
284 {
285 auto task = Aws::MakeShared< std::packaged_task< CreateFirewallRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateFirewallRule(request); } );
286 auto packagedFunction = [task]() { (*task)(); };
287 m_executor->Submit(packagedFunction);
288 return task->get_future();
289 }
290
CreateFirewallRuleAsync(const CreateFirewallRuleRequest & request,const CreateFirewallRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const291 void Route53ResolverClient::CreateFirewallRuleAsync(const CreateFirewallRuleRequest& request, const CreateFirewallRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
292 {
293 m_executor->Submit( [this, request, handler, context](){ this->CreateFirewallRuleAsyncHelper( request, handler, context ); } );
294 }
295
CreateFirewallRuleAsyncHelper(const CreateFirewallRuleRequest & request,const CreateFirewallRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const296 void Route53ResolverClient::CreateFirewallRuleAsyncHelper(const CreateFirewallRuleRequest& request, const CreateFirewallRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
297 {
298 handler(this, request, CreateFirewallRule(request), context);
299 }
300
CreateFirewallRuleGroup(const CreateFirewallRuleGroupRequest & request) const301 CreateFirewallRuleGroupOutcome Route53ResolverClient::CreateFirewallRuleGroup(const CreateFirewallRuleGroupRequest& request) const
302 {
303 Aws::Http::URI uri = m_uri;
304 return CreateFirewallRuleGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
305 }
306
CreateFirewallRuleGroupCallable(const CreateFirewallRuleGroupRequest & request) const307 CreateFirewallRuleGroupOutcomeCallable Route53ResolverClient::CreateFirewallRuleGroupCallable(const CreateFirewallRuleGroupRequest& request) const
308 {
309 auto task = Aws::MakeShared< std::packaged_task< CreateFirewallRuleGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateFirewallRuleGroup(request); } );
310 auto packagedFunction = [task]() { (*task)(); };
311 m_executor->Submit(packagedFunction);
312 return task->get_future();
313 }
314
CreateFirewallRuleGroupAsync(const CreateFirewallRuleGroupRequest & request,const CreateFirewallRuleGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const315 void Route53ResolverClient::CreateFirewallRuleGroupAsync(const CreateFirewallRuleGroupRequest& request, const CreateFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
316 {
317 m_executor->Submit( [this, request, handler, context](){ this->CreateFirewallRuleGroupAsyncHelper( request, handler, context ); } );
318 }
319
CreateFirewallRuleGroupAsyncHelper(const CreateFirewallRuleGroupRequest & request,const CreateFirewallRuleGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const320 void Route53ResolverClient::CreateFirewallRuleGroupAsyncHelper(const CreateFirewallRuleGroupRequest& request, const CreateFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
321 {
322 handler(this, request, CreateFirewallRuleGroup(request), context);
323 }
324
CreateResolverEndpoint(const CreateResolverEndpointRequest & request) const325 CreateResolverEndpointOutcome Route53ResolverClient::CreateResolverEndpoint(const CreateResolverEndpointRequest& request) const
326 {
327 Aws::Http::URI uri = m_uri;
328 return CreateResolverEndpointOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
329 }
330
CreateResolverEndpointCallable(const CreateResolverEndpointRequest & request) const331 CreateResolverEndpointOutcomeCallable Route53ResolverClient::CreateResolverEndpointCallable(const CreateResolverEndpointRequest& request) const
332 {
333 auto task = Aws::MakeShared< std::packaged_task< CreateResolverEndpointOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateResolverEndpoint(request); } );
334 auto packagedFunction = [task]() { (*task)(); };
335 m_executor->Submit(packagedFunction);
336 return task->get_future();
337 }
338
CreateResolverEndpointAsync(const CreateResolverEndpointRequest & request,const CreateResolverEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const339 void Route53ResolverClient::CreateResolverEndpointAsync(const CreateResolverEndpointRequest& request, const CreateResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
340 {
341 m_executor->Submit( [this, request, handler, context](){ this->CreateResolverEndpointAsyncHelper( request, handler, context ); } );
342 }
343
CreateResolverEndpointAsyncHelper(const CreateResolverEndpointRequest & request,const CreateResolverEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const344 void Route53ResolverClient::CreateResolverEndpointAsyncHelper(const CreateResolverEndpointRequest& request, const CreateResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
345 {
346 handler(this, request, CreateResolverEndpoint(request), context);
347 }
348
CreateResolverQueryLogConfig(const CreateResolverQueryLogConfigRequest & request) const349 CreateResolverQueryLogConfigOutcome Route53ResolverClient::CreateResolverQueryLogConfig(const CreateResolverQueryLogConfigRequest& request) const
350 {
351 Aws::Http::URI uri = m_uri;
352 return CreateResolverQueryLogConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
353 }
354
CreateResolverQueryLogConfigCallable(const CreateResolverQueryLogConfigRequest & request) const355 CreateResolverQueryLogConfigOutcomeCallable Route53ResolverClient::CreateResolverQueryLogConfigCallable(const CreateResolverQueryLogConfigRequest& request) const
356 {
357 auto task = Aws::MakeShared< std::packaged_task< CreateResolverQueryLogConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateResolverQueryLogConfig(request); } );
358 auto packagedFunction = [task]() { (*task)(); };
359 m_executor->Submit(packagedFunction);
360 return task->get_future();
361 }
362
CreateResolverQueryLogConfigAsync(const CreateResolverQueryLogConfigRequest & request,const CreateResolverQueryLogConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const363 void Route53ResolverClient::CreateResolverQueryLogConfigAsync(const CreateResolverQueryLogConfigRequest& request, const CreateResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
364 {
365 m_executor->Submit( [this, request, handler, context](){ this->CreateResolverQueryLogConfigAsyncHelper( request, handler, context ); } );
366 }
367
CreateResolverQueryLogConfigAsyncHelper(const CreateResolverQueryLogConfigRequest & request,const CreateResolverQueryLogConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const368 void Route53ResolverClient::CreateResolverQueryLogConfigAsyncHelper(const CreateResolverQueryLogConfigRequest& request, const CreateResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
369 {
370 handler(this, request, CreateResolverQueryLogConfig(request), context);
371 }
372
CreateResolverRule(const CreateResolverRuleRequest & request) const373 CreateResolverRuleOutcome Route53ResolverClient::CreateResolverRule(const CreateResolverRuleRequest& request) const
374 {
375 Aws::Http::URI uri = m_uri;
376 return CreateResolverRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
377 }
378
CreateResolverRuleCallable(const CreateResolverRuleRequest & request) const379 CreateResolverRuleOutcomeCallable Route53ResolverClient::CreateResolverRuleCallable(const CreateResolverRuleRequest& request) const
380 {
381 auto task = Aws::MakeShared< std::packaged_task< CreateResolverRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateResolverRule(request); } );
382 auto packagedFunction = [task]() { (*task)(); };
383 m_executor->Submit(packagedFunction);
384 return task->get_future();
385 }
386
CreateResolverRuleAsync(const CreateResolverRuleRequest & request,const CreateResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const387 void Route53ResolverClient::CreateResolverRuleAsync(const CreateResolverRuleRequest& request, const CreateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
388 {
389 m_executor->Submit( [this, request, handler, context](){ this->CreateResolverRuleAsyncHelper( request, handler, context ); } );
390 }
391
CreateResolverRuleAsyncHelper(const CreateResolverRuleRequest & request,const CreateResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const392 void Route53ResolverClient::CreateResolverRuleAsyncHelper(const CreateResolverRuleRequest& request, const CreateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
393 {
394 handler(this, request, CreateResolverRule(request), context);
395 }
396
DeleteFirewallDomainList(const DeleteFirewallDomainListRequest & request) const397 DeleteFirewallDomainListOutcome Route53ResolverClient::DeleteFirewallDomainList(const DeleteFirewallDomainListRequest& request) const
398 {
399 Aws::Http::URI uri = m_uri;
400 return DeleteFirewallDomainListOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
401 }
402
DeleteFirewallDomainListCallable(const DeleteFirewallDomainListRequest & request) const403 DeleteFirewallDomainListOutcomeCallable Route53ResolverClient::DeleteFirewallDomainListCallable(const DeleteFirewallDomainListRequest& request) const
404 {
405 auto task = Aws::MakeShared< std::packaged_task< DeleteFirewallDomainListOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteFirewallDomainList(request); } );
406 auto packagedFunction = [task]() { (*task)(); };
407 m_executor->Submit(packagedFunction);
408 return task->get_future();
409 }
410
DeleteFirewallDomainListAsync(const DeleteFirewallDomainListRequest & request,const DeleteFirewallDomainListResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const411 void Route53ResolverClient::DeleteFirewallDomainListAsync(const DeleteFirewallDomainListRequest& request, const DeleteFirewallDomainListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
412 {
413 m_executor->Submit( [this, request, handler, context](){ this->DeleteFirewallDomainListAsyncHelper( request, handler, context ); } );
414 }
415
DeleteFirewallDomainListAsyncHelper(const DeleteFirewallDomainListRequest & request,const DeleteFirewallDomainListResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const416 void Route53ResolverClient::DeleteFirewallDomainListAsyncHelper(const DeleteFirewallDomainListRequest& request, const DeleteFirewallDomainListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
417 {
418 handler(this, request, DeleteFirewallDomainList(request), context);
419 }
420
DeleteFirewallRule(const DeleteFirewallRuleRequest & request) const421 DeleteFirewallRuleOutcome Route53ResolverClient::DeleteFirewallRule(const DeleteFirewallRuleRequest& request) const
422 {
423 Aws::Http::URI uri = m_uri;
424 return DeleteFirewallRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
425 }
426
DeleteFirewallRuleCallable(const DeleteFirewallRuleRequest & request) const427 DeleteFirewallRuleOutcomeCallable Route53ResolverClient::DeleteFirewallRuleCallable(const DeleteFirewallRuleRequest& request) const
428 {
429 auto task = Aws::MakeShared< std::packaged_task< DeleteFirewallRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteFirewallRule(request); } );
430 auto packagedFunction = [task]() { (*task)(); };
431 m_executor->Submit(packagedFunction);
432 return task->get_future();
433 }
434
DeleteFirewallRuleAsync(const DeleteFirewallRuleRequest & request,const DeleteFirewallRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const435 void Route53ResolverClient::DeleteFirewallRuleAsync(const DeleteFirewallRuleRequest& request, const DeleteFirewallRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
436 {
437 m_executor->Submit( [this, request, handler, context](){ this->DeleteFirewallRuleAsyncHelper( request, handler, context ); } );
438 }
439
DeleteFirewallRuleAsyncHelper(const DeleteFirewallRuleRequest & request,const DeleteFirewallRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const440 void Route53ResolverClient::DeleteFirewallRuleAsyncHelper(const DeleteFirewallRuleRequest& request, const DeleteFirewallRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
441 {
442 handler(this, request, DeleteFirewallRule(request), context);
443 }
444
DeleteFirewallRuleGroup(const DeleteFirewallRuleGroupRequest & request) const445 DeleteFirewallRuleGroupOutcome Route53ResolverClient::DeleteFirewallRuleGroup(const DeleteFirewallRuleGroupRequest& request) const
446 {
447 Aws::Http::URI uri = m_uri;
448 return DeleteFirewallRuleGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
449 }
450
DeleteFirewallRuleGroupCallable(const DeleteFirewallRuleGroupRequest & request) const451 DeleteFirewallRuleGroupOutcomeCallable Route53ResolverClient::DeleteFirewallRuleGroupCallable(const DeleteFirewallRuleGroupRequest& request) const
452 {
453 auto task = Aws::MakeShared< std::packaged_task< DeleteFirewallRuleGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteFirewallRuleGroup(request); } );
454 auto packagedFunction = [task]() { (*task)(); };
455 m_executor->Submit(packagedFunction);
456 return task->get_future();
457 }
458
DeleteFirewallRuleGroupAsync(const DeleteFirewallRuleGroupRequest & request,const DeleteFirewallRuleGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const459 void Route53ResolverClient::DeleteFirewallRuleGroupAsync(const DeleteFirewallRuleGroupRequest& request, const DeleteFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
460 {
461 m_executor->Submit( [this, request, handler, context](){ this->DeleteFirewallRuleGroupAsyncHelper( request, handler, context ); } );
462 }
463
DeleteFirewallRuleGroupAsyncHelper(const DeleteFirewallRuleGroupRequest & request,const DeleteFirewallRuleGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const464 void Route53ResolverClient::DeleteFirewallRuleGroupAsyncHelper(const DeleteFirewallRuleGroupRequest& request, const DeleteFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
465 {
466 handler(this, request, DeleteFirewallRuleGroup(request), context);
467 }
468
DeleteResolverEndpoint(const DeleteResolverEndpointRequest & request) const469 DeleteResolverEndpointOutcome Route53ResolverClient::DeleteResolverEndpoint(const DeleteResolverEndpointRequest& request) const
470 {
471 Aws::Http::URI uri = m_uri;
472 return DeleteResolverEndpointOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
473 }
474
DeleteResolverEndpointCallable(const DeleteResolverEndpointRequest & request) const475 DeleteResolverEndpointOutcomeCallable Route53ResolverClient::DeleteResolverEndpointCallable(const DeleteResolverEndpointRequest& request) const
476 {
477 auto task = Aws::MakeShared< std::packaged_task< DeleteResolverEndpointOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteResolverEndpoint(request); } );
478 auto packagedFunction = [task]() { (*task)(); };
479 m_executor->Submit(packagedFunction);
480 return task->get_future();
481 }
482
DeleteResolverEndpointAsync(const DeleteResolverEndpointRequest & request,const DeleteResolverEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const483 void Route53ResolverClient::DeleteResolverEndpointAsync(const DeleteResolverEndpointRequest& request, const DeleteResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
484 {
485 m_executor->Submit( [this, request, handler, context](){ this->DeleteResolverEndpointAsyncHelper( request, handler, context ); } );
486 }
487
DeleteResolverEndpointAsyncHelper(const DeleteResolverEndpointRequest & request,const DeleteResolverEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const488 void Route53ResolverClient::DeleteResolverEndpointAsyncHelper(const DeleteResolverEndpointRequest& request, const DeleteResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
489 {
490 handler(this, request, DeleteResolverEndpoint(request), context);
491 }
492
DeleteResolverQueryLogConfig(const DeleteResolverQueryLogConfigRequest & request) const493 DeleteResolverQueryLogConfigOutcome Route53ResolverClient::DeleteResolverQueryLogConfig(const DeleteResolverQueryLogConfigRequest& request) const
494 {
495 Aws::Http::URI uri = m_uri;
496 return DeleteResolverQueryLogConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
497 }
498
DeleteResolverQueryLogConfigCallable(const DeleteResolverQueryLogConfigRequest & request) const499 DeleteResolverQueryLogConfigOutcomeCallable Route53ResolverClient::DeleteResolverQueryLogConfigCallable(const DeleteResolverQueryLogConfigRequest& request) const
500 {
501 auto task = Aws::MakeShared< std::packaged_task< DeleteResolverQueryLogConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteResolverQueryLogConfig(request); } );
502 auto packagedFunction = [task]() { (*task)(); };
503 m_executor->Submit(packagedFunction);
504 return task->get_future();
505 }
506
DeleteResolverQueryLogConfigAsync(const DeleteResolverQueryLogConfigRequest & request,const DeleteResolverQueryLogConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const507 void Route53ResolverClient::DeleteResolverQueryLogConfigAsync(const DeleteResolverQueryLogConfigRequest& request, const DeleteResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
508 {
509 m_executor->Submit( [this, request, handler, context](){ this->DeleteResolverQueryLogConfigAsyncHelper( request, handler, context ); } );
510 }
511
DeleteResolverQueryLogConfigAsyncHelper(const DeleteResolverQueryLogConfigRequest & request,const DeleteResolverQueryLogConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const512 void Route53ResolverClient::DeleteResolverQueryLogConfigAsyncHelper(const DeleteResolverQueryLogConfigRequest& request, const DeleteResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
513 {
514 handler(this, request, DeleteResolverQueryLogConfig(request), context);
515 }
516
DeleteResolverRule(const DeleteResolverRuleRequest & request) const517 DeleteResolverRuleOutcome Route53ResolverClient::DeleteResolverRule(const DeleteResolverRuleRequest& request) const
518 {
519 Aws::Http::URI uri = m_uri;
520 return DeleteResolverRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
521 }
522
DeleteResolverRuleCallable(const DeleteResolverRuleRequest & request) const523 DeleteResolverRuleOutcomeCallable Route53ResolverClient::DeleteResolverRuleCallable(const DeleteResolverRuleRequest& request) const
524 {
525 auto task = Aws::MakeShared< std::packaged_task< DeleteResolverRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteResolverRule(request); } );
526 auto packagedFunction = [task]() { (*task)(); };
527 m_executor->Submit(packagedFunction);
528 return task->get_future();
529 }
530
DeleteResolverRuleAsync(const DeleteResolverRuleRequest & request,const DeleteResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const531 void Route53ResolverClient::DeleteResolverRuleAsync(const DeleteResolverRuleRequest& request, const DeleteResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
532 {
533 m_executor->Submit( [this, request, handler, context](){ this->DeleteResolverRuleAsyncHelper( request, handler, context ); } );
534 }
535
DeleteResolverRuleAsyncHelper(const DeleteResolverRuleRequest & request,const DeleteResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const536 void Route53ResolverClient::DeleteResolverRuleAsyncHelper(const DeleteResolverRuleRequest& request, const DeleteResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
537 {
538 handler(this, request, DeleteResolverRule(request), context);
539 }
540
DisassociateFirewallRuleGroup(const DisassociateFirewallRuleGroupRequest & request) const541 DisassociateFirewallRuleGroupOutcome Route53ResolverClient::DisassociateFirewallRuleGroup(const DisassociateFirewallRuleGroupRequest& request) const
542 {
543 Aws::Http::URI uri = m_uri;
544 return DisassociateFirewallRuleGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
545 }
546
DisassociateFirewallRuleGroupCallable(const DisassociateFirewallRuleGroupRequest & request) const547 DisassociateFirewallRuleGroupOutcomeCallable Route53ResolverClient::DisassociateFirewallRuleGroupCallable(const DisassociateFirewallRuleGroupRequest& request) const
548 {
549 auto task = Aws::MakeShared< std::packaged_task< DisassociateFirewallRuleGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateFirewallRuleGroup(request); } );
550 auto packagedFunction = [task]() { (*task)(); };
551 m_executor->Submit(packagedFunction);
552 return task->get_future();
553 }
554
DisassociateFirewallRuleGroupAsync(const DisassociateFirewallRuleGroupRequest & request,const DisassociateFirewallRuleGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const555 void Route53ResolverClient::DisassociateFirewallRuleGroupAsync(const DisassociateFirewallRuleGroupRequest& request, const DisassociateFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
556 {
557 m_executor->Submit( [this, request, handler, context](){ this->DisassociateFirewallRuleGroupAsyncHelper( request, handler, context ); } );
558 }
559
DisassociateFirewallRuleGroupAsyncHelper(const DisassociateFirewallRuleGroupRequest & request,const DisassociateFirewallRuleGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const560 void Route53ResolverClient::DisassociateFirewallRuleGroupAsyncHelper(const DisassociateFirewallRuleGroupRequest& request, const DisassociateFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
561 {
562 handler(this, request, DisassociateFirewallRuleGroup(request), context);
563 }
564
DisassociateResolverEndpointIpAddress(const DisassociateResolverEndpointIpAddressRequest & request) const565 DisassociateResolverEndpointIpAddressOutcome Route53ResolverClient::DisassociateResolverEndpointIpAddress(const DisassociateResolverEndpointIpAddressRequest& request) const
566 {
567 Aws::Http::URI uri = m_uri;
568 return DisassociateResolverEndpointIpAddressOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
569 }
570
DisassociateResolverEndpointIpAddressCallable(const DisassociateResolverEndpointIpAddressRequest & request) const571 DisassociateResolverEndpointIpAddressOutcomeCallable Route53ResolverClient::DisassociateResolverEndpointIpAddressCallable(const DisassociateResolverEndpointIpAddressRequest& request) const
572 {
573 auto task = Aws::MakeShared< std::packaged_task< DisassociateResolverEndpointIpAddressOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateResolverEndpointIpAddress(request); } );
574 auto packagedFunction = [task]() { (*task)(); };
575 m_executor->Submit(packagedFunction);
576 return task->get_future();
577 }
578
DisassociateResolverEndpointIpAddressAsync(const DisassociateResolverEndpointIpAddressRequest & request,const DisassociateResolverEndpointIpAddressResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const579 void Route53ResolverClient::DisassociateResolverEndpointIpAddressAsync(const DisassociateResolverEndpointIpAddressRequest& request, const DisassociateResolverEndpointIpAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
580 {
581 m_executor->Submit( [this, request, handler, context](){ this->DisassociateResolverEndpointIpAddressAsyncHelper( request, handler, context ); } );
582 }
583
DisassociateResolverEndpointIpAddressAsyncHelper(const DisassociateResolverEndpointIpAddressRequest & request,const DisassociateResolverEndpointIpAddressResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const584 void Route53ResolverClient::DisassociateResolverEndpointIpAddressAsyncHelper(const DisassociateResolverEndpointIpAddressRequest& request, const DisassociateResolverEndpointIpAddressResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
585 {
586 handler(this, request, DisassociateResolverEndpointIpAddress(request), context);
587 }
588
DisassociateResolverQueryLogConfig(const DisassociateResolverQueryLogConfigRequest & request) const589 DisassociateResolverQueryLogConfigOutcome Route53ResolverClient::DisassociateResolverQueryLogConfig(const DisassociateResolverQueryLogConfigRequest& request) const
590 {
591 Aws::Http::URI uri = m_uri;
592 return DisassociateResolverQueryLogConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
593 }
594
DisassociateResolverQueryLogConfigCallable(const DisassociateResolverQueryLogConfigRequest & request) const595 DisassociateResolverQueryLogConfigOutcomeCallable Route53ResolverClient::DisassociateResolverQueryLogConfigCallable(const DisassociateResolverQueryLogConfigRequest& request) const
596 {
597 auto task = Aws::MakeShared< std::packaged_task< DisassociateResolverQueryLogConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateResolverQueryLogConfig(request); } );
598 auto packagedFunction = [task]() { (*task)(); };
599 m_executor->Submit(packagedFunction);
600 return task->get_future();
601 }
602
DisassociateResolverQueryLogConfigAsync(const DisassociateResolverQueryLogConfigRequest & request,const DisassociateResolverQueryLogConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const603 void Route53ResolverClient::DisassociateResolverQueryLogConfigAsync(const DisassociateResolverQueryLogConfigRequest& request, const DisassociateResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
604 {
605 m_executor->Submit( [this, request, handler, context](){ this->DisassociateResolverQueryLogConfigAsyncHelper( request, handler, context ); } );
606 }
607
DisassociateResolverQueryLogConfigAsyncHelper(const DisassociateResolverQueryLogConfigRequest & request,const DisassociateResolverQueryLogConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const608 void Route53ResolverClient::DisassociateResolverQueryLogConfigAsyncHelper(const DisassociateResolverQueryLogConfigRequest& request, const DisassociateResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
609 {
610 handler(this, request, DisassociateResolverQueryLogConfig(request), context);
611 }
612
DisassociateResolverRule(const DisassociateResolverRuleRequest & request) const613 DisassociateResolverRuleOutcome Route53ResolverClient::DisassociateResolverRule(const DisassociateResolverRuleRequest& request) const
614 {
615 Aws::Http::URI uri = m_uri;
616 return DisassociateResolverRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
617 }
618
DisassociateResolverRuleCallable(const DisassociateResolverRuleRequest & request) const619 DisassociateResolverRuleOutcomeCallable Route53ResolverClient::DisassociateResolverRuleCallable(const DisassociateResolverRuleRequest& request) const
620 {
621 auto task = Aws::MakeShared< std::packaged_task< DisassociateResolverRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateResolverRule(request); } );
622 auto packagedFunction = [task]() { (*task)(); };
623 m_executor->Submit(packagedFunction);
624 return task->get_future();
625 }
626
DisassociateResolverRuleAsync(const DisassociateResolverRuleRequest & request,const DisassociateResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const627 void Route53ResolverClient::DisassociateResolverRuleAsync(const DisassociateResolverRuleRequest& request, const DisassociateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
628 {
629 m_executor->Submit( [this, request, handler, context](){ this->DisassociateResolverRuleAsyncHelper( request, handler, context ); } );
630 }
631
DisassociateResolverRuleAsyncHelper(const DisassociateResolverRuleRequest & request,const DisassociateResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const632 void Route53ResolverClient::DisassociateResolverRuleAsyncHelper(const DisassociateResolverRuleRequest& request, const DisassociateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
633 {
634 handler(this, request, DisassociateResolverRule(request), context);
635 }
636
GetFirewallConfig(const GetFirewallConfigRequest & request) const637 GetFirewallConfigOutcome Route53ResolverClient::GetFirewallConfig(const GetFirewallConfigRequest& request) const
638 {
639 Aws::Http::URI uri = m_uri;
640 return GetFirewallConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
641 }
642
GetFirewallConfigCallable(const GetFirewallConfigRequest & request) const643 GetFirewallConfigOutcomeCallable Route53ResolverClient::GetFirewallConfigCallable(const GetFirewallConfigRequest& request) const
644 {
645 auto task = Aws::MakeShared< std::packaged_task< GetFirewallConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFirewallConfig(request); } );
646 auto packagedFunction = [task]() { (*task)(); };
647 m_executor->Submit(packagedFunction);
648 return task->get_future();
649 }
650
GetFirewallConfigAsync(const GetFirewallConfigRequest & request,const GetFirewallConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const651 void Route53ResolverClient::GetFirewallConfigAsync(const GetFirewallConfigRequest& request, const GetFirewallConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
652 {
653 m_executor->Submit( [this, request, handler, context](){ this->GetFirewallConfigAsyncHelper( request, handler, context ); } );
654 }
655
GetFirewallConfigAsyncHelper(const GetFirewallConfigRequest & request,const GetFirewallConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const656 void Route53ResolverClient::GetFirewallConfigAsyncHelper(const GetFirewallConfigRequest& request, const GetFirewallConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
657 {
658 handler(this, request, GetFirewallConfig(request), context);
659 }
660
GetFirewallDomainList(const GetFirewallDomainListRequest & request) const661 GetFirewallDomainListOutcome Route53ResolverClient::GetFirewallDomainList(const GetFirewallDomainListRequest& request) const
662 {
663 Aws::Http::URI uri = m_uri;
664 return GetFirewallDomainListOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
665 }
666
GetFirewallDomainListCallable(const GetFirewallDomainListRequest & request) const667 GetFirewallDomainListOutcomeCallable Route53ResolverClient::GetFirewallDomainListCallable(const GetFirewallDomainListRequest& request) const
668 {
669 auto task = Aws::MakeShared< std::packaged_task< GetFirewallDomainListOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFirewallDomainList(request); } );
670 auto packagedFunction = [task]() { (*task)(); };
671 m_executor->Submit(packagedFunction);
672 return task->get_future();
673 }
674
GetFirewallDomainListAsync(const GetFirewallDomainListRequest & request,const GetFirewallDomainListResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const675 void Route53ResolverClient::GetFirewallDomainListAsync(const GetFirewallDomainListRequest& request, const GetFirewallDomainListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
676 {
677 m_executor->Submit( [this, request, handler, context](){ this->GetFirewallDomainListAsyncHelper( request, handler, context ); } );
678 }
679
GetFirewallDomainListAsyncHelper(const GetFirewallDomainListRequest & request,const GetFirewallDomainListResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const680 void Route53ResolverClient::GetFirewallDomainListAsyncHelper(const GetFirewallDomainListRequest& request, const GetFirewallDomainListResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
681 {
682 handler(this, request, GetFirewallDomainList(request), context);
683 }
684
GetFirewallRuleGroup(const GetFirewallRuleGroupRequest & request) const685 GetFirewallRuleGroupOutcome Route53ResolverClient::GetFirewallRuleGroup(const GetFirewallRuleGroupRequest& request) const
686 {
687 Aws::Http::URI uri = m_uri;
688 return GetFirewallRuleGroupOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
689 }
690
GetFirewallRuleGroupCallable(const GetFirewallRuleGroupRequest & request) const691 GetFirewallRuleGroupOutcomeCallable Route53ResolverClient::GetFirewallRuleGroupCallable(const GetFirewallRuleGroupRequest& request) const
692 {
693 auto task = Aws::MakeShared< std::packaged_task< GetFirewallRuleGroupOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFirewallRuleGroup(request); } );
694 auto packagedFunction = [task]() { (*task)(); };
695 m_executor->Submit(packagedFunction);
696 return task->get_future();
697 }
698
GetFirewallRuleGroupAsync(const GetFirewallRuleGroupRequest & request,const GetFirewallRuleGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const699 void Route53ResolverClient::GetFirewallRuleGroupAsync(const GetFirewallRuleGroupRequest& request, const GetFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
700 {
701 m_executor->Submit( [this, request, handler, context](){ this->GetFirewallRuleGroupAsyncHelper( request, handler, context ); } );
702 }
703
GetFirewallRuleGroupAsyncHelper(const GetFirewallRuleGroupRequest & request,const GetFirewallRuleGroupResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const704 void Route53ResolverClient::GetFirewallRuleGroupAsyncHelper(const GetFirewallRuleGroupRequest& request, const GetFirewallRuleGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
705 {
706 handler(this, request, GetFirewallRuleGroup(request), context);
707 }
708
GetFirewallRuleGroupAssociation(const GetFirewallRuleGroupAssociationRequest & request) const709 GetFirewallRuleGroupAssociationOutcome Route53ResolverClient::GetFirewallRuleGroupAssociation(const GetFirewallRuleGroupAssociationRequest& request) const
710 {
711 Aws::Http::URI uri = m_uri;
712 return GetFirewallRuleGroupAssociationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
713 }
714
GetFirewallRuleGroupAssociationCallable(const GetFirewallRuleGroupAssociationRequest & request) const715 GetFirewallRuleGroupAssociationOutcomeCallable Route53ResolverClient::GetFirewallRuleGroupAssociationCallable(const GetFirewallRuleGroupAssociationRequest& request) const
716 {
717 auto task = Aws::MakeShared< std::packaged_task< GetFirewallRuleGroupAssociationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFirewallRuleGroupAssociation(request); } );
718 auto packagedFunction = [task]() { (*task)(); };
719 m_executor->Submit(packagedFunction);
720 return task->get_future();
721 }
722
GetFirewallRuleGroupAssociationAsync(const GetFirewallRuleGroupAssociationRequest & request,const GetFirewallRuleGroupAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const723 void Route53ResolverClient::GetFirewallRuleGroupAssociationAsync(const GetFirewallRuleGroupAssociationRequest& request, const GetFirewallRuleGroupAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
724 {
725 m_executor->Submit( [this, request, handler, context](){ this->GetFirewallRuleGroupAssociationAsyncHelper( request, handler, context ); } );
726 }
727
GetFirewallRuleGroupAssociationAsyncHelper(const GetFirewallRuleGroupAssociationRequest & request,const GetFirewallRuleGroupAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const728 void Route53ResolverClient::GetFirewallRuleGroupAssociationAsyncHelper(const GetFirewallRuleGroupAssociationRequest& request, const GetFirewallRuleGroupAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
729 {
730 handler(this, request, GetFirewallRuleGroupAssociation(request), context);
731 }
732
GetFirewallRuleGroupPolicy(const GetFirewallRuleGroupPolicyRequest & request) const733 GetFirewallRuleGroupPolicyOutcome Route53ResolverClient::GetFirewallRuleGroupPolicy(const GetFirewallRuleGroupPolicyRequest& request) const
734 {
735 Aws::Http::URI uri = m_uri;
736 return GetFirewallRuleGroupPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
737 }
738
GetFirewallRuleGroupPolicyCallable(const GetFirewallRuleGroupPolicyRequest & request) const739 GetFirewallRuleGroupPolicyOutcomeCallable Route53ResolverClient::GetFirewallRuleGroupPolicyCallable(const GetFirewallRuleGroupPolicyRequest& request) const
740 {
741 auto task = Aws::MakeShared< std::packaged_task< GetFirewallRuleGroupPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFirewallRuleGroupPolicy(request); } );
742 auto packagedFunction = [task]() { (*task)(); };
743 m_executor->Submit(packagedFunction);
744 return task->get_future();
745 }
746
GetFirewallRuleGroupPolicyAsync(const GetFirewallRuleGroupPolicyRequest & request,const GetFirewallRuleGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const747 void Route53ResolverClient::GetFirewallRuleGroupPolicyAsync(const GetFirewallRuleGroupPolicyRequest& request, const GetFirewallRuleGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
748 {
749 m_executor->Submit( [this, request, handler, context](){ this->GetFirewallRuleGroupPolicyAsyncHelper( request, handler, context ); } );
750 }
751
GetFirewallRuleGroupPolicyAsyncHelper(const GetFirewallRuleGroupPolicyRequest & request,const GetFirewallRuleGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const752 void Route53ResolverClient::GetFirewallRuleGroupPolicyAsyncHelper(const GetFirewallRuleGroupPolicyRequest& request, const GetFirewallRuleGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
753 {
754 handler(this, request, GetFirewallRuleGroupPolicy(request), context);
755 }
756
GetResolverDnssecConfig(const GetResolverDnssecConfigRequest & request) const757 GetResolverDnssecConfigOutcome Route53ResolverClient::GetResolverDnssecConfig(const GetResolverDnssecConfigRequest& request) const
758 {
759 Aws::Http::URI uri = m_uri;
760 return GetResolverDnssecConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
761 }
762
GetResolverDnssecConfigCallable(const GetResolverDnssecConfigRequest & request) const763 GetResolverDnssecConfigOutcomeCallable Route53ResolverClient::GetResolverDnssecConfigCallable(const GetResolverDnssecConfigRequest& request) const
764 {
765 auto task = Aws::MakeShared< std::packaged_task< GetResolverDnssecConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetResolverDnssecConfig(request); } );
766 auto packagedFunction = [task]() { (*task)(); };
767 m_executor->Submit(packagedFunction);
768 return task->get_future();
769 }
770
GetResolverDnssecConfigAsync(const GetResolverDnssecConfigRequest & request,const GetResolverDnssecConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const771 void Route53ResolverClient::GetResolverDnssecConfigAsync(const GetResolverDnssecConfigRequest& request, const GetResolverDnssecConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
772 {
773 m_executor->Submit( [this, request, handler, context](){ this->GetResolverDnssecConfigAsyncHelper( request, handler, context ); } );
774 }
775
GetResolverDnssecConfigAsyncHelper(const GetResolverDnssecConfigRequest & request,const GetResolverDnssecConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const776 void Route53ResolverClient::GetResolverDnssecConfigAsyncHelper(const GetResolverDnssecConfigRequest& request, const GetResolverDnssecConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
777 {
778 handler(this, request, GetResolverDnssecConfig(request), context);
779 }
780
GetResolverEndpoint(const GetResolverEndpointRequest & request) const781 GetResolverEndpointOutcome Route53ResolverClient::GetResolverEndpoint(const GetResolverEndpointRequest& request) const
782 {
783 Aws::Http::URI uri = m_uri;
784 return GetResolverEndpointOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
785 }
786
GetResolverEndpointCallable(const GetResolverEndpointRequest & request) const787 GetResolverEndpointOutcomeCallable Route53ResolverClient::GetResolverEndpointCallable(const GetResolverEndpointRequest& request) const
788 {
789 auto task = Aws::MakeShared< std::packaged_task< GetResolverEndpointOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetResolverEndpoint(request); } );
790 auto packagedFunction = [task]() { (*task)(); };
791 m_executor->Submit(packagedFunction);
792 return task->get_future();
793 }
794
GetResolverEndpointAsync(const GetResolverEndpointRequest & request,const GetResolverEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const795 void Route53ResolverClient::GetResolverEndpointAsync(const GetResolverEndpointRequest& request, const GetResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
796 {
797 m_executor->Submit( [this, request, handler, context](){ this->GetResolverEndpointAsyncHelper( request, handler, context ); } );
798 }
799
GetResolverEndpointAsyncHelper(const GetResolverEndpointRequest & request,const GetResolverEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const800 void Route53ResolverClient::GetResolverEndpointAsyncHelper(const GetResolverEndpointRequest& request, const GetResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
801 {
802 handler(this, request, GetResolverEndpoint(request), context);
803 }
804
GetResolverQueryLogConfig(const GetResolverQueryLogConfigRequest & request) const805 GetResolverQueryLogConfigOutcome Route53ResolverClient::GetResolverQueryLogConfig(const GetResolverQueryLogConfigRequest& request) const
806 {
807 Aws::Http::URI uri = m_uri;
808 return GetResolverQueryLogConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
809 }
810
GetResolverQueryLogConfigCallable(const GetResolverQueryLogConfigRequest & request) const811 GetResolverQueryLogConfigOutcomeCallable Route53ResolverClient::GetResolverQueryLogConfigCallable(const GetResolverQueryLogConfigRequest& request) const
812 {
813 auto task = Aws::MakeShared< std::packaged_task< GetResolverQueryLogConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetResolverQueryLogConfig(request); } );
814 auto packagedFunction = [task]() { (*task)(); };
815 m_executor->Submit(packagedFunction);
816 return task->get_future();
817 }
818
GetResolverQueryLogConfigAsync(const GetResolverQueryLogConfigRequest & request,const GetResolverQueryLogConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const819 void Route53ResolverClient::GetResolverQueryLogConfigAsync(const GetResolverQueryLogConfigRequest& request, const GetResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
820 {
821 m_executor->Submit( [this, request, handler, context](){ this->GetResolverQueryLogConfigAsyncHelper( request, handler, context ); } );
822 }
823
GetResolverQueryLogConfigAsyncHelper(const GetResolverQueryLogConfigRequest & request,const GetResolverQueryLogConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const824 void Route53ResolverClient::GetResolverQueryLogConfigAsyncHelper(const GetResolverQueryLogConfigRequest& request, const GetResolverQueryLogConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
825 {
826 handler(this, request, GetResolverQueryLogConfig(request), context);
827 }
828
GetResolverQueryLogConfigAssociation(const GetResolverQueryLogConfigAssociationRequest & request) const829 GetResolverQueryLogConfigAssociationOutcome Route53ResolverClient::GetResolverQueryLogConfigAssociation(const GetResolverQueryLogConfigAssociationRequest& request) const
830 {
831 Aws::Http::URI uri = m_uri;
832 return GetResolverQueryLogConfigAssociationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
833 }
834
GetResolverQueryLogConfigAssociationCallable(const GetResolverQueryLogConfigAssociationRequest & request) const835 GetResolverQueryLogConfigAssociationOutcomeCallable Route53ResolverClient::GetResolverQueryLogConfigAssociationCallable(const GetResolverQueryLogConfigAssociationRequest& request) const
836 {
837 auto task = Aws::MakeShared< std::packaged_task< GetResolverQueryLogConfigAssociationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetResolverQueryLogConfigAssociation(request); } );
838 auto packagedFunction = [task]() { (*task)(); };
839 m_executor->Submit(packagedFunction);
840 return task->get_future();
841 }
842
GetResolverQueryLogConfigAssociationAsync(const GetResolverQueryLogConfigAssociationRequest & request,const GetResolverQueryLogConfigAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const843 void Route53ResolverClient::GetResolverQueryLogConfigAssociationAsync(const GetResolverQueryLogConfigAssociationRequest& request, const GetResolverQueryLogConfigAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
844 {
845 m_executor->Submit( [this, request, handler, context](){ this->GetResolverQueryLogConfigAssociationAsyncHelper( request, handler, context ); } );
846 }
847
GetResolverQueryLogConfigAssociationAsyncHelper(const GetResolverQueryLogConfigAssociationRequest & request,const GetResolverQueryLogConfigAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const848 void Route53ResolverClient::GetResolverQueryLogConfigAssociationAsyncHelper(const GetResolverQueryLogConfigAssociationRequest& request, const GetResolverQueryLogConfigAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
849 {
850 handler(this, request, GetResolverQueryLogConfigAssociation(request), context);
851 }
852
GetResolverQueryLogConfigPolicy(const GetResolverQueryLogConfigPolicyRequest & request) const853 GetResolverQueryLogConfigPolicyOutcome Route53ResolverClient::GetResolverQueryLogConfigPolicy(const GetResolverQueryLogConfigPolicyRequest& request) const
854 {
855 Aws::Http::URI uri = m_uri;
856 return GetResolverQueryLogConfigPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
857 }
858
GetResolverQueryLogConfigPolicyCallable(const GetResolverQueryLogConfigPolicyRequest & request) const859 GetResolverQueryLogConfigPolicyOutcomeCallable Route53ResolverClient::GetResolverQueryLogConfigPolicyCallable(const GetResolverQueryLogConfigPolicyRequest& request) const
860 {
861 auto task = Aws::MakeShared< std::packaged_task< GetResolverQueryLogConfigPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetResolverQueryLogConfigPolicy(request); } );
862 auto packagedFunction = [task]() { (*task)(); };
863 m_executor->Submit(packagedFunction);
864 return task->get_future();
865 }
866
GetResolverQueryLogConfigPolicyAsync(const GetResolverQueryLogConfigPolicyRequest & request,const GetResolverQueryLogConfigPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const867 void Route53ResolverClient::GetResolverQueryLogConfigPolicyAsync(const GetResolverQueryLogConfigPolicyRequest& request, const GetResolverQueryLogConfigPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
868 {
869 m_executor->Submit( [this, request, handler, context](){ this->GetResolverQueryLogConfigPolicyAsyncHelper( request, handler, context ); } );
870 }
871
GetResolverQueryLogConfigPolicyAsyncHelper(const GetResolverQueryLogConfigPolicyRequest & request,const GetResolverQueryLogConfigPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const872 void Route53ResolverClient::GetResolverQueryLogConfigPolicyAsyncHelper(const GetResolverQueryLogConfigPolicyRequest& request, const GetResolverQueryLogConfigPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
873 {
874 handler(this, request, GetResolverQueryLogConfigPolicy(request), context);
875 }
876
GetResolverRule(const GetResolverRuleRequest & request) const877 GetResolverRuleOutcome Route53ResolverClient::GetResolverRule(const GetResolverRuleRequest& request) const
878 {
879 Aws::Http::URI uri = m_uri;
880 return GetResolverRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
881 }
882
GetResolverRuleCallable(const GetResolverRuleRequest & request) const883 GetResolverRuleOutcomeCallable Route53ResolverClient::GetResolverRuleCallable(const GetResolverRuleRequest& request) const
884 {
885 auto task = Aws::MakeShared< std::packaged_task< GetResolverRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetResolverRule(request); } );
886 auto packagedFunction = [task]() { (*task)(); };
887 m_executor->Submit(packagedFunction);
888 return task->get_future();
889 }
890
GetResolverRuleAsync(const GetResolverRuleRequest & request,const GetResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const891 void Route53ResolverClient::GetResolverRuleAsync(const GetResolverRuleRequest& request, const GetResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
892 {
893 m_executor->Submit( [this, request, handler, context](){ this->GetResolverRuleAsyncHelper( request, handler, context ); } );
894 }
895
GetResolverRuleAsyncHelper(const GetResolverRuleRequest & request,const GetResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const896 void Route53ResolverClient::GetResolverRuleAsyncHelper(const GetResolverRuleRequest& request, const GetResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
897 {
898 handler(this, request, GetResolverRule(request), context);
899 }
900
GetResolverRuleAssociation(const GetResolverRuleAssociationRequest & request) const901 GetResolverRuleAssociationOutcome Route53ResolverClient::GetResolverRuleAssociation(const GetResolverRuleAssociationRequest& request) const
902 {
903 Aws::Http::URI uri = m_uri;
904 return GetResolverRuleAssociationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
905 }
906
GetResolverRuleAssociationCallable(const GetResolverRuleAssociationRequest & request) const907 GetResolverRuleAssociationOutcomeCallable Route53ResolverClient::GetResolverRuleAssociationCallable(const GetResolverRuleAssociationRequest& request) const
908 {
909 auto task = Aws::MakeShared< std::packaged_task< GetResolverRuleAssociationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetResolverRuleAssociation(request); } );
910 auto packagedFunction = [task]() { (*task)(); };
911 m_executor->Submit(packagedFunction);
912 return task->get_future();
913 }
914
GetResolverRuleAssociationAsync(const GetResolverRuleAssociationRequest & request,const GetResolverRuleAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const915 void Route53ResolverClient::GetResolverRuleAssociationAsync(const GetResolverRuleAssociationRequest& request, const GetResolverRuleAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
916 {
917 m_executor->Submit( [this, request, handler, context](){ this->GetResolverRuleAssociationAsyncHelper( request, handler, context ); } );
918 }
919
GetResolverRuleAssociationAsyncHelper(const GetResolverRuleAssociationRequest & request,const GetResolverRuleAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const920 void Route53ResolverClient::GetResolverRuleAssociationAsyncHelper(const GetResolverRuleAssociationRequest& request, const GetResolverRuleAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
921 {
922 handler(this, request, GetResolverRuleAssociation(request), context);
923 }
924
GetResolverRulePolicy(const GetResolverRulePolicyRequest & request) const925 GetResolverRulePolicyOutcome Route53ResolverClient::GetResolverRulePolicy(const GetResolverRulePolicyRequest& request) const
926 {
927 Aws::Http::URI uri = m_uri;
928 return GetResolverRulePolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
929 }
930
GetResolverRulePolicyCallable(const GetResolverRulePolicyRequest & request) const931 GetResolverRulePolicyOutcomeCallable Route53ResolverClient::GetResolverRulePolicyCallable(const GetResolverRulePolicyRequest& request) const
932 {
933 auto task = Aws::MakeShared< std::packaged_task< GetResolverRulePolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetResolverRulePolicy(request); } );
934 auto packagedFunction = [task]() { (*task)(); };
935 m_executor->Submit(packagedFunction);
936 return task->get_future();
937 }
938
GetResolverRulePolicyAsync(const GetResolverRulePolicyRequest & request,const GetResolverRulePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const939 void Route53ResolverClient::GetResolverRulePolicyAsync(const GetResolverRulePolicyRequest& request, const GetResolverRulePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
940 {
941 m_executor->Submit( [this, request, handler, context](){ this->GetResolverRulePolicyAsyncHelper( request, handler, context ); } );
942 }
943
GetResolverRulePolicyAsyncHelper(const GetResolverRulePolicyRequest & request,const GetResolverRulePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const944 void Route53ResolverClient::GetResolverRulePolicyAsyncHelper(const GetResolverRulePolicyRequest& request, const GetResolverRulePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
945 {
946 handler(this, request, GetResolverRulePolicy(request), context);
947 }
948
ImportFirewallDomains(const ImportFirewallDomainsRequest & request) const949 ImportFirewallDomainsOutcome Route53ResolverClient::ImportFirewallDomains(const ImportFirewallDomainsRequest& request) const
950 {
951 Aws::Http::URI uri = m_uri;
952 return ImportFirewallDomainsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
953 }
954
ImportFirewallDomainsCallable(const ImportFirewallDomainsRequest & request) const955 ImportFirewallDomainsOutcomeCallable Route53ResolverClient::ImportFirewallDomainsCallable(const ImportFirewallDomainsRequest& request) const
956 {
957 auto task = Aws::MakeShared< std::packaged_task< ImportFirewallDomainsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ImportFirewallDomains(request); } );
958 auto packagedFunction = [task]() { (*task)(); };
959 m_executor->Submit(packagedFunction);
960 return task->get_future();
961 }
962
ImportFirewallDomainsAsync(const ImportFirewallDomainsRequest & request,const ImportFirewallDomainsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const963 void Route53ResolverClient::ImportFirewallDomainsAsync(const ImportFirewallDomainsRequest& request, const ImportFirewallDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
964 {
965 m_executor->Submit( [this, request, handler, context](){ this->ImportFirewallDomainsAsyncHelper( request, handler, context ); } );
966 }
967
ImportFirewallDomainsAsyncHelper(const ImportFirewallDomainsRequest & request,const ImportFirewallDomainsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const968 void Route53ResolverClient::ImportFirewallDomainsAsyncHelper(const ImportFirewallDomainsRequest& request, const ImportFirewallDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
969 {
970 handler(this, request, ImportFirewallDomains(request), context);
971 }
972
ListFirewallConfigs(const ListFirewallConfigsRequest & request) const973 ListFirewallConfigsOutcome Route53ResolverClient::ListFirewallConfigs(const ListFirewallConfigsRequest& request) const
974 {
975 Aws::Http::URI uri = m_uri;
976 return ListFirewallConfigsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
977 }
978
ListFirewallConfigsCallable(const ListFirewallConfigsRequest & request) const979 ListFirewallConfigsOutcomeCallable Route53ResolverClient::ListFirewallConfigsCallable(const ListFirewallConfigsRequest& request) const
980 {
981 auto task = Aws::MakeShared< std::packaged_task< ListFirewallConfigsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListFirewallConfigs(request); } );
982 auto packagedFunction = [task]() { (*task)(); };
983 m_executor->Submit(packagedFunction);
984 return task->get_future();
985 }
986
ListFirewallConfigsAsync(const ListFirewallConfigsRequest & request,const ListFirewallConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const987 void Route53ResolverClient::ListFirewallConfigsAsync(const ListFirewallConfigsRequest& request, const ListFirewallConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
988 {
989 m_executor->Submit( [this, request, handler, context](){ this->ListFirewallConfigsAsyncHelper( request, handler, context ); } );
990 }
991
ListFirewallConfigsAsyncHelper(const ListFirewallConfigsRequest & request,const ListFirewallConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const992 void Route53ResolverClient::ListFirewallConfigsAsyncHelper(const ListFirewallConfigsRequest& request, const ListFirewallConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
993 {
994 handler(this, request, ListFirewallConfigs(request), context);
995 }
996
ListFirewallDomainLists(const ListFirewallDomainListsRequest & request) const997 ListFirewallDomainListsOutcome Route53ResolverClient::ListFirewallDomainLists(const ListFirewallDomainListsRequest& request) const
998 {
999 Aws::Http::URI uri = m_uri;
1000 return ListFirewallDomainListsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1001 }
1002
ListFirewallDomainListsCallable(const ListFirewallDomainListsRequest & request) const1003 ListFirewallDomainListsOutcomeCallable Route53ResolverClient::ListFirewallDomainListsCallable(const ListFirewallDomainListsRequest& request) const
1004 {
1005 auto task = Aws::MakeShared< std::packaged_task< ListFirewallDomainListsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListFirewallDomainLists(request); } );
1006 auto packagedFunction = [task]() { (*task)(); };
1007 m_executor->Submit(packagedFunction);
1008 return task->get_future();
1009 }
1010
ListFirewallDomainListsAsync(const ListFirewallDomainListsRequest & request,const ListFirewallDomainListsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1011 void Route53ResolverClient::ListFirewallDomainListsAsync(const ListFirewallDomainListsRequest& request, const ListFirewallDomainListsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1012 {
1013 m_executor->Submit( [this, request, handler, context](){ this->ListFirewallDomainListsAsyncHelper( request, handler, context ); } );
1014 }
1015
ListFirewallDomainListsAsyncHelper(const ListFirewallDomainListsRequest & request,const ListFirewallDomainListsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1016 void Route53ResolverClient::ListFirewallDomainListsAsyncHelper(const ListFirewallDomainListsRequest& request, const ListFirewallDomainListsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1017 {
1018 handler(this, request, ListFirewallDomainLists(request), context);
1019 }
1020
ListFirewallDomains(const ListFirewallDomainsRequest & request) const1021 ListFirewallDomainsOutcome Route53ResolverClient::ListFirewallDomains(const ListFirewallDomainsRequest& request) const
1022 {
1023 Aws::Http::URI uri = m_uri;
1024 return ListFirewallDomainsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1025 }
1026
ListFirewallDomainsCallable(const ListFirewallDomainsRequest & request) const1027 ListFirewallDomainsOutcomeCallable Route53ResolverClient::ListFirewallDomainsCallable(const ListFirewallDomainsRequest& request) const
1028 {
1029 auto task = Aws::MakeShared< std::packaged_task< ListFirewallDomainsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListFirewallDomains(request); } );
1030 auto packagedFunction = [task]() { (*task)(); };
1031 m_executor->Submit(packagedFunction);
1032 return task->get_future();
1033 }
1034
ListFirewallDomainsAsync(const ListFirewallDomainsRequest & request,const ListFirewallDomainsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1035 void Route53ResolverClient::ListFirewallDomainsAsync(const ListFirewallDomainsRequest& request, const ListFirewallDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1036 {
1037 m_executor->Submit( [this, request, handler, context](){ this->ListFirewallDomainsAsyncHelper( request, handler, context ); } );
1038 }
1039
ListFirewallDomainsAsyncHelper(const ListFirewallDomainsRequest & request,const ListFirewallDomainsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1040 void Route53ResolverClient::ListFirewallDomainsAsyncHelper(const ListFirewallDomainsRequest& request, const ListFirewallDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1041 {
1042 handler(this, request, ListFirewallDomains(request), context);
1043 }
1044
ListFirewallRuleGroupAssociations(const ListFirewallRuleGroupAssociationsRequest & request) const1045 ListFirewallRuleGroupAssociationsOutcome Route53ResolverClient::ListFirewallRuleGroupAssociations(const ListFirewallRuleGroupAssociationsRequest& request) const
1046 {
1047 Aws::Http::URI uri = m_uri;
1048 return ListFirewallRuleGroupAssociationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1049 }
1050
ListFirewallRuleGroupAssociationsCallable(const ListFirewallRuleGroupAssociationsRequest & request) const1051 ListFirewallRuleGroupAssociationsOutcomeCallable Route53ResolverClient::ListFirewallRuleGroupAssociationsCallable(const ListFirewallRuleGroupAssociationsRequest& request) const
1052 {
1053 auto task = Aws::MakeShared< std::packaged_task< ListFirewallRuleGroupAssociationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListFirewallRuleGroupAssociations(request); } );
1054 auto packagedFunction = [task]() { (*task)(); };
1055 m_executor->Submit(packagedFunction);
1056 return task->get_future();
1057 }
1058
ListFirewallRuleGroupAssociationsAsync(const ListFirewallRuleGroupAssociationsRequest & request,const ListFirewallRuleGroupAssociationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1059 void Route53ResolverClient::ListFirewallRuleGroupAssociationsAsync(const ListFirewallRuleGroupAssociationsRequest& request, const ListFirewallRuleGroupAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1060 {
1061 m_executor->Submit( [this, request, handler, context](){ this->ListFirewallRuleGroupAssociationsAsyncHelper( request, handler, context ); } );
1062 }
1063
ListFirewallRuleGroupAssociationsAsyncHelper(const ListFirewallRuleGroupAssociationsRequest & request,const ListFirewallRuleGroupAssociationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1064 void Route53ResolverClient::ListFirewallRuleGroupAssociationsAsyncHelper(const ListFirewallRuleGroupAssociationsRequest& request, const ListFirewallRuleGroupAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1065 {
1066 handler(this, request, ListFirewallRuleGroupAssociations(request), context);
1067 }
1068
ListFirewallRuleGroups(const ListFirewallRuleGroupsRequest & request) const1069 ListFirewallRuleGroupsOutcome Route53ResolverClient::ListFirewallRuleGroups(const ListFirewallRuleGroupsRequest& request) const
1070 {
1071 Aws::Http::URI uri = m_uri;
1072 return ListFirewallRuleGroupsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1073 }
1074
ListFirewallRuleGroupsCallable(const ListFirewallRuleGroupsRequest & request) const1075 ListFirewallRuleGroupsOutcomeCallable Route53ResolverClient::ListFirewallRuleGroupsCallable(const ListFirewallRuleGroupsRequest& request) const
1076 {
1077 auto task = Aws::MakeShared< std::packaged_task< ListFirewallRuleGroupsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListFirewallRuleGroups(request); } );
1078 auto packagedFunction = [task]() { (*task)(); };
1079 m_executor->Submit(packagedFunction);
1080 return task->get_future();
1081 }
1082
ListFirewallRuleGroupsAsync(const ListFirewallRuleGroupsRequest & request,const ListFirewallRuleGroupsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1083 void Route53ResolverClient::ListFirewallRuleGroupsAsync(const ListFirewallRuleGroupsRequest& request, const ListFirewallRuleGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1084 {
1085 m_executor->Submit( [this, request, handler, context](){ this->ListFirewallRuleGroupsAsyncHelper( request, handler, context ); } );
1086 }
1087
ListFirewallRuleGroupsAsyncHelper(const ListFirewallRuleGroupsRequest & request,const ListFirewallRuleGroupsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1088 void Route53ResolverClient::ListFirewallRuleGroupsAsyncHelper(const ListFirewallRuleGroupsRequest& request, const ListFirewallRuleGroupsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1089 {
1090 handler(this, request, ListFirewallRuleGroups(request), context);
1091 }
1092
ListFirewallRules(const ListFirewallRulesRequest & request) const1093 ListFirewallRulesOutcome Route53ResolverClient::ListFirewallRules(const ListFirewallRulesRequest& request) const
1094 {
1095 Aws::Http::URI uri = m_uri;
1096 return ListFirewallRulesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1097 }
1098
ListFirewallRulesCallable(const ListFirewallRulesRequest & request) const1099 ListFirewallRulesOutcomeCallable Route53ResolverClient::ListFirewallRulesCallable(const ListFirewallRulesRequest& request) const
1100 {
1101 auto task = Aws::MakeShared< std::packaged_task< ListFirewallRulesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListFirewallRules(request); } );
1102 auto packagedFunction = [task]() { (*task)(); };
1103 m_executor->Submit(packagedFunction);
1104 return task->get_future();
1105 }
1106
ListFirewallRulesAsync(const ListFirewallRulesRequest & request,const ListFirewallRulesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1107 void Route53ResolverClient::ListFirewallRulesAsync(const ListFirewallRulesRequest& request, const ListFirewallRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1108 {
1109 m_executor->Submit( [this, request, handler, context](){ this->ListFirewallRulesAsyncHelper( request, handler, context ); } );
1110 }
1111
ListFirewallRulesAsyncHelper(const ListFirewallRulesRequest & request,const ListFirewallRulesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1112 void Route53ResolverClient::ListFirewallRulesAsyncHelper(const ListFirewallRulesRequest& request, const ListFirewallRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1113 {
1114 handler(this, request, ListFirewallRules(request), context);
1115 }
1116
ListResolverDnssecConfigs(const ListResolverDnssecConfigsRequest & request) const1117 ListResolverDnssecConfigsOutcome Route53ResolverClient::ListResolverDnssecConfigs(const ListResolverDnssecConfigsRequest& request) const
1118 {
1119 Aws::Http::URI uri = m_uri;
1120 return ListResolverDnssecConfigsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1121 }
1122
ListResolverDnssecConfigsCallable(const ListResolverDnssecConfigsRequest & request) const1123 ListResolverDnssecConfigsOutcomeCallable Route53ResolverClient::ListResolverDnssecConfigsCallable(const ListResolverDnssecConfigsRequest& request) const
1124 {
1125 auto task = Aws::MakeShared< std::packaged_task< ListResolverDnssecConfigsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListResolverDnssecConfigs(request); } );
1126 auto packagedFunction = [task]() { (*task)(); };
1127 m_executor->Submit(packagedFunction);
1128 return task->get_future();
1129 }
1130
ListResolverDnssecConfigsAsync(const ListResolverDnssecConfigsRequest & request,const ListResolverDnssecConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1131 void Route53ResolverClient::ListResolverDnssecConfigsAsync(const ListResolverDnssecConfigsRequest& request, const ListResolverDnssecConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1132 {
1133 m_executor->Submit( [this, request, handler, context](){ this->ListResolverDnssecConfigsAsyncHelper( request, handler, context ); } );
1134 }
1135
ListResolverDnssecConfigsAsyncHelper(const ListResolverDnssecConfigsRequest & request,const ListResolverDnssecConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1136 void Route53ResolverClient::ListResolverDnssecConfigsAsyncHelper(const ListResolverDnssecConfigsRequest& request, const ListResolverDnssecConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1137 {
1138 handler(this, request, ListResolverDnssecConfigs(request), context);
1139 }
1140
ListResolverEndpointIpAddresses(const ListResolverEndpointIpAddressesRequest & request) const1141 ListResolverEndpointIpAddressesOutcome Route53ResolverClient::ListResolverEndpointIpAddresses(const ListResolverEndpointIpAddressesRequest& request) const
1142 {
1143 Aws::Http::URI uri = m_uri;
1144 return ListResolverEndpointIpAddressesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1145 }
1146
ListResolverEndpointIpAddressesCallable(const ListResolverEndpointIpAddressesRequest & request) const1147 ListResolverEndpointIpAddressesOutcomeCallable Route53ResolverClient::ListResolverEndpointIpAddressesCallable(const ListResolverEndpointIpAddressesRequest& request) const
1148 {
1149 auto task = Aws::MakeShared< std::packaged_task< ListResolverEndpointIpAddressesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListResolverEndpointIpAddresses(request); } );
1150 auto packagedFunction = [task]() { (*task)(); };
1151 m_executor->Submit(packagedFunction);
1152 return task->get_future();
1153 }
1154
ListResolverEndpointIpAddressesAsync(const ListResolverEndpointIpAddressesRequest & request,const ListResolverEndpointIpAddressesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1155 void Route53ResolverClient::ListResolverEndpointIpAddressesAsync(const ListResolverEndpointIpAddressesRequest& request, const ListResolverEndpointIpAddressesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1156 {
1157 m_executor->Submit( [this, request, handler, context](){ this->ListResolverEndpointIpAddressesAsyncHelper( request, handler, context ); } );
1158 }
1159
ListResolverEndpointIpAddressesAsyncHelper(const ListResolverEndpointIpAddressesRequest & request,const ListResolverEndpointIpAddressesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1160 void Route53ResolverClient::ListResolverEndpointIpAddressesAsyncHelper(const ListResolverEndpointIpAddressesRequest& request, const ListResolverEndpointIpAddressesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1161 {
1162 handler(this, request, ListResolverEndpointIpAddresses(request), context);
1163 }
1164
ListResolverEndpoints(const ListResolverEndpointsRequest & request) const1165 ListResolverEndpointsOutcome Route53ResolverClient::ListResolverEndpoints(const ListResolverEndpointsRequest& request) const
1166 {
1167 Aws::Http::URI uri = m_uri;
1168 return ListResolverEndpointsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1169 }
1170
ListResolverEndpointsCallable(const ListResolverEndpointsRequest & request) const1171 ListResolverEndpointsOutcomeCallable Route53ResolverClient::ListResolverEndpointsCallable(const ListResolverEndpointsRequest& request) const
1172 {
1173 auto task = Aws::MakeShared< std::packaged_task< ListResolverEndpointsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListResolverEndpoints(request); } );
1174 auto packagedFunction = [task]() { (*task)(); };
1175 m_executor->Submit(packagedFunction);
1176 return task->get_future();
1177 }
1178
ListResolverEndpointsAsync(const ListResolverEndpointsRequest & request,const ListResolverEndpointsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1179 void Route53ResolverClient::ListResolverEndpointsAsync(const ListResolverEndpointsRequest& request, const ListResolverEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1180 {
1181 m_executor->Submit( [this, request, handler, context](){ this->ListResolverEndpointsAsyncHelper( request, handler, context ); } );
1182 }
1183
ListResolverEndpointsAsyncHelper(const ListResolverEndpointsRequest & request,const ListResolverEndpointsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1184 void Route53ResolverClient::ListResolverEndpointsAsyncHelper(const ListResolverEndpointsRequest& request, const ListResolverEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1185 {
1186 handler(this, request, ListResolverEndpoints(request), context);
1187 }
1188
ListResolverQueryLogConfigAssociations(const ListResolverQueryLogConfigAssociationsRequest & request) const1189 ListResolverQueryLogConfigAssociationsOutcome Route53ResolverClient::ListResolverQueryLogConfigAssociations(const ListResolverQueryLogConfigAssociationsRequest& request) const
1190 {
1191 Aws::Http::URI uri = m_uri;
1192 return ListResolverQueryLogConfigAssociationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1193 }
1194
ListResolverQueryLogConfigAssociationsCallable(const ListResolverQueryLogConfigAssociationsRequest & request) const1195 ListResolverQueryLogConfigAssociationsOutcomeCallable Route53ResolverClient::ListResolverQueryLogConfigAssociationsCallable(const ListResolverQueryLogConfigAssociationsRequest& request) const
1196 {
1197 auto task = Aws::MakeShared< std::packaged_task< ListResolverQueryLogConfigAssociationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListResolverQueryLogConfigAssociations(request); } );
1198 auto packagedFunction = [task]() { (*task)(); };
1199 m_executor->Submit(packagedFunction);
1200 return task->get_future();
1201 }
1202
ListResolverQueryLogConfigAssociationsAsync(const ListResolverQueryLogConfigAssociationsRequest & request,const ListResolverQueryLogConfigAssociationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1203 void Route53ResolverClient::ListResolverQueryLogConfigAssociationsAsync(const ListResolverQueryLogConfigAssociationsRequest& request, const ListResolverQueryLogConfigAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1204 {
1205 m_executor->Submit( [this, request, handler, context](){ this->ListResolverQueryLogConfigAssociationsAsyncHelper( request, handler, context ); } );
1206 }
1207
ListResolverQueryLogConfigAssociationsAsyncHelper(const ListResolverQueryLogConfigAssociationsRequest & request,const ListResolverQueryLogConfigAssociationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1208 void Route53ResolverClient::ListResolverQueryLogConfigAssociationsAsyncHelper(const ListResolverQueryLogConfigAssociationsRequest& request, const ListResolverQueryLogConfigAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1209 {
1210 handler(this, request, ListResolverQueryLogConfigAssociations(request), context);
1211 }
1212
ListResolverQueryLogConfigs(const ListResolverQueryLogConfigsRequest & request) const1213 ListResolverQueryLogConfigsOutcome Route53ResolverClient::ListResolverQueryLogConfigs(const ListResolverQueryLogConfigsRequest& request) const
1214 {
1215 Aws::Http::URI uri = m_uri;
1216 return ListResolverQueryLogConfigsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1217 }
1218
ListResolverQueryLogConfigsCallable(const ListResolverQueryLogConfigsRequest & request) const1219 ListResolverQueryLogConfigsOutcomeCallable Route53ResolverClient::ListResolverQueryLogConfigsCallable(const ListResolverQueryLogConfigsRequest& request) const
1220 {
1221 auto task = Aws::MakeShared< std::packaged_task< ListResolverQueryLogConfigsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListResolverQueryLogConfigs(request); } );
1222 auto packagedFunction = [task]() { (*task)(); };
1223 m_executor->Submit(packagedFunction);
1224 return task->get_future();
1225 }
1226
ListResolverQueryLogConfigsAsync(const ListResolverQueryLogConfigsRequest & request,const ListResolverQueryLogConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1227 void Route53ResolverClient::ListResolverQueryLogConfigsAsync(const ListResolverQueryLogConfigsRequest& request, const ListResolverQueryLogConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1228 {
1229 m_executor->Submit( [this, request, handler, context](){ this->ListResolverQueryLogConfigsAsyncHelper( request, handler, context ); } );
1230 }
1231
ListResolverQueryLogConfigsAsyncHelper(const ListResolverQueryLogConfigsRequest & request,const ListResolverQueryLogConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1232 void Route53ResolverClient::ListResolverQueryLogConfigsAsyncHelper(const ListResolverQueryLogConfigsRequest& request, const ListResolverQueryLogConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1233 {
1234 handler(this, request, ListResolverQueryLogConfigs(request), context);
1235 }
1236
ListResolverRuleAssociations(const ListResolverRuleAssociationsRequest & request) const1237 ListResolverRuleAssociationsOutcome Route53ResolverClient::ListResolverRuleAssociations(const ListResolverRuleAssociationsRequest& request) const
1238 {
1239 Aws::Http::URI uri = m_uri;
1240 return ListResolverRuleAssociationsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1241 }
1242
ListResolverRuleAssociationsCallable(const ListResolverRuleAssociationsRequest & request) const1243 ListResolverRuleAssociationsOutcomeCallable Route53ResolverClient::ListResolverRuleAssociationsCallable(const ListResolverRuleAssociationsRequest& request) const
1244 {
1245 auto task = Aws::MakeShared< std::packaged_task< ListResolverRuleAssociationsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListResolverRuleAssociations(request); } );
1246 auto packagedFunction = [task]() { (*task)(); };
1247 m_executor->Submit(packagedFunction);
1248 return task->get_future();
1249 }
1250
ListResolverRuleAssociationsAsync(const ListResolverRuleAssociationsRequest & request,const ListResolverRuleAssociationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1251 void Route53ResolverClient::ListResolverRuleAssociationsAsync(const ListResolverRuleAssociationsRequest& request, const ListResolverRuleAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1252 {
1253 m_executor->Submit( [this, request, handler, context](){ this->ListResolverRuleAssociationsAsyncHelper( request, handler, context ); } );
1254 }
1255
ListResolverRuleAssociationsAsyncHelper(const ListResolverRuleAssociationsRequest & request,const ListResolverRuleAssociationsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1256 void Route53ResolverClient::ListResolverRuleAssociationsAsyncHelper(const ListResolverRuleAssociationsRequest& request, const ListResolverRuleAssociationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1257 {
1258 handler(this, request, ListResolverRuleAssociations(request), context);
1259 }
1260
ListResolverRules(const ListResolverRulesRequest & request) const1261 ListResolverRulesOutcome Route53ResolverClient::ListResolverRules(const ListResolverRulesRequest& request) const
1262 {
1263 Aws::Http::URI uri = m_uri;
1264 return ListResolverRulesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1265 }
1266
ListResolverRulesCallable(const ListResolverRulesRequest & request) const1267 ListResolverRulesOutcomeCallable Route53ResolverClient::ListResolverRulesCallable(const ListResolverRulesRequest& request) const
1268 {
1269 auto task = Aws::MakeShared< std::packaged_task< ListResolverRulesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListResolverRules(request); } );
1270 auto packagedFunction = [task]() { (*task)(); };
1271 m_executor->Submit(packagedFunction);
1272 return task->get_future();
1273 }
1274
ListResolverRulesAsync(const ListResolverRulesRequest & request,const ListResolverRulesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1275 void Route53ResolverClient::ListResolverRulesAsync(const ListResolverRulesRequest& request, const ListResolverRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1276 {
1277 m_executor->Submit( [this, request, handler, context](){ this->ListResolverRulesAsyncHelper( request, handler, context ); } );
1278 }
1279
ListResolverRulesAsyncHelper(const ListResolverRulesRequest & request,const ListResolverRulesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1280 void Route53ResolverClient::ListResolverRulesAsyncHelper(const ListResolverRulesRequest& request, const ListResolverRulesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1281 {
1282 handler(this, request, ListResolverRules(request), context);
1283 }
1284
ListTagsForResource(const ListTagsForResourceRequest & request) const1285 ListTagsForResourceOutcome Route53ResolverClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
1286 {
1287 Aws::Http::URI uri = m_uri;
1288 return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1289 }
1290
ListTagsForResourceCallable(const ListTagsForResourceRequest & request) const1291 ListTagsForResourceOutcomeCallable Route53ResolverClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
1292 {
1293 auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
1294 auto packagedFunction = [task]() { (*task)(); };
1295 m_executor->Submit(packagedFunction);
1296 return task->get_future();
1297 }
1298
ListTagsForResourceAsync(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1299 void Route53ResolverClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1300 {
1301 m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
1302 }
1303
ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1304 void Route53ResolverClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1305 {
1306 handler(this, request, ListTagsForResource(request), context);
1307 }
1308
PutFirewallRuleGroupPolicy(const PutFirewallRuleGroupPolicyRequest & request) const1309 PutFirewallRuleGroupPolicyOutcome Route53ResolverClient::PutFirewallRuleGroupPolicy(const PutFirewallRuleGroupPolicyRequest& request) const
1310 {
1311 Aws::Http::URI uri = m_uri;
1312 return PutFirewallRuleGroupPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1313 }
1314
PutFirewallRuleGroupPolicyCallable(const PutFirewallRuleGroupPolicyRequest & request) const1315 PutFirewallRuleGroupPolicyOutcomeCallable Route53ResolverClient::PutFirewallRuleGroupPolicyCallable(const PutFirewallRuleGroupPolicyRequest& request) const
1316 {
1317 auto task = Aws::MakeShared< std::packaged_task< PutFirewallRuleGroupPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutFirewallRuleGroupPolicy(request); } );
1318 auto packagedFunction = [task]() { (*task)(); };
1319 m_executor->Submit(packagedFunction);
1320 return task->get_future();
1321 }
1322
PutFirewallRuleGroupPolicyAsync(const PutFirewallRuleGroupPolicyRequest & request,const PutFirewallRuleGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1323 void Route53ResolverClient::PutFirewallRuleGroupPolicyAsync(const PutFirewallRuleGroupPolicyRequest& request, const PutFirewallRuleGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1324 {
1325 m_executor->Submit( [this, request, handler, context](){ this->PutFirewallRuleGroupPolicyAsyncHelper( request, handler, context ); } );
1326 }
1327
PutFirewallRuleGroupPolicyAsyncHelper(const PutFirewallRuleGroupPolicyRequest & request,const PutFirewallRuleGroupPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1328 void Route53ResolverClient::PutFirewallRuleGroupPolicyAsyncHelper(const PutFirewallRuleGroupPolicyRequest& request, const PutFirewallRuleGroupPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1329 {
1330 handler(this, request, PutFirewallRuleGroupPolicy(request), context);
1331 }
1332
PutResolverQueryLogConfigPolicy(const PutResolverQueryLogConfigPolicyRequest & request) const1333 PutResolverQueryLogConfigPolicyOutcome Route53ResolverClient::PutResolverQueryLogConfigPolicy(const PutResolverQueryLogConfigPolicyRequest& request) const
1334 {
1335 Aws::Http::URI uri = m_uri;
1336 return PutResolverQueryLogConfigPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1337 }
1338
PutResolverQueryLogConfigPolicyCallable(const PutResolverQueryLogConfigPolicyRequest & request) const1339 PutResolverQueryLogConfigPolicyOutcomeCallable Route53ResolverClient::PutResolverQueryLogConfigPolicyCallable(const PutResolverQueryLogConfigPolicyRequest& request) const
1340 {
1341 auto task = Aws::MakeShared< std::packaged_task< PutResolverQueryLogConfigPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutResolverQueryLogConfigPolicy(request); } );
1342 auto packagedFunction = [task]() { (*task)(); };
1343 m_executor->Submit(packagedFunction);
1344 return task->get_future();
1345 }
1346
PutResolverQueryLogConfigPolicyAsync(const PutResolverQueryLogConfigPolicyRequest & request,const PutResolverQueryLogConfigPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1347 void Route53ResolverClient::PutResolverQueryLogConfigPolicyAsync(const PutResolverQueryLogConfigPolicyRequest& request, const PutResolverQueryLogConfigPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1348 {
1349 m_executor->Submit( [this, request, handler, context](){ this->PutResolverQueryLogConfigPolicyAsyncHelper( request, handler, context ); } );
1350 }
1351
PutResolverQueryLogConfigPolicyAsyncHelper(const PutResolverQueryLogConfigPolicyRequest & request,const PutResolverQueryLogConfigPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1352 void Route53ResolverClient::PutResolverQueryLogConfigPolicyAsyncHelper(const PutResolverQueryLogConfigPolicyRequest& request, const PutResolverQueryLogConfigPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1353 {
1354 handler(this, request, PutResolverQueryLogConfigPolicy(request), context);
1355 }
1356
PutResolverRulePolicy(const PutResolverRulePolicyRequest & request) const1357 PutResolverRulePolicyOutcome Route53ResolverClient::PutResolverRulePolicy(const PutResolverRulePolicyRequest& request) const
1358 {
1359 Aws::Http::URI uri = m_uri;
1360 return PutResolverRulePolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1361 }
1362
PutResolverRulePolicyCallable(const PutResolverRulePolicyRequest & request) const1363 PutResolverRulePolicyOutcomeCallable Route53ResolverClient::PutResolverRulePolicyCallable(const PutResolverRulePolicyRequest& request) const
1364 {
1365 auto task = Aws::MakeShared< std::packaged_task< PutResolverRulePolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutResolverRulePolicy(request); } );
1366 auto packagedFunction = [task]() { (*task)(); };
1367 m_executor->Submit(packagedFunction);
1368 return task->get_future();
1369 }
1370
PutResolverRulePolicyAsync(const PutResolverRulePolicyRequest & request,const PutResolverRulePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1371 void Route53ResolverClient::PutResolverRulePolicyAsync(const PutResolverRulePolicyRequest& request, const PutResolverRulePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1372 {
1373 m_executor->Submit( [this, request, handler, context](){ this->PutResolverRulePolicyAsyncHelper( request, handler, context ); } );
1374 }
1375
PutResolverRulePolicyAsyncHelper(const PutResolverRulePolicyRequest & request,const PutResolverRulePolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1376 void Route53ResolverClient::PutResolverRulePolicyAsyncHelper(const PutResolverRulePolicyRequest& request, const PutResolverRulePolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1377 {
1378 handler(this, request, PutResolverRulePolicy(request), context);
1379 }
1380
TagResource(const TagResourceRequest & request) const1381 TagResourceOutcome Route53ResolverClient::TagResource(const TagResourceRequest& request) const
1382 {
1383 Aws::Http::URI uri = m_uri;
1384 return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1385 }
1386
TagResourceCallable(const TagResourceRequest & request) const1387 TagResourceOutcomeCallable Route53ResolverClient::TagResourceCallable(const TagResourceRequest& request) const
1388 {
1389 auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
1390 auto packagedFunction = [task]() { (*task)(); };
1391 m_executor->Submit(packagedFunction);
1392 return task->get_future();
1393 }
1394
TagResourceAsync(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1395 void Route53ResolverClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1396 {
1397 m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
1398 }
1399
TagResourceAsyncHelper(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1400 void Route53ResolverClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1401 {
1402 handler(this, request, TagResource(request), context);
1403 }
1404
UntagResource(const UntagResourceRequest & request) const1405 UntagResourceOutcome Route53ResolverClient::UntagResource(const UntagResourceRequest& request) const
1406 {
1407 Aws::Http::URI uri = m_uri;
1408 return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1409 }
1410
UntagResourceCallable(const UntagResourceRequest & request) const1411 UntagResourceOutcomeCallable Route53ResolverClient::UntagResourceCallable(const UntagResourceRequest& request) const
1412 {
1413 auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
1414 auto packagedFunction = [task]() { (*task)(); };
1415 m_executor->Submit(packagedFunction);
1416 return task->get_future();
1417 }
1418
UntagResourceAsync(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1419 void Route53ResolverClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1420 {
1421 m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
1422 }
1423
UntagResourceAsyncHelper(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1424 void Route53ResolverClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1425 {
1426 handler(this, request, UntagResource(request), context);
1427 }
1428
UpdateFirewallConfig(const UpdateFirewallConfigRequest & request) const1429 UpdateFirewallConfigOutcome Route53ResolverClient::UpdateFirewallConfig(const UpdateFirewallConfigRequest& request) const
1430 {
1431 Aws::Http::URI uri = m_uri;
1432 return UpdateFirewallConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1433 }
1434
UpdateFirewallConfigCallable(const UpdateFirewallConfigRequest & request) const1435 UpdateFirewallConfigOutcomeCallable Route53ResolverClient::UpdateFirewallConfigCallable(const UpdateFirewallConfigRequest& request) const
1436 {
1437 auto task = Aws::MakeShared< std::packaged_task< UpdateFirewallConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateFirewallConfig(request); } );
1438 auto packagedFunction = [task]() { (*task)(); };
1439 m_executor->Submit(packagedFunction);
1440 return task->get_future();
1441 }
1442
UpdateFirewallConfigAsync(const UpdateFirewallConfigRequest & request,const UpdateFirewallConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1443 void Route53ResolverClient::UpdateFirewallConfigAsync(const UpdateFirewallConfigRequest& request, const UpdateFirewallConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1444 {
1445 m_executor->Submit( [this, request, handler, context](){ this->UpdateFirewallConfigAsyncHelper( request, handler, context ); } );
1446 }
1447
UpdateFirewallConfigAsyncHelper(const UpdateFirewallConfigRequest & request,const UpdateFirewallConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1448 void Route53ResolverClient::UpdateFirewallConfigAsyncHelper(const UpdateFirewallConfigRequest& request, const UpdateFirewallConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1449 {
1450 handler(this, request, UpdateFirewallConfig(request), context);
1451 }
1452
UpdateFirewallDomains(const UpdateFirewallDomainsRequest & request) const1453 UpdateFirewallDomainsOutcome Route53ResolverClient::UpdateFirewallDomains(const UpdateFirewallDomainsRequest& request) const
1454 {
1455 Aws::Http::URI uri = m_uri;
1456 return UpdateFirewallDomainsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1457 }
1458
UpdateFirewallDomainsCallable(const UpdateFirewallDomainsRequest & request) const1459 UpdateFirewallDomainsOutcomeCallable Route53ResolverClient::UpdateFirewallDomainsCallable(const UpdateFirewallDomainsRequest& request) const
1460 {
1461 auto task = Aws::MakeShared< std::packaged_task< UpdateFirewallDomainsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateFirewallDomains(request); } );
1462 auto packagedFunction = [task]() { (*task)(); };
1463 m_executor->Submit(packagedFunction);
1464 return task->get_future();
1465 }
1466
UpdateFirewallDomainsAsync(const UpdateFirewallDomainsRequest & request,const UpdateFirewallDomainsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1467 void Route53ResolverClient::UpdateFirewallDomainsAsync(const UpdateFirewallDomainsRequest& request, const UpdateFirewallDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1468 {
1469 m_executor->Submit( [this, request, handler, context](){ this->UpdateFirewallDomainsAsyncHelper( request, handler, context ); } );
1470 }
1471
UpdateFirewallDomainsAsyncHelper(const UpdateFirewallDomainsRequest & request,const UpdateFirewallDomainsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1472 void Route53ResolverClient::UpdateFirewallDomainsAsyncHelper(const UpdateFirewallDomainsRequest& request, const UpdateFirewallDomainsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1473 {
1474 handler(this, request, UpdateFirewallDomains(request), context);
1475 }
1476
UpdateFirewallRule(const UpdateFirewallRuleRequest & request) const1477 UpdateFirewallRuleOutcome Route53ResolverClient::UpdateFirewallRule(const UpdateFirewallRuleRequest& request) const
1478 {
1479 Aws::Http::URI uri = m_uri;
1480 return UpdateFirewallRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1481 }
1482
UpdateFirewallRuleCallable(const UpdateFirewallRuleRequest & request) const1483 UpdateFirewallRuleOutcomeCallable Route53ResolverClient::UpdateFirewallRuleCallable(const UpdateFirewallRuleRequest& request) const
1484 {
1485 auto task = Aws::MakeShared< std::packaged_task< UpdateFirewallRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateFirewallRule(request); } );
1486 auto packagedFunction = [task]() { (*task)(); };
1487 m_executor->Submit(packagedFunction);
1488 return task->get_future();
1489 }
1490
UpdateFirewallRuleAsync(const UpdateFirewallRuleRequest & request,const UpdateFirewallRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1491 void Route53ResolverClient::UpdateFirewallRuleAsync(const UpdateFirewallRuleRequest& request, const UpdateFirewallRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1492 {
1493 m_executor->Submit( [this, request, handler, context](){ this->UpdateFirewallRuleAsyncHelper( request, handler, context ); } );
1494 }
1495
UpdateFirewallRuleAsyncHelper(const UpdateFirewallRuleRequest & request,const UpdateFirewallRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1496 void Route53ResolverClient::UpdateFirewallRuleAsyncHelper(const UpdateFirewallRuleRequest& request, const UpdateFirewallRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1497 {
1498 handler(this, request, UpdateFirewallRule(request), context);
1499 }
1500
UpdateFirewallRuleGroupAssociation(const UpdateFirewallRuleGroupAssociationRequest & request) const1501 UpdateFirewallRuleGroupAssociationOutcome Route53ResolverClient::UpdateFirewallRuleGroupAssociation(const UpdateFirewallRuleGroupAssociationRequest& request) const
1502 {
1503 Aws::Http::URI uri = m_uri;
1504 return UpdateFirewallRuleGroupAssociationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1505 }
1506
UpdateFirewallRuleGroupAssociationCallable(const UpdateFirewallRuleGroupAssociationRequest & request) const1507 UpdateFirewallRuleGroupAssociationOutcomeCallable Route53ResolverClient::UpdateFirewallRuleGroupAssociationCallable(const UpdateFirewallRuleGroupAssociationRequest& request) const
1508 {
1509 auto task = Aws::MakeShared< std::packaged_task< UpdateFirewallRuleGroupAssociationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateFirewallRuleGroupAssociation(request); } );
1510 auto packagedFunction = [task]() { (*task)(); };
1511 m_executor->Submit(packagedFunction);
1512 return task->get_future();
1513 }
1514
UpdateFirewallRuleGroupAssociationAsync(const UpdateFirewallRuleGroupAssociationRequest & request,const UpdateFirewallRuleGroupAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1515 void Route53ResolverClient::UpdateFirewallRuleGroupAssociationAsync(const UpdateFirewallRuleGroupAssociationRequest& request, const UpdateFirewallRuleGroupAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1516 {
1517 m_executor->Submit( [this, request, handler, context](){ this->UpdateFirewallRuleGroupAssociationAsyncHelper( request, handler, context ); } );
1518 }
1519
UpdateFirewallRuleGroupAssociationAsyncHelper(const UpdateFirewallRuleGroupAssociationRequest & request,const UpdateFirewallRuleGroupAssociationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1520 void Route53ResolverClient::UpdateFirewallRuleGroupAssociationAsyncHelper(const UpdateFirewallRuleGroupAssociationRequest& request, const UpdateFirewallRuleGroupAssociationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1521 {
1522 handler(this, request, UpdateFirewallRuleGroupAssociation(request), context);
1523 }
1524
UpdateResolverDnssecConfig(const UpdateResolverDnssecConfigRequest & request) const1525 UpdateResolverDnssecConfigOutcome Route53ResolverClient::UpdateResolverDnssecConfig(const UpdateResolverDnssecConfigRequest& request) const
1526 {
1527 Aws::Http::URI uri = m_uri;
1528 return UpdateResolverDnssecConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1529 }
1530
UpdateResolverDnssecConfigCallable(const UpdateResolverDnssecConfigRequest & request) const1531 UpdateResolverDnssecConfigOutcomeCallable Route53ResolverClient::UpdateResolverDnssecConfigCallable(const UpdateResolverDnssecConfigRequest& request) const
1532 {
1533 auto task = Aws::MakeShared< std::packaged_task< UpdateResolverDnssecConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateResolverDnssecConfig(request); } );
1534 auto packagedFunction = [task]() { (*task)(); };
1535 m_executor->Submit(packagedFunction);
1536 return task->get_future();
1537 }
1538
UpdateResolverDnssecConfigAsync(const UpdateResolverDnssecConfigRequest & request,const UpdateResolverDnssecConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1539 void Route53ResolverClient::UpdateResolverDnssecConfigAsync(const UpdateResolverDnssecConfigRequest& request, const UpdateResolverDnssecConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1540 {
1541 m_executor->Submit( [this, request, handler, context](){ this->UpdateResolverDnssecConfigAsyncHelper( request, handler, context ); } );
1542 }
1543
UpdateResolverDnssecConfigAsyncHelper(const UpdateResolverDnssecConfigRequest & request,const UpdateResolverDnssecConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1544 void Route53ResolverClient::UpdateResolverDnssecConfigAsyncHelper(const UpdateResolverDnssecConfigRequest& request, const UpdateResolverDnssecConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1545 {
1546 handler(this, request, UpdateResolverDnssecConfig(request), context);
1547 }
1548
UpdateResolverEndpoint(const UpdateResolverEndpointRequest & request) const1549 UpdateResolverEndpointOutcome Route53ResolverClient::UpdateResolverEndpoint(const UpdateResolverEndpointRequest& request) const
1550 {
1551 Aws::Http::URI uri = m_uri;
1552 return UpdateResolverEndpointOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1553 }
1554
UpdateResolverEndpointCallable(const UpdateResolverEndpointRequest & request) const1555 UpdateResolverEndpointOutcomeCallable Route53ResolverClient::UpdateResolverEndpointCallable(const UpdateResolverEndpointRequest& request) const
1556 {
1557 auto task = Aws::MakeShared< std::packaged_task< UpdateResolverEndpointOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateResolverEndpoint(request); } );
1558 auto packagedFunction = [task]() { (*task)(); };
1559 m_executor->Submit(packagedFunction);
1560 return task->get_future();
1561 }
1562
UpdateResolverEndpointAsync(const UpdateResolverEndpointRequest & request,const UpdateResolverEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1563 void Route53ResolverClient::UpdateResolverEndpointAsync(const UpdateResolverEndpointRequest& request, const UpdateResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1564 {
1565 m_executor->Submit( [this, request, handler, context](){ this->UpdateResolverEndpointAsyncHelper( request, handler, context ); } );
1566 }
1567
UpdateResolverEndpointAsyncHelper(const UpdateResolverEndpointRequest & request,const UpdateResolverEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1568 void Route53ResolverClient::UpdateResolverEndpointAsyncHelper(const UpdateResolverEndpointRequest& request, const UpdateResolverEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1569 {
1570 handler(this, request, UpdateResolverEndpoint(request), context);
1571 }
1572
UpdateResolverRule(const UpdateResolverRuleRequest & request) const1573 UpdateResolverRuleOutcome Route53ResolverClient::UpdateResolverRule(const UpdateResolverRuleRequest& request) const
1574 {
1575 Aws::Http::URI uri = m_uri;
1576 return UpdateResolverRuleOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1577 }
1578
UpdateResolverRuleCallable(const UpdateResolverRuleRequest & request) const1579 UpdateResolverRuleOutcomeCallable Route53ResolverClient::UpdateResolverRuleCallable(const UpdateResolverRuleRequest& request) const
1580 {
1581 auto task = Aws::MakeShared< std::packaged_task< UpdateResolverRuleOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateResolverRule(request); } );
1582 auto packagedFunction = [task]() { (*task)(); };
1583 m_executor->Submit(packagedFunction);
1584 return task->get_future();
1585 }
1586
UpdateResolverRuleAsync(const UpdateResolverRuleRequest & request,const UpdateResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1587 void Route53ResolverClient::UpdateResolverRuleAsync(const UpdateResolverRuleRequest& request, const UpdateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1588 {
1589 m_executor->Submit( [this, request, handler, context](){ this->UpdateResolverRuleAsyncHelper( request, handler, context ); } );
1590 }
1591
UpdateResolverRuleAsyncHelper(const UpdateResolverRuleRequest & request,const UpdateResolverRuleResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1592 void Route53ResolverClient::UpdateResolverRuleAsyncHelper(const UpdateResolverRuleRequest& request, const UpdateResolverRuleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1593 {
1594 handler(this, request, UpdateResolverRule(request), context);
1595 }
1596
1597