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/comprehend/ComprehendClient.h>
21 #include <aws/comprehend/ComprehendEndpoint.h>
22 #include <aws/comprehend/ComprehendErrorMarshaller.h>
23 #include <aws/comprehend/model/BatchDetectDominantLanguageRequest.h>
24 #include <aws/comprehend/model/BatchDetectEntitiesRequest.h>
25 #include <aws/comprehend/model/BatchDetectKeyPhrasesRequest.h>
26 #include <aws/comprehend/model/BatchDetectSentimentRequest.h>
27 #include <aws/comprehend/model/BatchDetectSyntaxRequest.h>
28 #include <aws/comprehend/model/ClassifyDocumentRequest.h>
29 #include <aws/comprehend/model/ContainsPiiEntitiesRequest.h>
30 #include <aws/comprehend/model/CreateDocumentClassifierRequest.h>
31 #include <aws/comprehend/model/CreateEndpointRequest.h>
32 #include <aws/comprehend/model/CreateEntityRecognizerRequest.h>
33 #include <aws/comprehend/model/DeleteDocumentClassifierRequest.h>
34 #include <aws/comprehend/model/DeleteEndpointRequest.h>
35 #include <aws/comprehend/model/DeleteEntityRecognizerRequest.h>
36 #include <aws/comprehend/model/DescribeDocumentClassificationJobRequest.h>
37 #include <aws/comprehend/model/DescribeDocumentClassifierRequest.h>
38 #include <aws/comprehend/model/DescribeDominantLanguageDetectionJobRequest.h>
39 #include <aws/comprehend/model/DescribeEndpointRequest.h>
40 #include <aws/comprehend/model/DescribeEntitiesDetectionJobRequest.h>
41 #include <aws/comprehend/model/DescribeEntityRecognizerRequest.h>
42 #include <aws/comprehend/model/DescribeEventsDetectionJobRequest.h>
43 #include <aws/comprehend/model/DescribeKeyPhrasesDetectionJobRequest.h>
44 #include <aws/comprehend/model/DescribePiiEntitiesDetectionJobRequest.h>
45 #include <aws/comprehend/model/DescribeSentimentDetectionJobRequest.h>
46 #include <aws/comprehend/model/DescribeTopicsDetectionJobRequest.h>
47 #include <aws/comprehend/model/DetectDominantLanguageRequest.h>
48 #include <aws/comprehend/model/DetectEntitiesRequest.h>
49 #include <aws/comprehend/model/DetectKeyPhrasesRequest.h>
50 #include <aws/comprehend/model/DetectPiiEntitiesRequest.h>
51 #include <aws/comprehend/model/DetectSentimentRequest.h>
52 #include <aws/comprehend/model/DetectSyntaxRequest.h>
53 #include <aws/comprehend/model/ListDocumentClassificationJobsRequest.h>
54 #include <aws/comprehend/model/ListDocumentClassifierSummariesRequest.h>
55 #include <aws/comprehend/model/ListDocumentClassifiersRequest.h>
56 #include <aws/comprehend/model/ListDominantLanguageDetectionJobsRequest.h>
57 #include <aws/comprehend/model/ListEndpointsRequest.h>
58 #include <aws/comprehend/model/ListEntitiesDetectionJobsRequest.h>
59 #include <aws/comprehend/model/ListEntityRecognizerSummariesRequest.h>
60 #include <aws/comprehend/model/ListEntityRecognizersRequest.h>
61 #include <aws/comprehend/model/ListEventsDetectionJobsRequest.h>
62 #include <aws/comprehend/model/ListKeyPhrasesDetectionJobsRequest.h>
63 #include <aws/comprehend/model/ListPiiEntitiesDetectionJobsRequest.h>
64 #include <aws/comprehend/model/ListSentimentDetectionJobsRequest.h>
65 #include <aws/comprehend/model/ListTagsForResourceRequest.h>
66 #include <aws/comprehend/model/ListTopicsDetectionJobsRequest.h>
67 #include <aws/comprehend/model/StartDocumentClassificationJobRequest.h>
68 #include <aws/comprehend/model/StartDominantLanguageDetectionJobRequest.h>
69 #include <aws/comprehend/model/StartEntitiesDetectionJobRequest.h>
70 #include <aws/comprehend/model/StartEventsDetectionJobRequest.h>
71 #include <aws/comprehend/model/StartKeyPhrasesDetectionJobRequest.h>
72 #include <aws/comprehend/model/StartPiiEntitiesDetectionJobRequest.h>
73 #include <aws/comprehend/model/StartSentimentDetectionJobRequest.h>
74 #include <aws/comprehend/model/StartTopicsDetectionJobRequest.h>
75 #include <aws/comprehend/model/StopDominantLanguageDetectionJobRequest.h>
76 #include <aws/comprehend/model/StopEntitiesDetectionJobRequest.h>
77 #include <aws/comprehend/model/StopEventsDetectionJobRequest.h>
78 #include <aws/comprehend/model/StopKeyPhrasesDetectionJobRequest.h>
79 #include <aws/comprehend/model/StopPiiEntitiesDetectionJobRequest.h>
80 #include <aws/comprehend/model/StopSentimentDetectionJobRequest.h>
81 #include <aws/comprehend/model/StopTrainingDocumentClassifierRequest.h>
82 #include <aws/comprehend/model/StopTrainingEntityRecognizerRequest.h>
83 #include <aws/comprehend/model/TagResourceRequest.h>
84 #include <aws/comprehend/model/UntagResourceRequest.h>
85 #include <aws/comprehend/model/UpdateEndpointRequest.h>
86
87 using namespace Aws;
88 using namespace Aws::Auth;
89 using namespace Aws::Client;
90 using namespace Aws::Comprehend;
91 using namespace Aws::Comprehend::Model;
92 using namespace Aws::Http;
93 using namespace Aws::Utils::Json;
94
95 static const char* SERVICE_NAME = "comprehend";
96 static const char* ALLOCATION_TAG = "ComprehendClient";
97
98
ComprehendClient(const Client::ClientConfiguration & clientConfiguration)99 ComprehendClient::ComprehendClient(const Client::ClientConfiguration& clientConfiguration) :
100 BASECLASS(clientConfiguration,
101 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
102 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
103 Aws::MakeShared<ComprehendErrorMarshaller>(ALLOCATION_TAG)),
104 m_executor(clientConfiguration.executor)
105 {
106 init(clientConfiguration);
107 }
108
ComprehendClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)109 ComprehendClient::ComprehendClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
110 BASECLASS(clientConfiguration,
111 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
112 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
113 Aws::MakeShared<ComprehendErrorMarshaller>(ALLOCATION_TAG)),
114 m_executor(clientConfiguration.executor)
115 {
116 init(clientConfiguration);
117 }
118
ComprehendClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)119 ComprehendClient::ComprehendClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
120 const Client::ClientConfiguration& clientConfiguration) :
121 BASECLASS(clientConfiguration,
122 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
123 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
124 Aws::MakeShared<ComprehendErrorMarshaller>(ALLOCATION_TAG)),
125 m_executor(clientConfiguration.executor)
126 {
127 init(clientConfiguration);
128 }
129
~ComprehendClient()130 ComprehendClient::~ComprehendClient()
131 {
132 }
133
init(const Client::ClientConfiguration & config)134 void ComprehendClient::init(const Client::ClientConfiguration& config)
135 {
136 SetServiceClientName("Comprehend");
137 m_configScheme = SchemeMapper::ToString(config.scheme);
138 if (config.endpointOverride.empty())
139 {
140 m_uri = m_configScheme + "://" + ComprehendEndpoint::ForRegion(config.region, config.useDualStack);
141 }
142 else
143 {
144 OverrideEndpoint(config.endpointOverride);
145 }
146 }
147
OverrideEndpoint(const Aws::String & endpoint)148 void ComprehendClient::OverrideEndpoint(const Aws::String& endpoint)
149 {
150 if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
151 {
152 m_uri = endpoint;
153 }
154 else
155 {
156 m_uri = m_configScheme + "://" + endpoint;
157 }
158 }
159
BatchDetectDominantLanguage(const BatchDetectDominantLanguageRequest & request) const160 BatchDetectDominantLanguageOutcome ComprehendClient::BatchDetectDominantLanguage(const BatchDetectDominantLanguageRequest& request) const
161 {
162 Aws::Http::URI uri = m_uri;
163 return BatchDetectDominantLanguageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
164 }
165
BatchDetectDominantLanguageCallable(const BatchDetectDominantLanguageRequest & request) const166 BatchDetectDominantLanguageOutcomeCallable ComprehendClient::BatchDetectDominantLanguageCallable(const BatchDetectDominantLanguageRequest& request) const
167 {
168 auto task = Aws::MakeShared< std::packaged_task< BatchDetectDominantLanguageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchDetectDominantLanguage(request); } );
169 auto packagedFunction = [task]() { (*task)(); };
170 m_executor->Submit(packagedFunction);
171 return task->get_future();
172 }
173
BatchDetectDominantLanguageAsync(const BatchDetectDominantLanguageRequest & request,const BatchDetectDominantLanguageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const174 void ComprehendClient::BatchDetectDominantLanguageAsync(const BatchDetectDominantLanguageRequest& request, const BatchDetectDominantLanguageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
175 {
176 m_executor->Submit( [this, request, handler, context](){ this->BatchDetectDominantLanguageAsyncHelper( request, handler, context ); } );
177 }
178
BatchDetectDominantLanguageAsyncHelper(const BatchDetectDominantLanguageRequest & request,const BatchDetectDominantLanguageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const179 void ComprehendClient::BatchDetectDominantLanguageAsyncHelper(const BatchDetectDominantLanguageRequest& request, const BatchDetectDominantLanguageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
180 {
181 handler(this, request, BatchDetectDominantLanguage(request), context);
182 }
183
BatchDetectEntities(const BatchDetectEntitiesRequest & request) const184 BatchDetectEntitiesOutcome ComprehendClient::BatchDetectEntities(const BatchDetectEntitiesRequest& request) const
185 {
186 Aws::Http::URI uri = m_uri;
187 return BatchDetectEntitiesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
188 }
189
BatchDetectEntitiesCallable(const BatchDetectEntitiesRequest & request) const190 BatchDetectEntitiesOutcomeCallable ComprehendClient::BatchDetectEntitiesCallable(const BatchDetectEntitiesRequest& request) const
191 {
192 auto task = Aws::MakeShared< std::packaged_task< BatchDetectEntitiesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchDetectEntities(request); } );
193 auto packagedFunction = [task]() { (*task)(); };
194 m_executor->Submit(packagedFunction);
195 return task->get_future();
196 }
197
BatchDetectEntitiesAsync(const BatchDetectEntitiesRequest & request,const BatchDetectEntitiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const198 void ComprehendClient::BatchDetectEntitiesAsync(const BatchDetectEntitiesRequest& request, const BatchDetectEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
199 {
200 m_executor->Submit( [this, request, handler, context](){ this->BatchDetectEntitiesAsyncHelper( request, handler, context ); } );
201 }
202
BatchDetectEntitiesAsyncHelper(const BatchDetectEntitiesRequest & request,const BatchDetectEntitiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const203 void ComprehendClient::BatchDetectEntitiesAsyncHelper(const BatchDetectEntitiesRequest& request, const BatchDetectEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
204 {
205 handler(this, request, BatchDetectEntities(request), context);
206 }
207
BatchDetectKeyPhrases(const BatchDetectKeyPhrasesRequest & request) const208 BatchDetectKeyPhrasesOutcome ComprehendClient::BatchDetectKeyPhrases(const BatchDetectKeyPhrasesRequest& request) const
209 {
210 Aws::Http::URI uri = m_uri;
211 return BatchDetectKeyPhrasesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
212 }
213
BatchDetectKeyPhrasesCallable(const BatchDetectKeyPhrasesRequest & request) const214 BatchDetectKeyPhrasesOutcomeCallable ComprehendClient::BatchDetectKeyPhrasesCallable(const BatchDetectKeyPhrasesRequest& request) const
215 {
216 auto task = Aws::MakeShared< std::packaged_task< BatchDetectKeyPhrasesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchDetectKeyPhrases(request); } );
217 auto packagedFunction = [task]() { (*task)(); };
218 m_executor->Submit(packagedFunction);
219 return task->get_future();
220 }
221
BatchDetectKeyPhrasesAsync(const BatchDetectKeyPhrasesRequest & request,const BatchDetectKeyPhrasesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const222 void ComprehendClient::BatchDetectKeyPhrasesAsync(const BatchDetectKeyPhrasesRequest& request, const BatchDetectKeyPhrasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
223 {
224 m_executor->Submit( [this, request, handler, context](){ this->BatchDetectKeyPhrasesAsyncHelper( request, handler, context ); } );
225 }
226
BatchDetectKeyPhrasesAsyncHelper(const BatchDetectKeyPhrasesRequest & request,const BatchDetectKeyPhrasesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const227 void ComprehendClient::BatchDetectKeyPhrasesAsyncHelper(const BatchDetectKeyPhrasesRequest& request, const BatchDetectKeyPhrasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
228 {
229 handler(this, request, BatchDetectKeyPhrases(request), context);
230 }
231
BatchDetectSentiment(const BatchDetectSentimentRequest & request) const232 BatchDetectSentimentOutcome ComprehendClient::BatchDetectSentiment(const BatchDetectSentimentRequest& request) const
233 {
234 Aws::Http::URI uri = m_uri;
235 return BatchDetectSentimentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
236 }
237
BatchDetectSentimentCallable(const BatchDetectSentimentRequest & request) const238 BatchDetectSentimentOutcomeCallable ComprehendClient::BatchDetectSentimentCallable(const BatchDetectSentimentRequest& request) const
239 {
240 auto task = Aws::MakeShared< std::packaged_task< BatchDetectSentimentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchDetectSentiment(request); } );
241 auto packagedFunction = [task]() { (*task)(); };
242 m_executor->Submit(packagedFunction);
243 return task->get_future();
244 }
245
BatchDetectSentimentAsync(const BatchDetectSentimentRequest & request,const BatchDetectSentimentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const246 void ComprehendClient::BatchDetectSentimentAsync(const BatchDetectSentimentRequest& request, const BatchDetectSentimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
247 {
248 m_executor->Submit( [this, request, handler, context](){ this->BatchDetectSentimentAsyncHelper( request, handler, context ); } );
249 }
250
BatchDetectSentimentAsyncHelper(const BatchDetectSentimentRequest & request,const BatchDetectSentimentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const251 void ComprehendClient::BatchDetectSentimentAsyncHelper(const BatchDetectSentimentRequest& request, const BatchDetectSentimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
252 {
253 handler(this, request, BatchDetectSentiment(request), context);
254 }
255
BatchDetectSyntax(const BatchDetectSyntaxRequest & request) const256 BatchDetectSyntaxOutcome ComprehendClient::BatchDetectSyntax(const BatchDetectSyntaxRequest& request) const
257 {
258 Aws::Http::URI uri = m_uri;
259 return BatchDetectSyntaxOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
260 }
261
BatchDetectSyntaxCallable(const BatchDetectSyntaxRequest & request) const262 BatchDetectSyntaxOutcomeCallable ComprehendClient::BatchDetectSyntaxCallable(const BatchDetectSyntaxRequest& request) const
263 {
264 auto task = Aws::MakeShared< std::packaged_task< BatchDetectSyntaxOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchDetectSyntax(request); } );
265 auto packagedFunction = [task]() { (*task)(); };
266 m_executor->Submit(packagedFunction);
267 return task->get_future();
268 }
269
BatchDetectSyntaxAsync(const BatchDetectSyntaxRequest & request,const BatchDetectSyntaxResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const270 void ComprehendClient::BatchDetectSyntaxAsync(const BatchDetectSyntaxRequest& request, const BatchDetectSyntaxResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
271 {
272 m_executor->Submit( [this, request, handler, context](){ this->BatchDetectSyntaxAsyncHelper( request, handler, context ); } );
273 }
274
BatchDetectSyntaxAsyncHelper(const BatchDetectSyntaxRequest & request,const BatchDetectSyntaxResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const275 void ComprehendClient::BatchDetectSyntaxAsyncHelper(const BatchDetectSyntaxRequest& request, const BatchDetectSyntaxResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
276 {
277 handler(this, request, BatchDetectSyntax(request), context);
278 }
279
ClassifyDocument(const ClassifyDocumentRequest & request) const280 ClassifyDocumentOutcome ComprehendClient::ClassifyDocument(const ClassifyDocumentRequest& request) const
281 {
282 Aws::Http::URI uri = m_uri;
283 return ClassifyDocumentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
284 }
285
ClassifyDocumentCallable(const ClassifyDocumentRequest & request) const286 ClassifyDocumentOutcomeCallable ComprehendClient::ClassifyDocumentCallable(const ClassifyDocumentRequest& request) const
287 {
288 auto task = Aws::MakeShared< std::packaged_task< ClassifyDocumentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ClassifyDocument(request); } );
289 auto packagedFunction = [task]() { (*task)(); };
290 m_executor->Submit(packagedFunction);
291 return task->get_future();
292 }
293
ClassifyDocumentAsync(const ClassifyDocumentRequest & request,const ClassifyDocumentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const294 void ComprehendClient::ClassifyDocumentAsync(const ClassifyDocumentRequest& request, const ClassifyDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
295 {
296 m_executor->Submit( [this, request, handler, context](){ this->ClassifyDocumentAsyncHelper( request, handler, context ); } );
297 }
298
ClassifyDocumentAsyncHelper(const ClassifyDocumentRequest & request,const ClassifyDocumentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const299 void ComprehendClient::ClassifyDocumentAsyncHelper(const ClassifyDocumentRequest& request, const ClassifyDocumentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
300 {
301 handler(this, request, ClassifyDocument(request), context);
302 }
303
ContainsPiiEntities(const ContainsPiiEntitiesRequest & request) const304 ContainsPiiEntitiesOutcome ComprehendClient::ContainsPiiEntities(const ContainsPiiEntitiesRequest& request) const
305 {
306 Aws::Http::URI uri = m_uri;
307 return ContainsPiiEntitiesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
308 }
309
ContainsPiiEntitiesCallable(const ContainsPiiEntitiesRequest & request) const310 ContainsPiiEntitiesOutcomeCallable ComprehendClient::ContainsPiiEntitiesCallable(const ContainsPiiEntitiesRequest& request) const
311 {
312 auto task = Aws::MakeShared< std::packaged_task< ContainsPiiEntitiesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ContainsPiiEntities(request); } );
313 auto packagedFunction = [task]() { (*task)(); };
314 m_executor->Submit(packagedFunction);
315 return task->get_future();
316 }
317
ContainsPiiEntitiesAsync(const ContainsPiiEntitiesRequest & request,const ContainsPiiEntitiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const318 void ComprehendClient::ContainsPiiEntitiesAsync(const ContainsPiiEntitiesRequest& request, const ContainsPiiEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
319 {
320 m_executor->Submit( [this, request, handler, context](){ this->ContainsPiiEntitiesAsyncHelper( request, handler, context ); } );
321 }
322
ContainsPiiEntitiesAsyncHelper(const ContainsPiiEntitiesRequest & request,const ContainsPiiEntitiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const323 void ComprehendClient::ContainsPiiEntitiesAsyncHelper(const ContainsPiiEntitiesRequest& request, const ContainsPiiEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
324 {
325 handler(this, request, ContainsPiiEntities(request), context);
326 }
327
CreateDocumentClassifier(const CreateDocumentClassifierRequest & request) const328 CreateDocumentClassifierOutcome ComprehendClient::CreateDocumentClassifier(const CreateDocumentClassifierRequest& request) const
329 {
330 Aws::Http::URI uri = m_uri;
331 return CreateDocumentClassifierOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
332 }
333
CreateDocumentClassifierCallable(const CreateDocumentClassifierRequest & request) const334 CreateDocumentClassifierOutcomeCallable ComprehendClient::CreateDocumentClassifierCallable(const CreateDocumentClassifierRequest& request) const
335 {
336 auto task = Aws::MakeShared< std::packaged_task< CreateDocumentClassifierOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateDocumentClassifier(request); } );
337 auto packagedFunction = [task]() { (*task)(); };
338 m_executor->Submit(packagedFunction);
339 return task->get_future();
340 }
341
CreateDocumentClassifierAsync(const CreateDocumentClassifierRequest & request,const CreateDocumentClassifierResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const342 void ComprehendClient::CreateDocumentClassifierAsync(const CreateDocumentClassifierRequest& request, const CreateDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
343 {
344 m_executor->Submit( [this, request, handler, context](){ this->CreateDocumentClassifierAsyncHelper( request, handler, context ); } );
345 }
346
CreateDocumentClassifierAsyncHelper(const CreateDocumentClassifierRequest & request,const CreateDocumentClassifierResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const347 void ComprehendClient::CreateDocumentClassifierAsyncHelper(const CreateDocumentClassifierRequest& request, const CreateDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
348 {
349 handler(this, request, CreateDocumentClassifier(request), context);
350 }
351
CreateEndpoint(const CreateEndpointRequest & request) const352 CreateEndpointOutcome ComprehendClient::CreateEndpoint(const CreateEndpointRequest& request) const
353 {
354 Aws::Http::URI uri = m_uri;
355 return CreateEndpointOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
356 }
357
CreateEndpointCallable(const CreateEndpointRequest & request) const358 CreateEndpointOutcomeCallable ComprehendClient::CreateEndpointCallable(const CreateEndpointRequest& request) const
359 {
360 auto task = Aws::MakeShared< std::packaged_task< CreateEndpointOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateEndpoint(request); } );
361 auto packagedFunction = [task]() { (*task)(); };
362 m_executor->Submit(packagedFunction);
363 return task->get_future();
364 }
365
CreateEndpointAsync(const CreateEndpointRequest & request,const CreateEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const366 void ComprehendClient::CreateEndpointAsync(const CreateEndpointRequest& request, const CreateEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
367 {
368 m_executor->Submit( [this, request, handler, context](){ this->CreateEndpointAsyncHelper( request, handler, context ); } );
369 }
370
CreateEndpointAsyncHelper(const CreateEndpointRequest & request,const CreateEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const371 void ComprehendClient::CreateEndpointAsyncHelper(const CreateEndpointRequest& request, const CreateEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
372 {
373 handler(this, request, CreateEndpoint(request), context);
374 }
375
CreateEntityRecognizer(const CreateEntityRecognizerRequest & request) const376 CreateEntityRecognizerOutcome ComprehendClient::CreateEntityRecognizer(const CreateEntityRecognizerRequest& request) const
377 {
378 Aws::Http::URI uri = m_uri;
379 return CreateEntityRecognizerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
380 }
381
CreateEntityRecognizerCallable(const CreateEntityRecognizerRequest & request) const382 CreateEntityRecognizerOutcomeCallable ComprehendClient::CreateEntityRecognizerCallable(const CreateEntityRecognizerRequest& request) const
383 {
384 auto task = Aws::MakeShared< std::packaged_task< CreateEntityRecognizerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateEntityRecognizer(request); } );
385 auto packagedFunction = [task]() { (*task)(); };
386 m_executor->Submit(packagedFunction);
387 return task->get_future();
388 }
389
CreateEntityRecognizerAsync(const CreateEntityRecognizerRequest & request,const CreateEntityRecognizerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const390 void ComprehendClient::CreateEntityRecognizerAsync(const CreateEntityRecognizerRequest& request, const CreateEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
391 {
392 m_executor->Submit( [this, request, handler, context](){ this->CreateEntityRecognizerAsyncHelper( request, handler, context ); } );
393 }
394
CreateEntityRecognizerAsyncHelper(const CreateEntityRecognizerRequest & request,const CreateEntityRecognizerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const395 void ComprehendClient::CreateEntityRecognizerAsyncHelper(const CreateEntityRecognizerRequest& request, const CreateEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
396 {
397 handler(this, request, CreateEntityRecognizer(request), context);
398 }
399
DeleteDocumentClassifier(const DeleteDocumentClassifierRequest & request) const400 DeleteDocumentClassifierOutcome ComprehendClient::DeleteDocumentClassifier(const DeleteDocumentClassifierRequest& request) const
401 {
402 Aws::Http::URI uri = m_uri;
403 return DeleteDocumentClassifierOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
404 }
405
DeleteDocumentClassifierCallable(const DeleteDocumentClassifierRequest & request) const406 DeleteDocumentClassifierOutcomeCallable ComprehendClient::DeleteDocumentClassifierCallable(const DeleteDocumentClassifierRequest& request) const
407 {
408 auto task = Aws::MakeShared< std::packaged_task< DeleteDocumentClassifierOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteDocumentClassifier(request); } );
409 auto packagedFunction = [task]() { (*task)(); };
410 m_executor->Submit(packagedFunction);
411 return task->get_future();
412 }
413
DeleteDocumentClassifierAsync(const DeleteDocumentClassifierRequest & request,const DeleteDocumentClassifierResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const414 void ComprehendClient::DeleteDocumentClassifierAsync(const DeleteDocumentClassifierRequest& request, const DeleteDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
415 {
416 m_executor->Submit( [this, request, handler, context](){ this->DeleteDocumentClassifierAsyncHelper( request, handler, context ); } );
417 }
418
DeleteDocumentClassifierAsyncHelper(const DeleteDocumentClassifierRequest & request,const DeleteDocumentClassifierResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const419 void ComprehendClient::DeleteDocumentClassifierAsyncHelper(const DeleteDocumentClassifierRequest& request, const DeleteDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
420 {
421 handler(this, request, DeleteDocumentClassifier(request), context);
422 }
423
DeleteEndpoint(const DeleteEndpointRequest & request) const424 DeleteEndpointOutcome ComprehendClient::DeleteEndpoint(const DeleteEndpointRequest& request) const
425 {
426 Aws::Http::URI uri = m_uri;
427 return DeleteEndpointOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
428 }
429
DeleteEndpointCallable(const DeleteEndpointRequest & request) const430 DeleteEndpointOutcomeCallable ComprehendClient::DeleteEndpointCallable(const DeleteEndpointRequest& request) const
431 {
432 auto task = Aws::MakeShared< std::packaged_task< DeleteEndpointOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteEndpoint(request); } );
433 auto packagedFunction = [task]() { (*task)(); };
434 m_executor->Submit(packagedFunction);
435 return task->get_future();
436 }
437
DeleteEndpointAsync(const DeleteEndpointRequest & request,const DeleteEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const438 void ComprehendClient::DeleteEndpointAsync(const DeleteEndpointRequest& request, const DeleteEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
439 {
440 m_executor->Submit( [this, request, handler, context](){ this->DeleteEndpointAsyncHelper( request, handler, context ); } );
441 }
442
DeleteEndpointAsyncHelper(const DeleteEndpointRequest & request,const DeleteEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const443 void ComprehendClient::DeleteEndpointAsyncHelper(const DeleteEndpointRequest& request, const DeleteEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
444 {
445 handler(this, request, DeleteEndpoint(request), context);
446 }
447
DeleteEntityRecognizer(const DeleteEntityRecognizerRequest & request) const448 DeleteEntityRecognizerOutcome ComprehendClient::DeleteEntityRecognizer(const DeleteEntityRecognizerRequest& request) const
449 {
450 Aws::Http::URI uri = m_uri;
451 return DeleteEntityRecognizerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
452 }
453
DeleteEntityRecognizerCallable(const DeleteEntityRecognizerRequest & request) const454 DeleteEntityRecognizerOutcomeCallable ComprehendClient::DeleteEntityRecognizerCallable(const DeleteEntityRecognizerRequest& request) const
455 {
456 auto task = Aws::MakeShared< std::packaged_task< DeleteEntityRecognizerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteEntityRecognizer(request); } );
457 auto packagedFunction = [task]() { (*task)(); };
458 m_executor->Submit(packagedFunction);
459 return task->get_future();
460 }
461
DeleteEntityRecognizerAsync(const DeleteEntityRecognizerRequest & request,const DeleteEntityRecognizerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const462 void ComprehendClient::DeleteEntityRecognizerAsync(const DeleteEntityRecognizerRequest& request, const DeleteEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
463 {
464 m_executor->Submit( [this, request, handler, context](){ this->DeleteEntityRecognizerAsyncHelper( request, handler, context ); } );
465 }
466
DeleteEntityRecognizerAsyncHelper(const DeleteEntityRecognizerRequest & request,const DeleteEntityRecognizerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const467 void ComprehendClient::DeleteEntityRecognizerAsyncHelper(const DeleteEntityRecognizerRequest& request, const DeleteEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
468 {
469 handler(this, request, DeleteEntityRecognizer(request), context);
470 }
471
DescribeDocumentClassificationJob(const DescribeDocumentClassificationJobRequest & request) const472 DescribeDocumentClassificationJobOutcome ComprehendClient::DescribeDocumentClassificationJob(const DescribeDocumentClassificationJobRequest& request) const
473 {
474 Aws::Http::URI uri = m_uri;
475 return DescribeDocumentClassificationJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
476 }
477
DescribeDocumentClassificationJobCallable(const DescribeDocumentClassificationJobRequest & request) const478 DescribeDocumentClassificationJobOutcomeCallable ComprehendClient::DescribeDocumentClassificationJobCallable(const DescribeDocumentClassificationJobRequest& request) const
479 {
480 auto task = Aws::MakeShared< std::packaged_task< DescribeDocumentClassificationJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeDocumentClassificationJob(request); } );
481 auto packagedFunction = [task]() { (*task)(); };
482 m_executor->Submit(packagedFunction);
483 return task->get_future();
484 }
485
DescribeDocumentClassificationJobAsync(const DescribeDocumentClassificationJobRequest & request,const DescribeDocumentClassificationJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const486 void ComprehendClient::DescribeDocumentClassificationJobAsync(const DescribeDocumentClassificationJobRequest& request, const DescribeDocumentClassificationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
487 {
488 m_executor->Submit( [this, request, handler, context](){ this->DescribeDocumentClassificationJobAsyncHelper( request, handler, context ); } );
489 }
490
DescribeDocumentClassificationJobAsyncHelper(const DescribeDocumentClassificationJobRequest & request,const DescribeDocumentClassificationJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const491 void ComprehendClient::DescribeDocumentClassificationJobAsyncHelper(const DescribeDocumentClassificationJobRequest& request, const DescribeDocumentClassificationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
492 {
493 handler(this, request, DescribeDocumentClassificationJob(request), context);
494 }
495
DescribeDocumentClassifier(const DescribeDocumentClassifierRequest & request) const496 DescribeDocumentClassifierOutcome ComprehendClient::DescribeDocumentClassifier(const DescribeDocumentClassifierRequest& request) const
497 {
498 Aws::Http::URI uri = m_uri;
499 return DescribeDocumentClassifierOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
500 }
501
DescribeDocumentClassifierCallable(const DescribeDocumentClassifierRequest & request) const502 DescribeDocumentClassifierOutcomeCallable ComprehendClient::DescribeDocumentClassifierCallable(const DescribeDocumentClassifierRequest& request) const
503 {
504 auto task = Aws::MakeShared< std::packaged_task< DescribeDocumentClassifierOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeDocumentClassifier(request); } );
505 auto packagedFunction = [task]() { (*task)(); };
506 m_executor->Submit(packagedFunction);
507 return task->get_future();
508 }
509
DescribeDocumentClassifierAsync(const DescribeDocumentClassifierRequest & request,const DescribeDocumentClassifierResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const510 void ComprehendClient::DescribeDocumentClassifierAsync(const DescribeDocumentClassifierRequest& request, const DescribeDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
511 {
512 m_executor->Submit( [this, request, handler, context](){ this->DescribeDocumentClassifierAsyncHelper( request, handler, context ); } );
513 }
514
DescribeDocumentClassifierAsyncHelper(const DescribeDocumentClassifierRequest & request,const DescribeDocumentClassifierResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const515 void ComprehendClient::DescribeDocumentClassifierAsyncHelper(const DescribeDocumentClassifierRequest& request, const DescribeDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
516 {
517 handler(this, request, DescribeDocumentClassifier(request), context);
518 }
519
DescribeDominantLanguageDetectionJob(const DescribeDominantLanguageDetectionJobRequest & request) const520 DescribeDominantLanguageDetectionJobOutcome ComprehendClient::DescribeDominantLanguageDetectionJob(const DescribeDominantLanguageDetectionJobRequest& request) const
521 {
522 Aws::Http::URI uri = m_uri;
523 return DescribeDominantLanguageDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
524 }
525
DescribeDominantLanguageDetectionJobCallable(const DescribeDominantLanguageDetectionJobRequest & request) const526 DescribeDominantLanguageDetectionJobOutcomeCallable ComprehendClient::DescribeDominantLanguageDetectionJobCallable(const DescribeDominantLanguageDetectionJobRequest& request) const
527 {
528 auto task = Aws::MakeShared< std::packaged_task< DescribeDominantLanguageDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeDominantLanguageDetectionJob(request); } );
529 auto packagedFunction = [task]() { (*task)(); };
530 m_executor->Submit(packagedFunction);
531 return task->get_future();
532 }
533
DescribeDominantLanguageDetectionJobAsync(const DescribeDominantLanguageDetectionJobRequest & request,const DescribeDominantLanguageDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const534 void ComprehendClient::DescribeDominantLanguageDetectionJobAsync(const DescribeDominantLanguageDetectionJobRequest& request, const DescribeDominantLanguageDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
535 {
536 m_executor->Submit( [this, request, handler, context](){ this->DescribeDominantLanguageDetectionJobAsyncHelper( request, handler, context ); } );
537 }
538
DescribeDominantLanguageDetectionJobAsyncHelper(const DescribeDominantLanguageDetectionJobRequest & request,const DescribeDominantLanguageDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const539 void ComprehendClient::DescribeDominantLanguageDetectionJobAsyncHelper(const DescribeDominantLanguageDetectionJobRequest& request, const DescribeDominantLanguageDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
540 {
541 handler(this, request, DescribeDominantLanguageDetectionJob(request), context);
542 }
543
DescribeEndpoint(const DescribeEndpointRequest & request) const544 DescribeEndpointOutcome ComprehendClient::DescribeEndpoint(const DescribeEndpointRequest& request) const
545 {
546 Aws::Http::URI uri = m_uri;
547 return DescribeEndpointOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
548 }
549
DescribeEndpointCallable(const DescribeEndpointRequest & request) const550 DescribeEndpointOutcomeCallable ComprehendClient::DescribeEndpointCallable(const DescribeEndpointRequest& request) const
551 {
552 auto task = Aws::MakeShared< std::packaged_task< DescribeEndpointOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeEndpoint(request); } );
553 auto packagedFunction = [task]() { (*task)(); };
554 m_executor->Submit(packagedFunction);
555 return task->get_future();
556 }
557
DescribeEndpointAsync(const DescribeEndpointRequest & request,const DescribeEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const558 void ComprehendClient::DescribeEndpointAsync(const DescribeEndpointRequest& request, const DescribeEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
559 {
560 m_executor->Submit( [this, request, handler, context](){ this->DescribeEndpointAsyncHelper( request, handler, context ); } );
561 }
562
DescribeEndpointAsyncHelper(const DescribeEndpointRequest & request,const DescribeEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const563 void ComprehendClient::DescribeEndpointAsyncHelper(const DescribeEndpointRequest& request, const DescribeEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
564 {
565 handler(this, request, DescribeEndpoint(request), context);
566 }
567
DescribeEntitiesDetectionJob(const DescribeEntitiesDetectionJobRequest & request) const568 DescribeEntitiesDetectionJobOutcome ComprehendClient::DescribeEntitiesDetectionJob(const DescribeEntitiesDetectionJobRequest& request) const
569 {
570 Aws::Http::URI uri = m_uri;
571 return DescribeEntitiesDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
572 }
573
DescribeEntitiesDetectionJobCallable(const DescribeEntitiesDetectionJobRequest & request) const574 DescribeEntitiesDetectionJobOutcomeCallable ComprehendClient::DescribeEntitiesDetectionJobCallable(const DescribeEntitiesDetectionJobRequest& request) const
575 {
576 auto task = Aws::MakeShared< std::packaged_task< DescribeEntitiesDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeEntitiesDetectionJob(request); } );
577 auto packagedFunction = [task]() { (*task)(); };
578 m_executor->Submit(packagedFunction);
579 return task->get_future();
580 }
581
DescribeEntitiesDetectionJobAsync(const DescribeEntitiesDetectionJobRequest & request,const DescribeEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const582 void ComprehendClient::DescribeEntitiesDetectionJobAsync(const DescribeEntitiesDetectionJobRequest& request, const DescribeEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
583 {
584 m_executor->Submit( [this, request, handler, context](){ this->DescribeEntitiesDetectionJobAsyncHelper( request, handler, context ); } );
585 }
586
DescribeEntitiesDetectionJobAsyncHelper(const DescribeEntitiesDetectionJobRequest & request,const DescribeEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const587 void ComprehendClient::DescribeEntitiesDetectionJobAsyncHelper(const DescribeEntitiesDetectionJobRequest& request, const DescribeEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
588 {
589 handler(this, request, DescribeEntitiesDetectionJob(request), context);
590 }
591
DescribeEntityRecognizer(const DescribeEntityRecognizerRequest & request) const592 DescribeEntityRecognizerOutcome ComprehendClient::DescribeEntityRecognizer(const DescribeEntityRecognizerRequest& request) const
593 {
594 Aws::Http::URI uri = m_uri;
595 return DescribeEntityRecognizerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
596 }
597
DescribeEntityRecognizerCallable(const DescribeEntityRecognizerRequest & request) const598 DescribeEntityRecognizerOutcomeCallable ComprehendClient::DescribeEntityRecognizerCallable(const DescribeEntityRecognizerRequest& request) const
599 {
600 auto task = Aws::MakeShared< std::packaged_task< DescribeEntityRecognizerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeEntityRecognizer(request); } );
601 auto packagedFunction = [task]() { (*task)(); };
602 m_executor->Submit(packagedFunction);
603 return task->get_future();
604 }
605
DescribeEntityRecognizerAsync(const DescribeEntityRecognizerRequest & request,const DescribeEntityRecognizerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const606 void ComprehendClient::DescribeEntityRecognizerAsync(const DescribeEntityRecognizerRequest& request, const DescribeEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
607 {
608 m_executor->Submit( [this, request, handler, context](){ this->DescribeEntityRecognizerAsyncHelper( request, handler, context ); } );
609 }
610
DescribeEntityRecognizerAsyncHelper(const DescribeEntityRecognizerRequest & request,const DescribeEntityRecognizerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const611 void ComprehendClient::DescribeEntityRecognizerAsyncHelper(const DescribeEntityRecognizerRequest& request, const DescribeEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
612 {
613 handler(this, request, DescribeEntityRecognizer(request), context);
614 }
615
DescribeEventsDetectionJob(const DescribeEventsDetectionJobRequest & request) const616 DescribeEventsDetectionJobOutcome ComprehendClient::DescribeEventsDetectionJob(const DescribeEventsDetectionJobRequest& request) const
617 {
618 Aws::Http::URI uri = m_uri;
619 return DescribeEventsDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
620 }
621
DescribeEventsDetectionJobCallable(const DescribeEventsDetectionJobRequest & request) const622 DescribeEventsDetectionJobOutcomeCallable ComprehendClient::DescribeEventsDetectionJobCallable(const DescribeEventsDetectionJobRequest& request) const
623 {
624 auto task = Aws::MakeShared< std::packaged_task< DescribeEventsDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeEventsDetectionJob(request); } );
625 auto packagedFunction = [task]() { (*task)(); };
626 m_executor->Submit(packagedFunction);
627 return task->get_future();
628 }
629
DescribeEventsDetectionJobAsync(const DescribeEventsDetectionJobRequest & request,const DescribeEventsDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const630 void ComprehendClient::DescribeEventsDetectionJobAsync(const DescribeEventsDetectionJobRequest& request, const DescribeEventsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
631 {
632 m_executor->Submit( [this, request, handler, context](){ this->DescribeEventsDetectionJobAsyncHelper( request, handler, context ); } );
633 }
634
DescribeEventsDetectionJobAsyncHelper(const DescribeEventsDetectionJobRequest & request,const DescribeEventsDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const635 void ComprehendClient::DescribeEventsDetectionJobAsyncHelper(const DescribeEventsDetectionJobRequest& request, const DescribeEventsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
636 {
637 handler(this, request, DescribeEventsDetectionJob(request), context);
638 }
639
DescribeKeyPhrasesDetectionJob(const DescribeKeyPhrasesDetectionJobRequest & request) const640 DescribeKeyPhrasesDetectionJobOutcome ComprehendClient::DescribeKeyPhrasesDetectionJob(const DescribeKeyPhrasesDetectionJobRequest& request) const
641 {
642 Aws::Http::URI uri = m_uri;
643 return DescribeKeyPhrasesDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
644 }
645
DescribeKeyPhrasesDetectionJobCallable(const DescribeKeyPhrasesDetectionJobRequest & request) const646 DescribeKeyPhrasesDetectionJobOutcomeCallable ComprehendClient::DescribeKeyPhrasesDetectionJobCallable(const DescribeKeyPhrasesDetectionJobRequest& request) const
647 {
648 auto task = Aws::MakeShared< std::packaged_task< DescribeKeyPhrasesDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeKeyPhrasesDetectionJob(request); } );
649 auto packagedFunction = [task]() { (*task)(); };
650 m_executor->Submit(packagedFunction);
651 return task->get_future();
652 }
653
DescribeKeyPhrasesDetectionJobAsync(const DescribeKeyPhrasesDetectionJobRequest & request,const DescribeKeyPhrasesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const654 void ComprehendClient::DescribeKeyPhrasesDetectionJobAsync(const DescribeKeyPhrasesDetectionJobRequest& request, const DescribeKeyPhrasesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
655 {
656 m_executor->Submit( [this, request, handler, context](){ this->DescribeKeyPhrasesDetectionJobAsyncHelper( request, handler, context ); } );
657 }
658
DescribeKeyPhrasesDetectionJobAsyncHelper(const DescribeKeyPhrasesDetectionJobRequest & request,const DescribeKeyPhrasesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const659 void ComprehendClient::DescribeKeyPhrasesDetectionJobAsyncHelper(const DescribeKeyPhrasesDetectionJobRequest& request, const DescribeKeyPhrasesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
660 {
661 handler(this, request, DescribeKeyPhrasesDetectionJob(request), context);
662 }
663
DescribePiiEntitiesDetectionJob(const DescribePiiEntitiesDetectionJobRequest & request) const664 DescribePiiEntitiesDetectionJobOutcome ComprehendClient::DescribePiiEntitiesDetectionJob(const DescribePiiEntitiesDetectionJobRequest& request) const
665 {
666 Aws::Http::URI uri = m_uri;
667 return DescribePiiEntitiesDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
668 }
669
DescribePiiEntitiesDetectionJobCallable(const DescribePiiEntitiesDetectionJobRequest & request) const670 DescribePiiEntitiesDetectionJobOutcomeCallable ComprehendClient::DescribePiiEntitiesDetectionJobCallable(const DescribePiiEntitiesDetectionJobRequest& request) const
671 {
672 auto task = Aws::MakeShared< std::packaged_task< DescribePiiEntitiesDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribePiiEntitiesDetectionJob(request); } );
673 auto packagedFunction = [task]() { (*task)(); };
674 m_executor->Submit(packagedFunction);
675 return task->get_future();
676 }
677
DescribePiiEntitiesDetectionJobAsync(const DescribePiiEntitiesDetectionJobRequest & request,const DescribePiiEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const678 void ComprehendClient::DescribePiiEntitiesDetectionJobAsync(const DescribePiiEntitiesDetectionJobRequest& request, const DescribePiiEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
679 {
680 m_executor->Submit( [this, request, handler, context](){ this->DescribePiiEntitiesDetectionJobAsyncHelper( request, handler, context ); } );
681 }
682
DescribePiiEntitiesDetectionJobAsyncHelper(const DescribePiiEntitiesDetectionJobRequest & request,const DescribePiiEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const683 void ComprehendClient::DescribePiiEntitiesDetectionJobAsyncHelper(const DescribePiiEntitiesDetectionJobRequest& request, const DescribePiiEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
684 {
685 handler(this, request, DescribePiiEntitiesDetectionJob(request), context);
686 }
687
DescribeSentimentDetectionJob(const DescribeSentimentDetectionJobRequest & request) const688 DescribeSentimentDetectionJobOutcome ComprehendClient::DescribeSentimentDetectionJob(const DescribeSentimentDetectionJobRequest& request) const
689 {
690 Aws::Http::URI uri = m_uri;
691 return DescribeSentimentDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
692 }
693
DescribeSentimentDetectionJobCallable(const DescribeSentimentDetectionJobRequest & request) const694 DescribeSentimentDetectionJobOutcomeCallable ComprehendClient::DescribeSentimentDetectionJobCallable(const DescribeSentimentDetectionJobRequest& request) const
695 {
696 auto task = Aws::MakeShared< std::packaged_task< DescribeSentimentDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeSentimentDetectionJob(request); } );
697 auto packagedFunction = [task]() { (*task)(); };
698 m_executor->Submit(packagedFunction);
699 return task->get_future();
700 }
701
DescribeSentimentDetectionJobAsync(const DescribeSentimentDetectionJobRequest & request,const DescribeSentimentDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const702 void ComprehendClient::DescribeSentimentDetectionJobAsync(const DescribeSentimentDetectionJobRequest& request, const DescribeSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
703 {
704 m_executor->Submit( [this, request, handler, context](){ this->DescribeSentimentDetectionJobAsyncHelper( request, handler, context ); } );
705 }
706
DescribeSentimentDetectionJobAsyncHelper(const DescribeSentimentDetectionJobRequest & request,const DescribeSentimentDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const707 void ComprehendClient::DescribeSentimentDetectionJobAsyncHelper(const DescribeSentimentDetectionJobRequest& request, const DescribeSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
708 {
709 handler(this, request, DescribeSentimentDetectionJob(request), context);
710 }
711
DescribeTopicsDetectionJob(const DescribeTopicsDetectionJobRequest & request) const712 DescribeTopicsDetectionJobOutcome ComprehendClient::DescribeTopicsDetectionJob(const DescribeTopicsDetectionJobRequest& request) const
713 {
714 Aws::Http::URI uri = m_uri;
715 return DescribeTopicsDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
716 }
717
DescribeTopicsDetectionJobCallable(const DescribeTopicsDetectionJobRequest & request) const718 DescribeTopicsDetectionJobOutcomeCallable ComprehendClient::DescribeTopicsDetectionJobCallable(const DescribeTopicsDetectionJobRequest& request) const
719 {
720 auto task = Aws::MakeShared< std::packaged_task< DescribeTopicsDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeTopicsDetectionJob(request); } );
721 auto packagedFunction = [task]() { (*task)(); };
722 m_executor->Submit(packagedFunction);
723 return task->get_future();
724 }
725
DescribeTopicsDetectionJobAsync(const DescribeTopicsDetectionJobRequest & request,const DescribeTopicsDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const726 void ComprehendClient::DescribeTopicsDetectionJobAsync(const DescribeTopicsDetectionJobRequest& request, const DescribeTopicsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
727 {
728 m_executor->Submit( [this, request, handler, context](){ this->DescribeTopicsDetectionJobAsyncHelper( request, handler, context ); } );
729 }
730
DescribeTopicsDetectionJobAsyncHelper(const DescribeTopicsDetectionJobRequest & request,const DescribeTopicsDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const731 void ComprehendClient::DescribeTopicsDetectionJobAsyncHelper(const DescribeTopicsDetectionJobRequest& request, const DescribeTopicsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
732 {
733 handler(this, request, DescribeTopicsDetectionJob(request), context);
734 }
735
DetectDominantLanguage(const DetectDominantLanguageRequest & request) const736 DetectDominantLanguageOutcome ComprehendClient::DetectDominantLanguage(const DetectDominantLanguageRequest& request) const
737 {
738 Aws::Http::URI uri = m_uri;
739 return DetectDominantLanguageOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
740 }
741
DetectDominantLanguageCallable(const DetectDominantLanguageRequest & request) const742 DetectDominantLanguageOutcomeCallable ComprehendClient::DetectDominantLanguageCallable(const DetectDominantLanguageRequest& request) const
743 {
744 auto task = Aws::MakeShared< std::packaged_task< DetectDominantLanguageOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DetectDominantLanguage(request); } );
745 auto packagedFunction = [task]() { (*task)(); };
746 m_executor->Submit(packagedFunction);
747 return task->get_future();
748 }
749
DetectDominantLanguageAsync(const DetectDominantLanguageRequest & request,const DetectDominantLanguageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const750 void ComprehendClient::DetectDominantLanguageAsync(const DetectDominantLanguageRequest& request, const DetectDominantLanguageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
751 {
752 m_executor->Submit( [this, request, handler, context](){ this->DetectDominantLanguageAsyncHelper( request, handler, context ); } );
753 }
754
DetectDominantLanguageAsyncHelper(const DetectDominantLanguageRequest & request,const DetectDominantLanguageResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const755 void ComprehendClient::DetectDominantLanguageAsyncHelper(const DetectDominantLanguageRequest& request, const DetectDominantLanguageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
756 {
757 handler(this, request, DetectDominantLanguage(request), context);
758 }
759
DetectEntities(const DetectEntitiesRequest & request) const760 DetectEntitiesOutcome ComprehendClient::DetectEntities(const DetectEntitiesRequest& request) const
761 {
762 Aws::Http::URI uri = m_uri;
763 return DetectEntitiesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
764 }
765
DetectEntitiesCallable(const DetectEntitiesRequest & request) const766 DetectEntitiesOutcomeCallable ComprehendClient::DetectEntitiesCallable(const DetectEntitiesRequest& request) const
767 {
768 auto task = Aws::MakeShared< std::packaged_task< DetectEntitiesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DetectEntities(request); } );
769 auto packagedFunction = [task]() { (*task)(); };
770 m_executor->Submit(packagedFunction);
771 return task->get_future();
772 }
773
DetectEntitiesAsync(const DetectEntitiesRequest & request,const DetectEntitiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const774 void ComprehendClient::DetectEntitiesAsync(const DetectEntitiesRequest& request, const DetectEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
775 {
776 m_executor->Submit( [this, request, handler, context](){ this->DetectEntitiesAsyncHelper( request, handler, context ); } );
777 }
778
DetectEntitiesAsyncHelper(const DetectEntitiesRequest & request,const DetectEntitiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const779 void ComprehendClient::DetectEntitiesAsyncHelper(const DetectEntitiesRequest& request, const DetectEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
780 {
781 handler(this, request, DetectEntities(request), context);
782 }
783
DetectKeyPhrases(const DetectKeyPhrasesRequest & request) const784 DetectKeyPhrasesOutcome ComprehendClient::DetectKeyPhrases(const DetectKeyPhrasesRequest& request) const
785 {
786 Aws::Http::URI uri = m_uri;
787 return DetectKeyPhrasesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
788 }
789
DetectKeyPhrasesCallable(const DetectKeyPhrasesRequest & request) const790 DetectKeyPhrasesOutcomeCallable ComprehendClient::DetectKeyPhrasesCallable(const DetectKeyPhrasesRequest& request) const
791 {
792 auto task = Aws::MakeShared< std::packaged_task< DetectKeyPhrasesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DetectKeyPhrases(request); } );
793 auto packagedFunction = [task]() { (*task)(); };
794 m_executor->Submit(packagedFunction);
795 return task->get_future();
796 }
797
DetectKeyPhrasesAsync(const DetectKeyPhrasesRequest & request,const DetectKeyPhrasesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const798 void ComprehendClient::DetectKeyPhrasesAsync(const DetectKeyPhrasesRequest& request, const DetectKeyPhrasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
799 {
800 m_executor->Submit( [this, request, handler, context](){ this->DetectKeyPhrasesAsyncHelper( request, handler, context ); } );
801 }
802
DetectKeyPhrasesAsyncHelper(const DetectKeyPhrasesRequest & request,const DetectKeyPhrasesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const803 void ComprehendClient::DetectKeyPhrasesAsyncHelper(const DetectKeyPhrasesRequest& request, const DetectKeyPhrasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
804 {
805 handler(this, request, DetectKeyPhrases(request), context);
806 }
807
DetectPiiEntities(const DetectPiiEntitiesRequest & request) const808 DetectPiiEntitiesOutcome ComprehendClient::DetectPiiEntities(const DetectPiiEntitiesRequest& request) const
809 {
810 Aws::Http::URI uri = m_uri;
811 return DetectPiiEntitiesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
812 }
813
DetectPiiEntitiesCallable(const DetectPiiEntitiesRequest & request) const814 DetectPiiEntitiesOutcomeCallable ComprehendClient::DetectPiiEntitiesCallable(const DetectPiiEntitiesRequest& request) const
815 {
816 auto task = Aws::MakeShared< std::packaged_task< DetectPiiEntitiesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DetectPiiEntities(request); } );
817 auto packagedFunction = [task]() { (*task)(); };
818 m_executor->Submit(packagedFunction);
819 return task->get_future();
820 }
821
DetectPiiEntitiesAsync(const DetectPiiEntitiesRequest & request,const DetectPiiEntitiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const822 void ComprehendClient::DetectPiiEntitiesAsync(const DetectPiiEntitiesRequest& request, const DetectPiiEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
823 {
824 m_executor->Submit( [this, request, handler, context](){ this->DetectPiiEntitiesAsyncHelper( request, handler, context ); } );
825 }
826
DetectPiiEntitiesAsyncHelper(const DetectPiiEntitiesRequest & request,const DetectPiiEntitiesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const827 void ComprehendClient::DetectPiiEntitiesAsyncHelper(const DetectPiiEntitiesRequest& request, const DetectPiiEntitiesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
828 {
829 handler(this, request, DetectPiiEntities(request), context);
830 }
831
DetectSentiment(const DetectSentimentRequest & request) const832 DetectSentimentOutcome ComprehendClient::DetectSentiment(const DetectSentimentRequest& request) const
833 {
834 Aws::Http::URI uri = m_uri;
835 return DetectSentimentOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
836 }
837
DetectSentimentCallable(const DetectSentimentRequest & request) const838 DetectSentimentOutcomeCallable ComprehendClient::DetectSentimentCallable(const DetectSentimentRequest& request) const
839 {
840 auto task = Aws::MakeShared< std::packaged_task< DetectSentimentOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DetectSentiment(request); } );
841 auto packagedFunction = [task]() { (*task)(); };
842 m_executor->Submit(packagedFunction);
843 return task->get_future();
844 }
845
DetectSentimentAsync(const DetectSentimentRequest & request,const DetectSentimentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const846 void ComprehendClient::DetectSentimentAsync(const DetectSentimentRequest& request, const DetectSentimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
847 {
848 m_executor->Submit( [this, request, handler, context](){ this->DetectSentimentAsyncHelper( request, handler, context ); } );
849 }
850
DetectSentimentAsyncHelper(const DetectSentimentRequest & request,const DetectSentimentResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const851 void ComprehendClient::DetectSentimentAsyncHelper(const DetectSentimentRequest& request, const DetectSentimentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
852 {
853 handler(this, request, DetectSentiment(request), context);
854 }
855
DetectSyntax(const DetectSyntaxRequest & request) const856 DetectSyntaxOutcome ComprehendClient::DetectSyntax(const DetectSyntaxRequest& request) const
857 {
858 Aws::Http::URI uri = m_uri;
859 return DetectSyntaxOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
860 }
861
DetectSyntaxCallable(const DetectSyntaxRequest & request) const862 DetectSyntaxOutcomeCallable ComprehendClient::DetectSyntaxCallable(const DetectSyntaxRequest& request) const
863 {
864 auto task = Aws::MakeShared< std::packaged_task< DetectSyntaxOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DetectSyntax(request); } );
865 auto packagedFunction = [task]() { (*task)(); };
866 m_executor->Submit(packagedFunction);
867 return task->get_future();
868 }
869
DetectSyntaxAsync(const DetectSyntaxRequest & request,const DetectSyntaxResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const870 void ComprehendClient::DetectSyntaxAsync(const DetectSyntaxRequest& request, const DetectSyntaxResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
871 {
872 m_executor->Submit( [this, request, handler, context](){ this->DetectSyntaxAsyncHelper( request, handler, context ); } );
873 }
874
DetectSyntaxAsyncHelper(const DetectSyntaxRequest & request,const DetectSyntaxResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const875 void ComprehendClient::DetectSyntaxAsyncHelper(const DetectSyntaxRequest& request, const DetectSyntaxResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
876 {
877 handler(this, request, DetectSyntax(request), context);
878 }
879
ListDocumentClassificationJobs(const ListDocumentClassificationJobsRequest & request) const880 ListDocumentClassificationJobsOutcome ComprehendClient::ListDocumentClassificationJobs(const ListDocumentClassificationJobsRequest& request) const
881 {
882 Aws::Http::URI uri = m_uri;
883 return ListDocumentClassificationJobsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
884 }
885
ListDocumentClassificationJobsCallable(const ListDocumentClassificationJobsRequest & request) const886 ListDocumentClassificationJobsOutcomeCallable ComprehendClient::ListDocumentClassificationJobsCallable(const ListDocumentClassificationJobsRequest& request) const
887 {
888 auto task = Aws::MakeShared< std::packaged_task< ListDocumentClassificationJobsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDocumentClassificationJobs(request); } );
889 auto packagedFunction = [task]() { (*task)(); };
890 m_executor->Submit(packagedFunction);
891 return task->get_future();
892 }
893
ListDocumentClassificationJobsAsync(const ListDocumentClassificationJobsRequest & request,const ListDocumentClassificationJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const894 void ComprehendClient::ListDocumentClassificationJobsAsync(const ListDocumentClassificationJobsRequest& request, const ListDocumentClassificationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
895 {
896 m_executor->Submit( [this, request, handler, context](){ this->ListDocumentClassificationJobsAsyncHelper( request, handler, context ); } );
897 }
898
ListDocumentClassificationJobsAsyncHelper(const ListDocumentClassificationJobsRequest & request,const ListDocumentClassificationJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const899 void ComprehendClient::ListDocumentClassificationJobsAsyncHelper(const ListDocumentClassificationJobsRequest& request, const ListDocumentClassificationJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
900 {
901 handler(this, request, ListDocumentClassificationJobs(request), context);
902 }
903
ListDocumentClassifierSummaries(const ListDocumentClassifierSummariesRequest & request) const904 ListDocumentClassifierSummariesOutcome ComprehendClient::ListDocumentClassifierSummaries(const ListDocumentClassifierSummariesRequest& request) const
905 {
906 Aws::Http::URI uri = m_uri;
907 return ListDocumentClassifierSummariesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
908 }
909
ListDocumentClassifierSummariesCallable(const ListDocumentClassifierSummariesRequest & request) const910 ListDocumentClassifierSummariesOutcomeCallable ComprehendClient::ListDocumentClassifierSummariesCallable(const ListDocumentClassifierSummariesRequest& request) const
911 {
912 auto task = Aws::MakeShared< std::packaged_task< ListDocumentClassifierSummariesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDocumentClassifierSummaries(request); } );
913 auto packagedFunction = [task]() { (*task)(); };
914 m_executor->Submit(packagedFunction);
915 return task->get_future();
916 }
917
ListDocumentClassifierSummariesAsync(const ListDocumentClassifierSummariesRequest & request,const ListDocumentClassifierSummariesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const918 void ComprehendClient::ListDocumentClassifierSummariesAsync(const ListDocumentClassifierSummariesRequest& request, const ListDocumentClassifierSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
919 {
920 m_executor->Submit( [this, request, handler, context](){ this->ListDocumentClassifierSummariesAsyncHelper( request, handler, context ); } );
921 }
922
ListDocumentClassifierSummariesAsyncHelper(const ListDocumentClassifierSummariesRequest & request,const ListDocumentClassifierSummariesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const923 void ComprehendClient::ListDocumentClassifierSummariesAsyncHelper(const ListDocumentClassifierSummariesRequest& request, const ListDocumentClassifierSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
924 {
925 handler(this, request, ListDocumentClassifierSummaries(request), context);
926 }
927
ListDocumentClassifiers(const ListDocumentClassifiersRequest & request) const928 ListDocumentClassifiersOutcome ComprehendClient::ListDocumentClassifiers(const ListDocumentClassifiersRequest& request) const
929 {
930 Aws::Http::URI uri = m_uri;
931 return ListDocumentClassifiersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
932 }
933
ListDocumentClassifiersCallable(const ListDocumentClassifiersRequest & request) const934 ListDocumentClassifiersOutcomeCallable ComprehendClient::ListDocumentClassifiersCallable(const ListDocumentClassifiersRequest& request) const
935 {
936 auto task = Aws::MakeShared< std::packaged_task< ListDocumentClassifiersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDocumentClassifiers(request); } );
937 auto packagedFunction = [task]() { (*task)(); };
938 m_executor->Submit(packagedFunction);
939 return task->get_future();
940 }
941
ListDocumentClassifiersAsync(const ListDocumentClassifiersRequest & request,const ListDocumentClassifiersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const942 void ComprehendClient::ListDocumentClassifiersAsync(const ListDocumentClassifiersRequest& request, const ListDocumentClassifiersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
943 {
944 m_executor->Submit( [this, request, handler, context](){ this->ListDocumentClassifiersAsyncHelper( request, handler, context ); } );
945 }
946
ListDocumentClassifiersAsyncHelper(const ListDocumentClassifiersRequest & request,const ListDocumentClassifiersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const947 void ComprehendClient::ListDocumentClassifiersAsyncHelper(const ListDocumentClassifiersRequest& request, const ListDocumentClassifiersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
948 {
949 handler(this, request, ListDocumentClassifiers(request), context);
950 }
951
ListDominantLanguageDetectionJobs(const ListDominantLanguageDetectionJobsRequest & request) const952 ListDominantLanguageDetectionJobsOutcome ComprehendClient::ListDominantLanguageDetectionJobs(const ListDominantLanguageDetectionJobsRequest& request) const
953 {
954 Aws::Http::URI uri = m_uri;
955 return ListDominantLanguageDetectionJobsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
956 }
957
ListDominantLanguageDetectionJobsCallable(const ListDominantLanguageDetectionJobsRequest & request) const958 ListDominantLanguageDetectionJobsOutcomeCallable ComprehendClient::ListDominantLanguageDetectionJobsCallable(const ListDominantLanguageDetectionJobsRequest& request) const
959 {
960 auto task = Aws::MakeShared< std::packaged_task< ListDominantLanguageDetectionJobsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDominantLanguageDetectionJobs(request); } );
961 auto packagedFunction = [task]() { (*task)(); };
962 m_executor->Submit(packagedFunction);
963 return task->get_future();
964 }
965
ListDominantLanguageDetectionJobsAsync(const ListDominantLanguageDetectionJobsRequest & request,const ListDominantLanguageDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const966 void ComprehendClient::ListDominantLanguageDetectionJobsAsync(const ListDominantLanguageDetectionJobsRequest& request, const ListDominantLanguageDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
967 {
968 m_executor->Submit( [this, request, handler, context](){ this->ListDominantLanguageDetectionJobsAsyncHelper( request, handler, context ); } );
969 }
970
ListDominantLanguageDetectionJobsAsyncHelper(const ListDominantLanguageDetectionJobsRequest & request,const ListDominantLanguageDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const971 void ComprehendClient::ListDominantLanguageDetectionJobsAsyncHelper(const ListDominantLanguageDetectionJobsRequest& request, const ListDominantLanguageDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
972 {
973 handler(this, request, ListDominantLanguageDetectionJobs(request), context);
974 }
975
ListEndpoints(const ListEndpointsRequest & request) const976 ListEndpointsOutcome ComprehendClient::ListEndpoints(const ListEndpointsRequest& request) const
977 {
978 Aws::Http::URI uri = m_uri;
979 return ListEndpointsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
980 }
981
ListEndpointsCallable(const ListEndpointsRequest & request) const982 ListEndpointsOutcomeCallable ComprehendClient::ListEndpointsCallable(const ListEndpointsRequest& request) const
983 {
984 auto task = Aws::MakeShared< std::packaged_task< ListEndpointsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListEndpoints(request); } );
985 auto packagedFunction = [task]() { (*task)(); };
986 m_executor->Submit(packagedFunction);
987 return task->get_future();
988 }
989
ListEndpointsAsync(const ListEndpointsRequest & request,const ListEndpointsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const990 void ComprehendClient::ListEndpointsAsync(const ListEndpointsRequest& request, const ListEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
991 {
992 m_executor->Submit( [this, request, handler, context](){ this->ListEndpointsAsyncHelper( request, handler, context ); } );
993 }
994
ListEndpointsAsyncHelper(const ListEndpointsRequest & request,const ListEndpointsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const995 void ComprehendClient::ListEndpointsAsyncHelper(const ListEndpointsRequest& request, const ListEndpointsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
996 {
997 handler(this, request, ListEndpoints(request), context);
998 }
999
ListEntitiesDetectionJobs(const ListEntitiesDetectionJobsRequest & request) const1000 ListEntitiesDetectionJobsOutcome ComprehendClient::ListEntitiesDetectionJobs(const ListEntitiesDetectionJobsRequest& request) const
1001 {
1002 Aws::Http::URI uri = m_uri;
1003 return ListEntitiesDetectionJobsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1004 }
1005
ListEntitiesDetectionJobsCallable(const ListEntitiesDetectionJobsRequest & request) const1006 ListEntitiesDetectionJobsOutcomeCallable ComprehendClient::ListEntitiesDetectionJobsCallable(const ListEntitiesDetectionJobsRequest& request) const
1007 {
1008 auto task = Aws::MakeShared< std::packaged_task< ListEntitiesDetectionJobsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListEntitiesDetectionJobs(request); } );
1009 auto packagedFunction = [task]() { (*task)(); };
1010 m_executor->Submit(packagedFunction);
1011 return task->get_future();
1012 }
1013
ListEntitiesDetectionJobsAsync(const ListEntitiesDetectionJobsRequest & request,const ListEntitiesDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1014 void ComprehendClient::ListEntitiesDetectionJobsAsync(const ListEntitiesDetectionJobsRequest& request, const ListEntitiesDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1015 {
1016 m_executor->Submit( [this, request, handler, context](){ this->ListEntitiesDetectionJobsAsyncHelper( request, handler, context ); } );
1017 }
1018
ListEntitiesDetectionJobsAsyncHelper(const ListEntitiesDetectionJobsRequest & request,const ListEntitiesDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1019 void ComprehendClient::ListEntitiesDetectionJobsAsyncHelper(const ListEntitiesDetectionJobsRequest& request, const ListEntitiesDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1020 {
1021 handler(this, request, ListEntitiesDetectionJobs(request), context);
1022 }
1023
ListEntityRecognizerSummaries(const ListEntityRecognizerSummariesRequest & request) const1024 ListEntityRecognizerSummariesOutcome ComprehendClient::ListEntityRecognizerSummaries(const ListEntityRecognizerSummariesRequest& request) const
1025 {
1026 Aws::Http::URI uri = m_uri;
1027 return ListEntityRecognizerSummariesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1028 }
1029
ListEntityRecognizerSummariesCallable(const ListEntityRecognizerSummariesRequest & request) const1030 ListEntityRecognizerSummariesOutcomeCallable ComprehendClient::ListEntityRecognizerSummariesCallable(const ListEntityRecognizerSummariesRequest& request) const
1031 {
1032 auto task = Aws::MakeShared< std::packaged_task< ListEntityRecognizerSummariesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListEntityRecognizerSummaries(request); } );
1033 auto packagedFunction = [task]() { (*task)(); };
1034 m_executor->Submit(packagedFunction);
1035 return task->get_future();
1036 }
1037
ListEntityRecognizerSummariesAsync(const ListEntityRecognizerSummariesRequest & request,const ListEntityRecognizerSummariesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1038 void ComprehendClient::ListEntityRecognizerSummariesAsync(const ListEntityRecognizerSummariesRequest& request, const ListEntityRecognizerSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1039 {
1040 m_executor->Submit( [this, request, handler, context](){ this->ListEntityRecognizerSummariesAsyncHelper( request, handler, context ); } );
1041 }
1042
ListEntityRecognizerSummariesAsyncHelper(const ListEntityRecognizerSummariesRequest & request,const ListEntityRecognizerSummariesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1043 void ComprehendClient::ListEntityRecognizerSummariesAsyncHelper(const ListEntityRecognizerSummariesRequest& request, const ListEntityRecognizerSummariesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1044 {
1045 handler(this, request, ListEntityRecognizerSummaries(request), context);
1046 }
1047
ListEntityRecognizers(const ListEntityRecognizersRequest & request) const1048 ListEntityRecognizersOutcome ComprehendClient::ListEntityRecognizers(const ListEntityRecognizersRequest& request) const
1049 {
1050 Aws::Http::URI uri = m_uri;
1051 return ListEntityRecognizersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1052 }
1053
ListEntityRecognizersCallable(const ListEntityRecognizersRequest & request) const1054 ListEntityRecognizersOutcomeCallable ComprehendClient::ListEntityRecognizersCallable(const ListEntityRecognizersRequest& request) const
1055 {
1056 auto task = Aws::MakeShared< std::packaged_task< ListEntityRecognizersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListEntityRecognizers(request); } );
1057 auto packagedFunction = [task]() { (*task)(); };
1058 m_executor->Submit(packagedFunction);
1059 return task->get_future();
1060 }
1061
ListEntityRecognizersAsync(const ListEntityRecognizersRequest & request,const ListEntityRecognizersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1062 void ComprehendClient::ListEntityRecognizersAsync(const ListEntityRecognizersRequest& request, const ListEntityRecognizersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1063 {
1064 m_executor->Submit( [this, request, handler, context](){ this->ListEntityRecognizersAsyncHelper( request, handler, context ); } );
1065 }
1066
ListEntityRecognizersAsyncHelper(const ListEntityRecognizersRequest & request,const ListEntityRecognizersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1067 void ComprehendClient::ListEntityRecognizersAsyncHelper(const ListEntityRecognizersRequest& request, const ListEntityRecognizersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1068 {
1069 handler(this, request, ListEntityRecognizers(request), context);
1070 }
1071
ListEventsDetectionJobs(const ListEventsDetectionJobsRequest & request) const1072 ListEventsDetectionJobsOutcome ComprehendClient::ListEventsDetectionJobs(const ListEventsDetectionJobsRequest& request) const
1073 {
1074 Aws::Http::URI uri = m_uri;
1075 return ListEventsDetectionJobsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1076 }
1077
ListEventsDetectionJobsCallable(const ListEventsDetectionJobsRequest & request) const1078 ListEventsDetectionJobsOutcomeCallable ComprehendClient::ListEventsDetectionJobsCallable(const ListEventsDetectionJobsRequest& request) const
1079 {
1080 auto task = Aws::MakeShared< std::packaged_task< ListEventsDetectionJobsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListEventsDetectionJobs(request); } );
1081 auto packagedFunction = [task]() { (*task)(); };
1082 m_executor->Submit(packagedFunction);
1083 return task->get_future();
1084 }
1085
ListEventsDetectionJobsAsync(const ListEventsDetectionJobsRequest & request,const ListEventsDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1086 void ComprehendClient::ListEventsDetectionJobsAsync(const ListEventsDetectionJobsRequest& request, const ListEventsDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1087 {
1088 m_executor->Submit( [this, request, handler, context](){ this->ListEventsDetectionJobsAsyncHelper( request, handler, context ); } );
1089 }
1090
ListEventsDetectionJobsAsyncHelper(const ListEventsDetectionJobsRequest & request,const ListEventsDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1091 void ComprehendClient::ListEventsDetectionJobsAsyncHelper(const ListEventsDetectionJobsRequest& request, const ListEventsDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1092 {
1093 handler(this, request, ListEventsDetectionJobs(request), context);
1094 }
1095
ListKeyPhrasesDetectionJobs(const ListKeyPhrasesDetectionJobsRequest & request) const1096 ListKeyPhrasesDetectionJobsOutcome ComprehendClient::ListKeyPhrasesDetectionJobs(const ListKeyPhrasesDetectionJobsRequest& request) const
1097 {
1098 Aws::Http::URI uri = m_uri;
1099 return ListKeyPhrasesDetectionJobsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1100 }
1101
ListKeyPhrasesDetectionJobsCallable(const ListKeyPhrasesDetectionJobsRequest & request) const1102 ListKeyPhrasesDetectionJobsOutcomeCallable ComprehendClient::ListKeyPhrasesDetectionJobsCallable(const ListKeyPhrasesDetectionJobsRequest& request) const
1103 {
1104 auto task = Aws::MakeShared< std::packaged_task< ListKeyPhrasesDetectionJobsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListKeyPhrasesDetectionJobs(request); } );
1105 auto packagedFunction = [task]() { (*task)(); };
1106 m_executor->Submit(packagedFunction);
1107 return task->get_future();
1108 }
1109
ListKeyPhrasesDetectionJobsAsync(const ListKeyPhrasesDetectionJobsRequest & request,const ListKeyPhrasesDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1110 void ComprehendClient::ListKeyPhrasesDetectionJobsAsync(const ListKeyPhrasesDetectionJobsRequest& request, const ListKeyPhrasesDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1111 {
1112 m_executor->Submit( [this, request, handler, context](){ this->ListKeyPhrasesDetectionJobsAsyncHelper( request, handler, context ); } );
1113 }
1114
ListKeyPhrasesDetectionJobsAsyncHelper(const ListKeyPhrasesDetectionJobsRequest & request,const ListKeyPhrasesDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1115 void ComprehendClient::ListKeyPhrasesDetectionJobsAsyncHelper(const ListKeyPhrasesDetectionJobsRequest& request, const ListKeyPhrasesDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1116 {
1117 handler(this, request, ListKeyPhrasesDetectionJobs(request), context);
1118 }
1119
ListPiiEntitiesDetectionJobs(const ListPiiEntitiesDetectionJobsRequest & request) const1120 ListPiiEntitiesDetectionJobsOutcome ComprehendClient::ListPiiEntitiesDetectionJobs(const ListPiiEntitiesDetectionJobsRequest& request) const
1121 {
1122 Aws::Http::URI uri = m_uri;
1123 return ListPiiEntitiesDetectionJobsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1124 }
1125
ListPiiEntitiesDetectionJobsCallable(const ListPiiEntitiesDetectionJobsRequest & request) const1126 ListPiiEntitiesDetectionJobsOutcomeCallable ComprehendClient::ListPiiEntitiesDetectionJobsCallable(const ListPiiEntitiesDetectionJobsRequest& request) const
1127 {
1128 auto task = Aws::MakeShared< std::packaged_task< ListPiiEntitiesDetectionJobsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPiiEntitiesDetectionJobs(request); } );
1129 auto packagedFunction = [task]() { (*task)(); };
1130 m_executor->Submit(packagedFunction);
1131 return task->get_future();
1132 }
1133
ListPiiEntitiesDetectionJobsAsync(const ListPiiEntitiesDetectionJobsRequest & request,const ListPiiEntitiesDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1134 void ComprehendClient::ListPiiEntitiesDetectionJobsAsync(const ListPiiEntitiesDetectionJobsRequest& request, const ListPiiEntitiesDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1135 {
1136 m_executor->Submit( [this, request, handler, context](){ this->ListPiiEntitiesDetectionJobsAsyncHelper( request, handler, context ); } );
1137 }
1138
ListPiiEntitiesDetectionJobsAsyncHelper(const ListPiiEntitiesDetectionJobsRequest & request,const ListPiiEntitiesDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1139 void ComprehendClient::ListPiiEntitiesDetectionJobsAsyncHelper(const ListPiiEntitiesDetectionJobsRequest& request, const ListPiiEntitiesDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1140 {
1141 handler(this, request, ListPiiEntitiesDetectionJobs(request), context);
1142 }
1143
ListSentimentDetectionJobs(const ListSentimentDetectionJobsRequest & request) const1144 ListSentimentDetectionJobsOutcome ComprehendClient::ListSentimentDetectionJobs(const ListSentimentDetectionJobsRequest& request) const
1145 {
1146 Aws::Http::URI uri = m_uri;
1147 return ListSentimentDetectionJobsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1148 }
1149
ListSentimentDetectionJobsCallable(const ListSentimentDetectionJobsRequest & request) const1150 ListSentimentDetectionJobsOutcomeCallable ComprehendClient::ListSentimentDetectionJobsCallable(const ListSentimentDetectionJobsRequest& request) const
1151 {
1152 auto task = Aws::MakeShared< std::packaged_task< ListSentimentDetectionJobsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListSentimentDetectionJobs(request); } );
1153 auto packagedFunction = [task]() { (*task)(); };
1154 m_executor->Submit(packagedFunction);
1155 return task->get_future();
1156 }
1157
ListSentimentDetectionJobsAsync(const ListSentimentDetectionJobsRequest & request,const ListSentimentDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1158 void ComprehendClient::ListSentimentDetectionJobsAsync(const ListSentimentDetectionJobsRequest& request, const ListSentimentDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1159 {
1160 m_executor->Submit( [this, request, handler, context](){ this->ListSentimentDetectionJobsAsyncHelper( request, handler, context ); } );
1161 }
1162
ListSentimentDetectionJobsAsyncHelper(const ListSentimentDetectionJobsRequest & request,const ListSentimentDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1163 void ComprehendClient::ListSentimentDetectionJobsAsyncHelper(const ListSentimentDetectionJobsRequest& request, const ListSentimentDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1164 {
1165 handler(this, request, ListSentimentDetectionJobs(request), context);
1166 }
1167
ListTagsForResource(const ListTagsForResourceRequest & request) const1168 ListTagsForResourceOutcome ComprehendClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
1169 {
1170 Aws::Http::URI uri = m_uri;
1171 return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1172 }
1173
ListTagsForResourceCallable(const ListTagsForResourceRequest & request) const1174 ListTagsForResourceOutcomeCallable ComprehendClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
1175 {
1176 auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
1177 auto packagedFunction = [task]() { (*task)(); };
1178 m_executor->Submit(packagedFunction);
1179 return task->get_future();
1180 }
1181
ListTagsForResourceAsync(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1182 void ComprehendClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1183 {
1184 m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
1185 }
1186
ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1187 void ComprehendClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1188 {
1189 handler(this, request, ListTagsForResource(request), context);
1190 }
1191
ListTopicsDetectionJobs(const ListTopicsDetectionJobsRequest & request) const1192 ListTopicsDetectionJobsOutcome ComprehendClient::ListTopicsDetectionJobs(const ListTopicsDetectionJobsRequest& request) const
1193 {
1194 Aws::Http::URI uri = m_uri;
1195 return ListTopicsDetectionJobsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1196 }
1197
ListTopicsDetectionJobsCallable(const ListTopicsDetectionJobsRequest & request) const1198 ListTopicsDetectionJobsOutcomeCallable ComprehendClient::ListTopicsDetectionJobsCallable(const ListTopicsDetectionJobsRequest& request) const
1199 {
1200 auto task = Aws::MakeShared< std::packaged_task< ListTopicsDetectionJobsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTopicsDetectionJobs(request); } );
1201 auto packagedFunction = [task]() { (*task)(); };
1202 m_executor->Submit(packagedFunction);
1203 return task->get_future();
1204 }
1205
ListTopicsDetectionJobsAsync(const ListTopicsDetectionJobsRequest & request,const ListTopicsDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1206 void ComprehendClient::ListTopicsDetectionJobsAsync(const ListTopicsDetectionJobsRequest& request, const ListTopicsDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1207 {
1208 m_executor->Submit( [this, request, handler, context](){ this->ListTopicsDetectionJobsAsyncHelper( request, handler, context ); } );
1209 }
1210
ListTopicsDetectionJobsAsyncHelper(const ListTopicsDetectionJobsRequest & request,const ListTopicsDetectionJobsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1211 void ComprehendClient::ListTopicsDetectionJobsAsyncHelper(const ListTopicsDetectionJobsRequest& request, const ListTopicsDetectionJobsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1212 {
1213 handler(this, request, ListTopicsDetectionJobs(request), context);
1214 }
1215
StartDocumentClassificationJob(const StartDocumentClassificationJobRequest & request) const1216 StartDocumentClassificationJobOutcome ComprehendClient::StartDocumentClassificationJob(const StartDocumentClassificationJobRequest& request) const
1217 {
1218 Aws::Http::URI uri = m_uri;
1219 return StartDocumentClassificationJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1220 }
1221
StartDocumentClassificationJobCallable(const StartDocumentClassificationJobRequest & request) const1222 StartDocumentClassificationJobOutcomeCallable ComprehendClient::StartDocumentClassificationJobCallable(const StartDocumentClassificationJobRequest& request) const
1223 {
1224 auto task = Aws::MakeShared< std::packaged_task< StartDocumentClassificationJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartDocumentClassificationJob(request); } );
1225 auto packagedFunction = [task]() { (*task)(); };
1226 m_executor->Submit(packagedFunction);
1227 return task->get_future();
1228 }
1229
StartDocumentClassificationJobAsync(const StartDocumentClassificationJobRequest & request,const StartDocumentClassificationJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1230 void ComprehendClient::StartDocumentClassificationJobAsync(const StartDocumentClassificationJobRequest& request, const StartDocumentClassificationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1231 {
1232 m_executor->Submit( [this, request, handler, context](){ this->StartDocumentClassificationJobAsyncHelper( request, handler, context ); } );
1233 }
1234
StartDocumentClassificationJobAsyncHelper(const StartDocumentClassificationJobRequest & request,const StartDocumentClassificationJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1235 void ComprehendClient::StartDocumentClassificationJobAsyncHelper(const StartDocumentClassificationJobRequest& request, const StartDocumentClassificationJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1236 {
1237 handler(this, request, StartDocumentClassificationJob(request), context);
1238 }
1239
StartDominantLanguageDetectionJob(const StartDominantLanguageDetectionJobRequest & request) const1240 StartDominantLanguageDetectionJobOutcome ComprehendClient::StartDominantLanguageDetectionJob(const StartDominantLanguageDetectionJobRequest& request) const
1241 {
1242 Aws::Http::URI uri = m_uri;
1243 return StartDominantLanguageDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1244 }
1245
StartDominantLanguageDetectionJobCallable(const StartDominantLanguageDetectionJobRequest & request) const1246 StartDominantLanguageDetectionJobOutcomeCallable ComprehendClient::StartDominantLanguageDetectionJobCallable(const StartDominantLanguageDetectionJobRequest& request) const
1247 {
1248 auto task = Aws::MakeShared< std::packaged_task< StartDominantLanguageDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartDominantLanguageDetectionJob(request); } );
1249 auto packagedFunction = [task]() { (*task)(); };
1250 m_executor->Submit(packagedFunction);
1251 return task->get_future();
1252 }
1253
StartDominantLanguageDetectionJobAsync(const StartDominantLanguageDetectionJobRequest & request,const StartDominantLanguageDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1254 void ComprehendClient::StartDominantLanguageDetectionJobAsync(const StartDominantLanguageDetectionJobRequest& request, const StartDominantLanguageDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1255 {
1256 m_executor->Submit( [this, request, handler, context](){ this->StartDominantLanguageDetectionJobAsyncHelper( request, handler, context ); } );
1257 }
1258
StartDominantLanguageDetectionJobAsyncHelper(const StartDominantLanguageDetectionJobRequest & request,const StartDominantLanguageDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1259 void ComprehendClient::StartDominantLanguageDetectionJobAsyncHelper(const StartDominantLanguageDetectionJobRequest& request, const StartDominantLanguageDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1260 {
1261 handler(this, request, StartDominantLanguageDetectionJob(request), context);
1262 }
1263
StartEntitiesDetectionJob(const StartEntitiesDetectionJobRequest & request) const1264 StartEntitiesDetectionJobOutcome ComprehendClient::StartEntitiesDetectionJob(const StartEntitiesDetectionJobRequest& request) const
1265 {
1266 Aws::Http::URI uri = m_uri;
1267 return StartEntitiesDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1268 }
1269
StartEntitiesDetectionJobCallable(const StartEntitiesDetectionJobRequest & request) const1270 StartEntitiesDetectionJobOutcomeCallable ComprehendClient::StartEntitiesDetectionJobCallable(const StartEntitiesDetectionJobRequest& request) const
1271 {
1272 auto task = Aws::MakeShared< std::packaged_task< StartEntitiesDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartEntitiesDetectionJob(request); } );
1273 auto packagedFunction = [task]() { (*task)(); };
1274 m_executor->Submit(packagedFunction);
1275 return task->get_future();
1276 }
1277
StartEntitiesDetectionJobAsync(const StartEntitiesDetectionJobRequest & request,const StartEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1278 void ComprehendClient::StartEntitiesDetectionJobAsync(const StartEntitiesDetectionJobRequest& request, const StartEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1279 {
1280 m_executor->Submit( [this, request, handler, context](){ this->StartEntitiesDetectionJobAsyncHelper( request, handler, context ); } );
1281 }
1282
StartEntitiesDetectionJobAsyncHelper(const StartEntitiesDetectionJobRequest & request,const StartEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1283 void ComprehendClient::StartEntitiesDetectionJobAsyncHelper(const StartEntitiesDetectionJobRequest& request, const StartEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1284 {
1285 handler(this, request, StartEntitiesDetectionJob(request), context);
1286 }
1287
StartEventsDetectionJob(const StartEventsDetectionJobRequest & request) const1288 StartEventsDetectionJobOutcome ComprehendClient::StartEventsDetectionJob(const StartEventsDetectionJobRequest& request) const
1289 {
1290 Aws::Http::URI uri = m_uri;
1291 return StartEventsDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1292 }
1293
StartEventsDetectionJobCallable(const StartEventsDetectionJobRequest & request) const1294 StartEventsDetectionJobOutcomeCallable ComprehendClient::StartEventsDetectionJobCallable(const StartEventsDetectionJobRequest& request) const
1295 {
1296 auto task = Aws::MakeShared< std::packaged_task< StartEventsDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartEventsDetectionJob(request); } );
1297 auto packagedFunction = [task]() { (*task)(); };
1298 m_executor->Submit(packagedFunction);
1299 return task->get_future();
1300 }
1301
StartEventsDetectionJobAsync(const StartEventsDetectionJobRequest & request,const StartEventsDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1302 void ComprehendClient::StartEventsDetectionJobAsync(const StartEventsDetectionJobRequest& request, const StartEventsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1303 {
1304 m_executor->Submit( [this, request, handler, context](){ this->StartEventsDetectionJobAsyncHelper( request, handler, context ); } );
1305 }
1306
StartEventsDetectionJobAsyncHelper(const StartEventsDetectionJobRequest & request,const StartEventsDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1307 void ComprehendClient::StartEventsDetectionJobAsyncHelper(const StartEventsDetectionJobRequest& request, const StartEventsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1308 {
1309 handler(this, request, StartEventsDetectionJob(request), context);
1310 }
1311
StartKeyPhrasesDetectionJob(const StartKeyPhrasesDetectionJobRequest & request) const1312 StartKeyPhrasesDetectionJobOutcome ComprehendClient::StartKeyPhrasesDetectionJob(const StartKeyPhrasesDetectionJobRequest& request) const
1313 {
1314 Aws::Http::URI uri = m_uri;
1315 return StartKeyPhrasesDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1316 }
1317
StartKeyPhrasesDetectionJobCallable(const StartKeyPhrasesDetectionJobRequest & request) const1318 StartKeyPhrasesDetectionJobOutcomeCallable ComprehendClient::StartKeyPhrasesDetectionJobCallable(const StartKeyPhrasesDetectionJobRequest& request) const
1319 {
1320 auto task = Aws::MakeShared< std::packaged_task< StartKeyPhrasesDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartKeyPhrasesDetectionJob(request); } );
1321 auto packagedFunction = [task]() { (*task)(); };
1322 m_executor->Submit(packagedFunction);
1323 return task->get_future();
1324 }
1325
StartKeyPhrasesDetectionJobAsync(const StartKeyPhrasesDetectionJobRequest & request,const StartKeyPhrasesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1326 void ComprehendClient::StartKeyPhrasesDetectionJobAsync(const StartKeyPhrasesDetectionJobRequest& request, const StartKeyPhrasesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1327 {
1328 m_executor->Submit( [this, request, handler, context](){ this->StartKeyPhrasesDetectionJobAsyncHelper( request, handler, context ); } );
1329 }
1330
StartKeyPhrasesDetectionJobAsyncHelper(const StartKeyPhrasesDetectionJobRequest & request,const StartKeyPhrasesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1331 void ComprehendClient::StartKeyPhrasesDetectionJobAsyncHelper(const StartKeyPhrasesDetectionJobRequest& request, const StartKeyPhrasesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1332 {
1333 handler(this, request, StartKeyPhrasesDetectionJob(request), context);
1334 }
1335
StartPiiEntitiesDetectionJob(const StartPiiEntitiesDetectionJobRequest & request) const1336 StartPiiEntitiesDetectionJobOutcome ComprehendClient::StartPiiEntitiesDetectionJob(const StartPiiEntitiesDetectionJobRequest& request) const
1337 {
1338 Aws::Http::URI uri = m_uri;
1339 return StartPiiEntitiesDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1340 }
1341
StartPiiEntitiesDetectionJobCallable(const StartPiiEntitiesDetectionJobRequest & request) const1342 StartPiiEntitiesDetectionJobOutcomeCallable ComprehendClient::StartPiiEntitiesDetectionJobCallable(const StartPiiEntitiesDetectionJobRequest& request) const
1343 {
1344 auto task = Aws::MakeShared< std::packaged_task< StartPiiEntitiesDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartPiiEntitiesDetectionJob(request); } );
1345 auto packagedFunction = [task]() { (*task)(); };
1346 m_executor->Submit(packagedFunction);
1347 return task->get_future();
1348 }
1349
StartPiiEntitiesDetectionJobAsync(const StartPiiEntitiesDetectionJobRequest & request,const StartPiiEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1350 void ComprehendClient::StartPiiEntitiesDetectionJobAsync(const StartPiiEntitiesDetectionJobRequest& request, const StartPiiEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1351 {
1352 m_executor->Submit( [this, request, handler, context](){ this->StartPiiEntitiesDetectionJobAsyncHelper( request, handler, context ); } );
1353 }
1354
StartPiiEntitiesDetectionJobAsyncHelper(const StartPiiEntitiesDetectionJobRequest & request,const StartPiiEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1355 void ComprehendClient::StartPiiEntitiesDetectionJobAsyncHelper(const StartPiiEntitiesDetectionJobRequest& request, const StartPiiEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1356 {
1357 handler(this, request, StartPiiEntitiesDetectionJob(request), context);
1358 }
1359
StartSentimentDetectionJob(const StartSentimentDetectionJobRequest & request) const1360 StartSentimentDetectionJobOutcome ComprehendClient::StartSentimentDetectionJob(const StartSentimentDetectionJobRequest& request) const
1361 {
1362 Aws::Http::URI uri = m_uri;
1363 return StartSentimentDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1364 }
1365
StartSentimentDetectionJobCallable(const StartSentimentDetectionJobRequest & request) const1366 StartSentimentDetectionJobOutcomeCallable ComprehendClient::StartSentimentDetectionJobCallable(const StartSentimentDetectionJobRequest& request) const
1367 {
1368 auto task = Aws::MakeShared< std::packaged_task< StartSentimentDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartSentimentDetectionJob(request); } );
1369 auto packagedFunction = [task]() { (*task)(); };
1370 m_executor->Submit(packagedFunction);
1371 return task->get_future();
1372 }
1373
StartSentimentDetectionJobAsync(const StartSentimentDetectionJobRequest & request,const StartSentimentDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1374 void ComprehendClient::StartSentimentDetectionJobAsync(const StartSentimentDetectionJobRequest& request, const StartSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1375 {
1376 m_executor->Submit( [this, request, handler, context](){ this->StartSentimentDetectionJobAsyncHelper( request, handler, context ); } );
1377 }
1378
StartSentimentDetectionJobAsyncHelper(const StartSentimentDetectionJobRequest & request,const StartSentimentDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1379 void ComprehendClient::StartSentimentDetectionJobAsyncHelper(const StartSentimentDetectionJobRequest& request, const StartSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1380 {
1381 handler(this, request, StartSentimentDetectionJob(request), context);
1382 }
1383
StartTopicsDetectionJob(const StartTopicsDetectionJobRequest & request) const1384 StartTopicsDetectionJobOutcome ComprehendClient::StartTopicsDetectionJob(const StartTopicsDetectionJobRequest& request) const
1385 {
1386 Aws::Http::URI uri = m_uri;
1387 return StartTopicsDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1388 }
1389
StartTopicsDetectionJobCallable(const StartTopicsDetectionJobRequest & request) const1390 StartTopicsDetectionJobOutcomeCallable ComprehendClient::StartTopicsDetectionJobCallable(const StartTopicsDetectionJobRequest& request) const
1391 {
1392 auto task = Aws::MakeShared< std::packaged_task< StartTopicsDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StartTopicsDetectionJob(request); } );
1393 auto packagedFunction = [task]() { (*task)(); };
1394 m_executor->Submit(packagedFunction);
1395 return task->get_future();
1396 }
1397
StartTopicsDetectionJobAsync(const StartTopicsDetectionJobRequest & request,const StartTopicsDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1398 void ComprehendClient::StartTopicsDetectionJobAsync(const StartTopicsDetectionJobRequest& request, const StartTopicsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1399 {
1400 m_executor->Submit( [this, request, handler, context](){ this->StartTopicsDetectionJobAsyncHelper( request, handler, context ); } );
1401 }
1402
StartTopicsDetectionJobAsyncHelper(const StartTopicsDetectionJobRequest & request,const StartTopicsDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1403 void ComprehendClient::StartTopicsDetectionJobAsyncHelper(const StartTopicsDetectionJobRequest& request, const StartTopicsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1404 {
1405 handler(this, request, StartTopicsDetectionJob(request), context);
1406 }
1407
StopDominantLanguageDetectionJob(const StopDominantLanguageDetectionJobRequest & request) const1408 StopDominantLanguageDetectionJobOutcome ComprehendClient::StopDominantLanguageDetectionJob(const StopDominantLanguageDetectionJobRequest& request) const
1409 {
1410 Aws::Http::URI uri = m_uri;
1411 return StopDominantLanguageDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1412 }
1413
StopDominantLanguageDetectionJobCallable(const StopDominantLanguageDetectionJobRequest & request) const1414 StopDominantLanguageDetectionJobOutcomeCallable ComprehendClient::StopDominantLanguageDetectionJobCallable(const StopDominantLanguageDetectionJobRequest& request) const
1415 {
1416 auto task = Aws::MakeShared< std::packaged_task< StopDominantLanguageDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopDominantLanguageDetectionJob(request); } );
1417 auto packagedFunction = [task]() { (*task)(); };
1418 m_executor->Submit(packagedFunction);
1419 return task->get_future();
1420 }
1421
StopDominantLanguageDetectionJobAsync(const StopDominantLanguageDetectionJobRequest & request,const StopDominantLanguageDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1422 void ComprehendClient::StopDominantLanguageDetectionJobAsync(const StopDominantLanguageDetectionJobRequest& request, const StopDominantLanguageDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1423 {
1424 m_executor->Submit( [this, request, handler, context](){ this->StopDominantLanguageDetectionJobAsyncHelper( request, handler, context ); } );
1425 }
1426
StopDominantLanguageDetectionJobAsyncHelper(const StopDominantLanguageDetectionJobRequest & request,const StopDominantLanguageDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1427 void ComprehendClient::StopDominantLanguageDetectionJobAsyncHelper(const StopDominantLanguageDetectionJobRequest& request, const StopDominantLanguageDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1428 {
1429 handler(this, request, StopDominantLanguageDetectionJob(request), context);
1430 }
1431
StopEntitiesDetectionJob(const StopEntitiesDetectionJobRequest & request) const1432 StopEntitiesDetectionJobOutcome ComprehendClient::StopEntitiesDetectionJob(const StopEntitiesDetectionJobRequest& request) const
1433 {
1434 Aws::Http::URI uri = m_uri;
1435 return StopEntitiesDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1436 }
1437
StopEntitiesDetectionJobCallable(const StopEntitiesDetectionJobRequest & request) const1438 StopEntitiesDetectionJobOutcomeCallable ComprehendClient::StopEntitiesDetectionJobCallable(const StopEntitiesDetectionJobRequest& request) const
1439 {
1440 auto task = Aws::MakeShared< std::packaged_task< StopEntitiesDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopEntitiesDetectionJob(request); } );
1441 auto packagedFunction = [task]() { (*task)(); };
1442 m_executor->Submit(packagedFunction);
1443 return task->get_future();
1444 }
1445
StopEntitiesDetectionJobAsync(const StopEntitiesDetectionJobRequest & request,const StopEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1446 void ComprehendClient::StopEntitiesDetectionJobAsync(const StopEntitiesDetectionJobRequest& request, const StopEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1447 {
1448 m_executor->Submit( [this, request, handler, context](){ this->StopEntitiesDetectionJobAsyncHelper( request, handler, context ); } );
1449 }
1450
StopEntitiesDetectionJobAsyncHelper(const StopEntitiesDetectionJobRequest & request,const StopEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1451 void ComprehendClient::StopEntitiesDetectionJobAsyncHelper(const StopEntitiesDetectionJobRequest& request, const StopEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1452 {
1453 handler(this, request, StopEntitiesDetectionJob(request), context);
1454 }
1455
StopEventsDetectionJob(const StopEventsDetectionJobRequest & request) const1456 StopEventsDetectionJobOutcome ComprehendClient::StopEventsDetectionJob(const StopEventsDetectionJobRequest& request) const
1457 {
1458 Aws::Http::URI uri = m_uri;
1459 return StopEventsDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1460 }
1461
StopEventsDetectionJobCallable(const StopEventsDetectionJobRequest & request) const1462 StopEventsDetectionJobOutcomeCallable ComprehendClient::StopEventsDetectionJobCallable(const StopEventsDetectionJobRequest& request) const
1463 {
1464 auto task = Aws::MakeShared< std::packaged_task< StopEventsDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopEventsDetectionJob(request); } );
1465 auto packagedFunction = [task]() { (*task)(); };
1466 m_executor->Submit(packagedFunction);
1467 return task->get_future();
1468 }
1469
StopEventsDetectionJobAsync(const StopEventsDetectionJobRequest & request,const StopEventsDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1470 void ComprehendClient::StopEventsDetectionJobAsync(const StopEventsDetectionJobRequest& request, const StopEventsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1471 {
1472 m_executor->Submit( [this, request, handler, context](){ this->StopEventsDetectionJobAsyncHelper( request, handler, context ); } );
1473 }
1474
StopEventsDetectionJobAsyncHelper(const StopEventsDetectionJobRequest & request,const StopEventsDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1475 void ComprehendClient::StopEventsDetectionJobAsyncHelper(const StopEventsDetectionJobRequest& request, const StopEventsDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1476 {
1477 handler(this, request, StopEventsDetectionJob(request), context);
1478 }
1479
StopKeyPhrasesDetectionJob(const StopKeyPhrasesDetectionJobRequest & request) const1480 StopKeyPhrasesDetectionJobOutcome ComprehendClient::StopKeyPhrasesDetectionJob(const StopKeyPhrasesDetectionJobRequest& request) const
1481 {
1482 Aws::Http::URI uri = m_uri;
1483 return StopKeyPhrasesDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1484 }
1485
StopKeyPhrasesDetectionJobCallable(const StopKeyPhrasesDetectionJobRequest & request) const1486 StopKeyPhrasesDetectionJobOutcomeCallable ComprehendClient::StopKeyPhrasesDetectionJobCallable(const StopKeyPhrasesDetectionJobRequest& request) const
1487 {
1488 auto task = Aws::MakeShared< std::packaged_task< StopKeyPhrasesDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopKeyPhrasesDetectionJob(request); } );
1489 auto packagedFunction = [task]() { (*task)(); };
1490 m_executor->Submit(packagedFunction);
1491 return task->get_future();
1492 }
1493
StopKeyPhrasesDetectionJobAsync(const StopKeyPhrasesDetectionJobRequest & request,const StopKeyPhrasesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1494 void ComprehendClient::StopKeyPhrasesDetectionJobAsync(const StopKeyPhrasesDetectionJobRequest& request, const StopKeyPhrasesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1495 {
1496 m_executor->Submit( [this, request, handler, context](){ this->StopKeyPhrasesDetectionJobAsyncHelper( request, handler, context ); } );
1497 }
1498
StopKeyPhrasesDetectionJobAsyncHelper(const StopKeyPhrasesDetectionJobRequest & request,const StopKeyPhrasesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1499 void ComprehendClient::StopKeyPhrasesDetectionJobAsyncHelper(const StopKeyPhrasesDetectionJobRequest& request, const StopKeyPhrasesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1500 {
1501 handler(this, request, StopKeyPhrasesDetectionJob(request), context);
1502 }
1503
StopPiiEntitiesDetectionJob(const StopPiiEntitiesDetectionJobRequest & request) const1504 StopPiiEntitiesDetectionJobOutcome ComprehendClient::StopPiiEntitiesDetectionJob(const StopPiiEntitiesDetectionJobRequest& request) const
1505 {
1506 Aws::Http::URI uri = m_uri;
1507 return StopPiiEntitiesDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1508 }
1509
StopPiiEntitiesDetectionJobCallable(const StopPiiEntitiesDetectionJobRequest & request) const1510 StopPiiEntitiesDetectionJobOutcomeCallable ComprehendClient::StopPiiEntitiesDetectionJobCallable(const StopPiiEntitiesDetectionJobRequest& request) const
1511 {
1512 auto task = Aws::MakeShared< std::packaged_task< StopPiiEntitiesDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopPiiEntitiesDetectionJob(request); } );
1513 auto packagedFunction = [task]() { (*task)(); };
1514 m_executor->Submit(packagedFunction);
1515 return task->get_future();
1516 }
1517
StopPiiEntitiesDetectionJobAsync(const StopPiiEntitiesDetectionJobRequest & request,const StopPiiEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1518 void ComprehendClient::StopPiiEntitiesDetectionJobAsync(const StopPiiEntitiesDetectionJobRequest& request, const StopPiiEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1519 {
1520 m_executor->Submit( [this, request, handler, context](){ this->StopPiiEntitiesDetectionJobAsyncHelper( request, handler, context ); } );
1521 }
1522
StopPiiEntitiesDetectionJobAsyncHelper(const StopPiiEntitiesDetectionJobRequest & request,const StopPiiEntitiesDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1523 void ComprehendClient::StopPiiEntitiesDetectionJobAsyncHelper(const StopPiiEntitiesDetectionJobRequest& request, const StopPiiEntitiesDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1524 {
1525 handler(this, request, StopPiiEntitiesDetectionJob(request), context);
1526 }
1527
StopSentimentDetectionJob(const StopSentimentDetectionJobRequest & request) const1528 StopSentimentDetectionJobOutcome ComprehendClient::StopSentimentDetectionJob(const StopSentimentDetectionJobRequest& request) const
1529 {
1530 Aws::Http::URI uri = m_uri;
1531 return StopSentimentDetectionJobOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1532 }
1533
StopSentimentDetectionJobCallable(const StopSentimentDetectionJobRequest & request) const1534 StopSentimentDetectionJobOutcomeCallable ComprehendClient::StopSentimentDetectionJobCallable(const StopSentimentDetectionJobRequest& request) const
1535 {
1536 auto task = Aws::MakeShared< std::packaged_task< StopSentimentDetectionJobOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopSentimentDetectionJob(request); } );
1537 auto packagedFunction = [task]() { (*task)(); };
1538 m_executor->Submit(packagedFunction);
1539 return task->get_future();
1540 }
1541
StopSentimentDetectionJobAsync(const StopSentimentDetectionJobRequest & request,const StopSentimentDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1542 void ComprehendClient::StopSentimentDetectionJobAsync(const StopSentimentDetectionJobRequest& request, const StopSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1543 {
1544 m_executor->Submit( [this, request, handler, context](){ this->StopSentimentDetectionJobAsyncHelper( request, handler, context ); } );
1545 }
1546
StopSentimentDetectionJobAsyncHelper(const StopSentimentDetectionJobRequest & request,const StopSentimentDetectionJobResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1547 void ComprehendClient::StopSentimentDetectionJobAsyncHelper(const StopSentimentDetectionJobRequest& request, const StopSentimentDetectionJobResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1548 {
1549 handler(this, request, StopSentimentDetectionJob(request), context);
1550 }
1551
StopTrainingDocumentClassifier(const StopTrainingDocumentClassifierRequest & request) const1552 StopTrainingDocumentClassifierOutcome ComprehendClient::StopTrainingDocumentClassifier(const StopTrainingDocumentClassifierRequest& request) const
1553 {
1554 Aws::Http::URI uri = m_uri;
1555 return StopTrainingDocumentClassifierOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1556 }
1557
StopTrainingDocumentClassifierCallable(const StopTrainingDocumentClassifierRequest & request) const1558 StopTrainingDocumentClassifierOutcomeCallable ComprehendClient::StopTrainingDocumentClassifierCallable(const StopTrainingDocumentClassifierRequest& request) const
1559 {
1560 auto task = Aws::MakeShared< std::packaged_task< StopTrainingDocumentClassifierOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopTrainingDocumentClassifier(request); } );
1561 auto packagedFunction = [task]() { (*task)(); };
1562 m_executor->Submit(packagedFunction);
1563 return task->get_future();
1564 }
1565
StopTrainingDocumentClassifierAsync(const StopTrainingDocumentClassifierRequest & request,const StopTrainingDocumentClassifierResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1566 void ComprehendClient::StopTrainingDocumentClassifierAsync(const StopTrainingDocumentClassifierRequest& request, const StopTrainingDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1567 {
1568 m_executor->Submit( [this, request, handler, context](){ this->StopTrainingDocumentClassifierAsyncHelper( request, handler, context ); } );
1569 }
1570
StopTrainingDocumentClassifierAsyncHelper(const StopTrainingDocumentClassifierRequest & request,const StopTrainingDocumentClassifierResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1571 void ComprehendClient::StopTrainingDocumentClassifierAsyncHelper(const StopTrainingDocumentClassifierRequest& request, const StopTrainingDocumentClassifierResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1572 {
1573 handler(this, request, StopTrainingDocumentClassifier(request), context);
1574 }
1575
StopTrainingEntityRecognizer(const StopTrainingEntityRecognizerRequest & request) const1576 StopTrainingEntityRecognizerOutcome ComprehendClient::StopTrainingEntityRecognizer(const StopTrainingEntityRecognizerRequest& request) const
1577 {
1578 Aws::Http::URI uri = m_uri;
1579 return StopTrainingEntityRecognizerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1580 }
1581
StopTrainingEntityRecognizerCallable(const StopTrainingEntityRecognizerRequest & request) const1582 StopTrainingEntityRecognizerOutcomeCallable ComprehendClient::StopTrainingEntityRecognizerCallable(const StopTrainingEntityRecognizerRequest& request) const
1583 {
1584 auto task = Aws::MakeShared< std::packaged_task< StopTrainingEntityRecognizerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->StopTrainingEntityRecognizer(request); } );
1585 auto packagedFunction = [task]() { (*task)(); };
1586 m_executor->Submit(packagedFunction);
1587 return task->get_future();
1588 }
1589
StopTrainingEntityRecognizerAsync(const StopTrainingEntityRecognizerRequest & request,const StopTrainingEntityRecognizerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1590 void ComprehendClient::StopTrainingEntityRecognizerAsync(const StopTrainingEntityRecognizerRequest& request, const StopTrainingEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1591 {
1592 m_executor->Submit( [this, request, handler, context](){ this->StopTrainingEntityRecognizerAsyncHelper( request, handler, context ); } );
1593 }
1594
StopTrainingEntityRecognizerAsyncHelper(const StopTrainingEntityRecognizerRequest & request,const StopTrainingEntityRecognizerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1595 void ComprehendClient::StopTrainingEntityRecognizerAsyncHelper(const StopTrainingEntityRecognizerRequest& request, const StopTrainingEntityRecognizerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1596 {
1597 handler(this, request, StopTrainingEntityRecognizer(request), context);
1598 }
1599
TagResource(const TagResourceRequest & request) const1600 TagResourceOutcome ComprehendClient::TagResource(const TagResourceRequest& request) const
1601 {
1602 Aws::Http::URI uri = m_uri;
1603 return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1604 }
1605
TagResourceCallable(const TagResourceRequest & request) const1606 TagResourceOutcomeCallable ComprehendClient::TagResourceCallable(const TagResourceRequest& request) const
1607 {
1608 auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
1609 auto packagedFunction = [task]() { (*task)(); };
1610 m_executor->Submit(packagedFunction);
1611 return task->get_future();
1612 }
1613
TagResourceAsync(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1614 void ComprehendClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1615 {
1616 m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
1617 }
1618
TagResourceAsyncHelper(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1619 void ComprehendClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1620 {
1621 handler(this, request, TagResource(request), context);
1622 }
1623
UntagResource(const UntagResourceRequest & request) const1624 UntagResourceOutcome ComprehendClient::UntagResource(const UntagResourceRequest& request) const
1625 {
1626 Aws::Http::URI uri = m_uri;
1627 return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1628 }
1629
UntagResourceCallable(const UntagResourceRequest & request) const1630 UntagResourceOutcomeCallable ComprehendClient::UntagResourceCallable(const UntagResourceRequest& request) const
1631 {
1632 auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
1633 auto packagedFunction = [task]() { (*task)(); };
1634 m_executor->Submit(packagedFunction);
1635 return task->get_future();
1636 }
1637
UntagResourceAsync(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1638 void ComprehendClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1639 {
1640 m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
1641 }
1642
UntagResourceAsyncHelper(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1643 void ComprehendClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1644 {
1645 handler(this, request, UntagResource(request), context);
1646 }
1647
UpdateEndpoint(const UpdateEndpointRequest & request) const1648 UpdateEndpointOutcome ComprehendClient::UpdateEndpoint(const UpdateEndpointRequest& request) const
1649 {
1650 Aws::Http::URI uri = m_uri;
1651 return UpdateEndpointOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1652 }
1653
UpdateEndpointCallable(const UpdateEndpointRequest & request) const1654 UpdateEndpointOutcomeCallable ComprehendClient::UpdateEndpointCallable(const UpdateEndpointRequest& request) const
1655 {
1656 auto task = Aws::MakeShared< std::packaged_task< UpdateEndpointOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateEndpoint(request); } );
1657 auto packagedFunction = [task]() { (*task)(); };
1658 m_executor->Submit(packagedFunction);
1659 return task->get_future();
1660 }
1661
UpdateEndpointAsync(const UpdateEndpointRequest & request,const UpdateEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1662 void ComprehendClient::UpdateEndpointAsync(const UpdateEndpointRequest& request, const UpdateEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1663 {
1664 m_executor->Submit( [this, request, handler, context](){ this->UpdateEndpointAsyncHelper( request, handler, context ); } );
1665 }
1666
UpdateEndpointAsyncHelper(const UpdateEndpointRequest & request,const UpdateEndpointResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1667 void ComprehendClient::UpdateEndpointAsyncHelper(const UpdateEndpointRequest& request, const UpdateEndpointResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1668 {
1669 handler(this, request, UpdateEndpoint(request), context);
1670 }
1671
1672