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/location/LocationServiceClient.h>
21 #include <aws/location/LocationServiceEndpoint.h>
22 #include <aws/location/LocationServiceErrorMarshaller.h>
23 #include <aws/location/model/AssociateTrackerConsumerRequest.h>
24 #include <aws/location/model/BatchDeleteDevicePositionHistoryRequest.h>
25 #include <aws/location/model/BatchDeleteGeofenceRequest.h>
26 #include <aws/location/model/BatchEvaluateGeofencesRequest.h>
27 #include <aws/location/model/BatchGetDevicePositionRequest.h>
28 #include <aws/location/model/BatchPutGeofenceRequest.h>
29 #include <aws/location/model/BatchUpdateDevicePositionRequest.h>
30 #include <aws/location/model/CalculateRouteRequest.h>
31 #include <aws/location/model/CreateGeofenceCollectionRequest.h>
32 #include <aws/location/model/CreateMapRequest.h>
33 #include <aws/location/model/CreatePlaceIndexRequest.h>
34 #include <aws/location/model/CreateRouteCalculatorRequest.h>
35 #include <aws/location/model/CreateTrackerRequest.h>
36 #include <aws/location/model/DeleteGeofenceCollectionRequest.h>
37 #include <aws/location/model/DeleteMapRequest.h>
38 #include <aws/location/model/DeletePlaceIndexRequest.h>
39 #include <aws/location/model/DeleteRouteCalculatorRequest.h>
40 #include <aws/location/model/DeleteTrackerRequest.h>
41 #include <aws/location/model/DescribeGeofenceCollectionRequest.h>
42 #include <aws/location/model/DescribeMapRequest.h>
43 #include <aws/location/model/DescribePlaceIndexRequest.h>
44 #include <aws/location/model/DescribeRouteCalculatorRequest.h>
45 #include <aws/location/model/DescribeTrackerRequest.h>
46 #include <aws/location/model/DisassociateTrackerConsumerRequest.h>
47 #include <aws/location/model/GetDevicePositionRequest.h>
48 #include <aws/location/model/GetDevicePositionHistoryRequest.h>
49 #include <aws/location/model/GetGeofenceRequest.h>
50 #include <aws/location/model/GetMapGlyphsRequest.h>
51 #include <aws/location/model/GetMapSpritesRequest.h>
52 #include <aws/location/model/GetMapStyleDescriptorRequest.h>
53 #include <aws/location/model/GetMapTileRequest.h>
54 #include <aws/location/model/ListDevicePositionsRequest.h>
55 #include <aws/location/model/ListGeofenceCollectionsRequest.h>
56 #include <aws/location/model/ListGeofencesRequest.h>
57 #include <aws/location/model/ListMapsRequest.h>
58 #include <aws/location/model/ListPlaceIndexesRequest.h>
59 #include <aws/location/model/ListRouteCalculatorsRequest.h>
60 #include <aws/location/model/ListTagsForResourceRequest.h>
61 #include <aws/location/model/ListTrackerConsumersRequest.h>
62 #include <aws/location/model/ListTrackersRequest.h>
63 #include <aws/location/model/PutGeofenceRequest.h>
64 #include <aws/location/model/SearchPlaceIndexForPositionRequest.h>
65 #include <aws/location/model/SearchPlaceIndexForTextRequest.h>
66 #include <aws/location/model/TagResourceRequest.h>
67 #include <aws/location/model/UntagResourceRequest.h>
68 #include <aws/location/model/UpdateGeofenceCollectionRequest.h>
69 #include <aws/location/model/UpdateMapRequest.h>
70 #include <aws/location/model/UpdatePlaceIndexRequest.h>
71 #include <aws/location/model/UpdateRouteCalculatorRequest.h>
72 #include <aws/location/model/UpdateTrackerRequest.h>
73
74 using namespace Aws;
75 using namespace Aws::Auth;
76 using namespace Aws::Client;
77 using namespace Aws::LocationService;
78 using namespace Aws::LocationService::Model;
79 using namespace Aws::Http;
80 using namespace Aws::Utils::Json;
81
82 static const char* SERVICE_NAME = "geo";
83 static const char* ALLOCATION_TAG = "LocationServiceClient";
84
85
LocationServiceClient(const Client::ClientConfiguration & clientConfiguration)86 LocationServiceClient::LocationServiceClient(const Client::ClientConfiguration& clientConfiguration) :
87 BASECLASS(clientConfiguration,
88 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
89 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
90 Aws::MakeShared<LocationServiceErrorMarshaller>(ALLOCATION_TAG)),
91 m_executor(clientConfiguration.executor)
92 {
93 init(clientConfiguration);
94 }
95
LocationServiceClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)96 LocationServiceClient::LocationServiceClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
97 BASECLASS(clientConfiguration,
98 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
99 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
100 Aws::MakeShared<LocationServiceErrorMarshaller>(ALLOCATION_TAG)),
101 m_executor(clientConfiguration.executor)
102 {
103 init(clientConfiguration);
104 }
105
LocationServiceClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)106 LocationServiceClient::LocationServiceClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
107 const Client::ClientConfiguration& clientConfiguration) :
108 BASECLASS(clientConfiguration,
109 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
110 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
111 Aws::MakeShared<LocationServiceErrorMarshaller>(ALLOCATION_TAG)),
112 m_executor(clientConfiguration.executor)
113 {
114 init(clientConfiguration);
115 }
116
~LocationServiceClient()117 LocationServiceClient::~LocationServiceClient()
118 {
119 }
120
init(const Client::ClientConfiguration & config)121 void LocationServiceClient::init(const Client::ClientConfiguration& config)
122 {
123 SetServiceClientName("Location");
124 m_configScheme = SchemeMapper::ToString(config.scheme);
125 m_scheme = m_configScheme;
126 if (config.endpointOverride.empty())
127 {
128 m_baseUri = LocationServiceEndpoint::ForRegion(config.region, config.useDualStack);
129 }
130 else
131 {
132 OverrideEndpoint(config.endpointOverride);
133 }
134 m_enableHostPrefixInjection = config.enableHostPrefixInjection;
135 }
136
OverrideEndpoint(const Aws::String & endpoint)137 void LocationServiceClient::OverrideEndpoint(const Aws::String& endpoint)
138 {
139 if (endpoint.compare(0, 7, "http://") == 0)
140 {
141 m_scheme = "http";
142 m_baseUri = endpoint.substr(7);
143 }
144 else if (endpoint.compare(0, 8, "https://") == 0)
145 {
146 m_scheme = "https";
147 m_baseUri = endpoint.substr(8);
148 }
149 else
150 {
151 m_scheme = m_configScheme;
152 m_baseUri = endpoint;
153 }
154 }
155
AssociateTrackerConsumer(const AssociateTrackerConsumerRequest & request) const156 AssociateTrackerConsumerOutcome LocationServiceClient::AssociateTrackerConsumer(const AssociateTrackerConsumerRequest& request) const
157 {
158 if (!request.TrackerNameHasBeenSet())
159 {
160 AWS_LOGSTREAM_ERROR("AssociateTrackerConsumer", "Required field: TrackerName, is not set");
161 return AssociateTrackerConsumerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
162 }
163 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
164 if (m_enableHostPrefixInjection)
165 {
166 uri.SetAuthority("tracking." + uri.GetAuthority());
167 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
168 {
169 AWS_LOGSTREAM_ERROR("AssociateTrackerConsumer", "Invalid DNS host: " << uri.GetAuthority());
170 return AssociateTrackerConsumerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
171 }
172 }
173 uri.AddPathSegments("/tracking/v0/trackers/");
174 uri.AddPathSegment(request.GetTrackerName());
175 uri.AddPathSegments("/consumers");
176 return AssociateTrackerConsumerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
177 }
178
AssociateTrackerConsumerCallable(const AssociateTrackerConsumerRequest & request) const179 AssociateTrackerConsumerOutcomeCallable LocationServiceClient::AssociateTrackerConsumerCallable(const AssociateTrackerConsumerRequest& request) const
180 {
181 auto task = Aws::MakeShared< std::packaged_task< AssociateTrackerConsumerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AssociateTrackerConsumer(request); } );
182 auto packagedFunction = [task]() { (*task)(); };
183 m_executor->Submit(packagedFunction);
184 return task->get_future();
185 }
186
AssociateTrackerConsumerAsync(const AssociateTrackerConsumerRequest & request,const AssociateTrackerConsumerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const187 void LocationServiceClient::AssociateTrackerConsumerAsync(const AssociateTrackerConsumerRequest& request, const AssociateTrackerConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
188 {
189 m_executor->Submit( [this, request, handler, context](){ this->AssociateTrackerConsumerAsyncHelper( request, handler, context ); } );
190 }
191
AssociateTrackerConsumerAsyncHelper(const AssociateTrackerConsumerRequest & request,const AssociateTrackerConsumerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const192 void LocationServiceClient::AssociateTrackerConsumerAsyncHelper(const AssociateTrackerConsumerRequest& request, const AssociateTrackerConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
193 {
194 handler(this, request, AssociateTrackerConsumer(request), context);
195 }
196
BatchDeleteDevicePositionHistory(const BatchDeleteDevicePositionHistoryRequest & request) const197 BatchDeleteDevicePositionHistoryOutcome LocationServiceClient::BatchDeleteDevicePositionHistory(const BatchDeleteDevicePositionHistoryRequest& request) const
198 {
199 if (!request.TrackerNameHasBeenSet())
200 {
201 AWS_LOGSTREAM_ERROR("BatchDeleteDevicePositionHistory", "Required field: TrackerName, is not set");
202 return BatchDeleteDevicePositionHistoryOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
203 }
204 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
205 if (m_enableHostPrefixInjection)
206 {
207 uri.SetAuthority("tracking." + uri.GetAuthority());
208 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
209 {
210 AWS_LOGSTREAM_ERROR("BatchDeleteDevicePositionHistory", "Invalid DNS host: " << uri.GetAuthority());
211 return BatchDeleteDevicePositionHistoryOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
212 }
213 }
214 uri.AddPathSegments("/tracking/v0/trackers/");
215 uri.AddPathSegment(request.GetTrackerName());
216 uri.AddPathSegments("/delete-positions");
217 return BatchDeleteDevicePositionHistoryOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
218 }
219
BatchDeleteDevicePositionHistoryCallable(const BatchDeleteDevicePositionHistoryRequest & request) const220 BatchDeleteDevicePositionHistoryOutcomeCallable LocationServiceClient::BatchDeleteDevicePositionHistoryCallable(const BatchDeleteDevicePositionHistoryRequest& request) const
221 {
222 auto task = Aws::MakeShared< std::packaged_task< BatchDeleteDevicePositionHistoryOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchDeleteDevicePositionHistory(request); } );
223 auto packagedFunction = [task]() { (*task)(); };
224 m_executor->Submit(packagedFunction);
225 return task->get_future();
226 }
227
BatchDeleteDevicePositionHistoryAsync(const BatchDeleteDevicePositionHistoryRequest & request,const BatchDeleteDevicePositionHistoryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const228 void LocationServiceClient::BatchDeleteDevicePositionHistoryAsync(const BatchDeleteDevicePositionHistoryRequest& request, const BatchDeleteDevicePositionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
229 {
230 m_executor->Submit( [this, request, handler, context](){ this->BatchDeleteDevicePositionHistoryAsyncHelper( request, handler, context ); } );
231 }
232
BatchDeleteDevicePositionHistoryAsyncHelper(const BatchDeleteDevicePositionHistoryRequest & request,const BatchDeleteDevicePositionHistoryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const233 void LocationServiceClient::BatchDeleteDevicePositionHistoryAsyncHelper(const BatchDeleteDevicePositionHistoryRequest& request, const BatchDeleteDevicePositionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
234 {
235 handler(this, request, BatchDeleteDevicePositionHistory(request), context);
236 }
237
BatchDeleteGeofence(const BatchDeleteGeofenceRequest & request) const238 BatchDeleteGeofenceOutcome LocationServiceClient::BatchDeleteGeofence(const BatchDeleteGeofenceRequest& request) const
239 {
240 if (!request.CollectionNameHasBeenSet())
241 {
242 AWS_LOGSTREAM_ERROR("BatchDeleteGeofence", "Required field: CollectionName, is not set");
243 return BatchDeleteGeofenceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CollectionName]", false));
244 }
245 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
246 if (m_enableHostPrefixInjection)
247 {
248 uri.SetAuthority("geofencing." + uri.GetAuthority());
249 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
250 {
251 AWS_LOGSTREAM_ERROR("BatchDeleteGeofence", "Invalid DNS host: " << uri.GetAuthority());
252 return BatchDeleteGeofenceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
253 }
254 }
255 uri.AddPathSegments("/geofencing/v0/collections/");
256 uri.AddPathSegment(request.GetCollectionName());
257 uri.AddPathSegments("/delete-geofences");
258 return BatchDeleteGeofenceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
259 }
260
BatchDeleteGeofenceCallable(const BatchDeleteGeofenceRequest & request) const261 BatchDeleteGeofenceOutcomeCallable LocationServiceClient::BatchDeleteGeofenceCallable(const BatchDeleteGeofenceRequest& request) const
262 {
263 auto task = Aws::MakeShared< std::packaged_task< BatchDeleteGeofenceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchDeleteGeofence(request); } );
264 auto packagedFunction = [task]() { (*task)(); };
265 m_executor->Submit(packagedFunction);
266 return task->get_future();
267 }
268
BatchDeleteGeofenceAsync(const BatchDeleteGeofenceRequest & request,const BatchDeleteGeofenceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const269 void LocationServiceClient::BatchDeleteGeofenceAsync(const BatchDeleteGeofenceRequest& request, const BatchDeleteGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
270 {
271 m_executor->Submit( [this, request, handler, context](){ this->BatchDeleteGeofenceAsyncHelper( request, handler, context ); } );
272 }
273
BatchDeleteGeofenceAsyncHelper(const BatchDeleteGeofenceRequest & request,const BatchDeleteGeofenceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const274 void LocationServiceClient::BatchDeleteGeofenceAsyncHelper(const BatchDeleteGeofenceRequest& request, const BatchDeleteGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
275 {
276 handler(this, request, BatchDeleteGeofence(request), context);
277 }
278
BatchEvaluateGeofences(const BatchEvaluateGeofencesRequest & request) const279 BatchEvaluateGeofencesOutcome LocationServiceClient::BatchEvaluateGeofences(const BatchEvaluateGeofencesRequest& request) const
280 {
281 if (!request.CollectionNameHasBeenSet())
282 {
283 AWS_LOGSTREAM_ERROR("BatchEvaluateGeofences", "Required field: CollectionName, is not set");
284 return BatchEvaluateGeofencesOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CollectionName]", false));
285 }
286 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
287 if (m_enableHostPrefixInjection)
288 {
289 uri.SetAuthority("geofencing." + uri.GetAuthority());
290 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
291 {
292 AWS_LOGSTREAM_ERROR("BatchEvaluateGeofences", "Invalid DNS host: " << uri.GetAuthority());
293 return BatchEvaluateGeofencesOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
294 }
295 }
296 uri.AddPathSegments("/geofencing/v0/collections/");
297 uri.AddPathSegment(request.GetCollectionName());
298 uri.AddPathSegments("/positions");
299 return BatchEvaluateGeofencesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
300 }
301
BatchEvaluateGeofencesCallable(const BatchEvaluateGeofencesRequest & request) const302 BatchEvaluateGeofencesOutcomeCallable LocationServiceClient::BatchEvaluateGeofencesCallable(const BatchEvaluateGeofencesRequest& request) const
303 {
304 auto task = Aws::MakeShared< std::packaged_task< BatchEvaluateGeofencesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchEvaluateGeofences(request); } );
305 auto packagedFunction = [task]() { (*task)(); };
306 m_executor->Submit(packagedFunction);
307 return task->get_future();
308 }
309
BatchEvaluateGeofencesAsync(const BatchEvaluateGeofencesRequest & request,const BatchEvaluateGeofencesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const310 void LocationServiceClient::BatchEvaluateGeofencesAsync(const BatchEvaluateGeofencesRequest& request, const BatchEvaluateGeofencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
311 {
312 m_executor->Submit( [this, request, handler, context](){ this->BatchEvaluateGeofencesAsyncHelper( request, handler, context ); } );
313 }
314
BatchEvaluateGeofencesAsyncHelper(const BatchEvaluateGeofencesRequest & request,const BatchEvaluateGeofencesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const315 void LocationServiceClient::BatchEvaluateGeofencesAsyncHelper(const BatchEvaluateGeofencesRequest& request, const BatchEvaluateGeofencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
316 {
317 handler(this, request, BatchEvaluateGeofences(request), context);
318 }
319
BatchGetDevicePosition(const BatchGetDevicePositionRequest & request) const320 BatchGetDevicePositionOutcome LocationServiceClient::BatchGetDevicePosition(const BatchGetDevicePositionRequest& request) const
321 {
322 if (!request.TrackerNameHasBeenSet())
323 {
324 AWS_LOGSTREAM_ERROR("BatchGetDevicePosition", "Required field: TrackerName, is not set");
325 return BatchGetDevicePositionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
326 }
327 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
328 if (m_enableHostPrefixInjection)
329 {
330 uri.SetAuthority("tracking." + uri.GetAuthority());
331 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
332 {
333 AWS_LOGSTREAM_ERROR("BatchGetDevicePosition", "Invalid DNS host: " << uri.GetAuthority());
334 return BatchGetDevicePositionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
335 }
336 }
337 uri.AddPathSegments("/tracking/v0/trackers/");
338 uri.AddPathSegment(request.GetTrackerName());
339 uri.AddPathSegments("/get-positions");
340 return BatchGetDevicePositionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
341 }
342
BatchGetDevicePositionCallable(const BatchGetDevicePositionRequest & request) const343 BatchGetDevicePositionOutcomeCallable LocationServiceClient::BatchGetDevicePositionCallable(const BatchGetDevicePositionRequest& request) const
344 {
345 auto task = Aws::MakeShared< std::packaged_task< BatchGetDevicePositionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchGetDevicePosition(request); } );
346 auto packagedFunction = [task]() { (*task)(); };
347 m_executor->Submit(packagedFunction);
348 return task->get_future();
349 }
350
BatchGetDevicePositionAsync(const BatchGetDevicePositionRequest & request,const BatchGetDevicePositionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const351 void LocationServiceClient::BatchGetDevicePositionAsync(const BatchGetDevicePositionRequest& request, const BatchGetDevicePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
352 {
353 m_executor->Submit( [this, request, handler, context](){ this->BatchGetDevicePositionAsyncHelper( request, handler, context ); } );
354 }
355
BatchGetDevicePositionAsyncHelper(const BatchGetDevicePositionRequest & request,const BatchGetDevicePositionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const356 void LocationServiceClient::BatchGetDevicePositionAsyncHelper(const BatchGetDevicePositionRequest& request, const BatchGetDevicePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
357 {
358 handler(this, request, BatchGetDevicePosition(request), context);
359 }
360
BatchPutGeofence(const BatchPutGeofenceRequest & request) const361 BatchPutGeofenceOutcome LocationServiceClient::BatchPutGeofence(const BatchPutGeofenceRequest& request) const
362 {
363 if (!request.CollectionNameHasBeenSet())
364 {
365 AWS_LOGSTREAM_ERROR("BatchPutGeofence", "Required field: CollectionName, is not set");
366 return BatchPutGeofenceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CollectionName]", false));
367 }
368 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
369 if (m_enableHostPrefixInjection)
370 {
371 uri.SetAuthority("geofencing." + uri.GetAuthority());
372 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
373 {
374 AWS_LOGSTREAM_ERROR("BatchPutGeofence", "Invalid DNS host: " << uri.GetAuthority());
375 return BatchPutGeofenceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
376 }
377 }
378 uri.AddPathSegments("/geofencing/v0/collections/");
379 uri.AddPathSegment(request.GetCollectionName());
380 uri.AddPathSegments("/put-geofences");
381 return BatchPutGeofenceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
382 }
383
BatchPutGeofenceCallable(const BatchPutGeofenceRequest & request) const384 BatchPutGeofenceOutcomeCallable LocationServiceClient::BatchPutGeofenceCallable(const BatchPutGeofenceRequest& request) const
385 {
386 auto task = Aws::MakeShared< std::packaged_task< BatchPutGeofenceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchPutGeofence(request); } );
387 auto packagedFunction = [task]() { (*task)(); };
388 m_executor->Submit(packagedFunction);
389 return task->get_future();
390 }
391
BatchPutGeofenceAsync(const BatchPutGeofenceRequest & request,const BatchPutGeofenceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const392 void LocationServiceClient::BatchPutGeofenceAsync(const BatchPutGeofenceRequest& request, const BatchPutGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
393 {
394 m_executor->Submit( [this, request, handler, context](){ this->BatchPutGeofenceAsyncHelper( request, handler, context ); } );
395 }
396
BatchPutGeofenceAsyncHelper(const BatchPutGeofenceRequest & request,const BatchPutGeofenceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const397 void LocationServiceClient::BatchPutGeofenceAsyncHelper(const BatchPutGeofenceRequest& request, const BatchPutGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
398 {
399 handler(this, request, BatchPutGeofence(request), context);
400 }
401
BatchUpdateDevicePosition(const BatchUpdateDevicePositionRequest & request) const402 BatchUpdateDevicePositionOutcome LocationServiceClient::BatchUpdateDevicePosition(const BatchUpdateDevicePositionRequest& request) const
403 {
404 if (!request.TrackerNameHasBeenSet())
405 {
406 AWS_LOGSTREAM_ERROR("BatchUpdateDevicePosition", "Required field: TrackerName, is not set");
407 return BatchUpdateDevicePositionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
408 }
409 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
410 if (m_enableHostPrefixInjection)
411 {
412 uri.SetAuthority("tracking." + uri.GetAuthority());
413 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
414 {
415 AWS_LOGSTREAM_ERROR("BatchUpdateDevicePosition", "Invalid DNS host: " << uri.GetAuthority());
416 return BatchUpdateDevicePositionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
417 }
418 }
419 uri.AddPathSegments("/tracking/v0/trackers/");
420 uri.AddPathSegment(request.GetTrackerName());
421 uri.AddPathSegments("/positions");
422 return BatchUpdateDevicePositionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
423 }
424
BatchUpdateDevicePositionCallable(const BatchUpdateDevicePositionRequest & request) const425 BatchUpdateDevicePositionOutcomeCallable LocationServiceClient::BatchUpdateDevicePositionCallable(const BatchUpdateDevicePositionRequest& request) const
426 {
427 auto task = Aws::MakeShared< std::packaged_task< BatchUpdateDevicePositionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->BatchUpdateDevicePosition(request); } );
428 auto packagedFunction = [task]() { (*task)(); };
429 m_executor->Submit(packagedFunction);
430 return task->get_future();
431 }
432
BatchUpdateDevicePositionAsync(const BatchUpdateDevicePositionRequest & request,const BatchUpdateDevicePositionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const433 void LocationServiceClient::BatchUpdateDevicePositionAsync(const BatchUpdateDevicePositionRequest& request, const BatchUpdateDevicePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
434 {
435 m_executor->Submit( [this, request, handler, context](){ this->BatchUpdateDevicePositionAsyncHelper( request, handler, context ); } );
436 }
437
BatchUpdateDevicePositionAsyncHelper(const BatchUpdateDevicePositionRequest & request,const BatchUpdateDevicePositionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const438 void LocationServiceClient::BatchUpdateDevicePositionAsyncHelper(const BatchUpdateDevicePositionRequest& request, const BatchUpdateDevicePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
439 {
440 handler(this, request, BatchUpdateDevicePosition(request), context);
441 }
442
CalculateRoute(const CalculateRouteRequest & request) const443 CalculateRouteOutcome LocationServiceClient::CalculateRoute(const CalculateRouteRequest& request) const
444 {
445 if (!request.CalculatorNameHasBeenSet())
446 {
447 AWS_LOGSTREAM_ERROR("CalculateRoute", "Required field: CalculatorName, is not set");
448 return CalculateRouteOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CalculatorName]", false));
449 }
450 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
451 if (m_enableHostPrefixInjection)
452 {
453 uri.SetAuthority("routes." + uri.GetAuthority());
454 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
455 {
456 AWS_LOGSTREAM_ERROR("CalculateRoute", "Invalid DNS host: " << uri.GetAuthority());
457 return CalculateRouteOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
458 }
459 }
460 uri.AddPathSegments("/routes/v0/calculators/");
461 uri.AddPathSegment(request.GetCalculatorName());
462 uri.AddPathSegments("/calculate/route");
463 return CalculateRouteOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
464 }
465
CalculateRouteCallable(const CalculateRouteRequest & request) const466 CalculateRouteOutcomeCallable LocationServiceClient::CalculateRouteCallable(const CalculateRouteRequest& request) const
467 {
468 auto task = Aws::MakeShared< std::packaged_task< CalculateRouteOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CalculateRoute(request); } );
469 auto packagedFunction = [task]() { (*task)(); };
470 m_executor->Submit(packagedFunction);
471 return task->get_future();
472 }
473
CalculateRouteAsync(const CalculateRouteRequest & request,const CalculateRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const474 void LocationServiceClient::CalculateRouteAsync(const CalculateRouteRequest& request, const CalculateRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
475 {
476 m_executor->Submit( [this, request, handler, context](){ this->CalculateRouteAsyncHelper( request, handler, context ); } );
477 }
478
CalculateRouteAsyncHelper(const CalculateRouteRequest & request,const CalculateRouteResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const479 void LocationServiceClient::CalculateRouteAsyncHelper(const CalculateRouteRequest& request, const CalculateRouteResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
480 {
481 handler(this, request, CalculateRoute(request), context);
482 }
483
CreateGeofenceCollection(const CreateGeofenceCollectionRequest & request) const484 CreateGeofenceCollectionOutcome LocationServiceClient::CreateGeofenceCollection(const CreateGeofenceCollectionRequest& request) const
485 {
486 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
487 if (m_enableHostPrefixInjection)
488 {
489 uri.SetAuthority("geofencing." + uri.GetAuthority());
490 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
491 {
492 AWS_LOGSTREAM_ERROR("CreateGeofenceCollection", "Invalid DNS host: " << uri.GetAuthority());
493 return CreateGeofenceCollectionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
494 }
495 }
496 uri.AddPathSegments("/geofencing/v0/collections");
497 return CreateGeofenceCollectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
498 }
499
CreateGeofenceCollectionCallable(const CreateGeofenceCollectionRequest & request) const500 CreateGeofenceCollectionOutcomeCallable LocationServiceClient::CreateGeofenceCollectionCallable(const CreateGeofenceCollectionRequest& request) const
501 {
502 auto task = Aws::MakeShared< std::packaged_task< CreateGeofenceCollectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateGeofenceCollection(request); } );
503 auto packagedFunction = [task]() { (*task)(); };
504 m_executor->Submit(packagedFunction);
505 return task->get_future();
506 }
507
CreateGeofenceCollectionAsync(const CreateGeofenceCollectionRequest & request,const CreateGeofenceCollectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const508 void LocationServiceClient::CreateGeofenceCollectionAsync(const CreateGeofenceCollectionRequest& request, const CreateGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
509 {
510 m_executor->Submit( [this, request, handler, context](){ this->CreateGeofenceCollectionAsyncHelper( request, handler, context ); } );
511 }
512
CreateGeofenceCollectionAsyncHelper(const CreateGeofenceCollectionRequest & request,const CreateGeofenceCollectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const513 void LocationServiceClient::CreateGeofenceCollectionAsyncHelper(const CreateGeofenceCollectionRequest& request, const CreateGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
514 {
515 handler(this, request, CreateGeofenceCollection(request), context);
516 }
517
CreateMap(const CreateMapRequest & request) const518 CreateMapOutcome LocationServiceClient::CreateMap(const CreateMapRequest& request) const
519 {
520 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
521 if (m_enableHostPrefixInjection)
522 {
523 uri.SetAuthority("maps." + uri.GetAuthority());
524 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
525 {
526 AWS_LOGSTREAM_ERROR("CreateMap", "Invalid DNS host: " << uri.GetAuthority());
527 return CreateMapOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
528 }
529 }
530 uri.AddPathSegments("/maps/v0/maps");
531 return CreateMapOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
532 }
533
CreateMapCallable(const CreateMapRequest & request) const534 CreateMapOutcomeCallable LocationServiceClient::CreateMapCallable(const CreateMapRequest& request) const
535 {
536 auto task = Aws::MakeShared< std::packaged_task< CreateMapOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateMap(request); } );
537 auto packagedFunction = [task]() { (*task)(); };
538 m_executor->Submit(packagedFunction);
539 return task->get_future();
540 }
541
CreateMapAsync(const CreateMapRequest & request,const CreateMapResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const542 void LocationServiceClient::CreateMapAsync(const CreateMapRequest& request, const CreateMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
543 {
544 m_executor->Submit( [this, request, handler, context](){ this->CreateMapAsyncHelper( request, handler, context ); } );
545 }
546
CreateMapAsyncHelper(const CreateMapRequest & request,const CreateMapResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const547 void LocationServiceClient::CreateMapAsyncHelper(const CreateMapRequest& request, const CreateMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
548 {
549 handler(this, request, CreateMap(request), context);
550 }
551
CreatePlaceIndex(const CreatePlaceIndexRequest & request) const552 CreatePlaceIndexOutcome LocationServiceClient::CreatePlaceIndex(const CreatePlaceIndexRequest& request) const
553 {
554 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
555 if (m_enableHostPrefixInjection)
556 {
557 uri.SetAuthority("places." + uri.GetAuthority());
558 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
559 {
560 AWS_LOGSTREAM_ERROR("CreatePlaceIndex", "Invalid DNS host: " << uri.GetAuthority());
561 return CreatePlaceIndexOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
562 }
563 }
564 uri.AddPathSegments("/places/v0/indexes");
565 return CreatePlaceIndexOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
566 }
567
CreatePlaceIndexCallable(const CreatePlaceIndexRequest & request) const568 CreatePlaceIndexOutcomeCallable LocationServiceClient::CreatePlaceIndexCallable(const CreatePlaceIndexRequest& request) const
569 {
570 auto task = Aws::MakeShared< std::packaged_task< CreatePlaceIndexOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreatePlaceIndex(request); } );
571 auto packagedFunction = [task]() { (*task)(); };
572 m_executor->Submit(packagedFunction);
573 return task->get_future();
574 }
575
CreatePlaceIndexAsync(const CreatePlaceIndexRequest & request,const CreatePlaceIndexResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const576 void LocationServiceClient::CreatePlaceIndexAsync(const CreatePlaceIndexRequest& request, const CreatePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
577 {
578 m_executor->Submit( [this, request, handler, context](){ this->CreatePlaceIndexAsyncHelper( request, handler, context ); } );
579 }
580
CreatePlaceIndexAsyncHelper(const CreatePlaceIndexRequest & request,const CreatePlaceIndexResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const581 void LocationServiceClient::CreatePlaceIndexAsyncHelper(const CreatePlaceIndexRequest& request, const CreatePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
582 {
583 handler(this, request, CreatePlaceIndex(request), context);
584 }
585
CreateRouteCalculator(const CreateRouteCalculatorRequest & request) const586 CreateRouteCalculatorOutcome LocationServiceClient::CreateRouteCalculator(const CreateRouteCalculatorRequest& request) const
587 {
588 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
589 if (m_enableHostPrefixInjection)
590 {
591 uri.SetAuthority("routes." + uri.GetAuthority());
592 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
593 {
594 AWS_LOGSTREAM_ERROR("CreateRouteCalculator", "Invalid DNS host: " << uri.GetAuthority());
595 return CreateRouteCalculatorOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
596 }
597 }
598 uri.AddPathSegments("/routes/v0/calculators");
599 return CreateRouteCalculatorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
600 }
601
CreateRouteCalculatorCallable(const CreateRouteCalculatorRequest & request) const602 CreateRouteCalculatorOutcomeCallable LocationServiceClient::CreateRouteCalculatorCallable(const CreateRouteCalculatorRequest& request) const
603 {
604 auto task = Aws::MakeShared< std::packaged_task< CreateRouteCalculatorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateRouteCalculator(request); } );
605 auto packagedFunction = [task]() { (*task)(); };
606 m_executor->Submit(packagedFunction);
607 return task->get_future();
608 }
609
CreateRouteCalculatorAsync(const CreateRouteCalculatorRequest & request,const CreateRouteCalculatorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const610 void LocationServiceClient::CreateRouteCalculatorAsync(const CreateRouteCalculatorRequest& request, const CreateRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
611 {
612 m_executor->Submit( [this, request, handler, context](){ this->CreateRouteCalculatorAsyncHelper( request, handler, context ); } );
613 }
614
CreateRouteCalculatorAsyncHelper(const CreateRouteCalculatorRequest & request,const CreateRouteCalculatorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const615 void LocationServiceClient::CreateRouteCalculatorAsyncHelper(const CreateRouteCalculatorRequest& request, const CreateRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
616 {
617 handler(this, request, CreateRouteCalculator(request), context);
618 }
619
CreateTracker(const CreateTrackerRequest & request) const620 CreateTrackerOutcome LocationServiceClient::CreateTracker(const CreateTrackerRequest& request) const
621 {
622 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
623 if (m_enableHostPrefixInjection)
624 {
625 uri.SetAuthority("tracking." + uri.GetAuthority());
626 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
627 {
628 AWS_LOGSTREAM_ERROR("CreateTracker", "Invalid DNS host: " << uri.GetAuthority());
629 return CreateTrackerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
630 }
631 }
632 uri.AddPathSegments("/tracking/v0/trackers");
633 return CreateTrackerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
634 }
635
CreateTrackerCallable(const CreateTrackerRequest & request) const636 CreateTrackerOutcomeCallable LocationServiceClient::CreateTrackerCallable(const CreateTrackerRequest& request) const
637 {
638 auto task = Aws::MakeShared< std::packaged_task< CreateTrackerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateTracker(request); } );
639 auto packagedFunction = [task]() { (*task)(); };
640 m_executor->Submit(packagedFunction);
641 return task->get_future();
642 }
643
CreateTrackerAsync(const CreateTrackerRequest & request,const CreateTrackerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const644 void LocationServiceClient::CreateTrackerAsync(const CreateTrackerRequest& request, const CreateTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
645 {
646 m_executor->Submit( [this, request, handler, context](){ this->CreateTrackerAsyncHelper( request, handler, context ); } );
647 }
648
CreateTrackerAsyncHelper(const CreateTrackerRequest & request,const CreateTrackerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const649 void LocationServiceClient::CreateTrackerAsyncHelper(const CreateTrackerRequest& request, const CreateTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
650 {
651 handler(this, request, CreateTracker(request), context);
652 }
653
DeleteGeofenceCollection(const DeleteGeofenceCollectionRequest & request) const654 DeleteGeofenceCollectionOutcome LocationServiceClient::DeleteGeofenceCollection(const DeleteGeofenceCollectionRequest& request) const
655 {
656 if (!request.CollectionNameHasBeenSet())
657 {
658 AWS_LOGSTREAM_ERROR("DeleteGeofenceCollection", "Required field: CollectionName, is not set");
659 return DeleteGeofenceCollectionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CollectionName]", false));
660 }
661 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
662 if (m_enableHostPrefixInjection)
663 {
664 uri.SetAuthority("geofencing." + uri.GetAuthority());
665 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
666 {
667 AWS_LOGSTREAM_ERROR("DeleteGeofenceCollection", "Invalid DNS host: " << uri.GetAuthority());
668 return DeleteGeofenceCollectionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
669 }
670 }
671 uri.AddPathSegments("/geofencing/v0/collections/");
672 uri.AddPathSegment(request.GetCollectionName());
673 return DeleteGeofenceCollectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
674 }
675
DeleteGeofenceCollectionCallable(const DeleteGeofenceCollectionRequest & request) const676 DeleteGeofenceCollectionOutcomeCallable LocationServiceClient::DeleteGeofenceCollectionCallable(const DeleteGeofenceCollectionRequest& request) const
677 {
678 auto task = Aws::MakeShared< std::packaged_task< DeleteGeofenceCollectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteGeofenceCollection(request); } );
679 auto packagedFunction = [task]() { (*task)(); };
680 m_executor->Submit(packagedFunction);
681 return task->get_future();
682 }
683
DeleteGeofenceCollectionAsync(const DeleteGeofenceCollectionRequest & request,const DeleteGeofenceCollectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const684 void LocationServiceClient::DeleteGeofenceCollectionAsync(const DeleteGeofenceCollectionRequest& request, const DeleteGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
685 {
686 m_executor->Submit( [this, request, handler, context](){ this->DeleteGeofenceCollectionAsyncHelper( request, handler, context ); } );
687 }
688
DeleteGeofenceCollectionAsyncHelper(const DeleteGeofenceCollectionRequest & request,const DeleteGeofenceCollectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const689 void LocationServiceClient::DeleteGeofenceCollectionAsyncHelper(const DeleteGeofenceCollectionRequest& request, const DeleteGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
690 {
691 handler(this, request, DeleteGeofenceCollection(request), context);
692 }
693
DeleteMap(const DeleteMapRequest & request) const694 DeleteMapOutcome LocationServiceClient::DeleteMap(const DeleteMapRequest& request) const
695 {
696 if (!request.MapNameHasBeenSet())
697 {
698 AWS_LOGSTREAM_ERROR("DeleteMap", "Required field: MapName, is not set");
699 return DeleteMapOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MapName]", false));
700 }
701 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
702 if (m_enableHostPrefixInjection)
703 {
704 uri.SetAuthority("maps." + uri.GetAuthority());
705 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
706 {
707 AWS_LOGSTREAM_ERROR("DeleteMap", "Invalid DNS host: " << uri.GetAuthority());
708 return DeleteMapOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
709 }
710 }
711 uri.AddPathSegments("/maps/v0/maps/");
712 uri.AddPathSegment(request.GetMapName());
713 return DeleteMapOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
714 }
715
DeleteMapCallable(const DeleteMapRequest & request) const716 DeleteMapOutcomeCallable LocationServiceClient::DeleteMapCallable(const DeleteMapRequest& request) const
717 {
718 auto task = Aws::MakeShared< std::packaged_task< DeleteMapOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteMap(request); } );
719 auto packagedFunction = [task]() { (*task)(); };
720 m_executor->Submit(packagedFunction);
721 return task->get_future();
722 }
723
DeleteMapAsync(const DeleteMapRequest & request,const DeleteMapResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const724 void LocationServiceClient::DeleteMapAsync(const DeleteMapRequest& request, const DeleteMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
725 {
726 m_executor->Submit( [this, request, handler, context](){ this->DeleteMapAsyncHelper( request, handler, context ); } );
727 }
728
DeleteMapAsyncHelper(const DeleteMapRequest & request,const DeleteMapResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const729 void LocationServiceClient::DeleteMapAsyncHelper(const DeleteMapRequest& request, const DeleteMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
730 {
731 handler(this, request, DeleteMap(request), context);
732 }
733
DeletePlaceIndex(const DeletePlaceIndexRequest & request) const734 DeletePlaceIndexOutcome LocationServiceClient::DeletePlaceIndex(const DeletePlaceIndexRequest& request) const
735 {
736 if (!request.IndexNameHasBeenSet())
737 {
738 AWS_LOGSTREAM_ERROR("DeletePlaceIndex", "Required field: IndexName, is not set");
739 return DeletePlaceIndexOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [IndexName]", false));
740 }
741 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
742 if (m_enableHostPrefixInjection)
743 {
744 uri.SetAuthority("places." + uri.GetAuthority());
745 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
746 {
747 AWS_LOGSTREAM_ERROR("DeletePlaceIndex", "Invalid DNS host: " << uri.GetAuthority());
748 return DeletePlaceIndexOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
749 }
750 }
751 uri.AddPathSegments("/places/v0/indexes/");
752 uri.AddPathSegment(request.GetIndexName());
753 return DeletePlaceIndexOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
754 }
755
DeletePlaceIndexCallable(const DeletePlaceIndexRequest & request) const756 DeletePlaceIndexOutcomeCallable LocationServiceClient::DeletePlaceIndexCallable(const DeletePlaceIndexRequest& request) const
757 {
758 auto task = Aws::MakeShared< std::packaged_task< DeletePlaceIndexOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeletePlaceIndex(request); } );
759 auto packagedFunction = [task]() { (*task)(); };
760 m_executor->Submit(packagedFunction);
761 return task->get_future();
762 }
763
DeletePlaceIndexAsync(const DeletePlaceIndexRequest & request,const DeletePlaceIndexResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const764 void LocationServiceClient::DeletePlaceIndexAsync(const DeletePlaceIndexRequest& request, const DeletePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
765 {
766 m_executor->Submit( [this, request, handler, context](){ this->DeletePlaceIndexAsyncHelper( request, handler, context ); } );
767 }
768
DeletePlaceIndexAsyncHelper(const DeletePlaceIndexRequest & request,const DeletePlaceIndexResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const769 void LocationServiceClient::DeletePlaceIndexAsyncHelper(const DeletePlaceIndexRequest& request, const DeletePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
770 {
771 handler(this, request, DeletePlaceIndex(request), context);
772 }
773
DeleteRouteCalculator(const DeleteRouteCalculatorRequest & request) const774 DeleteRouteCalculatorOutcome LocationServiceClient::DeleteRouteCalculator(const DeleteRouteCalculatorRequest& request) const
775 {
776 if (!request.CalculatorNameHasBeenSet())
777 {
778 AWS_LOGSTREAM_ERROR("DeleteRouteCalculator", "Required field: CalculatorName, is not set");
779 return DeleteRouteCalculatorOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CalculatorName]", false));
780 }
781 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
782 if (m_enableHostPrefixInjection)
783 {
784 uri.SetAuthority("routes." + uri.GetAuthority());
785 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
786 {
787 AWS_LOGSTREAM_ERROR("DeleteRouteCalculator", "Invalid DNS host: " << uri.GetAuthority());
788 return DeleteRouteCalculatorOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
789 }
790 }
791 uri.AddPathSegments("/routes/v0/calculators/");
792 uri.AddPathSegment(request.GetCalculatorName());
793 return DeleteRouteCalculatorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
794 }
795
DeleteRouteCalculatorCallable(const DeleteRouteCalculatorRequest & request) const796 DeleteRouteCalculatorOutcomeCallable LocationServiceClient::DeleteRouteCalculatorCallable(const DeleteRouteCalculatorRequest& request) const
797 {
798 auto task = Aws::MakeShared< std::packaged_task< DeleteRouteCalculatorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteRouteCalculator(request); } );
799 auto packagedFunction = [task]() { (*task)(); };
800 m_executor->Submit(packagedFunction);
801 return task->get_future();
802 }
803
DeleteRouteCalculatorAsync(const DeleteRouteCalculatorRequest & request,const DeleteRouteCalculatorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const804 void LocationServiceClient::DeleteRouteCalculatorAsync(const DeleteRouteCalculatorRequest& request, const DeleteRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
805 {
806 m_executor->Submit( [this, request, handler, context](){ this->DeleteRouteCalculatorAsyncHelper( request, handler, context ); } );
807 }
808
DeleteRouteCalculatorAsyncHelper(const DeleteRouteCalculatorRequest & request,const DeleteRouteCalculatorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const809 void LocationServiceClient::DeleteRouteCalculatorAsyncHelper(const DeleteRouteCalculatorRequest& request, const DeleteRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
810 {
811 handler(this, request, DeleteRouteCalculator(request), context);
812 }
813
DeleteTracker(const DeleteTrackerRequest & request) const814 DeleteTrackerOutcome LocationServiceClient::DeleteTracker(const DeleteTrackerRequest& request) const
815 {
816 if (!request.TrackerNameHasBeenSet())
817 {
818 AWS_LOGSTREAM_ERROR("DeleteTracker", "Required field: TrackerName, is not set");
819 return DeleteTrackerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
820 }
821 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
822 if (m_enableHostPrefixInjection)
823 {
824 uri.SetAuthority("tracking." + uri.GetAuthority());
825 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
826 {
827 AWS_LOGSTREAM_ERROR("DeleteTracker", "Invalid DNS host: " << uri.GetAuthority());
828 return DeleteTrackerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
829 }
830 }
831 uri.AddPathSegments("/tracking/v0/trackers/");
832 uri.AddPathSegment(request.GetTrackerName());
833 return DeleteTrackerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
834 }
835
DeleteTrackerCallable(const DeleteTrackerRequest & request) const836 DeleteTrackerOutcomeCallable LocationServiceClient::DeleteTrackerCallable(const DeleteTrackerRequest& request) const
837 {
838 auto task = Aws::MakeShared< std::packaged_task< DeleteTrackerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteTracker(request); } );
839 auto packagedFunction = [task]() { (*task)(); };
840 m_executor->Submit(packagedFunction);
841 return task->get_future();
842 }
843
DeleteTrackerAsync(const DeleteTrackerRequest & request,const DeleteTrackerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const844 void LocationServiceClient::DeleteTrackerAsync(const DeleteTrackerRequest& request, const DeleteTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
845 {
846 m_executor->Submit( [this, request, handler, context](){ this->DeleteTrackerAsyncHelper( request, handler, context ); } );
847 }
848
DeleteTrackerAsyncHelper(const DeleteTrackerRequest & request,const DeleteTrackerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const849 void LocationServiceClient::DeleteTrackerAsyncHelper(const DeleteTrackerRequest& request, const DeleteTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
850 {
851 handler(this, request, DeleteTracker(request), context);
852 }
853
DescribeGeofenceCollection(const DescribeGeofenceCollectionRequest & request) const854 DescribeGeofenceCollectionOutcome LocationServiceClient::DescribeGeofenceCollection(const DescribeGeofenceCollectionRequest& request) const
855 {
856 if (!request.CollectionNameHasBeenSet())
857 {
858 AWS_LOGSTREAM_ERROR("DescribeGeofenceCollection", "Required field: CollectionName, is not set");
859 return DescribeGeofenceCollectionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CollectionName]", false));
860 }
861 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
862 if (m_enableHostPrefixInjection)
863 {
864 uri.SetAuthority("geofencing." + uri.GetAuthority());
865 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
866 {
867 AWS_LOGSTREAM_ERROR("DescribeGeofenceCollection", "Invalid DNS host: " << uri.GetAuthority());
868 return DescribeGeofenceCollectionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
869 }
870 }
871 uri.AddPathSegments("/geofencing/v0/collections/");
872 uri.AddPathSegment(request.GetCollectionName());
873 return DescribeGeofenceCollectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
874 }
875
DescribeGeofenceCollectionCallable(const DescribeGeofenceCollectionRequest & request) const876 DescribeGeofenceCollectionOutcomeCallable LocationServiceClient::DescribeGeofenceCollectionCallable(const DescribeGeofenceCollectionRequest& request) const
877 {
878 auto task = Aws::MakeShared< std::packaged_task< DescribeGeofenceCollectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeGeofenceCollection(request); } );
879 auto packagedFunction = [task]() { (*task)(); };
880 m_executor->Submit(packagedFunction);
881 return task->get_future();
882 }
883
DescribeGeofenceCollectionAsync(const DescribeGeofenceCollectionRequest & request,const DescribeGeofenceCollectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const884 void LocationServiceClient::DescribeGeofenceCollectionAsync(const DescribeGeofenceCollectionRequest& request, const DescribeGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
885 {
886 m_executor->Submit( [this, request, handler, context](){ this->DescribeGeofenceCollectionAsyncHelper( request, handler, context ); } );
887 }
888
DescribeGeofenceCollectionAsyncHelper(const DescribeGeofenceCollectionRequest & request,const DescribeGeofenceCollectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const889 void LocationServiceClient::DescribeGeofenceCollectionAsyncHelper(const DescribeGeofenceCollectionRequest& request, const DescribeGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
890 {
891 handler(this, request, DescribeGeofenceCollection(request), context);
892 }
893
DescribeMap(const DescribeMapRequest & request) const894 DescribeMapOutcome LocationServiceClient::DescribeMap(const DescribeMapRequest& request) const
895 {
896 if (!request.MapNameHasBeenSet())
897 {
898 AWS_LOGSTREAM_ERROR("DescribeMap", "Required field: MapName, is not set");
899 return DescribeMapOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MapName]", false));
900 }
901 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
902 if (m_enableHostPrefixInjection)
903 {
904 uri.SetAuthority("maps." + uri.GetAuthority());
905 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
906 {
907 AWS_LOGSTREAM_ERROR("DescribeMap", "Invalid DNS host: " << uri.GetAuthority());
908 return DescribeMapOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
909 }
910 }
911 uri.AddPathSegments("/maps/v0/maps/");
912 uri.AddPathSegment(request.GetMapName());
913 return DescribeMapOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
914 }
915
DescribeMapCallable(const DescribeMapRequest & request) const916 DescribeMapOutcomeCallable LocationServiceClient::DescribeMapCallable(const DescribeMapRequest& request) const
917 {
918 auto task = Aws::MakeShared< std::packaged_task< DescribeMapOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeMap(request); } );
919 auto packagedFunction = [task]() { (*task)(); };
920 m_executor->Submit(packagedFunction);
921 return task->get_future();
922 }
923
DescribeMapAsync(const DescribeMapRequest & request,const DescribeMapResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const924 void LocationServiceClient::DescribeMapAsync(const DescribeMapRequest& request, const DescribeMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
925 {
926 m_executor->Submit( [this, request, handler, context](){ this->DescribeMapAsyncHelper( request, handler, context ); } );
927 }
928
DescribeMapAsyncHelper(const DescribeMapRequest & request,const DescribeMapResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const929 void LocationServiceClient::DescribeMapAsyncHelper(const DescribeMapRequest& request, const DescribeMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
930 {
931 handler(this, request, DescribeMap(request), context);
932 }
933
DescribePlaceIndex(const DescribePlaceIndexRequest & request) const934 DescribePlaceIndexOutcome LocationServiceClient::DescribePlaceIndex(const DescribePlaceIndexRequest& request) const
935 {
936 if (!request.IndexNameHasBeenSet())
937 {
938 AWS_LOGSTREAM_ERROR("DescribePlaceIndex", "Required field: IndexName, is not set");
939 return DescribePlaceIndexOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [IndexName]", false));
940 }
941 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
942 if (m_enableHostPrefixInjection)
943 {
944 uri.SetAuthority("places." + uri.GetAuthority());
945 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
946 {
947 AWS_LOGSTREAM_ERROR("DescribePlaceIndex", "Invalid DNS host: " << uri.GetAuthority());
948 return DescribePlaceIndexOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
949 }
950 }
951 uri.AddPathSegments("/places/v0/indexes/");
952 uri.AddPathSegment(request.GetIndexName());
953 return DescribePlaceIndexOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
954 }
955
DescribePlaceIndexCallable(const DescribePlaceIndexRequest & request) const956 DescribePlaceIndexOutcomeCallable LocationServiceClient::DescribePlaceIndexCallable(const DescribePlaceIndexRequest& request) const
957 {
958 auto task = Aws::MakeShared< std::packaged_task< DescribePlaceIndexOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribePlaceIndex(request); } );
959 auto packagedFunction = [task]() { (*task)(); };
960 m_executor->Submit(packagedFunction);
961 return task->get_future();
962 }
963
DescribePlaceIndexAsync(const DescribePlaceIndexRequest & request,const DescribePlaceIndexResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const964 void LocationServiceClient::DescribePlaceIndexAsync(const DescribePlaceIndexRequest& request, const DescribePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
965 {
966 m_executor->Submit( [this, request, handler, context](){ this->DescribePlaceIndexAsyncHelper( request, handler, context ); } );
967 }
968
DescribePlaceIndexAsyncHelper(const DescribePlaceIndexRequest & request,const DescribePlaceIndexResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const969 void LocationServiceClient::DescribePlaceIndexAsyncHelper(const DescribePlaceIndexRequest& request, const DescribePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
970 {
971 handler(this, request, DescribePlaceIndex(request), context);
972 }
973
DescribeRouteCalculator(const DescribeRouteCalculatorRequest & request) const974 DescribeRouteCalculatorOutcome LocationServiceClient::DescribeRouteCalculator(const DescribeRouteCalculatorRequest& request) const
975 {
976 if (!request.CalculatorNameHasBeenSet())
977 {
978 AWS_LOGSTREAM_ERROR("DescribeRouteCalculator", "Required field: CalculatorName, is not set");
979 return DescribeRouteCalculatorOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CalculatorName]", false));
980 }
981 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
982 if (m_enableHostPrefixInjection)
983 {
984 uri.SetAuthority("routes." + uri.GetAuthority());
985 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
986 {
987 AWS_LOGSTREAM_ERROR("DescribeRouteCalculator", "Invalid DNS host: " << uri.GetAuthority());
988 return DescribeRouteCalculatorOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
989 }
990 }
991 uri.AddPathSegments("/routes/v0/calculators/");
992 uri.AddPathSegment(request.GetCalculatorName());
993 return DescribeRouteCalculatorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
994 }
995
DescribeRouteCalculatorCallable(const DescribeRouteCalculatorRequest & request) const996 DescribeRouteCalculatorOutcomeCallable LocationServiceClient::DescribeRouteCalculatorCallable(const DescribeRouteCalculatorRequest& request) const
997 {
998 auto task = Aws::MakeShared< std::packaged_task< DescribeRouteCalculatorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeRouteCalculator(request); } );
999 auto packagedFunction = [task]() { (*task)(); };
1000 m_executor->Submit(packagedFunction);
1001 return task->get_future();
1002 }
1003
DescribeRouteCalculatorAsync(const DescribeRouteCalculatorRequest & request,const DescribeRouteCalculatorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1004 void LocationServiceClient::DescribeRouteCalculatorAsync(const DescribeRouteCalculatorRequest& request, const DescribeRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1005 {
1006 m_executor->Submit( [this, request, handler, context](){ this->DescribeRouteCalculatorAsyncHelper( request, handler, context ); } );
1007 }
1008
DescribeRouteCalculatorAsyncHelper(const DescribeRouteCalculatorRequest & request,const DescribeRouteCalculatorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1009 void LocationServiceClient::DescribeRouteCalculatorAsyncHelper(const DescribeRouteCalculatorRequest& request, const DescribeRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1010 {
1011 handler(this, request, DescribeRouteCalculator(request), context);
1012 }
1013
DescribeTracker(const DescribeTrackerRequest & request) const1014 DescribeTrackerOutcome LocationServiceClient::DescribeTracker(const DescribeTrackerRequest& request) const
1015 {
1016 if (!request.TrackerNameHasBeenSet())
1017 {
1018 AWS_LOGSTREAM_ERROR("DescribeTracker", "Required field: TrackerName, is not set");
1019 return DescribeTrackerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
1020 }
1021 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1022 if (m_enableHostPrefixInjection)
1023 {
1024 uri.SetAuthority("tracking." + uri.GetAuthority());
1025 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1026 {
1027 AWS_LOGSTREAM_ERROR("DescribeTracker", "Invalid DNS host: " << uri.GetAuthority());
1028 return DescribeTrackerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1029 }
1030 }
1031 uri.AddPathSegments("/tracking/v0/trackers/");
1032 uri.AddPathSegment(request.GetTrackerName());
1033 return DescribeTrackerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1034 }
1035
DescribeTrackerCallable(const DescribeTrackerRequest & request) const1036 DescribeTrackerOutcomeCallable LocationServiceClient::DescribeTrackerCallable(const DescribeTrackerRequest& request) const
1037 {
1038 auto task = Aws::MakeShared< std::packaged_task< DescribeTrackerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DescribeTracker(request); } );
1039 auto packagedFunction = [task]() { (*task)(); };
1040 m_executor->Submit(packagedFunction);
1041 return task->get_future();
1042 }
1043
DescribeTrackerAsync(const DescribeTrackerRequest & request,const DescribeTrackerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1044 void LocationServiceClient::DescribeTrackerAsync(const DescribeTrackerRequest& request, const DescribeTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1045 {
1046 m_executor->Submit( [this, request, handler, context](){ this->DescribeTrackerAsyncHelper( request, handler, context ); } );
1047 }
1048
DescribeTrackerAsyncHelper(const DescribeTrackerRequest & request,const DescribeTrackerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1049 void LocationServiceClient::DescribeTrackerAsyncHelper(const DescribeTrackerRequest& request, const DescribeTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1050 {
1051 handler(this, request, DescribeTracker(request), context);
1052 }
1053
DisassociateTrackerConsumer(const DisassociateTrackerConsumerRequest & request) const1054 DisassociateTrackerConsumerOutcome LocationServiceClient::DisassociateTrackerConsumer(const DisassociateTrackerConsumerRequest& request) const
1055 {
1056 if (!request.ConsumerArnHasBeenSet())
1057 {
1058 AWS_LOGSTREAM_ERROR("DisassociateTrackerConsumer", "Required field: ConsumerArn, is not set");
1059 return DisassociateTrackerConsumerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ConsumerArn]", false));
1060 }
1061 if (!request.TrackerNameHasBeenSet())
1062 {
1063 AWS_LOGSTREAM_ERROR("DisassociateTrackerConsumer", "Required field: TrackerName, is not set");
1064 return DisassociateTrackerConsumerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
1065 }
1066 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1067 if (m_enableHostPrefixInjection)
1068 {
1069 uri.SetAuthority("tracking." + uri.GetAuthority());
1070 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1071 {
1072 AWS_LOGSTREAM_ERROR("DisassociateTrackerConsumer", "Invalid DNS host: " << uri.GetAuthority());
1073 return DisassociateTrackerConsumerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1074 }
1075 }
1076 uri.AddPathSegments("/tracking/v0/trackers/");
1077 uri.AddPathSegment(request.GetTrackerName());
1078 uri.AddPathSegments("/consumers/");
1079 uri.AddPathSegment(request.GetConsumerArn());
1080 return DisassociateTrackerConsumerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1081 }
1082
DisassociateTrackerConsumerCallable(const DisassociateTrackerConsumerRequest & request) const1083 DisassociateTrackerConsumerOutcomeCallable LocationServiceClient::DisassociateTrackerConsumerCallable(const DisassociateTrackerConsumerRequest& request) const
1084 {
1085 auto task = Aws::MakeShared< std::packaged_task< DisassociateTrackerConsumerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DisassociateTrackerConsumer(request); } );
1086 auto packagedFunction = [task]() { (*task)(); };
1087 m_executor->Submit(packagedFunction);
1088 return task->get_future();
1089 }
1090
DisassociateTrackerConsumerAsync(const DisassociateTrackerConsumerRequest & request,const DisassociateTrackerConsumerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1091 void LocationServiceClient::DisassociateTrackerConsumerAsync(const DisassociateTrackerConsumerRequest& request, const DisassociateTrackerConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1092 {
1093 m_executor->Submit( [this, request, handler, context](){ this->DisassociateTrackerConsumerAsyncHelper( request, handler, context ); } );
1094 }
1095
DisassociateTrackerConsumerAsyncHelper(const DisassociateTrackerConsumerRequest & request,const DisassociateTrackerConsumerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1096 void LocationServiceClient::DisassociateTrackerConsumerAsyncHelper(const DisassociateTrackerConsumerRequest& request, const DisassociateTrackerConsumerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1097 {
1098 handler(this, request, DisassociateTrackerConsumer(request), context);
1099 }
1100
GetDevicePosition(const GetDevicePositionRequest & request) const1101 GetDevicePositionOutcome LocationServiceClient::GetDevicePosition(const GetDevicePositionRequest& request) const
1102 {
1103 if (!request.DeviceIdHasBeenSet())
1104 {
1105 AWS_LOGSTREAM_ERROR("GetDevicePosition", "Required field: DeviceId, is not set");
1106 return GetDevicePositionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeviceId]", false));
1107 }
1108 if (!request.TrackerNameHasBeenSet())
1109 {
1110 AWS_LOGSTREAM_ERROR("GetDevicePosition", "Required field: TrackerName, is not set");
1111 return GetDevicePositionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
1112 }
1113 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1114 if (m_enableHostPrefixInjection)
1115 {
1116 uri.SetAuthority("tracking." + uri.GetAuthority());
1117 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1118 {
1119 AWS_LOGSTREAM_ERROR("GetDevicePosition", "Invalid DNS host: " << uri.GetAuthority());
1120 return GetDevicePositionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1121 }
1122 }
1123 uri.AddPathSegments("/tracking/v0/trackers/");
1124 uri.AddPathSegment(request.GetTrackerName());
1125 uri.AddPathSegments("/devices/");
1126 uri.AddPathSegment(request.GetDeviceId());
1127 uri.AddPathSegments("/positions/latest");
1128 return GetDevicePositionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1129 }
1130
GetDevicePositionCallable(const GetDevicePositionRequest & request) const1131 GetDevicePositionOutcomeCallable LocationServiceClient::GetDevicePositionCallable(const GetDevicePositionRequest& request) const
1132 {
1133 auto task = Aws::MakeShared< std::packaged_task< GetDevicePositionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetDevicePosition(request); } );
1134 auto packagedFunction = [task]() { (*task)(); };
1135 m_executor->Submit(packagedFunction);
1136 return task->get_future();
1137 }
1138
GetDevicePositionAsync(const GetDevicePositionRequest & request,const GetDevicePositionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1139 void LocationServiceClient::GetDevicePositionAsync(const GetDevicePositionRequest& request, const GetDevicePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1140 {
1141 m_executor->Submit( [this, request, handler, context](){ this->GetDevicePositionAsyncHelper( request, handler, context ); } );
1142 }
1143
GetDevicePositionAsyncHelper(const GetDevicePositionRequest & request,const GetDevicePositionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1144 void LocationServiceClient::GetDevicePositionAsyncHelper(const GetDevicePositionRequest& request, const GetDevicePositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1145 {
1146 handler(this, request, GetDevicePosition(request), context);
1147 }
1148
GetDevicePositionHistory(const GetDevicePositionHistoryRequest & request) const1149 GetDevicePositionHistoryOutcome LocationServiceClient::GetDevicePositionHistory(const GetDevicePositionHistoryRequest& request) const
1150 {
1151 if (!request.DeviceIdHasBeenSet())
1152 {
1153 AWS_LOGSTREAM_ERROR("GetDevicePositionHistory", "Required field: DeviceId, is not set");
1154 return GetDevicePositionHistoryOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [DeviceId]", false));
1155 }
1156 if (!request.TrackerNameHasBeenSet())
1157 {
1158 AWS_LOGSTREAM_ERROR("GetDevicePositionHistory", "Required field: TrackerName, is not set");
1159 return GetDevicePositionHistoryOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
1160 }
1161 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1162 if (m_enableHostPrefixInjection)
1163 {
1164 uri.SetAuthority("tracking." + uri.GetAuthority());
1165 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1166 {
1167 AWS_LOGSTREAM_ERROR("GetDevicePositionHistory", "Invalid DNS host: " << uri.GetAuthority());
1168 return GetDevicePositionHistoryOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1169 }
1170 }
1171 uri.AddPathSegments("/tracking/v0/trackers/");
1172 uri.AddPathSegment(request.GetTrackerName());
1173 uri.AddPathSegments("/devices/");
1174 uri.AddPathSegment(request.GetDeviceId());
1175 uri.AddPathSegments("/list-positions");
1176 return GetDevicePositionHistoryOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1177 }
1178
GetDevicePositionHistoryCallable(const GetDevicePositionHistoryRequest & request) const1179 GetDevicePositionHistoryOutcomeCallable LocationServiceClient::GetDevicePositionHistoryCallable(const GetDevicePositionHistoryRequest& request) const
1180 {
1181 auto task = Aws::MakeShared< std::packaged_task< GetDevicePositionHistoryOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetDevicePositionHistory(request); } );
1182 auto packagedFunction = [task]() { (*task)(); };
1183 m_executor->Submit(packagedFunction);
1184 return task->get_future();
1185 }
1186
GetDevicePositionHistoryAsync(const GetDevicePositionHistoryRequest & request,const GetDevicePositionHistoryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1187 void LocationServiceClient::GetDevicePositionHistoryAsync(const GetDevicePositionHistoryRequest& request, const GetDevicePositionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1188 {
1189 m_executor->Submit( [this, request, handler, context](){ this->GetDevicePositionHistoryAsyncHelper( request, handler, context ); } );
1190 }
1191
GetDevicePositionHistoryAsyncHelper(const GetDevicePositionHistoryRequest & request,const GetDevicePositionHistoryResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1192 void LocationServiceClient::GetDevicePositionHistoryAsyncHelper(const GetDevicePositionHistoryRequest& request, const GetDevicePositionHistoryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1193 {
1194 handler(this, request, GetDevicePositionHistory(request), context);
1195 }
1196
GetGeofence(const GetGeofenceRequest & request) const1197 GetGeofenceOutcome LocationServiceClient::GetGeofence(const GetGeofenceRequest& request) const
1198 {
1199 if (!request.CollectionNameHasBeenSet())
1200 {
1201 AWS_LOGSTREAM_ERROR("GetGeofence", "Required field: CollectionName, is not set");
1202 return GetGeofenceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CollectionName]", false));
1203 }
1204 if (!request.GeofenceIdHasBeenSet())
1205 {
1206 AWS_LOGSTREAM_ERROR("GetGeofence", "Required field: GeofenceId, is not set");
1207 return GetGeofenceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [GeofenceId]", false));
1208 }
1209 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1210 if (m_enableHostPrefixInjection)
1211 {
1212 uri.SetAuthority("geofencing." + uri.GetAuthority());
1213 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1214 {
1215 AWS_LOGSTREAM_ERROR("GetGeofence", "Invalid DNS host: " << uri.GetAuthority());
1216 return GetGeofenceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1217 }
1218 }
1219 uri.AddPathSegments("/geofencing/v0/collections/");
1220 uri.AddPathSegment(request.GetCollectionName());
1221 uri.AddPathSegments("/geofences/");
1222 uri.AddPathSegment(request.GetGeofenceId());
1223 return GetGeofenceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1224 }
1225
GetGeofenceCallable(const GetGeofenceRequest & request) const1226 GetGeofenceOutcomeCallable LocationServiceClient::GetGeofenceCallable(const GetGeofenceRequest& request) const
1227 {
1228 auto task = Aws::MakeShared< std::packaged_task< GetGeofenceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetGeofence(request); } );
1229 auto packagedFunction = [task]() { (*task)(); };
1230 m_executor->Submit(packagedFunction);
1231 return task->get_future();
1232 }
1233
GetGeofenceAsync(const GetGeofenceRequest & request,const GetGeofenceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1234 void LocationServiceClient::GetGeofenceAsync(const GetGeofenceRequest& request, const GetGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1235 {
1236 m_executor->Submit( [this, request, handler, context](){ this->GetGeofenceAsyncHelper( request, handler, context ); } );
1237 }
1238
GetGeofenceAsyncHelper(const GetGeofenceRequest & request,const GetGeofenceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1239 void LocationServiceClient::GetGeofenceAsyncHelper(const GetGeofenceRequest& request, const GetGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1240 {
1241 handler(this, request, GetGeofence(request), context);
1242 }
1243
GetMapGlyphs(const GetMapGlyphsRequest & request) const1244 GetMapGlyphsOutcome LocationServiceClient::GetMapGlyphs(const GetMapGlyphsRequest& request) const
1245 {
1246 if (!request.FontStackHasBeenSet())
1247 {
1248 AWS_LOGSTREAM_ERROR("GetMapGlyphs", "Required field: FontStack, is not set");
1249 return GetMapGlyphsOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FontStack]", false));
1250 }
1251 if (!request.FontUnicodeRangeHasBeenSet())
1252 {
1253 AWS_LOGSTREAM_ERROR("GetMapGlyphs", "Required field: FontUnicodeRange, is not set");
1254 return GetMapGlyphsOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FontUnicodeRange]", false));
1255 }
1256 if (!request.MapNameHasBeenSet())
1257 {
1258 AWS_LOGSTREAM_ERROR("GetMapGlyphs", "Required field: MapName, is not set");
1259 return GetMapGlyphsOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MapName]", false));
1260 }
1261 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1262 if (m_enableHostPrefixInjection)
1263 {
1264 uri.SetAuthority("maps." + uri.GetAuthority());
1265 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1266 {
1267 AWS_LOGSTREAM_ERROR("GetMapGlyphs", "Invalid DNS host: " << uri.GetAuthority());
1268 return GetMapGlyphsOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1269 }
1270 }
1271 uri.AddPathSegments("/maps/v0/maps/");
1272 uri.AddPathSegment(request.GetMapName());
1273 uri.AddPathSegments("/glyphs/");
1274 uri.AddPathSegment(request.GetFontStack());
1275 uri.AddPathSegment(request.GetFontUnicodeRange());
1276 return GetMapGlyphsOutcome(MakeRequestWithUnparsedResponse(uri, request, Aws::Http::HttpMethod::HTTP_GET));
1277 }
1278
GetMapGlyphsCallable(const GetMapGlyphsRequest & request) const1279 GetMapGlyphsOutcomeCallable LocationServiceClient::GetMapGlyphsCallable(const GetMapGlyphsRequest& request) const
1280 {
1281 auto task = Aws::MakeShared< std::packaged_task< GetMapGlyphsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetMapGlyphs(request); } );
1282 auto packagedFunction = [task]() { (*task)(); };
1283 m_executor->Submit(packagedFunction);
1284 return task->get_future();
1285 }
1286
GetMapGlyphsAsync(const GetMapGlyphsRequest & request,const GetMapGlyphsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1287 void LocationServiceClient::GetMapGlyphsAsync(const GetMapGlyphsRequest& request, const GetMapGlyphsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1288 {
1289 m_executor->Submit( [this, request, handler, context](){ this->GetMapGlyphsAsyncHelper( request, handler, context ); } );
1290 }
1291
GetMapGlyphsAsyncHelper(const GetMapGlyphsRequest & request,const GetMapGlyphsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1292 void LocationServiceClient::GetMapGlyphsAsyncHelper(const GetMapGlyphsRequest& request, const GetMapGlyphsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1293 {
1294 handler(this, request, GetMapGlyphs(request), context);
1295 }
1296
GetMapSprites(const GetMapSpritesRequest & request) const1297 GetMapSpritesOutcome LocationServiceClient::GetMapSprites(const GetMapSpritesRequest& request) const
1298 {
1299 if (!request.FileNameHasBeenSet())
1300 {
1301 AWS_LOGSTREAM_ERROR("GetMapSprites", "Required field: FileName, is not set");
1302 return GetMapSpritesOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FileName]", false));
1303 }
1304 if (!request.MapNameHasBeenSet())
1305 {
1306 AWS_LOGSTREAM_ERROR("GetMapSprites", "Required field: MapName, is not set");
1307 return GetMapSpritesOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MapName]", false));
1308 }
1309 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1310 if (m_enableHostPrefixInjection)
1311 {
1312 uri.SetAuthority("maps." + uri.GetAuthority());
1313 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1314 {
1315 AWS_LOGSTREAM_ERROR("GetMapSprites", "Invalid DNS host: " << uri.GetAuthority());
1316 return GetMapSpritesOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1317 }
1318 }
1319 uri.AddPathSegments("/maps/v0/maps/");
1320 uri.AddPathSegment(request.GetMapName());
1321 uri.AddPathSegments("/sprites/");
1322 uri.AddPathSegment(request.GetFileName());
1323 return GetMapSpritesOutcome(MakeRequestWithUnparsedResponse(uri, request, Aws::Http::HttpMethod::HTTP_GET));
1324 }
1325
GetMapSpritesCallable(const GetMapSpritesRequest & request) const1326 GetMapSpritesOutcomeCallable LocationServiceClient::GetMapSpritesCallable(const GetMapSpritesRequest& request) const
1327 {
1328 auto task = Aws::MakeShared< std::packaged_task< GetMapSpritesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetMapSprites(request); } );
1329 auto packagedFunction = [task]() { (*task)(); };
1330 m_executor->Submit(packagedFunction);
1331 return task->get_future();
1332 }
1333
GetMapSpritesAsync(const GetMapSpritesRequest & request,const GetMapSpritesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1334 void LocationServiceClient::GetMapSpritesAsync(const GetMapSpritesRequest& request, const GetMapSpritesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1335 {
1336 m_executor->Submit( [this, request, handler, context](){ this->GetMapSpritesAsyncHelper( request, handler, context ); } );
1337 }
1338
GetMapSpritesAsyncHelper(const GetMapSpritesRequest & request,const GetMapSpritesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1339 void LocationServiceClient::GetMapSpritesAsyncHelper(const GetMapSpritesRequest& request, const GetMapSpritesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1340 {
1341 handler(this, request, GetMapSprites(request), context);
1342 }
1343
GetMapStyleDescriptor(const GetMapStyleDescriptorRequest & request) const1344 GetMapStyleDescriptorOutcome LocationServiceClient::GetMapStyleDescriptor(const GetMapStyleDescriptorRequest& request) const
1345 {
1346 if (!request.MapNameHasBeenSet())
1347 {
1348 AWS_LOGSTREAM_ERROR("GetMapStyleDescriptor", "Required field: MapName, is not set");
1349 return GetMapStyleDescriptorOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MapName]", false));
1350 }
1351 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1352 if (m_enableHostPrefixInjection)
1353 {
1354 uri.SetAuthority("maps." + uri.GetAuthority());
1355 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1356 {
1357 AWS_LOGSTREAM_ERROR("GetMapStyleDescriptor", "Invalid DNS host: " << uri.GetAuthority());
1358 return GetMapStyleDescriptorOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1359 }
1360 }
1361 uri.AddPathSegments("/maps/v0/maps/");
1362 uri.AddPathSegment(request.GetMapName());
1363 uri.AddPathSegments("/style-descriptor");
1364 return GetMapStyleDescriptorOutcome(MakeRequestWithUnparsedResponse(uri, request, Aws::Http::HttpMethod::HTTP_GET));
1365 }
1366
GetMapStyleDescriptorCallable(const GetMapStyleDescriptorRequest & request) const1367 GetMapStyleDescriptorOutcomeCallable LocationServiceClient::GetMapStyleDescriptorCallable(const GetMapStyleDescriptorRequest& request) const
1368 {
1369 auto task = Aws::MakeShared< std::packaged_task< GetMapStyleDescriptorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetMapStyleDescriptor(request); } );
1370 auto packagedFunction = [task]() { (*task)(); };
1371 m_executor->Submit(packagedFunction);
1372 return task->get_future();
1373 }
1374
GetMapStyleDescriptorAsync(const GetMapStyleDescriptorRequest & request,const GetMapStyleDescriptorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1375 void LocationServiceClient::GetMapStyleDescriptorAsync(const GetMapStyleDescriptorRequest& request, const GetMapStyleDescriptorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1376 {
1377 m_executor->Submit( [this, request, handler, context](){ this->GetMapStyleDescriptorAsyncHelper( request, handler, context ); } );
1378 }
1379
GetMapStyleDescriptorAsyncHelper(const GetMapStyleDescriptorRequest & request,const GetMapStyleDescriptorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1380 void LocationServiceClient::GetMapStyleDescriptorAsyncHelper(const GetMapStyleDescriptorRequest& request, const GetMapStyleDescriptorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1381 {
1382 handler(this, request, GetMapStyleDescriptor(request), context);
1383 }
1384
GetMapTile(const GetMapTileRequest & request) const1385 GetMapTileOutcome LocationServiceClient::GetMapTile(const GetMapTileRequest& request) const
1386 {
1387 if (!request.MapNameHasBeenSet())
1388 {
1389 AWS_LOGSTREAM_ERROR("GetMapTile", "Required field: MapName, is not set");
1390 return GetMapTileOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MapName]", false));
1391 }
1392 if (!request.XHasBeenSet())
1393 {
1394 AWS_LOGSTREAM_ERROR("GetMapTile", "Required field: X, is not set");
1395 return GetMapTileOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [X]", false));
1396 }
1397 if (!request.YHasBeenSet())
1398 {
1399 AWS_LOGSTREAM_ERROR("GetMapTile", "Required field: Y, is not set");
1400 return GetMapTileOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Y]", false));
1401 }
1402 if (!request.ZHasBeenSet())
1403 {
1404 AWS_LOGSTREAM_ERROR("GetMapTile", "Required field: Z, is not set");
1405 return GetMapTileOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Z]", false));
1406 }
1407 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1408 if (m_enableHostPrefixInjection)
1409 {
1410 uri.SetAuthority("maps." + uri.GetAuthority());
1411 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1412 {
1413 AWS_LOGSTREAM_ERROR("GetMapTile", "Invalid DNS host: " << uri.GetAuthority());
1414 return GetMapTileOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1415 }
1416 }
1417 uri.AddPathSegments("/maps/v0/maps/");
1418 uri.AddPathSegment(request.GetMapName());
1419 uri.AddPathSegments("/tiles/");
1420 uri.AddPathSegment(request.GetZ());
1421 uri.AddPathSegment(request.GetX());
1422 uri.AddPathSegment(request.GetY());
1423 return GetMapTileOutcome(MakeRequestWithUnparsedResponse(uri, request, Aws::Http::HttpMethod::HTTP_GET));
1424 }
1425
GetMapTileCallable(const GetMapTileRequest & request) const1426 GetMapTileOutcomeCallable LocationServiceClient::GetMapTileCallable(const GetMapTileRequest& request) const
1427 {
1428 auto task = Aws::MakeShared< std::packaged_task< GetMapTileOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetMapTile(request); } );
1429 auto packagedFunction = [task]() { (*task)(); };
1430 m_executor->Submit(packagedFunction);
1431 return task->get_future();
1432 }
1433
GetMapTileAsync(const GetMapTileRequest & request,const GetMapTileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1434 void LocationServiceClient::GetMapTileAsync(const GetMapTileRequest& request, const GetMapTileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1435 {
1436 m_executor->Submit( [this, request, handler, context](){ this->GetMapTileAsyncHelper( request, handler, context ); } );
1437 }
1438
GetMapTileAsyncHelper(const GetMapTileRequest & request,const GetMapTileResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1439 void LocationServiceClient::GetMapTileAsyncHelper(const GetMapTileRequest& request, const GetMapTileResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1440 {
1441 handler(this, request, GetMapTile(request), context);
1442 }
1443
ListDevicePositions(const ListDevicePositionsRequest & request) const1444 ListDevicePositionsOutcome LocationServiceClient::ListDevicePositions(const ListDevicePositionsRequest& request) const
1445 {
1446 if (!request.TrackerNameHasBeenSet())
1447 {
1448 AWS_LOGSTREAM_ERROR("ListDevicePositions", "Required field: TrackerName, is not set");
1449 return ListDevicePositionsOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
1450 }
1451 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1452 if (m_enableHostPrefixInjection)
1453 {
1454 uri.SetAuthority("tracking." + uri.GetAuthority());
1455 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1456 {
1457 AWS_LOGSTREAM_ERROR("ListDevicePositions", "Invalid DNS host: " << uri.GetAuthority());
1458 return ListDevicePositionsOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1459 }
1460 }
1461 uri.AddPathSegments("/tracking/v0/trackers/");
1462 uri.AddPathSegment(request.GetTrackerName());
1463 uri.AddPathSegments("/list-positions");
1464 return ListDevicePositionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1465 }
1466
ListDevicePositionsCallable(const ListDevicePositionsRequest & request) const1467 ListDevicePositionsOutcomeCallable LocationServiceClient::ListDevicePositionsCallable(const ListDevicePositionsRequest& request) const
1468 {
1469 auto task = Aws::MakeShared< std::packaged_task< ListDevicePositionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListDevicePositions(request); } );
1470 auto packagedFunction = [task]() { (*task)(); };
1471 m_executor->Submit(packagedFunction);
1472 return task->get_future();
1473 }
1474
ListDevicePositionsAsync(const ListDevicePositionsRequest & request,const ListDevicePositionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1475 void LocationServiceClient::ListDevicePositionsAsync(const ListDevicePositionsRequest& request, const ListDevicePositionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1476 {
1477 m_executor->Submit( [this, request, handler, context](){ this->ListDevicePositionsAsyncHelper( request, handler, context ); } );
1478 }
1479
ListDevicePositionsAsyncHelper(const ListDevicePositionsRequest & request,const ListDevicePositionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1480 void LocationServiceClient::ListDevicePositionsAsyncHelper(const ListDevicePositionsRequest& request, const ListDevicePositionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1481 {
1482 handler(this, request, ListDevicePositions(request), context);
1483 }
1484
ListGeofenceCollections(const ListGeofenceCollectionsRequest & request) const1485 ListGeofenceCollectionsOutcome LocationServiceClient::ListGeofenceCollections(const ListGeofenceCollectionsRequest& request) const
1486 {
1487 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1488 if (m_enableHostPrefixInjection)
1489 {
1490 uri.SetAuthority("geofencing." + uri.GetAuthority());
1491 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1492 {
1493 AWS_LOGSTREAM_ERROR("ListGeofenceCollections", "Invalid DNS host: " << uri.GetAuthority());
1494 return ListGeofenceCollectionsOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1495 }
1496 }
1497 uri.AddPathSegments("/geofencing/v0/list-collections");
1498 return ListGeofenceCollectionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1499 }
1500
ListGeofenceCollectionsCallable(const ListGeofenceCollectionsRequest & request) const1501 ListGeofenceCollectionsOutcomeCallable LocationServiceClient::ListGeofenceCollectionsCallable(const ListGeofenceCollectionsRequest& request) const
1502 {
1503 auto task = Aws::MakeShared< std::packaged_task< ListGeofenceCollectionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListGeofenceCollections(request); } );
1504 auto packagedFunction = [task]() { (*task)(); };
1505 m_executor->Submit(packagedFunction);
1506 return task->get_future();
1507 }
1508
ListGeofenceCollectionsAsync(const ListGeofenceCollectionsRequest & request,const ListGeofenceCollectionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1509 void LocationServiceClient::ListGeofenceCollectionsAsync(const ListGeofenceCollectionsRequest& request, const ListGeofenceCollectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1510 {
1511 m_executor->Submit( [this, request, handler, context](){ this->ListGeofenceCollectionsAsyncHelper( request, handler, context ); } );
1512 }
1513
ListGeofenceCollectionsAsyncHelper(const ListGeofenceCollectionsRequest & request,const ListGeofenceCollectionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1514 void LocationServiceClient::ListGeofenceCollectionsAsyncHelper(const ListGeofenceCollectionsRequest& request, const ListGeofenceCollectionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1515 {
1516 handler(this, request, ListGeofenceCollections(request), context);
1517 }
1518
ListGeofences(const ListGeofencesRequest & request) const1519 ListGeofencesOutcome LocationServiceClient::ListGeofences(const ListGeofencesRequest& request) const
1520 {
1521 if (!request.CollectionNameHasBeenSet())
1522 {
1523 AWS_LOGSTREAM_ERROR("ListGeofences", "Required field: CollectionName, is not set");
1524 return ListGeofencesOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CollectionName]", false));
1525 }
1526 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1527 if (m_enableHostPrefixInjection)
1528 {
1529 uri.SetAuthority("geofencing." + uri.GetAuthority());
1530 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1531 {
1532 AWS_LOGSTREAM_ERROR("ListGeofences", "Invalid DNS host: " << uri.GetAuthority());
1533 return ListGeofencesOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1534 }
1535 }
1536 uri.AddPathSegments("/geofencing/v0/collections/");
1537 uri.AddPathSegment(request.GetCollectionName());
1538 uri.AddPathSegments("/list-geofences");
1539 return ListGeofencesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1540 }
1541
ListGeofencesCallable(const ListGeofencesRequest & request) const1542 ListGeofencesOutcomeCallable LocationServiceClient::ListGeofencesCallable(const ListGeofencesRequest& request) const
1543 {
1544 auto task = Aws::MakeShared< std::packaged_task< ListGeofencesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListGeofences(request); } );
1545 auto packagedFunction = [task]() { (*task)(); };
1546 m_executor->Submit(packagedFunction);
1547 return task->get_future();
1548 }
1549
ListGeofencesAsync(const ListGeofencesRequest & request,const ListGeofencesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1550 void LocationServiceClient::ListGeofencesAsync(const ListGeofencesRequest& request, const ListGeofencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1551 {
1552 m_executor->Submit( [this, request, handler, context](){ this->ListGeofencesAsyncHelper( request, handler, context ); } );
1553 }
1554
ListGeofencesAsyncHelper(const ListGeofencesRequest & request,const ListGeofencesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1555 void LocationServiceClient::ListGeofencesAsyncHelper(const ListGeofencesRequest& request, const ListGeofencesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1556 {
1557 handler(this, request, ListGeofences(request), context);
1558 }
1559
ListMaps(const ListMapsRequest & request) const1560 ListMapsOutcome LocationServiceClient::ListMaps(const ListMapsRequest& request) const
1561 {
1562 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1563 if (m_enableHostPrefixInjection)
1564 {
1565 uri.SetAuthority("maps." + uri.GetAuthority());
1566 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1567 {
1568 AWS_LOGSTREAM_ERROR("ListMaps", "Invalid DNS host: " << uri.GetAuthority());
1569 return ListMapsOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1570 }
1571 }
1572 uri.AddPathSegments("/maps/v0/list-maps");
1573 return ListMapsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1574 }
1575
ListMapsCallable(const ListMapsRequest & request) const1576 ListMapsOutcomeCallable LocationServiceClient::ListMapsCallable(const ListMapsRequest& request) const
1577 {
1578 auto task = Aws::MakeShared< std::packaged_task< ListMapsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListMaps(request); } );
1579 auto packagedFunction = [task]() { (*task)(); };
1580 m_executor->Submit(packagedFunction);
1581 return task->get_future();
1582 }
1583
ListMapsAsync(const ListMapsRequest & request,const ListMapsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1584 void LocationServiceClient::ListMapsAsync(const ListMapsRequest& request, const ListMapsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1585 {
1586 m_executor->Submit( [this, request, handler, context](){ this->ListMapsAsyncHelper( request, handler, context ); } );
1587 }
1588
ListMapsAsyncHelper(const ListMapsRequest & request,const ListMapsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1589 void LocationServiceClient::ListMapsAsyncHelper(const ListMapsRequest& request, const ListMapsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1590 {
1591 handler(this, request, ListMaps(request), context);
1592 }
1593
ListPlaceIndexes(const ListPlaceIndexesRequest & request) const1594 ListPlaceIndexesOutcome LocationServiceClient::ListPlaceIndexes(const ListPlaceIndexesRequest& request) const
1595 {
1596 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1597 if (m_enableHostPrefixInjection)
1598 {
1599 uri.SetAuthority("places." + uri.GetAuthority());
1600 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1601 {
1602 AWS_LOGSTREAM_ERROR("ListPlaceIndexes", "Invalid DNS host: " << uri.GetAuthority());
1603 return ListPlaceIndexesOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1604 }
1605 }
1606 uri.AddPathSegments("/places/v0/list-indexes");
1607 return ListPlaceIndexesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1608 }
1609
ListPlaceIndexesCallable(const ListPlaceIndexesRequest & request) const1610 ListPlaceIndexesOutcomeCallable LocationServiceClient::ListPlaceIndexesCallable(const ListPlaceIndexesRequest& request) const
1611 {
1612 auto task = Aws::MakeShared< std::packaged_task< ListPlaceIndexesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListPlaceIndexes(request); } );
1613 auto packagedFunction = [task]() { (*task)(); };
1614 m_executor->Submit(packagedFunction);
1615 return task->get_future();
1616 }
1617
ListPlaceIndexesAsync(const ListPlaceIndexesRequest & request,const ListPlaceIndexesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1618 void LocationServiceClient::ListPlaceIndexesAsync(const ListPlaceIndexesRequest& request, const ListPlaceIndexesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1619 {
1620 m_executor->Submit( [this, request, handler, context](){ this->ListPlaceIndexesAsyncHelper( request, handler, context ); } );
1621 }
1622
ListPlaceIndexesAsyncHelper(const ListPlaceIndexesRequest & request,const ListPlaceIndexesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1623 void LocationServiceClient::ListPlaceIndexesAsyncHelper(const ListPlaceIndexesRequest& request, const ListPlaceIndexesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1624 {
1625 handler(this, request, ListPlaceIndexes(request), context);
1626 }
1627
ListRouteCalculators(const ListRouteCalculatorsRequest & request) const1628 ListRouteCalculatorsOutcome LocationServiceClient::ListRouteCalculators(const ListRouteCalculatorsRequest& request) const
1629 {
1630 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1631 if (m_enableHostPrefixInjection)
1632 {
1633 uri.SetAuthority("routes." + uri.GetAuthority());
1634 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1635 {
1636 AWS_LOGSTREAM_ERROR("ListRouteCalculators", "Invalid DNS host: " << uri.GetAuthority());
1637 return ListRouteCalculatorsOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1638 }
1639 }
1640 uri.AddPathSegments("/routes/v0/list-calculators");
1641 return ListRouteCalculatorsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1642 }
1643
ListRouteCalculatorsCallable(const ListRouteCalculatorsRequest & request) const1644 ListRouteCalculatorsOutcomeCallable LocationServiceClient::ListRouteCalculatorsCallable(const ListRouteCalculatorsRequest& request) const
1645 {
1646 auto task = Aws::MakeShared< std::packaged_task< ListRouteCalculatorsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListRouteCalculators(request); } );
1647 auto packagedFunction = [task]() { (*task)(); };
1648 m_executor->Submit(packagedFunction);
1649 return task->get_future();
1650 }
1651
ListRouteCalculatorsAsync(const ListRouteCalculatorsRequest & request,const ListRouteCalculatorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1652 void LocationServiceClient::ListRouteCalculatorsAsync(const ListRouteCalculatorsRequest& request, const ListRouteCalculatorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1653 {
1654 m_executor->Submit( [this, request, handler, context](){ this->ListRouteCalculatorsAsyncHelper( request, handler, context ); } );
1655 }
1656
ListRouteCalculatorsAsyncHelper(const ListRouteCalculatorsRequest & request,const ListRouteCalculatorsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1657 void LocationServiceClient::ListRouteCalculatorsAsyncHelper(const ListRouteCalculatorsRequest& request, const ListRouteCalculatorsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1658 {
1659 handler(this, request, ListRouteCalculators(request), context);
1660 }
1661
ListTagsForResource(const ListTagsForResourceRequest & request) const1662 ListTagsForResourceOutcome LocationServiceClient::ListTagsForResource(const ListTagsForResourceRequest& request) const
1663 {
1664 if (!request.ResourceArnHasBeenSet())
1665 {
1666 AWS_LOGSTREAM_ERROR("ListTagsForResource", "Required field: ResourceArn, is not set");
1667 return ListTagsForResourceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
1668 }
1669 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1670 if (m_enableHostPrefixInjection)
1671 {
1672 uri.SetAuthority("metadata." + uri.GetAuthority());
1673 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1674 {
1675 AWS_LOGSTREAM_ERROR("ListTagsForResource", "Invalid DNS host: " << uri.GetAuthority());
1676 return ListTagsForResourceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1677 }
1678 }
1679 uri.AddPathSegments("/tags/");
1680 uri.AddPathSegment(request.GetResourceArn());
1681 return ListTagsForResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1682 }
1683
ListTagsForResourceCallable(const ListTagsForResourceRequest & request) const1684 ListTagsForResourceOutcomeCallable LocationServiceClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request) const
1685 {
1686 auto task = Aws::MakeShared< std::packaged_task< ListTagsForResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTagsForResource(request); } );
1687 auto packagedFunction = [task]() { (*task)(); };
1688 m_executor->Submit(packagedFunction);
1689 return task->get_future();
1690 }
1691
ListTagsForResourceAsync(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1692 void LocationServiceClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1693 {
1694 m_executor->Submit( [this, request, handler, context](){ this->ListTagsForResourceAsyncHelper( request, handler, context ); } );
1695 }
1696
ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest & request,const ListTagsForResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1697 void LocationServiceClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1698 {
1699 handler(this, request, ListTagsForResource(request), context);
1700 }
1701
ListTrackerConsumers(const ListTrackerConsumersRequest & request) const1702 ListTrackerConsumersOutcome LocationServiceClient::ListTrackerConsumers(const ListTrackerConsumersRequest& request) const
1703 {
1704 if (!request.TrackerNameHasBeenSet())
1705 {
1706 AWS_LOGSTREAM_ERROR("ListTrackerConsumers", "Required field: TrackerName, is not set");
1707 return ListTrackerConsumersOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
1708 }
1709 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1710 if (m_enableHostPrefixInjection)
1711 {
1712 uri.SetAuthority("tracking." + uri.GetAuthority());
1713 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1714 {
1715 AWS_LOGSTREAM_ERROR("ListTrackerConsumers", "Invalid DNS host: " << uri.GetAuthority());
1716 return ListTrackerConsumersOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1717 }
1718 }
1719 uri.AddPathSegments("/tracking/v0/trackers/");
1720 uri.AddPathSegment(request.GetTrackerName());
1721 uri.AddPathSegments("/list-consumers");
1722 return ListTrackerConsumersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1723 }
1724
ListTrackerConsumersCallable(const ListTrackerConsumersRequest & request) const1725 ListTrackerConsumersOutcomeCallable LocationServiceClient::ListTrackerConsumersCallable(const ListTrackerConsumersRequest& request) const
1726 {
1727 auto task = Aws::MakeShared< std::packaged_task< ListTrackerConsumersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTrackerConsumers(request); } );
1728 auto packagedFunction = [task]() { (*task)(); };
1729 m_executor->Submit(packagedFunction);
1730 return task->get_future();
1731 }
1732
ListTrackerConsumersAsync(const ListTrackerConsumersRequest & request,const ListTrackerConsumersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1733 void LocationServiceClient::ListTrackerConsumersAsync(const ListTrackerConsumersRequest& request, const ListTrackerConsumersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1734 {
1735 m_executor->Submit( [this, request, handler, context](){ this->ListTrackerConsumersAsyncHelper( request, handler, context ); } );
1736 }
1737
ListTrackerConsumersAsyncHelper(const ListTrackerConsumersRequest & request,const ListTrackerConsumersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1738 void LocationServiceClient::ListTrackerConsumersAsyncHelper(const ListTrackerConsumersRequest& request, const ListTrackerConsumersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1739 {
1740 handler(this, request, ListTrackerConsumers(request), context);
1741 }
1742
ListTrackers(const ListTrackersRequest & request) const1743 ListTrackersOutcome LocationServiceClient::ListTrackers(const ListTrackersRequest& request) const
1744 {
1745 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1746 if (m_enableHostPrefixInjection)
1747 {
1748 uri.SetAuthority("tracking." + uri.GetAuthority());
1749 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1750 {
1751 AWS_LOGSTREAM_ERROR("ListTrackers", "Invalid DNS host: " << uri.GetAuthority());
1752 return ListTrackersOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1753 }
1754 }
1755 uri.AddPathSegments("/tracking/v0/list-trackers");
1756 return ListTrackersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1757 }
1758
ListTrackersCallable(const ListTrackersRequest & request) const1759 ListTrackersOutcomeCallable LocationServiceClient::ListTrackersCallable(const ListTrackersRequest& request) const
1760 {
1761 auto task = Aws::MakeShared< std::packaged_task< ListTrackersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTrackers(request); } );
1762 auto packagedFunction = [task]() { (*task)(); };
1763 m_executor->Submit(packagedFunction);
1764 return task->get_future();
1765 }
1766
ListTrackersAsync(const ListTrackersRequest & request,const ListTrackersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1767 void LocationServiceClient::ListTrackersAsync(const ListTrackersRequest& request, const ListTrackersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1768 {
1769 m_executor->Submit( [this, request, handler, context](){ this->ListTrackersAsyncHelper( request, handler, context ); } );
1770 }
1771
ListTrackersAsyncHelper(const ListTrackersRequest & request,const ListTrackersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1772 void LocationServiceClient::ListTrackersAsyncHelper(const ListTrackersRequest& request, const ListTrackersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1773 {
1774 handler(this, request, ListTrackers(request), context);
1775 }
1776
PutGeofence(const PutGeofenceRequest & request) const1777 PutGeofenceOutcome LocationServiceClient::PutGeofence(const PutGeofenceRequest& request) const
1778 {
1779 if (!request.CollectionNameHasBeenSet())
1780 {
1781 AWS_LOGSTREAM_ERROR("PutGeofence", "Required field: CollectionName, is not set");
1782 return PutGeofenceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CollectionName]", false));
1783 }
1784 if (!request.GeofenceIdHasBeenSet())
1785 {
1786 AWS_LOGSTREAM_ERROR("PutGeofence", "Required field: GeofenceId, is not set");
1787 return PutGeofenceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [GeofenceId]", false));
1788 }
1789 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1790 if (m_enableHostPrefixInjection)
1791 {
1792 uri.SetAuthority("geofencing." + uri.GetAuthority());
1793 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1794 {
1795 AWS_LOGSTREAM_ERROR("PutGeofence", "Invalid DNS host: " << uri.GetAuthority());
1796 return PutGeofenceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1797 }
1798 }
1799 uri.AddPathSegments("/geofencing/v0/collections/");
1800 uri.AddPathSegment(request.GetCollectionName());
1801 uri.AddPathSegments("/geofences/");
1802 uri.AddPathSegment(request.GetGeofenceId());
1803 return PutGeofenceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1804 }
1805
PutGeofenceCallable(const PutGeofenceRequest & request) const1806 PutGeofenceOutcomeCallable LocationServiceClient::PutGeofenceCallable(const PutGeofenceRequest& request) const
1807 {
1808 auto task = Aws::MakeShared< std::packaged_task< PutGeofenceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutGeofence(request); } );
1809 auto packagedFunction = [task]() { (*task)(); };
1810 m_executor->Submit(packagedFunction);
1811 return task->get_future();
1812 }
1813
PutGeofenceAsync(const PutGeofenceRequest & request,const PutGeofenceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1814 void LocationServiceClient::PutGeofenceAsync(const PutGeofenceRequest& request, const PutGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1815 {
1816 m_executor->Submit( [this, request, handler, context](){ this->PutGeofenceAsyncHelper( request, handler, context ); } );
1817 }
1818
PutGeofenceAsyncHelper(const PutGeofenceRequest & request,const PutGeofenceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1819 void LocationServiceClient::PutGeofenceAsyncHelper(const PutGeofenceRequest& request, const PutGeofenceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1820 {
1821 handler(this, request, PutGeofence(request), context);
1822 }
1823
SearchPlaceIndexForPosition(const SearchPlaceIndexForPositionRequest & request) const1824 SearchPlaceIndexForPositionOutcome LocationServiceClient::SearchPlaceIndexForPosition(const SearchPlaceIndexForPositionRequest& request) const
1825 {
1826 if (!request.IndexNameHasBeenSet())
1827 {
1828 AWS_LOGSTREAM_ERROR("SearchPlaceIndexForPosition", "Required field: IndexName, is not set");
1829 return SearchPlaceIndexForPositionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [IndexName]", false));
1830 }
1831 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1832 if (m_enableHostPrefixInjection)
1833 {
1834 uri.SetAuthority("places." + uri.GetAuthority());
1835 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1836 {
1837 AWS_LOGSTREAM_ERROR("SearchPlaceIndexForPosition", "Invalid DNS host: " << uri.GetAuthority());
1838 return SearchPlaceIndexForPositionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1839 }
1840 }
1841 uri.AddPathSegments("/places/v0/indexes/");
1842 uri.AddPathSegment(request.GetIndexName());
1843 uri.AddPathSegments("/search/position");
1844 return SearchPlaceIndexForPositionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1845 }
1846
SearchPlaceIndexForPositionCallable(const SearchPlaceIndexForPositionRequest & request) const1847 SearchPlaceIndexForPositionOutcomeCallable LocationServiceClient::SearchPlaceIndexForPositionCallable(const SearchPlaceIndexForPositionRequest& request) const
1848 {
1849 auto task = Aws::MakeShared< std::packaged_task< SearchPlaceIndexForPositionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SearchPlaceIndexForPosition(request); } );
1850 auto packagedFunction = [task]() { (*task)(); };
1851 m_executor->Submit(packagedFunction);
1852 return task->get_future();
1853 }
1854
SearchPlaceIndexForPositionAsync(const SearchPlaceIndexForPositionRequest & request,const SearchPlaceIndexForPositionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1855 void LocationServiceClient::SearchPlaceIndexForPositionAsync(const SearchPlaceIndexForPositionRequest& request, const SearchPlaceIndexForPositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1856 {
1857 m_executor->Submit( [this, request, handler, context](){ this->SearchPlaceIndexForPositionAsyncHelper( request, handler, context ); } );
1858 }
1859
SearchPlaceIndexForPositionAsyncHelper(const SearchPlaceIndexForPositionRequest & request,const SearchPlaceIndexForPositionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1860 void LocationServiceClient::SearchPlaceIndexForPositionAsyncHelper(const SearchPlaceIndexForPositionRequest& request, const SearchPlaceIndexForPositionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1861 {
1862 handler(this, request, SearchPlaceIndexForPosition(request), context);
1863 }
1864
SearchPlaceIndexForText(const SearchPlaceIndexForTextRequest & request) const1865 SearchPlaceIndexForTextOutcome LocationServiceClient::SearchPlaceIndexForText(const SearchPlaceIndexForTextRequest& request) const
1866 {
1867 if (!request.IndexNameHasBeenSet())
1868 {
1869 AWS_LOGSTREAM_ERROR("SearchPlaceIndexForText", "Required field: IndexName, is not set");
1870 return SearchPlaceIndexForTextOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [IndexName]", false));
1871 }
1872 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1873 if (m_enableHostPrefixInjection)
1874 {
1875 uri.SetAuthority("places." + uri.GetAuthority());
1876 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1877 {
1878 AWS_LOGSTREAM_ERROR("SearchPlaceIndexForText", "Invalid DNS host: " << uri.GetAuthority());
1879 return SearchPlaceIndexForTextOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1880 }
1881 }
1882 uri.AddPathSegments("/places/v0/indexes/");
1883 uri.AddPathSegment(request.GetIndexName());
1884 uri.AddPathSegments("/search/text");
1885 return SearchPlaceIndexForTextOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1886 }
1887
SearchPlaceIndexForTextCallable(const SearchPlaceIndexForTextRequest & request) const1888 SearchPlaceIndexForTextOutcomeCallable LocationServiceClient::SearchPlaceIndexForTextCallable(const SearchPlaceIndexForTextRequest& request) const
1889 {
1890 auto task = Aws::MakeShared< std::packaged_task< SearchPlaceIndexForTextOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->SearchPlaceIndexForText(request); } );
1891 auto packagedFunction = [task]() { (*task)(); };
1892 m_executor->Submit(packagedFunction);
1893 return task->get_future();
1894 }
1895
SearchPlaceIndexForTextAsync(const SearchPlaceIndexForTextRequest & request,const SearchPlaceIndexForTextResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1896 void LocationServiceClient::SearchPlaceIndexForTextAsync(const SearchPlaceIndexForTextRequest& request, const SearchPlaceIndexForTextResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1897 {
1898 m_executor->Submit( [this, request, handler, context](){ this->SearchPlaceIndexForTextAsyncHelper( request, handler, context ); } );
1899 }
1900
SearchPlaceIndexForTextAsyncHelper(const SearchPlaceIndexForTextRequest & request,const SearchPlaceIndexForTextResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1901 void LocationServiceClient::SearchPlaceIndexForTextAsyncHelper(const SearchPlaceIndexForTextRequest& request, const SearchPlaceIndexForTextResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1902 {
1903 handler(this, request, SearchPlaceIndexForText(request), context);
1904 }
1905
TagResource(const TagResourceRequest & request) const1906 TagResourceOutcome LocationServiceClient::TagResource(const TagResourceRequest& request) const
1907 {
1908 if (!request.ResourceArnHasBeenSet())
1909 {
1910 AWS_LOGSTREAM_ERROR("TagResource", "Required field: ResourceArn, is not set");
1911 return TagResourceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
1912 }
1913 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1914 if (m_enableHostPrefixInjection)
1915 {
1916 uri.SetAuthority("metadata." + uri.GetAuthority());
1917 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1918 {
1919 AWS_LOGSTREAM_ERROR("TagResource", "Invalid DNS host: " << uri.GetAuthority());
1920 return TagResourceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1921 }
1922 }
1923 uri.AddPathSegments("/tags/");
1924 uri.AddPathSegment(request.GetResourceArn());
1925 return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1926 }
1927
TagResourceCallable(const TagResourceRequest & request) const1928 TagResourceOutcomeCallable LocationServiceClient::TagResourceCallable(const TagResourceRequest& request) const
1929 {
1930 auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
1931 auto packagedFunction = [task]() { (*task)(); };
1932 m_executor->Submit(packagedFunction);
1933 return task->get_future();
1934 }
1935
TagResourceAsync(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1936 void LocationServiceClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1937 {
1938 m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
1939 }
1940
TagResourceAsyncHelper(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1941 void LocationServiceClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1942 {
1943 handler(this, request, TagResource(request), context);
1944 }
1945
UntagResource(const UntagResourceRequest & request) const1946 UntagResourceOutcome LocationServiceClient::UntagResource(const UntagResourceRequest& request) const
1947 {
1948 if (!request.ResourceArnHasBeenSet())
1949 {
1950 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: ResourceArn, is not set");
1951 return UntagResourceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [ResourceArn]", false));
1952 }
1953 if (!request.TagKeysHasBeenSet())
1954 {
1955 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: TagKeys, is not set");
1956 return UntagResourceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TagKeys]", false));
1957 }
1958 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1959 if (m_enableHostPrefixInjection)
1960 {
1961 uri.SetAuthority("metadata." + uri.GetAuthority());
1962 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
1963 {
1964 AWS_LOGSTREAM_ERROR("UntagResource", "Invalid DNS host: " << uri.GetAuthority());
1965 return UntagResourceOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
1966 }
1967 }
1968 uri.AddPathSegments("/tags/");
1969 uri.AddPathSegment(request.GetResourceArn());
1970 return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1971 }
1972
UntagResourceCallable(const UntagResourceRequest & request) const1973 UntagResourceOutcomeCallable LocationServiceClient::UntagResourceCallable(const UntagResourceRequest& request) const
1974 {
1975 auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
1976 auto packagedFunction = [task]() { (*task)(); };
1977 m_executor->Submit(packagedFunction);
1978 return task->get_future();
1979 }
1980
UntagResourceAsync(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1981 void LocationServiceClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1982 {
1983 m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
1984 }
1985
UntagResourceAsyncHelper(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1986 void LocationServiceClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1987 {
1988 handler(this, request, UntagResource(request), context);
1989 }
1990
UpdateGeofenceCollection(const UpdateGeofenceCollectionRequest & request) const1991 UpdateGeofenceCollectionOutcome LocationServiceClient::UpdateGeofenceCollection(const UpdateGeofenceCollectionRequest& request) const
1992 {
1993 if (!request.CollectionNameHasBeenSet())
1994 {
1995 AWS_LOGSTREAM_ERROR("UpdateGeofenceCollection", "Required field: CollectionName, is not set");
1996 return UpdateGeofenceCollectionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CollectionName]", false));
1997 }
1998 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
1999 if (m_enableHostPrefixInjection)
2000 {
2001 uri.SetAuthority("geofencing." + uri.GetAuthority());
2002 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2003 {
2004 AWS_LOGSTREAM_ERROR("UpdateGeofenceCollection", "Invalid DNS host: " << uri.GetAuthority());
2005 return UpdateGeofenceCollectionOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2006 }
2007 }
2008 uri.AddPathSegments("/geofencing/v0/collections/");
2009 uri.AddPathSegment(request.GetCollectionName());
2010 return UpdateGeofenceCollectionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PATCH, Aws::Auth::SIGV4_SIGNER));
2011 }
2012
UpdateGeofenceCollectionCallable(const UpdateGeofenceCollectionRequest & request) const2013 UpdateGeofenceCollectionOutcomeCallable LocationServiceClient::UpdateGeofenceCollectionCallable(const UpdateGeofenceCollectionRequest& request) const
2014 {
2015 auto task = Aws::MakeShared< std::packaged_task< UpdateGeofenceCollectionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateGeofenceCollection(request); } );
2016 auto packagedFunction = [task]() { (*task)(); };
2017 m_executor->Submit(packagedFunction);
2018 return task->get_future();
2019 }
2020
UpdateGeofenceCollectionAsync(const UpdateGeofenceCollectionRequest & request,const UpdateGeofenceCollectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2021 void LocationServiceClient::UpdateGeofenceCollectionAsync(const UpdateGeofenceCollectionRequest& request, const UpdateGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2022 {
2023 m_executor->Submit( [this, request, handler, context](){ this->UpdateGeofenceCollectionAsyncHelper( request, handler, context ); } );
2024 }
2025
UpdateGeofenceCollectionAsyncHelper(const UpdateGeofenceCollectionRequest & request,const UpdateGeofenceCollectionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2026 void LocationServiceClient::UpdateGeofenceCollectionAsyncHelper(const UpdateGeofenceCollectionRequest& request, const UpdateGeofenceCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2027 {
2028 handler(this, request, UpdateGeofenceCollection(request), context);
2029 }
2030
UpdateMap(const UpdateMapRequest & request) const2031 UpdateMapOutcome LocationServiceClient::UpdateMap(const UpdateMapRequest& request) const
2032 {
2033 if (!request.MapNameHasBeenSet())
2034 {
2035 AWS_LOGSTREAM_ERROR("UpdateMap", "Required field: MapName, is not set");
2036 return UpdateMapOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [MapName]", false));
2037 }
2038 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2039 if (m_enableHostPrefixInjection)
2040 {
2041 uri.SetAuthority("maps." + uri.GetAuthority());
2042 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2043 {
2044 AWS_LOGSTREAM_ERROR("UpdateMap", "Invalid DNS host: " << uri.GetAuthority());
2045 return UpdateMapOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2046 }
2047 }
2048 uri.AddPathSegments("/maps/v0/maps/");
2049 uri.AddPathSegment(request.GetMapName());
2050 return UpdateMapOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PATCH, Aws::Auth::SIGV4_SIGNER));
2051 }
2052
UpdateMapCallable(const UpdateMapRequest & request) const2053 UpdateMapOutcomeCallable LocationServiceClient::UpdateMapCallable(const UpdateMapRequest& request) const
2054 {
2055 auto task = Aws::MakeShared< std::packaged_task< UpdateMapOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateMap(request); } );
2056 auto packagedFunction = [task]() { (*task)(); };
2057 m_executor->Submit(packagedFunction);
2058 return task->get_future();
2059 }
2060
UpdateMapAsync(const UpdateMapRequest & request,const UpdateMapResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2061 void LocationServiceClient::UpdateMapAsync(const UpdateMapRequest& request, const UpdateMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2062 {
2063 m_executor->Submit( [this, request, handler, context](){ this->UpdateMapAsyncHelper( request, handler, context ); } );
2064 }
2065
UpdateMapAsyncHelper(const UpdateMapRequest & request,const UpdateMapResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2066 void LocationServiceClient::UpdateMapAsyncHelper(const UpdateMapRequest& request, const UpdateMapResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2067 {
2068 handler(this, request, UpdateMap(request), context);
2069 }
2070
UpdatePlaceIndex(const UpdatePlaceIndexRequest & request) const2071 UpdatePlaceIndexOutcome LocationServiceClient::UpdatePlaceIndex(const UpdatePlaceIndexRequest& request) const
2072 {
2073 if (!request.IndexNameHasBeenSet())
2074 {
2075 AWS_LOGSTREAM_ERROR("UpdatePlaceIndex", "Required field: IndexName, is not set");
2076 return UpdatePlaceIndexOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [IndexName]", false));
2077 }
2078 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2079 if (m_enableHostPrefixInjection)
2080 {
2081 uri.SetAuthority("places." + uri.GetAuthority());
2082 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2083 {
2084 AWS_LOGSTREAM_ERROR("UpdatePlaceIndex", "Invalid DNS host: " << uri.GetAuthority());
2085 return UpdatePlaceIndexOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2086 }
2087 }
2088 uri.AddPathSegments("/places/v0/indexes/");
2089 uri.AddPathSegment(request.GetIndexName());
2090 return UpdatePlaceIndexOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PATCH, Aws::Auth::SIGV4_SIGNER));
2091 }
2092
UpdatePlaceIndexCallable(const UpdatePlaceIndexRequest & request) const2093 UpdatePlaceIndexOutcomeCallable LocationServiceClient::UpdatePlaceIndexCallable(const UpdatePlaceIndexRequest& request) const
2094 {
2095 auto task = Aws::MakeShared< std::packaged_task< UpdatePlaceIndexOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdatePlaceIndex(request); } );
2096 auto packagedFunction = [task]() { (*task)(); };
2097 m_executor->Submit(packagedFunction);
2098 return task->get_future();
2099 }
2100
UpdatePlaceIndexAsync(const UpdatePlaceIndexRequest & request,const UpdatePlaceIndexResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2101 void LocationServiceClient::UpdatePlaceIndexAsync(const UpdatePlaceIndexRequest& request, const UpdatePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2102 {
2103 m_executor->Submit( [this, request, handler, context](){ this->UpdatePlaceIndexAsyncHelper( request, handler, context ); } );
2104 }
2105
UpdatePlaceIndexAsyncHelper(const UpdatePlaceIndexRequest & request,const UpdatePlaceIndexResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2106 void LocationServiceClient::UpdatePlaceIndexAsyncHelper(const UpdatePlaceIndexRequest& request, const UpdatePlaceIndexResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2107 {
2108 handler(this, request, UpdatePlaceIndex(request), context);
2109 }
2110
UpdateRouteCalculator(const UpdateRouteCalculatorRequest & request) const2111 UpdateRouteCalculatorOutcome LocationServiceClient::UpdateRouteCalculator(const UpdateRouteCalculatorRequest& request) const
2112 {
2113 if (!request.CalculatorNameHasBeenSet())
2114 {
2115 AWS_LOGSTREAM_ERROR("UpdateRouteCalculator", "Required field: CalculatorName, is not set");
2116 return UpdateRouteCalculatorOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CalculatorName]", false));
2117 }
2118 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2119 if (m_enableHostPrefixInjection)
2120 {
2121 uri.SetAuthority("routes." + uri.GetAuthority());
2122 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2123 {
2124 AWS_LOGSTREAM_ERROR("UpdateRouteCalculator", "Invalid DNS host: " << uri.GetAuthority());
2125 return UpdateRouteCalculatorOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2126 }
2127 }
2128 uri.AddPathSegments("/routes/v0/calculators/");
2129 uri.AddPathSegment(request.GetCalculatorName());
2130 return UpdateRouteCalculatorOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PATCH, Aws::Auth::SIGV4_SIGNER));
2131 }
2132
UpdateRouteCalculatorCallable(const UpdateRouteCalculatorRequest & request) const2133 UpdateRouteCalculatorOutcomeCallable LocationServiceClient::UpdateRouteCalculatorCallable(const UpdateRouteCalculatorRequest& request) const
2134 {
2135 auto task = Aws::MakeShared< std::packaged_task< UpdateRouteCalculatorOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateRouteCalculator(request); } );
2136 auto packagedFunction = [task]() { (*task)(); };
2137 m_executor->Submit(packagedFunction);
2138 return task->get_future();
2139 }
2140
UpdateRouteCalculatorAsync(const UpdateRouteCalculatorRequest & request,const UpdateRouteCalculatorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2141 void LocationServiceClient::UpdateRouteCalculatorAsync(const UpdateRouteCalculatorRequest& request, const UpdateRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2142 {
2143 m_executor->Submit( [this, request, handler, context](){ this->UpdateRouteCalculatorAsyncHelper( request, handler, context ); } );
2144 }
2145
UpdateRouteCalculatorAsyncHelper(const UpdateRouteCalculatorRequest & request,const UpdateRouteCalculatorResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2146 void LocationServiceClient::UpdateRouteCalculatorAsyncHelper(const UpdateRouteCalculatorRequest& request, const UpdateRouteCalculatorResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2147 {
2148 handler(this, request, UpdateRouteCalculator(request), context);
2149 }
2150
UpdateTracker(const UpdateTrackerRequest & request) const2151 UpdateTrackerOutcome LocationServiceClient::UpdateTracker(const UpdateTrackerRequest& request) const
2152 {
2153 if (!request.TrackerNameHasBeenSet())
2154 {
2155 AWS_LOGSTREAM_ERROR("UpdateTracker", "Required field: TrackerName, is not set");
2156 return UpdateTrackerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TrackerName]", false));
2157 }
2158 Aws::Http::URI uri = m_scheme + "://" + m_baseUri;
2159 if (m_enableHostPrefixInjection)
2160 {
2161 uri.SetAuthority("tracking." + uri.GetAuthority());
2162 if (!Aws::Utils::IsValidHost(uri.GetAuthority()))
2163 {
2164 AWS_LOGSTREAM_ERROR("UpdateTracker", "Invalid DNS host: " << uri.GetAuthority());
2165 return UpdateTrackerOutcome(Aws::Client::AWSError<LocationServiceErrors>(LocationServiceErrors::INVALID_PARAMETER_VALUE, "INVALID_PARAMETER", "Host is invalid", false));
2166 }
2167 }
2168 uri.AddPathSegments("/tracking/v0/trackers/");
2169 uri.AddPathSegment(request.GetTrackerName());
2170 return UpdateTrackerOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PATCH, Aws::Auth::SIGV4_SIGNER));
2171 }
2172
UpdateTrackerCallable(const UpdateTrackerRequest & request) const2173 UpdateTrackerOutcomeCallable LocationServiceClient::UpdateTrackerCallable(const UpdateTrackerRequest& request) const
2174 {
2175 auto task = Aws::MakeShared< std::packaged_task< UpdateTrackerOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateTracker(request); } );
2176 auto packagedFunction = [task]() { (*task)(); };
2177 m_executor->Submit(packagedFunction);
2178 return task->get_future();
2179 }
2180
UpdateTrackerAsync(const UpdateTrackerRequest & request,const UpdateTrackerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2181 void LocationServiceClient::UpdateTrackerAsync(const UpdateTrackerRequest& request, const UpdateTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2182 {
2183 m_executor->Submit( [this, request, handler, context](){ this->UpdateTrackerAsyncHelper( request, handler, context ); } );
2184 }
2185
UpdateTrackerAsyncHelper(const UpdateTrackerRequest & request,const UpdateTrackerResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const2186 void LocationServiceClient::UpdateTrackerAsyncHelper(const UpdateTrackerRequest& request, const UpdateTrackerResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
2187 {
2188 handler(this, request, UpdateTracker(request), context);
2189 }
2190
2191