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/lambda/LambdaClient.h>
21 #include <aws/lambda/LambdaEndpoint.h>
22 #include <aws/lambda/LambdaErrorMarshaller.h>
23 #include <aws/lambda/model/AddLayerVersionPermissionRequest.h>
24 #include <aws/lambda/model/AddPermissionRequest.h>
25 #include <aws/lambda/model/CreateAliasRequest.h>
26 #include <aws/lambda/model/CreateCodeSigningConfigRequest.h>
27 #include <aws/lambda/model/CreateEventSourceMappingRequest.h>
28 #include <aws/lambda/model/CreateFunctionRequest.h>
29 #include <aws/lambda/model/DeleteAliasRequest.h>
30 #include <aws/lambda/model/DeleteCodeSigningConfigRequest.h>
31 #include <aws/lambda/model/DeleteEventSourceMappingRequest.h>
32 #include <aws/lambda/model/DeleteFunctionRequest.h>
33 #include <aws/lambda/model/DeleteFunctionCodeSigningConfigRequest.h>
34 #include <aws/lambda/model/DeleteFunctionConcurrencyRequest.h>
35 #include <aws/lambda/model/DeleteFunctionEventInvokeConfigRequest.h>
36 #include <aws/lambda/model/DeleteLayerVersionRequest.h>
37 #include <aws/lambda/model/DeleteProvisionedConcurrencyConfigRequest.h>
38 #include <aws/lambda/model/GetAccountSettingsRequest.h>
39 #include <aws/lambda/model/GetAliasRequest.h>
40 #include <aws/lambda/model/GetCodeSigningConfigRequest.h>
41 #include <aws/lambda/model/GetEventSourceMappingRequest.h>
42 #include <aws/lambda/model/GetFunctionRequest.h>
43 #include <aws/lambda/model/GetFunctionCodeSigningConfigRequest.h>
44 #include <aws/lambda/model/GetFunctionConcurrencyRequest.h>
45 #include <aws/lambda/model/GetFunctionConfigurationRequest.h>
46 #include <aws/lambda/model/GetFunctionEventInvokeConfigRequest.h>
47 #include <aws/lambda/model/GetLayerVersionRequest.h>
48 #include <aws/lambda/model/GetLayerVersionByArnRequest.h>
49 #include <aws/lambda/model/GetLayerVersionPolicyRequest.h>
50 #include <aws/lambda/model/GetPolicyRequest.h>
51 #include <aws/lambda/model/GetProvisionedConcurrencyConfigRequest.h>
52 #include <aws/lambda/model/InvokeRequest.h>
53 #include <aws/lambda/model/ListAliasesRequest.h>
54 #include <aws/lambda/model/ListCodeSigningConfigsRequest.h>
55 #include <aws/lambda/model/ListEventSourceMappingsRequest.h>
56 #include <aws/lambda/model/ListFunctionEventInvokeConfigsRequest.h>
57 #include <aws/lambda/model/ListFunctionsRequest.h>
58 #include <aws/lambda/model/ListFunctionsByCodeSigningConfigRequest.h>
59 #include <aws/lambda/model/ListLayerVersionsRequest.h>
60 #include <aws/lambda/model/ListLayersRequest.h>
61 #include <aws/lambda/model/ListProvisionedConcurrencyConfigsRequest.h>
62 #include <aws/lambda/model/ListTagsRequest.h>
63 #include <aws/lambda/model/ListVersionsByFunctionRequest.h>
64 #include <aws/lambda/model/PublishLayerVersionRequest.h>
65 #include <aws/lambda/model/PublishVersionRequest.h>
66 #include <aws/lambda/model/PutFunctionCodeSigningConfigRequest.h>
67 #include <aws/lambda/model/PutFunctionConcurrencyRequest.h>
68 #include <aws/lambda/model/PutFunctionEventInvokeConfigRequest.h>
69 #include <aws/lambda/model/PutProvisionedConcurrencyConfigRequest.h>
70 #include <aws/lambda/model/RemoveLayerVersionPermissionRequest.h>
71 #include <aws/lambda/model/RemovePermissionRequest.h>
72 #include <aws/lambda/model/TagResourceRequest.h>
73 #include <aws/lambda/model/UntagResourceRequest.h>
74 #include <aws/lambda/model/UpdateAliasRequest.h>
75 #include <aws/lambda/model/UpdateCodeSigningConfigRequest.h>
76 #include <aws/lambda/model/UpdateEventSourceMappingRequest.h>
77 #include <aws/lambda/model/UpdateFunctionCodeRequest.h>
78 #include <aws/lambda/model/UpdateFunctionConfigurationRequest.h>
79 #include <aws/lambda/model/UpdateFunctionEventInvokeConfigRequest.h>
80
81 using namespace Aws;
82 using namespace Aws::Auth;
83 using namespace Aws::Client;
84 using namespace Aws::Lambda;
85 using namespace Aws::Lambda::Model;
86 using namespace Aws::Http;
87 using namespace Aws::Utils::Json;
88
89 static const char* SERVICE_NAME = "lambda";
90 static const char* ALLOCATION_TAG = "LambdaClient";
91
92
LambdaClient(const Client::ClientConfiguration & clientConfiguration)93 LambdaClient::LambdaClient(const Client::ClientConfiguration& clientConfiguration) :
94 BASECLASS(clientConfiguration,
95 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<DefaultAWSCredentialsProviderChain>(ALLOCATION_TAG),
96 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
97 Aws::MakeShared<LambdaErrorMarshaller>(ALLOCATION_TAG)),
98 m_executor(clientConfiguration.executor)
99 {
100 init(clientConfiguration);
101 }
102
LambdaClient(const AWSCredentials & credentials,const Client::ClientConfiguration & clientConfiguration)103 LambdaClient::LambdaClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration) :
104 BASECLASS(clientConfiguration,
105 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, Aws::MakeShared<SimpleAWSCredentialsProvider>(ALLOCATION_TAG, credentials),
106 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
107 Aws::MakeShared<LambdaErrorMarshaller>(ALLOCATION_TAG)),
108 m_executor(clientConfiguration.executor)
109 {
110 init(clientConfiguration);
111 }
112
LambdaClient(const std::shared_ptr<AWSCredentialsProvider> & credentialsProvider,const Client::ClientConfiguration & clientConfiguration)113 LambdaClient::LambdaClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider,
114 const Client::ClientConfiguration& clientConfiguration) :
115 BASECLASS(clientConfiguration,
116 Aws::MakeShared<AWSAuthV4Signer>(ALLOCATION_TAG, credentialsProvider,
117 SERVICE_NAME, Aws::Region::ComputeSignerRegion(clientConfiguration.region)),
118 Aws::MakeShared<LambdaErrorMarshaller>(ALLOCATION_TAG)),
119 m_executor(clientConfiguration.executor)
120 {
121 init(clientConfiguration);
122 }
123
~LambdaClient()124 LambdaClient::~LambdaClient()
125 {
126 }
127
init(const Client::ClientConfiguration & config)128 void LambdaClient::init(const Client::ClientConfiguration& config)
129 {
130 SetServiceClientName("Lambda");
131 m_configScheme = SchemeMapper::ToString(config.scheme);
132 if (config.endpointOverride.empty())
133 {
134 m_uri = m_configScheme + "://" + LambdaEndpoint::ForRegion(config.region, config.useDualStack);
135 }
136 else
137 {
138 OverrideEndpoint(config.endpointOverride);
139 }
140 }
141
OverrideEndpoint(const Aws::String & endpoint)142 void LambdaClient::OverrideEndpoint(const Aws::String& endpoint)
143 {
144 if (endpoint.compare(0, 7, "http://") == 0 || endpoint.compare(0, 8, "https://") == 0)
145 {
146 m_uri = endpoint;
147 }
148 else
149 {
150 m_uri = m_configScheme + "://" + endpoint;
151 }
152 }
153
AddLayerVersionPermission(const AddLayerVersionPermissionRequest & request) const154 AddLayerVersionPermissionOutcome LambdaClient::AddLayerVersionPermission(const AddLayerVersionPermissionRequest& request) const
155 {
156 if (!request.LayerNameHasBeenSet())
157 {
158 AWS_LOGSTREAM_ERROR("AddLayerVersionPermission", "Required field: LayerName, is not set");
159 return AddLayerVersionPermissionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [LayerName]", false));
160 }
161 if (!request.VersionNumberHasBeenSet())
162 {
163 AWS_LOGSTREAM_ERROR("AddLayerVersionPermission", "Required field: VersionNumber, is not set");
164 return AddLayerVersionPermissionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VersionNumber]", false));
165 }
166 Aws::Http::URI uri = m_uri;
167 uri.AddPathSegments("/2018-10-31/layers/");
168 uri.AddPathSegment(request.GetLayerName());
169 uri.AddPathSegments("/versions/");
170 uri.AddPathSegment(request.GetVersionNumber());
171 uri.AddPathSegments("/policy");
172 return AddLayerVersionPermissionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
173 }
174
AddLayerVersionPermissionCallable(const AddLayerVersionPermissionRequest & request) const175 AddLayerVersionPermissionOutcomeCallable LambdaClient::AddLayerVersionPermissionCallable(const AddLayerVersionPermissionRequest& request) const
176 {
177 auto task = Aws::MakeShared< std::packaged_task< AddLayerVersionPermissionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AddLayerVersionPermission(request); } );
178 auto packagedFunction = [task]() { (*task)(); };
179 m_executor->Submit(packagedFunction);
180 return task->get_future();
181 }
182
AddLayerVersionPermissionAsync(const AddLayerVersionPermissionRequest & request,const AddLayerVersionPermissionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const183 void LambdaClient::AddLayerVersionPermissionAsync(const AddLayerVersionPermissionRequest& request, const AddLayerVersionPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
184 {
185 m_executor->Submit( [this, request, handler, context](){ this->AddLayerVersionPermissionAsyncHelper( request, handler, context ); } );
186 }
187
AddLayerVersionPermissionAsyncHelper(const AddLayerVersionPermissionRequest & request,const AddLayerVersionPermissionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const188 void LambdaClient::AddLayerVersionPermissionAsyncHelper(const AddLayerVersionPermissionRequest& request, const AddLayerVersionPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
189 {
190 handler(this, request, AddLayerVersionPermission(request), context);
191 }
192
AddPermission(const AddPermissionRequest & request) const193 AddPermissionOutcome LambdaClient::AddPermission(const AddPermissionRequest& request) const
194 {
195 if (!request.FunctionNameHasBeenSet())
196 {
197 AWS_LOGSTREAM_ERROR("AddPermission", "Required field: FunctionName, is not set");
198 return AddPermissionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
199 }
200 Aws::Http::URI uri = m_uri;
201 uri.AddPathSegments("/2015-03-31/functions/");
202 uri.AddPathSegment(request.GetFunctionName());
203 uri.AddPathSegments("/policy");
204 return AddPermissionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
205 }
206
AddPermissionCallable(const AddPermissionRequest & request) const207 AddPermissionOutcomeCallable LambdaClient::AddPermissionCallable(const AddPermissionRequest& request) const
208 {
209 auto task = Aws::MakeShared< std::packaged_task< AddPermissionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->AddPermission(request); } );
210 auto packagedFunction = [task]() { (*task)(); };
211 m_executor->Submit(packagedFunction);
212 return task->get_future();
213 }
214
AddPermissionAsync(const AddPermissionRequest & request,const AddPermissionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const215 void LambdaClient::AddPermissionAsync(const AddPermissionRequest& request, const AddPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
216 {
217 m_executor->Submit( [this, request, handler, context](){ this->AddPermissionAsyncHelper( request, handler, context ); } );
218 }
219
AddPermissionAsyncHelper(const AddPermissionRequest & request,const AddPermissionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const220 void LambdaClient::AddPermissionAsyncHelper(const AddPermissionRequest& request, const AddPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
221 {
222 handler(this, request, AddPermission(request), context);
223 }
224
CreateAlias(const CreateAliasRequest & request) const225 CreateAliasOutcome LambdaClient::CreateAlias(const CreateAliasRequest& request) const
226 {
227 if (!request.FunctionNameHasBeenSet())
228 {
229 AWS_LOGSTREAM_ERROR("CreateAlias", "Required field: FunctionName, is not set");
230 return CreateAliasOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
231 }
232 Aws::Http::URI uri = m_uri;
233 uri.AddPathSegments("/2015-03-31/functions/");
234 uri.AddPathSegment(request.GetFunctionName());
235 uri.AddPathSegments("/aliases");
236 return CreateAliasOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
237 }
238
CreateAliasCallable(const CreateAliasRequest & request) const239 CreateAliasOutcomeCallable LambdaClient::CreateAliasCallable(const CreateAliasRequest& request) const
240 {
241 auto task = Aws::MakeShared< std::packaged_task< CreateAliasOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateAlias(request); } );
242 auto packagedFunction = [task]() { (*task)(); };
243 m_executor->Submit(packagedFunction);
244 return task->get_future();
245 }
246
CreateAliasAsync(const CreateAliasRequest & request,const CreateAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const247 void LambdaClient::CreateAliasAsync(const CreateAliasRequest& request, const CreateAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
248 {
249 m_executor->Submit( [this, request, handler, context](){ this->CreateAliasAsyncHelper( request, handler, context ); } );
250 }
251
CreateAliasAsyncHelper(const CreateAliasRequest & request,const CreateAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const252 void LambdaClient::CreateAliasAsyncHelper(const CreateAliasRequest& request, const CreateAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
253 {
254 handler(this, request, CreateAlias(request), context);
255 }
256
CreateCodeSigningConfig(const CreateCodeSigningConfigRequest & request) const257 CreateCodeSigningConfigOutcome LambdaClient::CreateCodeSigningConfig(const CreateCodeSigningConfigRequest& request) const
258 {
259 Aws::Http::URI uri = m_uri;
260 uri.AddPathSegments("/2020-04-22/code-signing-configs/");
261 return CreateCodeSigningConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
262 }
263
CreateCodeSigningConfigCallable(const CreateCodeSigningConfigRequest & request) const264 CreateCodeSigningConfigOutcomeCallable LambdaClient::CreateCodeSigningConfigCallable(const CreateCodeSigningConfigRequest& request) const
265 {
266 auto task = Aws::MakeShared< std::packaged_task< CreateCodeSigningConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateCodeSigningConfig(request); } );
267 auto packagedFunction = [task]() { (*task)(); };
268 m_executor->Submit(packagedFunction);
269 return task->get_future();
270 }
271
CreateCodeSigningConfigAsync(const CreateCodeSigningConfigRequest & request,const CreateCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const272 void LambdaClient::CreateCodeSigningConfigAsync(const CreateCodeSigningConfigRequest& request, const CreateCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
273 {
274 m_executor->Submit( [this, request, handler, context](){ this->CreateCodeSigningConfigAsyncHelper( request, handler, context ); } );
275 }
276
CreateCodeSigningConfigAsyncHelper(const CreateCodeSigningConfigRequest & request,const CreateCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const277 void LambdaClient::CreateCodeSigningConfigAsyncHelper(const CreateCodeSigningConfigRequest& request, const CreateCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
278 {
279 handler(this, request, CreateCodeSigningConfig(request), context);
280 }
281
CreateEventSourceMapping(const CreateEventSourceMappingRequest & request) const282 CreateEventSourceMappingOutcome LambdaClient::CreateEventSourceMapping(const CreateEventSourceMappingRequest& request) const
283 {
284 Aws::Http::URI uri = m_uri;
285 uri.AddPathSegments("/2015-03-31/event-source-mappings/");
286 return CreateEventSourceMappingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
287 }
288
CreateEventSourceMappingCallable(const CreateEventSourceMappingRequest & request) const289 CreateEventSourceMappingOutcomeCallable LambdaClient::CreateEventSourceMappingCallable(const CreateEventSourceMappingRequest& request) const
290 {
291 auto task = Aws::MakeShared< std::packaged_task< CreateEventSourceMappingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateEventSourceMapping(request); } );
292 auto packagedFunction = [task]() { (*task)(); };
293 m_executor->Submit(packagedFunction);
294 return task->get_future();
295 }
296
CreateEventSourceMappingAsync(const CreateEventSourceMappingRequest & request,const CreateEventSourceMappingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const297 void LambdaClient::CreateEventSourceMappingAsync(const CreateEventSourceMappingRequest& request, const CreateEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
298 {
299 m_executor->Submit( [this, request, handler, context](){ this->CreateEventSourceMappingAsyncHelper( request, handler, context ); } );
300 }
301
CreateEventSourceMappingAsyncHelper(const CreateEventSourceMappingRequest & request,const CreateEventSourceMappingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const302 void LambdaClient::CreateEventSourceMappingAsyncHelper(const CreateEventSourceMappingRequest& request, const CreateEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
303 {
304 handler(this, request, CreateEventSourceMapping(request), context);
305 }
306
CreateFunction(const CreateFunctionRequest & request) const307 CreateFunctionOutcome LambdaClient::CreateFunction(const CreateFunctionRequest& request) const
308 {
309 Aws::Http::URI uri = m_uri;
310 uri.AddPathSegments("/2015-03-31/functions");
311 return CreateFunctionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
312 }
313
CreateFunctionCallable(const CreateFunctionRequest & request) const314 CreateFunctionOutcomeCallable LambdaClient::CreateFunctionCallable(const CreateFunctionRequest& request) const
315 {
316 auto task = Aws::MakeShared< std::packaged_task< CreateFunctionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->CreateFunction(request); } );
317 auto packagedFunction = [task]() { (*task)(); };
318 m_executor->Submit(packagedFunction);
319 return task->get_future();
320 }
321
CreateFunctionAsync(const CreateFunctionRequest & request,const CreateFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const322 void LambdaClient::CreateFunctionAsync(const CreateFunctionRequest& request, const CreateFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
323 {
324 m_executor->Submit( [this, request, handler, context](){ this->CreateFunctionAsyncHelper( request, handler, context ); } );
325 }
326
CreateFunctionAsyncHelper(const CreateFunctionRequest & request,const CreateFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const327 void LambdaClient::CreateFunctionAsyncHelper(const CreateFunctionRequest& request, const CreateFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
328 {
329 handler(this, request, CreateFunction(request), context);
330 }
331
DeleteAlias(const DeleteAliasRequest & request) const332 DeleteAliasOutcome LambdaClient::DeleteAlias(const DeleteAliasRequest& request) const
333 {
334 if (!request.FunctionNameHasBeenSet())
335 {
336 AWS_LOGSTREAM_ERROR("DeleteAlias", "Required field: FunctionName, is not set");
337 return DeleteAliasOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
338 }
339 if (!request.NameHasBeenSet())
340 {
341 AWS_LOGSTREAM_ERROR("DeleteAlias", "Required field: Name, is not set");
342 return DeleteAliasOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Name]", false));
343 }
344 Aws::Http::URI uri = m_uri;
345 uri.AddPathSegments("/2015-03-31/functions/");
346 uri.AddPathSegment(request.GetFunctionName());
347 uri.AddPathSegments("/aliases/");
348 uri.AddPathSegment(request.GetName());
349 return DeleteAliasOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
350 }
351
DeleteAliasCallable(const DeleteAliasRequest & request) const352 DeleteAliasOutcomeCallable LambdaClient::DeleteAliasCallable(const DeleteAliasRequest& request) const
353 {
354 auto task = Aws::MakeShared< std::packaged_task< DeleteAliasOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteAlias(request); } );
355 auto packagedFunction = [task]() { (*task)(); };
356 m_executor->Submit(packagedFunction);
357 return task->get_future();
358 }
359
DeleteAliasAsync(const DeleteAliasRequest & request,const DeleteAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const360 void LambdaClient::DeleteAliasAsync(const DeleteAliasRequest& request, const DeleteAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
361 {
362 m_executor->Submit( [this, request, handler, context](){ this->DeleteAliasAsyncHelper( request, handler, context ); } );
363 }
364
DeleteAliasAsyncHelper(const DeleteAliasRequest & request,const DeleteAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const365 void LambdaClient::DeleteAliasAsyncHelper(const DeleteAliasRequest& request, const DeleteAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
366 {
367 handler(this, request, DeleteAlias(request), context);
368 }
369
DeleteCodeSigningConfig(const DeleteCodeSigningConfigRequest & request) const370 DeleteCodeSigningConfigOutcome LambdaClient::DeleteCodeSigningConfig(const DeleteCodeSigningConfigRequest& request) const
371 {
372 if (!request.CodeSigningConfigArnHasBeenSet())
373 {
374 AWS_LOGSTREAM_ERROR("DeleteCodeSigningConfig", "Required field: CodeSigningConfigArn, is not set");
375 return DeleteCodeSigningConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CodeSigningConfigArn]", false));
376 }
377 Aws::Http::URI uri = m_uri;
378 uri.AddPathSegments("/2020-04-22/code-signing-configs/");
379 uri.AddPathSegment(request.GetCodeSigningConfigArn());
380 return DeleteCodeSigningConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
381 }
382
DeleteCodeSigningConfigCallable(const DeleteCodeSigningConfigRequest & request) const383 DeleteCodeSigningConfigOutcomeCallable LambdaClient::DeleteCodeSigningConfigCallable(const DeleteCodeSigningConfigRequest& request) const
384 {
385 auto task = Aws::MakeShared< std::packaged_task< DeleteCodeSigningConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteCodeSigningConfig(request); } );
386 auto packagedFunction = [task]() { (*task)(); };
387 m_executor->Submit(packagedFunction);
388 return task->get_future();
389 }
390
DeleteCodeSigningConfigAsync(const DeleteCodeSigningConfigRequest & request,const DeleteCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const391 void LambdaClient::DeleteCodeSigningConfigAsync(const DeleteCodeSigningConfigRequest& request, const DeleteCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
392 {
393 m_executor->Submit( [this, request, handler, context](){ this->DeleteCodeSigningConfigAsyncHelper( request, handler, context ); } );
394 }
395
DeleteCodeSigningConfigAsyncHelper(const DeleteCodeSigningConfigRequest & request,const DeleteCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const396 void LambdaClient::DeleteCodeSigningConfigAsyncHelper(const DeleteCodeSigningConfigRequest& request, const DeleteCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
397 {
398 handler(this, request, DeleteCodeSigningConfig(request), context);
399 }
400
DeleteEventSourceMapping(const DeleteEventSourceMappingRequest & request) const401 DeleteEventSourceMappingOutcome LambdaClient::DeleteEventSourceMapping(const DeleteEventSourceMappingRequest& request) const
402 {
403 if (!request.UUIDHasBeenSet())
404 {
405 AWS_LOGSTREAM_ERROR("DeleteEventSourceMapping", "Required field: UUID, is not set");
406 return DeleteEventSourceMappingOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UUID]", false));
407 }
408 Aws::Http::URI uri = m_uri;
409 uri.AddPathSegments("/2015-03-31/event-source-mappings/");
410 uri.AddPathSegment(request.GetUUID());
411 return DeleteEventSourceMappingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
412 }
413
DeleteEventSourceMappingCallable(const DeleteEventSourceMappingRequest & request) const414 DeleteEventSourceMappingOutcomeCallable LambdaClient::DeleteEventSourceMappingCallable(const DeleteEventSourceMappingRequest& request) const
415 {
416 auto task = Aws::MakeShared< std::packaged_task< DeleteEventSourceMappingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteEventSourceMapping(request); } );
417 auto packagedFunction = [task]() { (*task)(); };
418 m_executor->Submit(packagedFunction);
419 return task->get_future();
420 }
421
DeleteEventSourceMappingAsync(const DeleteEventSourceMappingRequest & request,const DeleteEventSourceMappingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const422 void LambdaClient::DeleteEventSourceMappingAsync(const DeleteEventSourceMappingRequest& request, const DeleteEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
423 {
424 m_executor->Submit( [this, request, handler, context](){ this->DeleteEventSourceMappingAsyncHelper( request, handler, context ); } );
425 }
426
DeleteEventSourceMappingAsyncHelper(const DeleteEventSourceMappingRequest & request,const DeleteEventSourceMappingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const427 void LambdaClient::DeleteEventSourceMappingAsyncHelper(const DeleteEventSourceMappingRequest& request, const DeleteEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
428 {
429 handler(this, request, DeleteEventSourceMapping(request), context);
430 }
431
DeleteFunction(const DeleteFunctionRequest & request) const432 DeleteFunctionOutcome LambdaClient::DeleteFunction(const DeleteFunctionRequest& request) const
433 {
434 if (!request.FunctionNameHasBeenSet())
435 {
436 AWS_LOGSTREAM_ERROR("DeleteFunction", "Required field: FunctionName, is not set");
437 return DeleteFunctionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
438 }
439 Aws::Http::URI uri = m_uri;
440 uri.AddPathSegments("/2015-03-31/functions/");
441 uri.AddPathSegment(request.GetFunctionName());
442 return DeleteFunctionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
443 }
444
DeleteFunctionCallable(const DeleteFunctionRequest & request) const445 DeleteFunctionOutcomeCallable LambdaClient::DeleteFunctionCallable(const DeleteFunctionRequest& request) const
446 {
447 auto task = Aws::MakeShared< std::packaged_task< DeleteFunctionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteFunction(request); } );
448 auto packagedFunction = [task]() { (*task)(); };
449 m_executor->Submit(packagedFunction);
450 return task->get_future();
451 }
452
DeleteFunctionAsync(const DeleteFunctionRequest & request,const DeleteFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const453 void LambdaClient::DeleteFunctionAsync(const DeleteFunctionRequest& request, const DeleteFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
454 {
455 m_executor->Submit( [this, request, handler, context](){ this->DeleteFunctionAsyncHelper( request, handler, context ); } );
456 }
457
DeleteFunctionAsyncHelper(const DeleteFunctionRequest & request,const DeleteFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const458 void LambdaClient::DeleteFunctionAsyncHelper(const DeleteFunctionRequest& request, const DeleteFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
459 {
460 handler(this, request, DeleteFunction(request), context);
461 }
462
DeleteFunctionCodeSigningConfig(const DeleteFunctionCodeSigningConfigRequest & request) const463 DeleteFunctionCodeSigningConfigOutcome LambdaClient::DeleteFunctionCodeSigningConfig(const DeleteFunctionCodeSigningConfigRequest& request) const
464 {
465 if (!request.FunctionNameHasBeenSet())
466 {
467 AWS_LOGSTREAM_ERROR("DeleteFunctionCodeSigningConfig", "Required field: FunctionName, is not set");
468 return DeleteFunctionCodeSigningConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
469 }
470 Aws::Http::URI uri = m_uri;
471 uri.AddPathSegments("/2020-06-30/functions/");
472 uri.AddPathSegment(request.GetFunctionName());
473 uri.AddPathSegments("/code-signing-config");
474 return DeleteFunctionCodeSigningConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
475 }
476
DeleteFunctionCodeSigningConfigCallable(const DeleteFunctionCodeSigningConfigRequest & request) const477 DeleteFunctionCodeSigningConfigOutcomeCallable LambdaClient::DeleteFunctionCodeSigningConfigCallable(const DeleteFunctionCodeSigningConfigRequest& request) const
478 {
479 auto task = Aws::MakeShared< std::packaged_task< DeleteFunctionCodeSigningConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteFunctionCodeSigningConfig(request); } );
480 auto packagedFunction = [task]() { (*task)(); };
481 m_executor->Submit(packagedFunction);
482 return task->get_future();
483 }
484
DeleteFunctionCodeSigningConfigAsync(const DeleteFunctionCodeSigningConfigRequest & request,const DeleteFunctionCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const485 void LambdaClient::DeleteFunctionCodeSigningConfigAsync(const DeleteFunctionCodeSigningConfigRequest& request, const DeleteFunctionCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
486 {
487 m_executor->Submit( [this, request, handler, context](){ this->DeleteFunctionCodeSigningConfigAsyncHelper( request, handler, context ); } );
488 }
489
DeleteFunctionCodeSigningConfigAsyncHelper(const DeleteFunctionCodeSigningConfigRequest & request,const DeleteFunctionCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const490 void LambdaClient::DeleteFunctionCodeSigningConfigAsyncHelper(const DeleteFunctionCodeSigningConfigRequest& request, const DeleteFunctionCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
491 {
492 handler(this, request, DeleteFunctionCodeSigningConfig(request), context);
493 }
494
DeleteFunctionConcurrency(const DeleteFunctionConcurrencyRequest & request) const495 DeleteFunctionConcurrencyOutcome LambdaClient::DeleteFunctionConcurrency(const DeleteFunctionConcurrencyRequest& request) const
496 {
497 if (!request.FunctionNameHasBeenSet())
498 {
499 AWS_LOGSTREAM_ERROR("DeleteFunctionConcurrency", "Required field: FunctionName, is not set");
500 return DeleteFunctionConcurrencyOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
501 }
502 Aws::Http::URI uri = m_uri;
503 uri.AddPathSegments("/2017-10-31/functions/");
504 uri.AddPathSegment(request.GetFunctionName());
505 uri.AddPathSegments("/concurrency");
506 return DeleteFunctionConcurrencyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
507 }
508
DeleteFunctionConcurrencyCallable(const DeleteFunctionConcurrencyRequest & request) const509 DeleteFunctionConcurrencyOutcomeCallable LambdaClient::DeleteFunctionConcurrencyCallable(const DeleteFunctionConcurrencyRequest& request) const
510 {
511 auto task = Aws::MakeShared< std::packaged_task< DeleteFunctionConcurrencyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteFunctionConcurrency(request); } );
512 auto packagedFunction = [task]() { (*task)(); };
513 m_executor->Submit(packagedFunction);
514 return task->get_future();
515 }
516
DeleteFunctionConcurrencyAsync(const DeleteFunctionConcurrencyRequest & request,const DeleteFunctionConcurrencyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const517 void LambdaClient::DeleteFunctionConcurrencyAsync(const DeleteFunctionConcurrencyRequest& request, const DeleteFunctionConcurrencyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
518 {
519 m_executor->Submit( [this, request, handler, context](){ this->DeleteFunctionConcurrencyAsyncHelper( request, handler, context ); } );
520 }
521
DeleteFunctionConcurrencyAsyncHelper(const DeleteFunctionConcurrencyRequest & request,const DeleteFunctionConcurrencyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const522 void LambdaClient::DeleteFunctionConcurrencyAsyncHelper(const DeleteFunctionConcurrencyRequest& request, const DeleteFunctionConcurrencyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
523 {
524 handler(this, request, DeleteFunctionConcurrency(request), context);
525 }
526
DeleteFunctionEventInvokeConfig(const DeleteFunctionEventInvokeConfigRequest & request) const527 DeleteFunctionEventInvokeConfigOutcome LambdaClient::DeleteFunctionEventInvokeConfig(const DeleteFunctionEventInvokeConfigRequest& request) const
528 {
529 if (!request.FunctionNameHasBeenSet())
530 {
531 AWS_LOGSTREAM_ERROR("DeleteFunctionEventInvokeConfig", "Required field: FunctionName, is not set");
532 return DeleteFunctionEventInvokeConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
533 }
534 Aws::Http::URI uri = m_uri;
535 uri.AddPathSegments("/2019-09-25/functions/");
536 uri.AddPathSegment(request.GetFunctionName());
537 uri.AddPathSegments("/event-invoke-config");
538 return DeleteFunctionEventInvokeConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
539 }
540
DeleteFunctionEventInvokeConfigCallable(const DeleteFunctionEventInvokeConfigRequest & request) const541 DeleteFunctionEventInvokeConfigOutcomeCallable LambdaClient::DeleteFunctionEventInvokeConfigCallable(const DeleteFunctionEventInvokeConfigRequest& request) const
542 {
543 auto task = Aws::MakeShared< std::packaged_task< DeleteFunctionEventInvokeConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteFunctionEventInvokeConfig(request); } );
544 auto packagedFunction = [task]() { (*task)(); };
545 m_executor->Submit(packagedFunction);
546 return task->get_future();
547 }
548
DeleteFunctionEventInvokeConfigAsync(const DeleteFunctionEventInvokeConfigRequest & request,const DeleteFunctionEventInvokeConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const549 void LambdaClient::DeleteFunctionEventInvokeConfigAsync(const DeleteFunctionEventInvokeConfigRequest& request, const DeleteFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
550 {
551 m_executor->Submit( [this, request, handler, context](){ this->DeleteFunctionEventInvokeConfigAsyncHelper( request, handler, context ); } );
552 }
553
DeleteFunctionEventInvokeConfigAsyncHelper(const DeleteFunctionEventInvokeConfigRequest & request,const DeleteFunctionEventInvokeConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const554 void LambdaClient::DeleteFunctionEventInvokeConfigAsyncHelper(const DeleteFunctionEventInvokeConfigRequest& request, const DeleteFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
555 {
556 handler(this, request, DeleteFunctionEventInvokeConfig(request), context);
557 }
558
DeleteLayerVersion(const DeleteLayerVersionRequest & request) const559 DeleteLayerVersionOutcome LambdaClient::DeleteLayerVersion(const DeleteLayerVersionRequest& request) const
560 {
561 if (!request.LayerNameHasBeenSet())
562 {
563 AWS_LOGSTREAM_ERROR("DeleteLayerVersion", "Required field: LayerName, is not set");
564 return DeleteLayerVersionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [LayerName]", false));
565 }
566 if (!request.VersionNumberHasBeenSet())
567 {
568 AWS_LOGSTREAM_ERROR("DeleteLayerVersion", "Required field: VersionNumber, is not set");
569 return DeleteLayerVersionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VersionNumber]", false));
570 }
571 Aws::Http::URI uri = m_uri;
572 uri.AddPathSegments("/2018-10-31/layers/");
573 uri.AddPathSegment(request.GetLayerName());
574 uri.AddPathSegments("/versions/");
575 uri.AddPathSegment(request.GetVersionNumber());
576 return DeleteLayerVersionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
577 }
578
DeleteLayerVersionCallable(const DeleteLayerVersionRequest & request) const579 DeleteLayerVersionOutcomeCallable LambdaClient::DeleteLayerVersionCallable(const DeleteLayerVersionRequest& request) const
580 {
581 auto task = Aws::MakeShared< std::packaged_task< DeleteLayerVersionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteLayerVersion(request); } );
582 auto packagedFunction = [task]() { (*task)(); };
583 m_executor->Submit(packagedFunction);
584 return task->get_future();
585 }
586
DeleteLayerVersionAsync(const DeleteLayerVersionRequest & request,const DeleteLayerVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const587 void LambdaClient::DeleteLayerVersionAsync(const DeleteLayerVersionRequest& request, const DeleteLayerVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
588 {
589 m_executor->Submit( [this, request, handler, context](){ this->DeleteLayerVersionAsyncHelper( request, handler, context ); } );
590 }
591
DeleteLayerVersionAsyncHelper(const DeleteLayerVersionRequest & request,const DeleteLayerVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const592 void LambdaClient::DeleteLayerVersionAsyncHelper(const DeleteLayerVersionRequest& request, const DeleteLayerVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
593 {
594 handler(this, request, DeleteLayerVersion(request), context);
595 }
596
DeleteProvisionedConcurrencyConfig(const DeleteProvisionedConcurrencyConfigRequest & request) const597 DeleteProvisionedConcurrencyConfigOutcome LambdaClient::DeleteProvisionedConcurrencyConfig(const DeleteProvisionedConcurrencyConfigRequest& request) const
598 {
599 if (!request.FunctionNameHasBeenSet())
600 {
601 AWS_LOGSTREAM_ERROR("DeleteProvisionedConcurrencyConfig", "Required field: FunctionName, is not set");
602 return DeleteProvisionedConcurrencyConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
603 }
604 if (!request.QualifierHasBeenSet())
605 {
606 AWS_LOGSTREAM_ERROR("DeleteProvisionedConcurrencyConfig", "Required field: Qualifier, is not set");
607 return DeleteProvisionedConcurrencyConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Qualifier]", false));
608 }
609 Aws::Http::URI uri = m_uri;
610 uri.AddPathSegments("/2019-09-30/functions/");
611 uri.AddPathSegment(request.GetFunctionName());
612 uri.AddPathSegments("/provisioned-concurrency");
613 return DeleteProvisionedConcurrencyConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
614 }
615
DeleteProvisionedConcurrencyConfigCallable(const DeleteProvisionedConcurrencyConfigRequest & request) const616 DeleteProvisionedConcurrencyConfigOutcomeCallable LambdaClient::DeleteProvisionedConcurrencyConfigCallable(const DeleteProvisionedConcurrencyConfigRequest& request) const
617 {
618 auto task = Aws::MakeShared< std::packaged_task< DeleteProvisionedConcurrencyConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->DeleteProvisionedConcurrencyConfig(request); } );
619 auto packagedFunction = [task]() { (*task)(); };
620 m_executor->Submit(packagedFunction);
621 return task->get_future();
622 }
623
DeleteProvisionedConcurrencyConfigAsync(const DeleteProvisionedConcurrencyConfigRequest & request,const DeleteProvisionedConcurrencyConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const624 void LambdaClient::DeleteProvisionedConcurrencyConfigAsync(const DeleteProvisionedConcurrencyConfigRequest& request, const DeleteProvisionedConcurrencyConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
625 {
626 m_executor->Submit( [this, request, handler, context](){ this->DeleteProvisionedConcurrencyConfigAsyncHelper( request, handler, context ); } );
627 }
628
DeleteProvisionedConcurrencyConfigAsyncHelper(const DeleteProvisionedConcurrencyConfigRequest & request,const DeleteProvisionedConcurrencyConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const629 void LambdaClient::DeleteProvisionedConcurrencyConfigAsyncHelper(const DeleteProvisionedConcurrencyConfigRequest& request, const DeleteProvisionedConcurrencyConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
630 {
631 handler(this, request, DeleteProvisionedConcurrencyConfig(request), context);
632 }
633
GetAccountSettings(const GetAccountSettingsRequest & request) const634 GetAccountSettingsOutcome LambdaClient::GetAccountSettings(const GetAccountSettingsRequest& request) const
635 {
636 Aws::Http::URI uri = m_uri;
637 uri.AddPathSegments("/2016-08-19/account-settings/");
638 return GetAccountSettingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
639 }
640
GetAccountSettingsCallable(const GetAccountSettingsRequest & request) const641 GetAccountSettingsOutcomeCallable LambdaClient::GetAccountSettingsCallable(const GetAccountSettingsRequest& request) const
642 {
643 auto task = Aws::MakeShared< std::packaged_task< GetAccountSettingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetAccountSettings(request); } );
644 auto packagedFunction = [task]() { (*task)(); };
645 m_executor->Submit(packagedFunction);
646 return task->get_future();
647 }
648
GetAccountSettingsAsync(const GetAccountSettingsRequest & request,const GetAccountSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const649 void LambdaClient::GetAccountSettingsAsync(const GetAccountSettingsRequest& request, const GetAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
650 {
651 m_executor->Submit( [this, request, handler, context](){ this->GetAccountSettingsAsyncHelper( request, handler, context ); } );
652 }
653
GetAccountSettingsAsyncHelper(const GetAccountSettingsRequest & request,const GetAccountSettingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const654 void LambdaClient::GetAccountSettingsAsyncHelper(const GetAccountSettingsRequest& request, const GetAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
655 {
656 handler(this, request, GetAccountSettings(request), context);
657 }
658
GetAlias(const GetAliasRequest & request) const659 GetAliasOutcome LambdaClient::GetAlias(const GetAliasRequest& request) const
660 {
661 if (!request.FunctionNameHasBeenSet())
662 {
663 AWS_LOGSTREAM_ERROR("GetAlias", "Required field: FunctionName, is not set");
664 return GetAliasOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
665 }
666 if (!request.NameHasBeenSet())
667 {
668 AWS_LOGSTREAM_ERROR("GetAlias", "Required field: Name, is not set");
669 return GetAliasOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Name]", false));
670 }
671 Aws::Http::URI uri = m_uri;
672 uri.AddPathSegments("/2015-03-31/functions/");
673 uri.AddPathSegment(request.GetFunctionName());
674 uri.AddPathSegments("/aliases/");
675 uri.AddPathSegment(request.GetName());
676 return GetAliasOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
677 }
678
GetAliasCallable(const GetAliasRequest & request) const679 GetAliasOutcomeCallable LambdaClient::GetAliasCallable(const GetAliasRequest& request) const
680 {
681 auto task = Aws::MakeShared< std::packaged_task< GetAliasOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetAlias(request); } );
682 auto packagedFunction = [task]() { (*task)(); };
683 m_executor->Submit(packagedFunction);
684 return task->get_future();
685 }
686
GetAliasAsync(const GetAliasRequest & request,const GetAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const687 void LambdaClient::GetAliasAsync(const GetAliasRequest& request, const GetAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
688 {
689 m_executor->Submit( [this, request, handler, context](){ this->GetAliasAsyncHelper( request, handler, context ); } );
690 }
691
GetAliasAsyncHelper(const GetAliasRequest & request,const GetAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const692 void LambdaClient::GetAliasAsyncHelper(const GetAliasRequest& request, const GetAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
693 {
694 handler(this, request, GetAlias(request), context);
695 }
696
GetCodeSigningConfig(const GetCodeSigningConfigRequest & request) const697 GetCodeSigningConfigOutcome LambdaClient::GetCodeSigningConfig(const GetCodeSigningConfigRequest& request) const
698 {
699 if (!request.CodeSigningConfigArnHasBeenSet())
700 {
701 AWS_LOGSTREAM_ERROR("GetCodeSigningConfig", "Required field: CodeSigningConfigArn, is not set");
702 return GetCodeSigningConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CodeSigningConfigArn]", false));
703 }
704 Aws::Http::URI uri = m_uri;
705 uri.AddPathSegments("/2020-04-22/code-signing-configs/");
706 uri.AddPathSegment(request.GetCodeSigningConfigArn());
707 return GetCodeSigningConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
708 }
709
GetCodeSigningConfigCallable(const GetCodeSigningConfigRequest & request) const710 GetCodeSigningConfigOutcomeCallable LambdaClient::GetCodeSigningConfigCallable(const GetCodeSigningConfigRequest& request) const
711 {
712 auto task = Aws::MakeShared< std::packaged_task< GetCodeSigningConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetCodeSigningConfig(request); } );
713 auto packagedFunction = [task]() { (*task)(); };
714 m_executor->Submit(packagedFunction);
715 return task->get_future();
716 }
717
GetCodeSigningConfigAsync(const GetCodeSigningConfigRequest & request,const GetCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const718 void LambdaClient::GetCodeSigningConfigAsync(const GetCodeSigningConfigRequest& request, const GetCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
719 {
720 m_executor->Submit( [this, request, handler, context](){ this->GetCodeSigningConfigAsyncHelper( request, handler, context ); } );
721 }
722
GetCodeSigningConfigAsyncHelper(const GetCodeSigningConfigRequest & request,const GetCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const723 void LambdaClient::GetCodeSigningConfigAsyncHelper(const GetCodeSigningConfigRequest& request, const GetCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
724 {
725 handler(this, request, GetCodeSigningConfig(request), context);
726 }
727
GetEventSourceMapping(const GetEventSourceMappingRequest & request) const728 GetEventSourceMappingOutcome LambdaClient::GetEventSourceMapping(const GetEventSourceMappingRequest& request) const
729 {
730 if (!request.UUIDHasBeenSet())
731 {
732 AWS_LOGSTREAM_ERROR("GetEventSourceMapping", "Required field: UUID, is not set");
733 return GetEventSourceMappingOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UUID]", false));
734 }
735 Aws::Http::URI uri = m_uri;
736 uri.AddPathSegments("/2015-03-31/event-source-mappings/");
737 uri.AddPathSegment(request.GetUUID());
738 return GetEventSourceMappingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
739 }
740
GetEventSourceMappingCallable(const GetEventSourceMappingRequest & request) const741 GetEventSourceMappingOutcomeCallable LambdaClient::GetEventSourceMappingCallable(const GetEventSourceMappingRequest& request) const
742 {
743 auto task = Aws::MakeShared< std::packaged_task< GetEventSourceMappingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetEventSourceMapping(request); } );
744 auto packagedFunction = [task]() { (*task)(); };
745 m_executor->Submit(packagedFunction);
746 return task->get_future();
747 }
748
GetEventSourceMappingAsync(const GetEventSourceMappingRequest & request,const GetEventSourceMappingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const749 void LambdaClient::GetEventSourceMappingAsync(const GetEventSourceMappingRequest& request, const GetEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
750 {
751 m_executor->Submit( [this, request, handler, context](){ this->GetEventSourceMappingAsyncHelper( request, handler, context ); } );
752 }
753
GetEventSourceMappingAsyncHelper(const GetEventSourceMappingRequest & request,const GetEventSourceMappingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const754 void LambdaClient::GetEventSourceMappingAsyncHelper(const GetEventSourceMappingRequest& request, const GetEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
755 {
756 handler(this, request, GetEventSourceMapping(request), context);
757 }
758
GetFunction(const GetFunctionRequest & request) const759 GetFunctionOutcome LambdaClient::GetFunction(const GetFunctionRequest& request) const
760 {
761 if (!request.FunctionNameHasBeenSet())
762 {
763 AWS_LOGSTREAM_ERROR("GetFunction", "Required field: FunctionName, is not set");
764 return GetFunctionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
765 }
766 Aws::Http::URI uri = m_uri;
767 uri.AddPathSegments("/2015-03-31/functions/");
768 uri.AddPathSegment(request.GetFunctionName());
769 return GetFunctionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
770 }
771
GetFunctionCallable(const GetFunctionRequest & request) const772 GetFunctionOutcomeCallable LambdaClient::GetFunctionCallable(const GetFunctionRequest& request) const
773 {
774 auto task = Aws::MakeShared< std::packaged_task< GetFunctionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFunction(request); } );
775 auto packagedFunction = [task]() { (*task)(); };
776 m_executor->Submit(packagedFunction);
777 return task->get_future();
778 }
779
GetFunctionAsync(const GetFunctionRequest & request,const GetFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const780 void LambdaClient::GetFunctionAsync(const GetFunctionRequest& request, const GetFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
781 {
782 m_executor->Submit( [this, request, handler, context](){ this->GetFunctionAsyncHelper( request, handler, context ); } );
783 }
784
GetFunctionAsyncHelper(const GetFunctionRequest & request,const GetFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const785 void LambdaClient::GetFunctionAsyncHelper(const GetFunctionRequest& request, const GetFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
786 {
787 handler(this, request, GetFunction(request), context);
788 }
789
GetFunctionCodeSigningConfig(const GetFunctionCodeSigningConfigRequest & request) const790 GetFunctionCodeSigningConfigOutcome LambdaClient::GetFunctionCodeSigningConfig(const GetFunctionCodeSigningConfigRequest& request) const
791 {
792 if (!request.FunctionNameHasBeenSet())
793 {
794 AWS_LOGSTREAM_ERROR("GetFunctionCodeSigningConfig", "Required field: FunctionName, is not set");
795 return GetFunctionCodeSigningConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
796 }
797 Aws::Http::URI uri = m_uri;
798 uri.AddPathSegments("/2020-06-30/functions/");
799 uri.AddPathSegment(request.GetFunctionName());
800 uri.AddPathSegments("/code-signing-config");
801 return GetFunctionCodeSigningConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
802 }
803
GetFunctionCodeSigningConfigCallable(const GetFunctionCodeSigningConfigRequest & request) const804 GetFunctionCodeSigningConfigOutcomeCallable LambdaClient::GetFunctionCodeSigningConfigCallable(const GetFunctionCodeSigningConfigRequest& request) const
805 {
806 auto task = Aws::MakeShared< std::packaged_task< GetFunctionCodeSigningConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFunctionCodeSigningConfig(request); } );
807 auto packagedFunction = [task]() { (*task)(); };
808 m_executor->Submit(packagedFunction);
809 return task->get_future();
810 }
811
GetFunctionCodeSigningConfigAsync(const GetFunctionCodeSigningConfigRequest & request,const GetFunctionCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const812 void LambdaClient::GetFunctionCodeSigningConfigAsync(const GetFunctionCodeSigningConfigRequest& request, const GetFunctionCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
813 {
814 m_executor->Submit( [this, request, handler, context](){ this->GetFunctionCodeSigningConfigAsyncHelper( request, handler, context ); } );
815 }
816
GetFunctionCodeSigningConfigAsyncHelper(const GetFunctionCodeSigningConfigRequest & request,const GetFunctionCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const817 void LambdaClient::GetFunctionCodeSigningConfigAsyncHelper(const GetFunctionCodeSigningConfigRequest& request, const GetFunctionCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
818 {
819 handler(this, request, GetFunctionCodeSigningConfig(request), context);
820 }
821
GetFunctionConcurrency(const GetFunctionConcurrencyRequest & request) const822 GetFunctionConcurrencyOutcome LambdaClient::GetFunctionConcurrency(const GetFunctionConcurrencyRequest& request) const
823 {
824 if (!request.FunctionNameHasBeenSet())
825 {
826 AWS_LOGSTREAM_ERROR("GetFunctionConcurrency", "Required field: FunctionName, is not set");
827 return GetFunctionConcurrencyOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
828 }
829 Aws::Http::URI uri = m_uri;
830 uri.AddPathSegments("/2019-09-30/functions/");
831 uri.AddPathSegment(request.GetFunctionName());
832 uri.AddPathSegments("/concurrency");
833 return GetFunctionConcurrencyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
834 }
835
GetFunctionConcurrencyCallable(const GetFunctionConcurrencyRequest & request) const836 GetFunctionConcurrencyOutcomeCallable LambdaClient::GetFunctionConcurrencyCallable(const GetFunctionConcurrencyRequest& request) const
837 {
838 auto task = Aws::MakeShared< std::packaged_task< GetFunctionConcurrencyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFunctionConcurrency(request); } );
839 auto packagedFunction = [task]() { (*task)(); };
840 m_executor->Submit(packagedFunction);
841 return task->get_future();
842 }
843
GetFunctionConcurrencyAsync(const GetFunctionConcurrencyRequest & request,const GetFunctionConcurrencyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const844 void LambdaClient::GetFunctionConcurrencyAsync(const GetFunctionConcurrencyRequest& request, const GetFunctionConcurrencyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
845 {
846 m_executor->Submit( [this, request, handler, context](){ this->GetFunctionConcurrencyAsyncHelper( request, handler, context ); } );
847 }
848
GetFunctionConcurrencyAsyncHelper(const GetFunctionConcurrencyRequest & request,const GetFunctionConcurrencyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const849 void LambdaClient::GetFunctionConcurrencyAsyncHelper(const GetFunctionConcurrencyRequest& request, const GetFunctionConcurrencyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
850 {
851 handler(this, request, GetFunctionConcurrency(request), context);
852 }
853
GetFunctionConfiguration(const GetFunctionConfigurationRequest & request) const854 GetFunctionConfigurationOutcome LambdaClient::GetFunctionConfiguration(const GetFunctionConfigurationRequest& request) const
855 {
856 if (!request.FunctionNameHasBeenSet())
857 {
858 AWS_LOGSTREAM_ERROR("GetFunctionConfiguration", "Required field: FunctionName, is not set");
859 return GetFunctionConfigurationOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
860 }
861 Aws::Http::URI uri = m_uri;
862 uri.AddPathSegments("/2015-03-31/functions/");
863 uri.AddPathSegment(request.GetFunctionName());
864 uri.AddPathSegments("/configuration");
865 return GetFunctionConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
866 }
867
GetFunctionConfigurationCallable(const GetFunctionConfigurationRequest & request) const868 GetFunctionConfigurationOutcomeCallable LambdaClient::GetFunctionConfigurationCallable(const GetFunctionConfigurationRequest& request) const
869 {
870 auto task = Aws::MakeShared< std::packaged_task< GetFunctionConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFunctionConfiguration(request); } );
871 auto packagedFunction = [task]() { (*task)(); };
872 m_executor->Submit(packagedFunction);
873 return task->get_future();
874 }
875
GetFunctionConfigurationAsync(const GetFunctionConfigurationRequest & request,const GetFunctionConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const876 void LambdaClient::GetFunctionConfigurationAsync(const GetFunctionConfigurationRequest& request, const GetFunctionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
877 {
878 m_executor->Submit( [this, request, handler, context](){ this->GetFunctionConfigurationAsyncHelper( request, handler, context ); } );
879 }
880
GetFunctionConfigurationAsyncHelper(const GetFunctionConfigurationRequest & request,const GetFunctionConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const881 void LambdaClient::GetFunctionConfigurationAsyncHelper(const GetFunctionConfigurationRequest& request, const GetFunctionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
882 {
883 handler(this, request, GetFunctionConfiguration(request), context);
884 }
885
GetFunctionEventInvokeConfig(const GetFunctionEventInvokeConfigRequest & request) const886 GetFunctionEventInvokeConfigOutcome LambdaClient::GetFunctionEventInvokeConfig(const GetFunctionEventInvokeConfigRequest& request) const
887 {
888 if (!request.FunctionNameHasBeenSet())
889 {
890 AWS_LOGSTREAM_ERROR("GetFunctionEventInvokeConfig", "Required field: FunctionName, is not set");
891 return GetFunctionEventInvokeConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
892 }
893 Aws::Http::URI uri = m_uri;
894 uri.AddPathSegments("/2019-09-25/functions/");
895 uri.AddPathSegment(request.GetFunctionName());
896 uri.AddPathSegments("/event-invoke-config");
897 return GetFunctionEventInvokeConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
898 }
899
GetFunctionEventInvokeConfigCallable(const GetFunctionEventInvokeConfigRequest & request) const900 GetFunctionEventInvokeConfigOutcomeCallable LambdaClient::GetFunctionEventInvokeConfigCallable(const GetFunctionEventInvokeConfigRequest& request) const
901 {
902 auto task = Aws::MakeShared< std::packaged_task< GetFunctionEventInvokeConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetFunctionEventInvokeConfig(request); } );
903 auto packagedFunction = [task]() { (*task)(); };
904 m_executor->Submit(packagedFunction);
905 return task->get_future();
906 }
907
GetFunctionEventInvokeConfigAsync(const GetFunctionEventInvokeConfigRequest & request,const GetFunctionEventInvokeConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const908 void LambdaClient::GetFunctionEventInvokeConfigAsync(const GetFunctionEventInvokeConfigRequest& request, const GetFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
909 {
910 m_executor->Submit( [this, request, handler, context](){ this->GetFunctionEventInvokeConfigAsyncHelper( request, handler, context ); } );
911 }
912
GetFunctionEventInvokeConfigAsyncHelper(const GetFunctionEventInvokeConfigRequest & request,const GetFunctionEventInvokeConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const913 void LambdaClient::GetFunctionEventInvokeConfigAsyncHelper(const GetFunctionEventInvokeConfigRequest& request, const GetFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
914 {
915 handler(this, request, GetFunctionEventInvokeConfig(request), context);
916 }
917
GetLayerVersion(const GetLayerVersionRequest & request) const918 GetLayerVersionOutcome LambdaClient::GetLayerVersion(const GetLayerVersionRequest& request) const
919 {
920 if (!request.LayerNameHasBeenSet())
921 {
922 AWS_LOGSTREAM_ERROR("GetLayerVersion", "Required field: LayerName, is not set");
923 return GetLayerVersionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [LayerName]", false));
924 }
925 if (!request.VersionNumberHasBeenSet())
926 {
927 AWS_LOGSTREAM_ERROR("GetLayerVersion", "Required field: VersionNumber, is not set");
928 return GetLayerVersionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VersionNumber]", false));
929 }
930 Aws::Http::URI uri = m_uri;
931 uri.AddPathSegments("/2018-10-31/layers/");
932 uri.AddPathSegment(request.GetLayerName());
933 uri.AddPathSegments("/versions/");
934 uri.AddPathSegment(request.GetVersionNumber());
935 return GetLayerVersionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
936 }
937
GetLayerVersionCallable(const GetLayerVersionRequest & request) const938 GetLayerVersionOutcomeCallable LambdaClient::GetLayerVersionCallable(const GetLayerVersionRequest& request) const
939 {
940 auto task = Aws::MakeShared< std::packaged_task< GetLayerVersionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetLayerVersion(request); } );
941 auto packagedFunction = [task]() { (*task)(); };
942 m_executor->Submit(packagedFunction);
943 return task->get_future();
944 }
945
GetLayerVersionAsync(const GetLayerVersionRequest & request,const GetLayerVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const946 void LambdaClient::GetLayerVersionAsync(const GetLayerVersionRequest& request, const GetLayerVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
947 {
948 m_executor->Submit( [this, request, handler, context](){ this->GetLayerVersionAsyncHelper( request, handler, context ); } );
949 }
950
GetLayerVersionAsyncHelper(const GetLayerVersionRequest & request,const GetLayerVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const951 void LambdaClient::GetLayerVersionAsyncHelper(const GetLayerVersionRequest& request, const GetLayerVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
952 {
953 handler(this, request, GetLayerVersion(request), context);
954 }
955
GetLayerVersionByArn(const GetLayerVersionByArnRequest & request) const956 GetLayerVersionByArnOutcome LambdaClient::GetLayerVersionByArn(const GetLayerVersionByArnRequest& request) const
957 {
958 if (!request.ArnHasBeenSet())
959 {
960 AWS_LOGSTREAM_ERROR("GetLayerVersionByArn", "Required field: Arn, is not set");
961 return GetLayerVersionByArnOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Arn]", false));
962 }
963 Aws::Http::URI uri = m_uri;
964 Aws::StringStream ss;
965 uri.AddPathSegments("/2018-10-31/layers");
966 ss.str("?find=LayerVersion");
967 uri.SetQueryString(ss.str());
968 return GetLayerVersionByArnOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
969 }
970
GetLayerVersionByArnCallable(const GetLayerVersionByArnRequest & request) const971 GetLayerVersionByArnOutcomeCallable LambdaClient::GetLayerVersionByArnCallable(const GetLayerVersionByArnRequest& request) const
972 {
973 auto task = Aws::MakeShared< std::packaged_task< GetLayerVersionByArnOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetLayerVersionByArn(request); } );
974 auto packagedFunction = [task]() { (*task)(); };
975 m_executor->Submit(packagedFunction);
976 return task->get_future();
977 }
978
GetLayerVersionByArnAsync(const GetLayerVersionByArnRequest & request,const GetLayerVersionByArnResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const979 void LambdaClient::GetLayerVersionByArnAsync(const GetLayerVersionByArnRequest& request, const GetLayerVersionByArnResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
980 {
981 m_executor->Submit( [this, request, handler, context](){ this->GetLayerVersionByArnAsyncHelper( request, handler, context ); } );
982 }
983
GetLayerVersionByArnAsyncHelper(const GetLayerVersionByArnRequest & request,const GetLayerVersionByArnResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const984 void LambdaClient::GetLayerVersionByArnAsyncHelper(const GetLayerVersionByArnRequest& request, const GetLayerVersionByArnResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
985 {
986 handler(this, request, GetLayerVersionByArn(request), context);
987 }
988
GetLayerVersionPolicy(const GetLayerVersionPolicyRequest & request) const989 GetLayerVersionPolicyOutcome LambdaClient::GetLayerVersionPolicy(const GetLayerVersionPolicyRequest& request) const
990 {
991 if (!request.LayerNameHasBeenSet())
992 {
993 AWS_LOGSTREAM_ERROR("GetLayerVersionPolicy", "Required field: LayerName, is not set");
994 return GetLayerVersionPolicyOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [LayerName]", false));
995 }
996 if (!request.VersionNumberHasBeenSet())
997 {
998 AWS_LOGSTREAM_ERROR("GetLayerVersionPolicy", "Required field: VersionNumber, is not set");
999 return GetLayerVersionPolicyOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VersionNumber]", false));
1000 }
1001 Aws::Http::URI uri = m_uri;
1002 uri.AddPathSegments("/2018-10-31/layers/");
1003 uri.AddPathSegment(request.GetLayerName());
1004 uri.AddPathSegments("/versions/");
1005 uri.AddPathSegment(request.GetVersionNumber());
1006 uri.AddPathSegments("/policy");
1007 return GetLayerVersionPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1008 }
1009
GetLayerVersionPolicyCallable(const GetLayerVersionPolicyRequest & request) const1010 GetLayerVersionPolicyOutcomeCallable LambdaClient::GetLayerVersionPolicyCallable(const GetLayerVersionPolicyRequest& request) const
1011 {
1012 auto task = Aws::MakeShared< std::packaged_task< GetLayerVersionPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetLayerVersionPolicy(request); } );
1013 auto packagedFunction = [task]() { (*task)(); };
1014 m_executor->Submit(packagedFunction);
1015 return task->get_future();
1016 }
1017
GetLayerVersionPolicyAsync(const GetLayerVersionPolicyRequest & request,const GetLayerVersionPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1018 void LambdaClient::GetLayerVersionPolicyAsync(const GetLayerVersionPolicyRequest& request, const GetLayerVersionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1019 {
1020 m_executor->Submit( [this, request, handler, context](){ this->GetLayerVersionPolicyAsyncHelper( request, handler, context ); } );
1021 }
1022
GetLayerVersionPolicyAsyncHelper(const GetLayerVersionPolicyRequest & request,const GetLayerVersionPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1023 void LambdaClient::GetLayerVersionPolicyAsyncHelper(const GetLayerVersionPolicyRequest& request, const GetLayerVersionPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1024 {
1025 handler(this, request, GetLayerVersionPolicy(request), context);
1026 }
1027
GetPolicy(const GetPolicyRequest & request) const1028 GetPolicyOutcome LambdaClient::GetPolicy(const GetPolicyRequest& request) const
1029 {
1030 if (!request.FunctionNameHasBeenSet())
1031 {
1032 AWS_LOGSTREAM_ERROR("GetPolicy", "Required field: FunctionName, is not set");
1033 return GetPolicyOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1034 }
1035 Aws::Http::URI uri = m_uri;
1036 uri.AddPathSegments("/2015-03-31/functions/");
1037 uri.AddPathSegment(request.GetFunctionName());
1038 uri.AddPathSegments("/policy");
1039 return GetPolicyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1040 }
1041
GetPolicyCallable(const GetPolicyRequest & request) const1042 GetPolicyOutcomeCallable LambdaClient::GetPolicyCallable(const GetPolicyRequest& request) const
1043 {
1044 auto task = Aws::MakeShared< std::packaged_task< GetPolicyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetPolicy(request); } );
1045 auto packagedFunction = [task]() { (*task)(); };
1046 m_executor->Submit(packagedFunction);
1047 return task->get_future();
1048 }
1049
GetPolicyAsync(const GetPolicyRequest & request,const GetPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1050 void LambdaClient::GetPolicyAsync(const GetPolicyRequest& request, const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1051 {
1052 m_executor->Submit( [this, request, handler, context](){ this->GetPolicyAsyncHelper( request, handler, context ); } );
1053 }
1054
GetPolicyAsyncHelper(const GetPolicyRequest & request,const GetPolicyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1055 void LambdaClient::GetPolicyAsyncHelper(const GetPolicyRequest& request, const GetPolicyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1056 {
1057 handler(this, request, GetPolicy(request), context);
1058 }
1059
GetProvisionedConcurrencyConfig(const GetProvisionedConcurrencyConfigRequest & request) const1060 GetProvisionedConcurrencyConfigOutcome LambdaClient::GetProvisionedConcurrencyConfig(const GetProvisionedConcurrencyConfigRequest& request) const
1061 {
1062 if (!request.FunctionNameHasBeenSet())
1063 {
1064 AWS_LOGSTREAM_ERROR("GetProvisionedConcurrencyConfig", "Required field: FunctionName, is not set");
1065 return GetProvisionedConcurrencyConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1066 }
1067 if (!request.QualifierHasBeenSet())
1068 {
1069 AWS_LOGSTREAM_ERROR("GetProvisionedConcurrencyConfig", "Required field: Qualifier, is not set");
1070 return GetProvisionedConcurrencyConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Qualifier]", false));
1071 }
1072 Aws::Http::URI uri = m_uri;
1073 uri.AddPathSegments("/2019-09-30/functions/");
1074 uri.AddPathSegment(request.GetFunctionName());
1075 uri.AddPathSegments("/provisioned-concurrency");
1076 return GetProvisionedConcurrencyConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1077 }
1078
GetProvisionedConcurrencyConfigCallable(const GetProvisionedConcurrencyConfigRequest & request) const1079 GetProvisionedConcurrencyConfigOutcomeCallable LambdaClient::GetProvisionedConcurrencyConfigCallable(const GetProvisionedConcurrencyConfigRequest& request) const
1080 {
1081 auto task = Aws::MakeShared< std::packaged_task< GetProvisionedConcurrencyConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->GetProvisionedConcurrencyConfig(request); } );
1082 auto packagedFunction = [task]() { (*task)(); };
1083 m_executor->Submit(packagedFunction);
1084 return task->get_future();
1085 }
1086
GetProvisionedConcurrencyConfigAsync(const GetProvisionedConcurrencyConfigRequest & request,const GetProvisionedConcurrencyConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1087 void LambdaClient::GetProvisionedConcurrencyConfigAsync(const GetProvisionedConcurrencyConfigRequest& request, const GetProvisionedConcurrencyConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1088 {
1089 m_executor->Submit( [this, request, handler, context](){ this->GetProvisionedConcurrencyConfigAsyncHelper( request, handler, context ); } );
1090 }
1091
GetProvisionedConcurrencyConfigAsyncHelper(const GetProvisionedConcurrencyConfigRequest & request,const GetProvisionedConcurrencyConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1092 void LambdaClient::GetProvisionedConcurrencyConfigAsyncHelper(const GetProvisionedConcurrencyConfigRequest& request, const GetProvisionedConcurrencyConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1093 {
1094 handler(this, request, GetProvisionedConcurrencyConfig(request), context);
1095 }
1096
Invoke(const InvokeRequest & request) const1097 InvokeOutcome LambdaClient::Invoke(const InvokeRequest& request) const
1098 {
1099 if (!request.FunctionNameHasBeenSet())
1100 {
1101 AWS_LOGSTREAM_ERROR("Invoke", "Required field: FunctionName, is not set");
1102 return InvokeOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1103 }
1104 Aws::Http::URI uri = m_uri;
1105 uri.AddPathSegments("/2015-03-31/functions/");
1106 uri.AddPathSegment(request.GetFunctionName());
1107 uri.AddPathSegments("/invocations");
1108 return InvokeOutcome(MakeRequestWithUnparsedResponse(uri, request, Aws::Http::HttpMethod::HTTP_POST));
1109 }
1110
InvokeCallable(const InvokeRequest & request) const1111 InvokeOutcomeCallable LambdaClient::InvokeCallable(const InvokeRequest& request) const
1112 {
1113 auto task = Aws::MakeShared< std::packaged_task< InvokeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->Invoke(request); } );
1114 auto packagedFunction = [task]() { (*task)(); };
1115 m_executor->Submit(packagedFunction);
1116 return task->get_future();
1117 }
1118
InvokeAsync(const InvokeRequest & request,const InvokeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1119 void LambdaClient::InvokeAsync(const InvokeRequest& request, const InvokeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1120 {
1121 m_executor->Submit( [this, request, handler, context](){ this->InvokeAsyncHelper( request, handler, context ); } );
1122 }
1123
InvokeAsyncHelper(const InvokeRequest & request,const InvokeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1124 void LambdaClient::InvokeAsyncHelper(const InvokeRequest& request, const InvokeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1125 {
1126 handler(this, request, Invoke(request), context);
1127 }
1128
ListAliases(const ListAliasesRequest & request) const1129 ListAliasesOutcome LambdaClient::ListAliases(const ListAliasesRequest& request) const
1130 {
1131 if (!request.FunctionNameHasBeenSet())
1132 {
1133 AWS_LOGSTREAM_ERROR("ListAliases", "Required field: FunctionName, is not set");
1134 return ListAliasesOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1135 }
1136 Aws::Http::URI uri = m_uri;
1137 uri.AddPathSegments("/2015-03-31/functions/");
1138 uri.AddPathSegment(request.GetFunctionName());
1139 uri.AddPathSegments("/aliases");
1140 return ListAliasesOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1141 }
1142
ListAliasesCallable(const ListAliasesRequest & request) const1143 ListAliasesOutcomeCallable LambdaClient::ListAliasesCallable(const ListAliasesRequest& request) const
1144 {
1145 auto task = Aws::MakeShared< std::packaged_task< ListAliasesOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListAliases(request); } );
1146 auto packagedFunction = [task]() { (*task)(); };
1147 m_executor->Submit(packagedFunction);
1148 return task->get_future();
1149 }
1150
ListAliasesAsync(const ListAliasesRequest & request,const ListAliasesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1151 void LambdaClient::ListAliasesAsync(const ListAliasesRequest& request, const ListAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1152 {
1153 m_executor->Submit( [this, request, handler, context](){ this->ListAliasesAsyncHelper( request, handler, context ); } );
1154 }
1155
ListAliasesAsyncHelper(const ListAliasesRequest & request,const ListAliasesResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1156 void LambdaClient::ListAliasesAsyncHelper(const ListAliasesRequest& request, const ListAliasesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1157 {
1158 handler(this, request, ListAliases(request), context);
1159 }
1160
ListCodeSigningConfigs(const ListCodeSigningConfigsRequest & request) const1161 ListCodeSigningConfigsOutcome LambdaClient::ListCodeSigningConfigs(const ListCodeSigningConfigsRequest& request) const
1162 {
1163 Aws::Http::URI uri = m_uri;
1164 uri.AddPathSegments("/2020-04-22/code-signing-configs/");
1165 return ListCodeSigningConfigsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1166 }
1167
ListCodeSigningConfigsCallable(const ListCodeSigningConfigsRequest & request) const1168 ListCodeSigningConfigsOutcomeCallable LambdaClient::ListCodeSigningConfigsCallable(const ListCodeSigningConfigsRequest& request) const
1169 {
1170 auto task = Aws::MakeShared< std::packaged_task< ListCodeSigningConfigsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListCodeSigningConfigs(request); } );
1171 auto packagedFunction = [task]() { (*task)(); };
1172 m_executor->Submit(packagedFunction);
1173 return task->get_future();
1174 }
1175
ListCodeSigningConfigsAsync(const ListCodeSigningConfigsRequest & request,const ListCodeSigningConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1176 void LambdaClient::ListCodeSigningConfigsAsync(const ListCodeSigningConfigsRequest& request, const ListCodeSigningConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1177 {
1178 m_executor->Submit( [this, request, handler, context](){ this->ListCodeSigningConfigsAsyncHelper( request, handler, context ); } );
1179 }
1180
ListCodeSigningConfigsAsyncHelper(const ListCodeSigningConfigsRequest & request,const ListCodeSigningConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1181 void LambdaClient::ListCodeSigningConfigsAsyncHelper(const ListCodeSigningConfigsRequest& request, const ListCodeSigningConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1182 {
1183 handler(this, request, ListCodeSigningConfigs(request), context);
1184 }
1185
ListEventSourceMappings(const ListEventSourceMappingsRequest & request) const1186 ListEventSourceMappingsOutcome LambdaClient::ListEventSourceMappings(const ListEventSourceMappingsRequest& request) const
1187 {
1188 Aws::Http::URI uri = m_uri;
1189 uri.AddPathSegments("/2015-03-31/event-source-mappings/");
1190 return ListEventSourceMappingsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1191 }
1192
ListEventSourceMappingsCallable(const ListEventSourceMappingsRequest & request) const1193 ListEventSourceMappingsOutcomeCallable LambdaClient::ListEventSourceMappingsCallable(const ListEventSourceMappingsRequest& request) const
1194 {
1195 auto task = Aws::MakeShared< std::packaged_task< ListEventSourceMappingsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListEventSourceMappings(request); } );
1196 auto packagedFunction = [task]() { (*task)(); };
1197 m_executor->Submit(packagedFunction);
1198 return task->get_future();
1199 }
1200
ListEventSourceMappingsAsync(const ListEventSourceMappingsRequest & request,const ListEventSourceMappingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1201 void LambdaClient::ListEventSourceMappingsAsync(const ListEventSourceMappingsRequest& request, const ListEventSourceMappingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1202 {
1203 m_executor->Submit( [this, request, handler, context](){ this->ListEventSourceMappingsAsyncHelper( request, handler, context ); } );
1204 }
1205
ListEventSourceMappingsAsyncHelper(const ListEventSourceMappingsRequest & request,const ListEventSourceMappingsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1206 void LambdaClient::ListEventSourceMappingsAsyncHelper(const ListEventSourceMappingsRequest& request, const ListEventSourceMappingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1207 {
1208 handler(this, request, ListEventSourceMappings(request), context);
1209 }
1210
ListFunctionEventInvokeConfigs(const ListFunctionEventInvokeConfigsRequest & request) const1211 ListFunctionEventInvokeConfigsOutcome LambdaClient::ListFunctionEventInvokeConfigs(const ListFunctionEventInvokeConfigsRequest& request) const
1212 {
1213 if (!request.FunctionNameHasBeenSet())
1214 {
1215 AWS_LOGSTREAM_ERROR("ListFunctionEventInvokeConfigs", "Required field: FunctionName, is not set");
1216 return ListFunctionEventInvokeConfigsOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1217 }
1218 Aws::Http::URI uri = m_uri;
1219 uri.AddPathSegments("/2019-09-25/functions/");
1220 uri.AddPathSegment(request.GetFunctionName());
1221 uri.AddPathSegments("/event-invoke-config/list");
1222 return ListFunctionEventInvokeConfigsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1223 }
1224
ListFunctionEventInvokeConfigsCallable(const ListFunctionEventInvokeConfigsRequest & request) const1225 ListFunctionEventInvokeConfigsOutcomeCallable LambdaClient::ListFunctionEventInvokeConfigsCallable(const ListFunctionEventInvokeConfigsRequest& request) const
1226 {
1227 auto task = Aws::MakeShared< std::packaged_task< ListFunctionEventInvokeConfigsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListFunctionEventInvokeConfigs(request); } );
1228 auto packagedFunction = [task]() { (*task)(); };
1229 m_executor->Submit(packagedFunction);
1230 return task->get_future();
1231 }
1232
ListFunctionEventInvokeConfigsAsync(const ListFunctionEventInvokeConfigsRequest & request,const ListFunctionEventInvokeConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1233 void LambdaClient::ListFunctionEventInvokeConfigsAsync(const ListFunctionEventInvokeConfigsRequest& request, const ListFunctionEventInvokeConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1234 {
1235 m_executor->Submit( [this, request, handler, context](){ this->ListFunctionEventInvokeConfigsAsyncHelper( request, handler, context ); } );
1236 }
1237
ListFunctionEventInvokeConfigsAsyncHelper(const ListFunctionEventInvokeConfigsRequest & request,const ListFunctionEventInvokeConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1238 void LambdaClient::ListFunctionEventInvokeConfigsAsyncHelper(const ListFunctionEventInvokeConfigsRequest& request, const ListFunctionEventInvokeConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1239 {
1240 handler(this, request, ListFunctionEventInvokeConfigs(request), context);
1241 }
1242
ListFunctions(const ListFunctionsRequest & request) const1243 ListFunctionsOutcome LambdaClient::ListFunctions(const ListFunctionsRequest& request) const
1244 {
1245 Aws::Http::URI uri = m_uri;
1246 uri.AddPathSegments("/2015-03-31/functions/");
1247 return ListFunctionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1248 }
1249
ListFunctionsCallable(const ListFunctionsRequest & request) const1250 ListFunctionsOutcomeCallable LambdaClient::ListFunctionsCallable(const ListFunctionsRequest& request) const
1251 {
1252 auto task = Aws::MakeShared< std::packaged_task< ListFunctionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListFunctions(request); } );
1253 auto packagedFunction = [task]() { (*task)(); };
1254 m_executor->Submit(packagedFunction);
1255 return task->get_future();
1256 }
1257
ListFunctionsAsync(const ListFunctionsRequest & request,const ListFunctionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1258 void LambdaClient::ListFunctionsAsync(const ListFunctionsRequest& request, const ListFunctionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1259 {
1260 m_executor->Submit( [this, request, handler, context](){ this->ListFunctionsAsyncHelper( request, handler, context ); } );
1261 }
1262
ListFunctionsAsyncHelper(const ListFunctionsRequest & request,const ListFunctionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1263 void LambdaClient::ListFunctionsAsyncHelper(const ListFunctionsRequest& request, const ListFunctionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1264 {
1265 handler(this, request, ListFunctions(request), context);
1266 }
1267
ListFunctionsByCodeSigningConfig(const ListFunctionsByCodeSigningConfigRequest & request) const1268 ListFunctionsByCodeSigningConfigOutcome LambdaClient::ListFunctionsByCodeSigningConfig(const ListFunctionsByCodeSigningConfigRequest& request) const
1269 {
1270 if (!request.CodeSigningConfigArnHasBeenSet())
1271 {
1272 AWS_LOGSTREAM_ERROR("ListFunctionsByCodeSigningConfig", "Required field: CodeSigningConfigArn, is not set");
1273 return ListFunctionsByCodeSigningConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CodeSigningConfigArn]", false));
1274 }
1275 Aws::Http::URI uri = m_uri;
1276 uri.AddPathSegments("/2020-04-22/code-signing-configs/");
1277 uri.AddPathSegment(request.GetCodeSigningConfigArn());
1278 uri.AddPathSegments("/functions");
1279 return ListFunctionsByCodeSigningConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1280 }
1281
ListFunctionsByCodeSigningConfigCallable(const ListFunctionsByCodeSigningConfigRequest & request) const1282 ListFunctionsByCodeSigningConfigOutcomeCallable LambdaClient::ListFunctionsByCodeSigningConfigCallable(const ListFunctionsByCodeSigningConfigRequest& request) const
1283 {
1284 auto task = Aws::MakeShared< std::packaged_task< ListFunctionsByCodeSigningConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListFunctionsByCodeSigningConfig(request); } );
1285 auto packagedFunction = [task]() { (*task)(); };
1286 m_executor->Submit(packagedFunction);
1287 return task->get_future();
1288 }
1289
ListFunctionsByCodeSigningConfigAsync(const ListFunctionsByCodeSigningConfigRequest & request,const ListFunctionsByCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1290 void LambdaClient::ListFunctionsByCodeSigningConfigAsync(const ListFunctionsByCodeSigningConfigRequest& request, const ListFunctionsByCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1291 {
1292 m_executor->Submit( [this, request, handler, context](){ this->ListFunctionsByCodeSigningConfigAsyncHelper( request, handler, context ); } );
1293 }
1294
ListFunctionsByCodeSigningConfigAsyncHelper(const ListFunctionsByCodeSigningConfigRequest & request,const ListFunctionsByCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1295 void LambdaClient::ListFunctionsByCodeSigningConfigAsyncHelper(const ListFunctionsByCodeSigningConfigRequest& request, const ListFunctionsByCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1296 {
1297 handler(this, request, ListFunctionsByCodeSigningConfig(request), context);
1298 }
1299
ListLayerVersions(const ListLayerVersionsRequest & request) const1300 ListLayerVersionsOutcome LambdaClient::ListLayerVersions(const ListLayerVersionsRequest& request) const
1301 {
1302 if (!request.LayerNameHasBeenSet())
1303 {
1304 AWS_LOGSTREAM_ERROR("ListLayerVersions", "Required field: LayerName, is not set");
1305 return ListLayerVersionsOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [LayerName]", false));
1306 }
1307 Aws::Http::URI uri = m_uri;
1308 uri.AddPathSegments("/2018-10-31/layers/");
1309 uri.AddPathSegment(request.GetLayerName());
1310 uri.AddPathSegments("/versions");
1311 return ListLayerVersionsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1312 }
1313
ListLayerVersionsCallable(const ListLayerVersionsRequest & request) const1314 ListLayerVersionsOutcomeCallable LambdaClient::ListLayerVersionsCallable(const ListLayerVersionsRequest& request) const
1315 {
1316 auto task = Aws::MakeShared< std::packaged_task< ListLayerVersionsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListLayerVersions(request); } );
1317 auto packagedFunction = [task]() { (*task)(); };
1318 m_executor->Submit(packagedFunction);
1319 return task->get_future();
1320 }
1321
ListLayerVersionsAsync(const ListLayerVersionsRequest & request,const ListLayerVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1322 void LambdaClient::ListLayerVersionsAsync(const ListLayerVersionsRequest& request, const ListLayerVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1323 {
1324 m_executor->Submit( [this, request, handler, context](){ this->ListLayerVersionsAsyncHelper( request, handler, context ); } );
1325 }
1326
ListLayerVersionsAsyncHelper(const ListLayerVersionsRequest & request,const ListLayerVersionsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1327 void LambdaClient::ListLayerVersionsAsyncHelper(const ListLayerVersionsRequest& request, const ListLayerVersionsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1328 {
1329 handler(this, request, ListLayerVersions(request), context);
1330 }
1331
ListLayers(const ListLayersRequest & request) const1332 ListLayersOutcome LambdaClient::ListLayers(const ListLayersRequest& request) const
1333 {
1334 Aws::Http::URI uri = m_uri;
1335 uri.AddPathSegments("/2018-10-31/layers");
1336 return ListLayersOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1337 }
1338
ListLayersCallable(const ListLayersRequest & request) const1339 ListLayersOutcomeCallable LambdaClient::ListLayersCallable(const ListLayersRequest& request) const
1340 {
1341 auto task = Aws::MakeShared< std::packaged_task< ListLayersOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListLayers(request); } );
1342 auto packagedFunction = [task]() { (*task)(); };
1343 m_executor->Submit(packagedFunction);
1344 return task->get_future();
1345 }
1346
ListLayersAsync(const ListLayersRequest & request,const ListLayersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1347 void LambdaClient::ListLayersAsync(const ListLayersRequest& request, const ListLayersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1348 {
1349 m_executor->Submit( [this, request, handler, context](){ this->ListLayersAsyncHelper( request, handler, context ); } );
1350 }
1351
ListLayersAsyncHelper(const ListLayersRequest & request,const ListLayersResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1352 void LambdaClient::ListLayersAsyncHelper(const ListLayersRequest& request, const ListLayersResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1353 {
1354 handler(this, request, ListLayers(request), context);
1355 }
1356
ListProvisionedConcurrencyConfigs(const ListProvisionedConcurrencyConfigsRequest & request) const1357 ListProvisionedConcurrencyConfigsOutcome LambdaClient::ListProvisionedConcurrencyConfigs(const ListProvisionedConcurrencyConfigsRequest& request) const
1358 {
1359 if (!request.FunctionNameHasBeenSet())
1360 {
1361 AWS_LOGSTREAM_ERROR("ListProvisionedConcurrencyConfigs", "Required field: FunctionName, is not set");
1362 return ListProvisionedConcurrencyConfigsOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1363 }
1364 Aws::Http::URI uri = m_uri;
1365 Aws::StringStream ss;
1366 uri.AddPathSegments("/2019-09-30/functions/");
1367 uri.AddPathSegment(request.GetFunctionName());
1368 uri.AddPathSegments("/provisioned-concurrency");
1369 ss.str("?List=ALL");
1370 uri.SetQueryString(ss.str());
1371 return ListProvisionedConcurrencyConfigsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1372 }
1373
ListProvisionedConcurrencyConfigsCallable(const ListProvisionedConcurrencyConfigsRequest & request) const1374 ListProvisionedConcurrencyConfigsOutcomeCallable LambdaClient::ListProvisionedConcurrencyConfigsCallable(const ListProvisionedConcurrencyConfigsRequest& request) const
1375 {
1376 auto task = Aws::MakeShared< std::packaged_task< ListProvisionedConcurrencyConfigsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListProvisionedConcurrencyConfigs(request); } );
1377 auto packagedFunction = [task]() { (*task)(); };
1378 m_executor->Submit(packagedFunction);
1379 return task->get_future();
1380 }
1381
ListProvisionedConcurrencyConfigsAsync(const ListProvisionedConcurrencyConfigsRequest & request,const ListProvisionedConcurrencyConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1382 void LambdaClient::ListProvisionedConcurrencyConfigsAsync(const ListProvisionedConcurrencyConfigsRequest& request, const ListProvisionedConcurrencyConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1383 {
1384 m_executor->Submit( [this, request, handler, context](){ this->ListProvisionedConcurrencyConfigsAsyncHelper( request, handler, context ); } );
1385 }
1386
ListProvisionedConcurrencyConfigsAsyncHelper(const ListProvisionedConcurrencyConfigsRequest & request,const ListProvisionedConcurrencyConfigsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1387 void LambdaClient::ListProvisionedConcurrencyConfigsAsyncHelper(const ListProvisionedConcurrencyConfigsRequest& request, const ListProvisionedConcurrencyConfigsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1388 {
1389 handler(this, request, ListProvisionedConcurrencyConfigs(request), context);
1390 }
1391
ListTags(const ListTagsRequest & request) const1392 ListTagsOutcome LambdaClient::ListTags(const ListTagsRequest& request) const
1393 {
1394 if (!request.ResourceHasBeenSet())
1395 {
1396 AWS_LOGSTREAM_ERROR("ListTags", "Required field: Resource, is not set");
1397 return ListTagsOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Resource]", false));
1398 }
1399 Aws::Http::URI uri = m_uri;
1400 uri.AddPathSegments("/2017-03-31/tags/");
1401 uri.AddPathSegment(request.GetResource());
1402 return ListTagsOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1403 }
1404
ListTagsCallable(const ListTagsRequest & request) const1405 ListTagsOutcomeCallable LambdaClient::ListTagsCallable(const ListTagsRequest& request) const
1406 {
1407 auto task = Aws::MakeShared< std::packaged_task< ListTagsOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListTags(request); } );
1408 auto packagedFunction = [task]() { (*task)(); };
1409 m_executor->Submit(packagedFunction);
1410 return task->get_future();
1411 }
1412
ListTagsAsync(const ListTagsRequest & request,const ListTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1413 void LambdaClient::ListTagsAsync(const ListTagsRequest& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1414 {
1415 m_executor->Submit( [this, request, handler, context](){ this->ListTagsAsyncHelper( request, handler, context ); } );
1416 }
1417
ListTagsAsyncHelper(const ListTagsRequest & request,const ListTagsResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1418 void LambdaClient::ListTagsAsyncHelper(const ListTagsRequest& request, const ListTagsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1419 {
1420 handler(this, request, ListTags(request), context);
1421 }
1422
ListVersionsByFunction(const ListVersionsByFunctionRequest & request) const1423 ListVersionsByFunctionOutcome LambdaClient::ListVersionsByFunction(const ListVersionsByFunctionRequest& request) const
1424 {
1425 if (!request.FunctionNameHasBeenSet())
1426 {
1427 AWS_LOGSTREAM_ERROR("ListVersionsByFunction", "Required field: FunctionName, is not set");
1428 return ListVersionsByFunctionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1429 }
1430 Aws::Http::URI uri = m_uri;
1431 uri.AddPathSegments("/2015-03-31/functions/");
1432 uri.AddPathSegment(request.GetFunctionName());
1433 uri.AddPathSegments("/versions");
1434 return ListVersionsByFunctionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_GET, Aws::Auth::SIGV4_SIGNER));
1435 }
1436
ListVersionsByFunctionCallable(const ListVersionsByFunctionRequest & request) const1437 ListVersionsByFunctionOutcomeCallable LambdaClient::ListVersionsByFunctionCallable(const ListVersionsByFunctionRequest& request) const
1438 {
1439 auto task = Aws::MakeShared< std::packaged_task< ListVersionsByFunctionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->ListVersionsByFunction(request); } );
1440 auto packagedFunction = [task]() { (*task)(); };
1441 m_executor->Submit(packagedFunction);
1442 return task->get_future();
1443 }
1444
ListVersionsByFunctionAsync(const ListVersionsByFunctionRequest & request,const ListVersionsByFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1445 void LambdaClient::ListVersionsByFunctionAsync(const ListVersionsByFunctionRequest& request, const ListVersionsByFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1446 {
1447 m_executor->Submit( [this, request, handler, context](){ this->ListVersionsByFunctionAsyncHelper( request, handler, context ); } );
1448 }
1449
ListVersionsByFunctionAsyncHelper(const ListVersionsByFunctionRequest & request,const ListVersionsByFunctionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1450 void LambdaClient::ListVersionsByFunctionAsyncHelper(const ListVersionsByFunctionRequest& request, const ListVersionsByFunctionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1451 {
1452 handler(this, request, ListVersionsByFunction(request), context);
1453 }
1454
PublishLayerVersion(const PublishLayerVersionRequest & request) const1455 PublishLayerVersionOutcome LambdaClient::PublishLayerVersion(const PublishLayerVersionRequest& request) const
1456 {
1457 if (!request.LayerNameHasBeenSet())
1458 {
1459 AWS_LOGSTREAM_ERROR("PublishLayerVersion", "Required field: LayerName, is not set");
1460 return PublishLayerVersionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [LayerName]", false));
1461 }
1462 Aws::Http::URI uri = m_uri;
1463 uri.AddPathSegments("/2018-10-31/layers/");
1464 uri.AddPathSegment(request.GetLayerName());
1465 uri.AddPathSegments("/versions");
1466 return PublishLayerVersionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1467 }
1468
PublishLayerVersionCallable(const PublishLayerVersionRequest & request) const1469 PublishLayerVersionOutcomeCallable LambdaClient::PublishLayerVersionCallable(const PublishLayerVersionRequest& request) const
1470 {
1471 auto task = Aws::MakeShared< std::packaged_task< PublishLayerVersionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PublishLayerVersion(request); } );
1472 auto packagedFunction = [task]() { (*task)(); };
1473 m_executor->Submit(packagedFunction);
1474 return task->get_future();
1475 }
1476
PublishLayerVersionAsync(const PublishLayerVersionRequest & request,const PublishLayerVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1477 void LambdaClient::PublishLayerVersionAsync(const PublishLayerVersionRequest& request, const PublishLayerVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1478 {
1479 m_executor->Submit( [this, request, handler, context](){ this->PublishLayerVersionAsyncHelper( request, handler, context ); } );
1480 }
1481
PublishLayerVersionAsyncHelper(const PublishLayerVersionRequest & request,const PublishLayerVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1482 void LambdaClient::PublishLayerVersionAsyncHelper(const PublishLayerVersionRequest& request, const PublishLayerVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1483 {
1484 handler(this, request, PublishLayerVersion(request), context);
1485 }
1486
PublishVersion(const PublishVersionRequest & request) const1487 PublishVersionOutcome LambdaClient::PublishVersion(const PublishVersionRequest& request) const
1488 {
1489 if (!request.FunctionNameHasBeenSet())
1490 {
1491 AWS_LOGSTREAM_ERROR("PublishVersion", "Required field: FunctionName, is not set");
1492 return PublishVersionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1493 }
1494 Aws::Http::URI uri = m_uri;
1495 uri.AddPathSegments("/2015-03-31/functions/");
1496 uri.AddPathSegment(request.GetFunctionName());
1497 uri.AddPathSegments("/versions");
1498 return PublishVersionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1499 }
1500
PublishVersionCallable(const PublishVersionRequest & request) const1501 PublishVersionOutcomeCallable LambdaClient::PublishVersionCallable(const PublishVersionRequest& request) const
1502 {
1503 auto task = Aws::MakeShared< std::packaged_task< PublishVersionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PublishVersion(request); } );
1504 auto packagedFunction = [task]() { (*task)(); };
1505 m_executor->Submit(packagedFunction);
1506 return task->get_future();
1507 }
1508
PublishVersionAsync(const PublishVersionRequest & request,const PublishVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1509 void LambdaClient::PublishVersionAsync(const PublishVersionRequest& request, const PublishVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1510 {
1511 m_executor->Submit( [this, request, handler, context](){ this->PublishVersionAsyncHelper( request, handler, context ); } );
1512 }
1513
PublishVersionAsyncHelper(const PublishVersionRequest & request,const PublishVersionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1514 void LambdaClient::PublishVersionAsyncHelper(const PublishVersionRequest& request, const PublishVersionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1515 {
1516 handler(this, request, PublishVersion(request), context);
1517 }
1518
PutFunctionCodeSigningConfig(const PutFunctionCodeSigningConfigRequest & request) const1519 PutFunctionCodeSigningConfigOutcome LambdaClient::PutFunctionCodeSigningConfig(const PutFunctionCodeSigningConfigRequest& request) const
1520 {
1521 if (!request.FunctionNameHasBeenSet())
1522 {
1523 AWS_LOGSTREAM_ERROR("PutFunctionCodeSigningConfig", "Required field: FunctionName, is not set");
1524 return PutFunctionCodeSigningConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1525 }
1526 Aws::Http::URI uri = m_uri;
1527 uri.AddPathSegments("/2020-06-30/functions/");
1528 uri.AddPathSegment(request.GetFunctionName());
1529 uri.AddPathSegments("/code-signing-config");
1530 return PutFunctionCodeSigningConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1531 }
1532
PutFunctionCodeSigningConfigCallable(const PutFunctionCodeSigningConfigRequest & request) const1533 PutFunctionCodeSigningConfigOutcomeCallable LambdaClient::PutFunctionCodeSigningConfigCallable(const PutFunctionCodeSigningConfigRequest& request) const
1534 {
1535 auto task = Aws::MakeShared< std::packaged_task< PutFunctionCodeSigningConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutFunctionCodeSigningConfig(request); } );
1536 auto packagedFunction = [task]() { (*task)(); };
1537 m_executor->Submit(packagedFunction);
1538 return task->get_future();
1539 }
1540
PutFunctionCodeSigningConfigAsync(const PutFunctionCodeSigningConfigRequest & request,const PutFunctionCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1541 void LambdaClient::PutFunctionCodeSigningConfigAsync(const PutFunctionCodeSigningConfigRequest& request, const PutFunctionCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1542 {
1543 m_executor->Submit( [this, request, handler, context](){ this->PutFunctionCodeSigningConfigAsyncHelper( request, handler, context ); } );
1544 }
1545
PutFunctionCodeSigningConfigAsyncHelper(const PutFunctionCodeSigningConfigRequest & request,const PutFunctionCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1546 void LambdaClient::PutFunctionCodeSigningConfigAsyncHelper(const PutFunctionCodeSigningConfigRequest& request, const PutFunctionCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1547 {
1548 handler(this, request, PutFunctionCodeSigningConfig(request), context);
1549 }
1550
PutFunctionConcurrency(const PutFunctionConcurrencyRequest & request) const1551 PutFunctionConcurrencyOutcome LambdaClient::PutFunctionConcurrency(const PutFunctionConcurrencyRequest& request) const
1552 {
1553 if (!request.FunctionNameHasBeenSet())
1554 {
1555 AWS_LOGSTREAM_ERROR("PutFunctionConcurrency", "Required field: FunctionName, is not set");
1556 return PutFunctionConcurrencyOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1557 }
1558 Aws::Http::URI uri = m_uri;
1559 uri.AddPathSegments("/2017-10-31/functions/");
1560 uri.AddPathSegment(request.GetFunctionName());
1561 uri.AddPathSegments("/concurrency");
1562 return PutFunctionConcurrencyOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1563 }
1564
PutFunctionConcurrencyCallable(const PutFunctionConcurrencyRequest & request) const1565 PutFunctionConcurrencyOutcomeCallable LambdaClient::PutFunctionConcurrencyCallable(const PutFunctionConcurrencyRequest& request) const
1566 {
1567 auto task = Aws::MakeShared< std::packaged_task< PutFunctionConcurrencyOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutFunctionConcurrency(request); } );
1568 auto packagedFunction = [task]() { (*task)(); };
1569 m_executor->Submit(packagedFunction);
1570 return task->get_future();
1571 }
1572
PutFunctionConcurrencyAsync(const PutFunctionConcurrencyRequest & request,const PutFunctionConcurrencyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1573 void LambdaClient::PutFunctionConcurrencyAsync(const PutFunctionConcurrencyRequest& request, const PutFunctionConcurrencyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1574 {
1575 m_executor->Submit( [this, request, handler, context](){ this->PutFunctionConcurrencyAsyncHelper( request, handler, context ); } );
1576 }
1577
PutFunctionConcurrencyAsyncHelper(const PutFunctionConcurrencyRequest & request,const PutFunctionConcurrencyResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1578 void LambdaClient::PutFunctionConcurrencyAsyncHelper(const PutFunctionConcurrencyRequest& request, const PutFunctionConcurrencyResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1579 {
1580 handler(this, request, PutFunctionConcurrency(request), context);
1581 }
1582
PutFunctionEventInvokeConfig(const PutFunctionEventInvokeConfigRequest & request) const1583 PutFunctionEventInvokeConfigOutcome LambdaClient::PutFunctionEventInvokeConfig(const PutFunctionEventInvokeConfigRequest& request) const
1584 {
1585 if (!request.FunctionNameHasBeenSet())
1586 {
1587 AWS_LOGSTREAM_ERROR("PutFunctionEventInvokeConfig", "Required field: FunctionName, is not set");
1588 return PutFunctionEventInvokeConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1589 }
1590 Aws::Http::URI uri = m_uri;
1591 uri.AddPathSegments("/2019-09-25/functions/");
1592 uri.AddPathSegment(request.GetFunctionName());
1593 uri.AddPathSegments("/event-invoke-config");
1594 return PutFunctionEventInvokeConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1595 }
1596
PutFunctionEventInvokeConfigCallable(const PutFunctionEventInvokeConfigRequest & request) const1597 PutFunctionEventInvokeConfigOutcomeCallable LambdaClient::PutFunctionEventInvokeConfigCallable(const PutFunctionEventInvokeConfigRequest& request) const
1598 {
1599 auto task = Aws::MakeShared< std::packaged_task< PutFunctionEventInvokeConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutFunctionEventInvokeConfig(request); } );
1600 auto packagedFunction = [task]() { (*task)(); };
1601 m_executor->Submit(packagedFunction);
1602 return task->get_future();
1603 }
1604
PutFunctionEventInvokeConfigAsync(const PutFunctionEventInvokeConfigRequest & request,const PutFunctionEventInvokeConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1605 void LambdaClient::PutFunctionEventInvokeConfigAsync(const PutFunctionEventInvokeConfigRequest& request, const PutFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1606 {
1607 m_executor->Submit( [this, request, handler, context](){ this->PutFunctionEventInvokeConfigAsyncHelper( request, handler, context ); } );
1608 }
1609
PutFunctionEventInvokeConfigAsyncHelper(const PutFunctionEventInvokeConfigRequest & request,const PutFunctionEventInvokeConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1610 void LambdaClient::PutFunctionEventInvokeConfigAsyncHelper(const PutFunctionEventInvokeConfigRequest& request, const PutFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1611 {
1612 handler(this, request, PutFunctionEventInvokeConfig(request), context);
1613 }
1614
PutProvisionedConcurrencyConfig(const PutProvisionedConcurrencyConfigRequest & request) const1615 PutProvisionedConcurrencyConfigOutcome LambdaClient::PutProvisionedConcurrencyConfig(const PutProvisionedConcurrencyConfigRequest& request) const
1616 {
1617 if (!request.FunctionNameHasBeenSet())
1618 {
1619 AWS_LOGSTREAM_ERROR("PutProvisionedConcurrencyConfig", "Required field: FunctionName, is not set");
1620 return PutProvisionedConcurrencyConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1621 }
1622 if (!request.QualifierHasBeenSet())
1623 {
1624 AWS_LOGSTREAM_ERROR("PutProvisionedConcurrencyConfig", "Required field: Qualifier, is not set");
1625 return PutProvisionedConcurrencyConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Qualifier]", false));
1626 }
1627 Aws::Http::URI uri = m_uri;
1628 uri.AddPathSegments("/2019-09-30/functions/");
1629 uri.AddPathSegment(request.GetFunctionName());
1630 uri.AddPathSegments("/provisioned-concurrency");
1631 return PutProvisionedConcurrencyConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1632 }
1633
PutProvisionedConcurrencyConfigCallable(const PutProvisionedConcurrencyConfigRequest & request) const1634 PutProvisionedConcurrencyConfigOutcomeCallable LambdaClient::PutProvisionedConcurrencyConfigCallable(const PutProvisionedConcurrencyConfigRequest& request) const
1635 {
1636 auto task = Aws::MakeShared< std::packaged_task< PutProvisionedConcurrencyConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->PutProvisionedConcurrencyConfig(request); } );
1637 auto packagedFunction = [task]() { (*task)(); };
1638 m_executor->Submit(packagedFunction);
1639 return task->get_future();
1640 }
1641
PutProvisionedConcurrencyConfigAsync(const PutProvisionedConcurrencyConfigRequest & request,const PutProvisionedConcurrencyConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1642 void LambdaClient::PutProvisionedConcurrencyConfigAsync(const PutProvisionedConcurrencyConfigRequest& request, const PutProvisionedConcurrencyConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1643 {
1644 m_executor->Submit( [this, request, handler, context](){ this->PutProvisionedConcurrencyConfigAsyncHelper( request, handler, context ); } );
1645 }
1646
PutProvisionedConcurrencyConfigAsyncHelper(const PutProvisionedConcurrencyConfigRequest & request,const PutProvisionedConcurrencyConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1647 void LambdaClient::PutProvisionedConcurrencyConfigAsyncHelper(const PutProvisionedConcurrencyConfigRequest& request, const PutProvisionedConcurrencyConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1648 {
1649 handler(this, request, PutProvisionedConcurrencyConfig(request), context);
1650 }
1651
RemoveLayerVersionPermission(const RemoveLayerVersionPermissionRequest & request) const1652 RemoveLayerVersionPermissionOutcome LambdaClient::RemoveLayerVersionPermission(const RemoveLayerVersionPermissionRequest& request) const
1653 {
1654 if (!request.LayerNameHasBeenSet())
1655 {
1656 AWS_LOGSTREAM_ERROR("RemoveLayerVersionPermission", "Required field: LayerName, is not set");
1657 return RemoveLayerVersionPermissionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [LayerName]", false));
1658 }
1659 if (!request.VersionNumberHasBeenSet())
1660 {
1661 AWS_LOGSTREAM_ERROR("RemoveLayerVersionPermission", "Required field: VersionNumber, is not set");
1662 return RemoveLayerVersionPermissionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [VersionNumber]", false));
1663 }
1664 if (!request.StatementIdHasBeenSet())
1665 {
1666 AWS_LOGSTREAM_ERROR("RemoveLayerVersionPermission", "Required field: StatementId, is not set");
1667 return RemoveLayerVersionPermissionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [StatementId]", false));
1668 }
1669 Aws::Http::URI uri = m_uri;
1670 uri.AddPathSegments("/2018-10-31/layers/");
1671 uri.AddPathSegment(request.GetLayerName());
1672 uri.AddPathSegments("/versions/");
1673 uri.AddPathSegment(request.GetVersionNumber());
1674 uri.AddPathSegments("/policy/");
1675 uri.AddPathSegment(request.GetStatementId());
1676 return RemoveLayerVersionPermissionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1677 }
1678
RemoveLayerVersionPermissionCallable(const RemoveLayerVersionPermissionRequest & request) const1679 RemoveLayerVersionPermissionOutcomeCallable LambdaClient::RemoveLayerVersionPermissionCallable(const RemoveLayerVersionPermissionRequest& request) const
1680 {
1681 auto task = Aws::MakeShared< std::packaged_task< RemoveLayerVersionPermissionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RemoveLayerVersionPermission(request); } );
1682 auto packagedFunction = [task]() { (*task)(); };
1683 m_executor->Submit(packagedFunction);
1684 return task->get_future();
1685 }
1686
RemoveLayerVersionPermissionAsync(const RemoveLayerVersionPermissionRequest & request,const RemoveLayerVersionPermissionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1687 void LambdaClient::RemoveLayerVersionPermissionAsync(const RemoveLayerVersionPermissionRequest& request, const RemoveLayerVersionPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1688 {
1689 m_executor->Submit( [this, request, handler, context](){ this->RemoveLayerVersionPermissionAsyncHelper( request, handler, context ); } );
1690 }
1691
RemoveLayerVersionPermissionAsyncHelper(const RemoveLayerVersionPermissionRequest & request,const RemoveLayerVersionPermissionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1692 void LambdaClient::RemoveLayerVersionPermissionAsyncHelper(const RemoveLayerVersionPermissionRequest& request, const RemoveLayerVersionPermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1693 {
1694 handler(this, request, RemoveLayerVersionPermission(request), context);
1695 }
1696
RemovePermission(const RemovePermissionRequest & request) const1697 RemovePermissionOutcome LambdaClient::RemovePermission(const RemovePermissionRequest& request) const
1698 {
1699 if (!request.FunctionNameHasBeenSet())
1700 {
1701 AWS_LOGSTREAM_ERROR("RemovePermission", "Required field: FunctionName, is not set");
1702 return RemovePermissionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1703 }
1704 if (!request.StatementIdHasBeenSet())
1705 {
1706 AWS_LOGSTREAM_ERROR("RemovePermission", "Required field: StatementId, is not set");
1707 return RemovePermissionOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [StatementId]", false));
1708 }
1709 Aws::Http::URI uri = m_uri;
1710 uri.AddPathSegments("/2015-03-31/functions/");
1711 uri.AddPathSegment(request.GetFunctionName());
1712 uri.AddPathSegments("/policy/");
1713 uri.AddPathSegment(request.GetStatementId());
1714 return RemovePermissionOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1715 }
1716
RemovePermissionCallable(const RemovePermissionRequest & request) const1717 RemovePermissionOutcomeCallable LambdaClient::RemovePermissionCallable(const RemovePermissionRequest& request) const
1718 {
1719 auto task = Aws::MakeShared< std::packaged_task< RemovePermissionOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->RemovePermission(request); } );
1720 auto packagedFunction = [task]() { (*task)(); };
1721 m_executor->Submit(packagedFunction);
1722 return task->get_future();
1723 }
1724
RemovePermissionAsync(const RemovePermissionRequest & request,const RemovePermissionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1725 void LambdaClient::RemovePermissionAsync(const RemovePermissionRequest& request, const RemovePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1726 {
1727 m_executor->Submit( [this, request, handler, context](){ this->RemovePermissionAsyncHelper( request, handler, context ); } );
1728 }
1729
RemovePermissionAsyncHelper(const RemovePermissionRequest & request,const RemovePermissionResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1730 void LambdaClient::RemovePermissionAsyncHelper(const RemovePermissionRequest& request, const RemovePermissionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1731 {
1732 handler(this, request, RemovePermission(request), context);
1733 }
1734
TagResource(const TagResourceRequest & request) const1735 TagResourceOutcome LambdaClient::TagResource(const TagResourceRequest& request) const
1736 {
1737 if (!request.ResourceHasBeenSet())
1738 {
1739 AWS_LOGSTREAM_ERROR("TagResource", "Required field: Resource, is not set");
1740 return TagResourceOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Resource]", false));
1741 }
1742 Aws::Http::URI uri = m_uri;
1743 uri.AddPathSegments("/2017-03-31/tags/");
1744 uri.AddPathSegment(request.GetResource());
1745 return TagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1746 }
1747
TagResourceCallable(const TagResourceRequest & request) const1748 TagResourceOutcomeCallable LambdaClient::TagResourceCallable(const TagResourceRequest& request) const
1749 {
1750 auto task = Aws::MakeShared< std::packaged_task< TagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->TagResource(request); } );
1751 auto packagedFunction = [task]() { (*task)(); };
1752 m_executor->Submit(packagedFunction);
1753 return task->get_future();
1754 }
1755
TagResourceAsync(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1756 void LambdaClient::TagResourceAsync(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1757 {
1758 m_executor->Submit( [this, request, handler, context](){ this->TagResourceAsyncHelper( request, handler, context ); } );
1759 }
1760
TagResourceAsyncHelper(const TagResourceRequest & request,const TagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1761 void LambdaClient::TagResourceAsyncHelper(const TagResourceRequest& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1762 {
1763 handler(this, request, TagResource(request), context);
1764 }
1765
UntagResource(const UntagResourceRequest & request) const1766 UntagResourceOutcome LambdaClient::UntagResource(const UntagResourceRequest& request) const
1767 {
1768 if (!request.ResourceHasBeenSet())
1769 {
1770 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: Resource, is not set");
1771 return UntagResourceOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Resource]", false));
1772 }
1773 if (!request.TagKeysHasBeenSet())
1774 {
1775 AWS_LOGSTREAM_ERROR("UntagResource", "Required field: TagKeys, is not set");
1776 return UntagResourceOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [TagKeys]", false));
1777 }
1778 Aws::Http::URI uri = m_uri;
1779 uri.AddPathSegments("/2017-03-31/tags/");
1780 uri.AddPathSegment(request.GetResource());
1781 return UntagResourceOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_DELETE, Aws::Auth::SIGV4_SIGNER));
1782 }
1783
UntagResourceCallable(const UntagResourceRequest & request) const1784 UntagResourceOutcomeCallable LambdaClient::UntagResourceCallable(const UntagResourceRequest& request) const
1785 {
1786 auto task = Aws::MakeShared< std::packaged_task< UntagResourceOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UntagResource(request); } );
1787 auto packagedFunction = [task]() { (*task)(); };
1788 m_executor->Submit(packagedFunction);
1789 return task->get_future();
1790 }
1791
UntagResourceAsync(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1792 void LambdaClient::UntagResourceAsync(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1793 {
1794 m_executor->Submit( [this, request, handler, context](){ this->UntagResourceAsyncHelper( request, handler, context ); } );
1795 }
1796
UntagResourceAsyncHelper(const UntagResourceRequest & request,const UntagResourceResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1797 void LambdaClient::UntagResourceAsyncHelper(const UntagResourceRequest& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1798 {
1799 handler(this, request, UntagResource(request), context);
1800 }
1801
UpdateAlias(const UpdateAliasRequest & request) const1802 UpdateAliasOutcome LambdaClient::UpdateAlias(const UpdateAliasRequest& request) const
1803 {
1804 if (!request.FunctionNameHasBeenSet())
1805 {
1806 AWS_LOGSTREAM_ERROR("UpdateAlias", "Required field: FunctionName, is not set");
1807 return UpdateAliasOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1808 }
1809 if (!request.NameHasBeenSet())
1810 {
1811 AWS_LOGSTREAM_ERROR("UpdateAlias", "Required field: Name, is not set");
1812 return UpdateAliasOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [Name]", false));
1813 }
1814 Aws::Http::URI uri = m_uri;
1815 uri.AddPathSegments("/2015-03-31/functions/");
1816 uri.AddPathSegment(request.GetFunctionName());
1817 uri.AddPathSegments("/aliases/");
1818 uri.AddPathSegment(request.GetName());
1819 return UpdateAliasOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1820 }
1821
UpdateAliasCallable(const UpdateAliasRequest & request) const1822 UpdateAliasOutcomeCallable LambdaClient::UpdateAliasCallable(const UpdateAliasRequest& request) const
1823 {
1824 auto task = Aws::MakeShared< std::packaged_task< UpdateAliasOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateAlias(request); } );
1825 auto packagedFunction = [task]() { (*task)(); };
1826 m_executor->Submit(packagedFunction);
1827 return task->get_future();
1828 }
1829
UpdateAliasAsync(const UpdateAliasRequest & request,const UpdateAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1830 void LambdaClient::UpdateAliasAsync(const UpdateAliasRequest& request, const UpdateAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1831 {
1832 m_executor->Submit( [this, request, handler, context](){ this->UpdateAliasAsyncHelper( request, handler, context ); } );
1833 }
1834
UpdateAliasAsyncHelper(const UpdateAliasRequest & request,const UpdateAliasResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1835 void LambdaClient::UpdateAliasAsyncHelper(const UpdateAliasRequest& request, const UpdateAliasResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1836 {
1837 handler(this, request, UpdateAlias(request), context);
1838 }
1839
UpdateCodeSigningConfig(const UpdateCodeSigningConfigRequest & request) const1840 UpdateCodeSigningConfigOutcome LambdaClient::UpdateCodeSigningConfig(const UpdateCodeSigningConfigRequest& request) const
1841 {
1842 if (!request.CodeSigningConfigArnHasBeenSet())
1843 {
1844 AWS_LOGSTREAM_ERROR("UpdateCodeSigningConfig", "Required field: CodeSigningConfigArn, is not set");
1845 return UpdateCodeSigningConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [CodeSigningConfigArn]", false));
1846 }
1847 Aws::Http::URI uri = m_uri;
1848 uri.AddPathSegments("/2020-04-22/code-signing-configs/");
1849 uri.AddPathSegment(request.GetCodeSigningConfigArn());
1850 return UpdateCodeSigningConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1851 }
1852
UpdateCodeSigningConfigCallable(const UpdateCodeSigningConfigRequest & request) const1853 UpdateCodeSigningConfigOutcomeCallable LambdaClient::UpdateCodeSigningConfigCallable(const UpdateCodeSigningConfigRequest& request) const
1854 {
1855 auto task = Aws::MakeShared< std::packaged_task< UpdateCodeSigningConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateCodeSigningConfig(request); } );
1856 auto packagedFunction = [task]() { (*task)(); };
1857 m_executor->Submit(packagedFunction);
1858 return task->get_future();
1859 }
1860
UpdateCodeSigningConfigAsync(const UpdateCodeSigningConfigRequest & request,const UpdateCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1861 void LambdaClient::UpdateCodeSigningConfigAsync(const UpdateCodeSigningConfigRequest& request, const UpdateCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1862 {
1863 m_executor->Submit( [this, request, handler, context](){ this->UpdateCodeSigningConfigAsyncHelper( request, handler, context ); } );
1864 }
1865
UpdateCodeSigningConfigAsyncHelper(const UpdateCodeSigningConfigRequest & request,const UpdateCodeSigningConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1866 void LambdaClient::UpdateCodeSigningConfigAsyncHelper(const UpdateCodeSigningConfigRequest& request, const UpdateCodeSigningConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1867 {
1868 handler(this, request, UpdateCodeSigningConfig(request), context);
1869 }
1870
UpdateEventSourceMapping(const UpdateEventSourceMappingRequest & request) const1871 UpdateEventSourceMappingOutcome LambdaClient::UpdateEventSourceMapping(const UpdateEventSourceMappingRequest& request) const
1872 {
1873 if (!request.UUIDHasBeenSet())
1874 {
1875 AWS_LOGSTREAM_ERROR("UpdateEventSourceMapping", "Required field: UUID, is not set");
1876 return UpdateEventSourceMappingOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [UUID]", false));
1877 }
1878 Aws::Http::URI uri = m_uri;
1879 uri.AddPathSegments("/2015-03-31/event-source-mappings/");
1880 uri.AddPathSegment(request.GetUUID());
1881 return UpdateEventSourceMappingOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1882 }
1883
UpdateEventSourceMappingCallable(const UpdateEventSourceMappingRequest & request) const1884 UpdateEventSourceMappingOutcomeCallable LambdaClient::UpdateEventSourceMappingCallable(const UpdateEventSourceMappingRequest& request) const
1885 {
1886 auto task = Aws::MakeShared< std::packaged_task< UpdateEventSourceMappingOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateEventSourceMapping(request); } );
1887 auto packagedFunction = [task]() { (*task)(); };
1888 m_executor->Submit(packagedFunction);
1889 return task->get_future();
1890 }
1891
UpdateEventSourceMappingAsync(const UpdateEventSourceMappingRequest & request,const UpdateEventSourceMappingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1892 void LambdaClient::UpdateEventSourceMappingAsync(const UpdateEventSourceMappingRequest& request, const UpdateEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1893 {
1894 m_executor->Submit( [this, request, handler, context](){ this->UpdateEventSourceMappingAsyncHelper( request, handler, context ); } );
1895 }
1896
UpdateEventSourceMappingAsyncHelper(const UpdateEventSourceMappingRequest & request,const UpdateEventSourceMappingResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1897 void LambdaClient::UpdateEventSourceMappingAsyncHelper(const UpdateEventSourceMappingRequest& request, const UpdateEventSourceMappingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1898 {
1899 handler(this, request, UpdateEventSourceMapping(request), context);
1900 }
1901
UpdateFunctionCode(const UpdateFunctionCodeRequest & request) const1902 UpdateFunctionCodeOutcome LambdaClient::UpdateFunctionCode(const UpdateFunctionCodeRequest& request) const
1903 {
1904 if (!request.FunctionNameHasBeenSet())
1905 {
1906 AWS_LOGSTREAM_ERROR("UpdateFunctionCode", "Required field: FunctionName, is not set");
1907 return UpdateFunctionCodeOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1908 }
1909 Aws::Http::URI uri = m_uri;
1910 uri.AddPathSegments("/2015-03-31/functions/");
1911 uri.AddPathSegment(request.GetFunctionName());
1912 uri.AddPathSegments("/code");
1913 return UpdateFunctionCodeOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1914 }
1915
UpdateFunctionCodeCallable(const UpdateFunctionCodeRequest & request) const1916 UpdateFunctionCodeOutcomeCallable LambdaClient::UpdateFunctionCodeCallable(const UpdateFunctionCodeRequest& request) const
1917 {
1918 auto task = Aws::MakeShared< std::packaged_task< UpdateFunctionCodeOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateFunctionCode(request); } );
1919 auto packagedFunction = [task]() { (*task)(); };
1920 m_executor->Submit(packagedFunction);
1921 return task->get_future();
1922 }
1923
UpdateFunctionCodeAsync(const UpdateFunctionCodeRequest & request,const UpdateFunctionCodeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1924 void LambdaClient::UpdateFunctionCodeAsync(const UpdateFunctionCodeRequest& request, const UpdateFunctionCodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1925 {
1926 m_executor->Submit( [this, request, handler, context](){ this->UpdateFunctionCodeAsyncHelper( request, handler, context ); } );
1927 }
1928
UpdateFunctionCodeAsyncHelper(const UpdateFunctionCodeRequest & request,const UpdateFunctionCodeResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1929 void LambdaClient::UpdateFunctionCodeAsyncHelper(const UpdateFunctionCodeRequest& request, const UpdateFunctionCodeResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1930 {
1931 handler(this, request, UpdateFunctionCode(request), context);
1932 }
1933
UpdateFunctionConfiguration(const UpdateFunctionConfigurationRequest & request) const1934 UpdateFunctionConfigurationOutcome LambdaClient::UpdateFunctionConfiguration(const UpdateFunctionConfigurationRequest& request) const
1935 {
1936 if (!request.FunctionNameHasBeenSet())
1937 {
1938 AWS_LOGSTREAM_ERROR("UpdateFunctionConfiguration", "Required field: FunctionName, is not set");
1939 return UpdateFunctionConfigurationOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1940 }
1941 Aws::Http::URI uri = m_uri;
1942 uri.AddPathSegments("/2015-03-31/functions/");
1943 uri.AddPathSegment(request.GetFunctionName());
1944 uri.AddPathSegments("/configuration");
1945 return UpdateFunctionConfigurationOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_PUT, Aws::Auth::SIGV4_SIGNER));
1946 }
1947
UpdateFunctionConfigurationCallable(const UpdateFunctionConfigurationRequest & request) const1948 UpdateFunctionConfigurationOutcomeCallable LambdaClient::UpdateFunctionConfigurationCallable(const UpdateFunctionConfigurationRequest& request) const
1949 {
1950 auto task = Aws::MakeShared< std::packaged_task< UpdateFunctionConfigurationOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateFunctionConfiguration(request); } );
1951 auto packagedFunction = [task]() { (*task)(); };
1952 m_executor->Submit(packagedFunction);
1953 return task->get_future();
1954 }
1955
UpdateFunctionConfigurationAsync(const UpdateFunctionConfigurationRequest & request,const UpdateFunctionConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1956 void LambdaClient::UpdateFunctionConfigurationAsync(const UpdateFunctionConfigurationRequest& request, const UpdateFunctionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1957 {
1958 m_executor->Submit( [this, request, handler, context](){ this->UpdateFunctionConfigurationAsyncHelper( request, handler, context ); } );
1959 }
1960
UpdateFunctionConfigurationAsyncHelper(const UpdateFunctionConfigurationRequest & request,const UpdateFunctionConfigurationResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1961 void LambdaClient::UpdateFunctionConfigurationAsyncHelper(const UpdateFunctionConfigurationRequest& request, const UpdateFunctionConfigurationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1962 {
1963 handler(this, request, UpdateFunctionConfiguration(request), context);
1964 }
1965
UpdateFunctionEventInvokeConfig(const UpdateFunctionEventInvokeConfigRequest & request) const1966 UpdateFunctionEventInvokeConfigOutcome LambdaClient::UpdateFunctionEventInvokeConfig(const UpdateFunctionEventInvokeConfigRequest& request) const
1967 {
1968 if (!request.FunctionNameHasBeenSet())
1969 {
1970 AWS_LOGSTREAM_ERROR("UpdateFunctionEventInvokeConfig", "Required field: FunctionName, is not set");
1971 return UpdateFunctionEventInvokeConfigOutcome(Aws::Client::AWSError<LambdaErrors>(LambdaErrors::MISSING_PARAMETER, "MISSING_PARAMETER", "Missing required field [FunctionName]", false));
1972 }
1973 Aws::Http::URI uri = m_uri;
1974 uri.AddPathSegments("/2019-09-25/functions/");
1975 uri.AddPathSegment(request.GetFunctionName());
1976 uri.AddPathSegments("/event-invoke-config");
1977 return UpdateFunctionEventInvokeConfigOutcome(MakeRequest(uri, request, Aws::Http::HttpMethod::HTTP_POST, Aws::Auth::SIGV4_SIGNER));
1978 }
1979
UpdateFunctionEventInvokeConfigCallable(const UpdateFunctionEventInvokeConfigRequest & request) const1980 UpdateFunctionEventInvokeConfigOutcomeCallable LambdaClient::UpdateFunctionEventInvokeConfigCallable(const UpdateFunctionEventInvokeConfigRequest& request) const
1981 {
1982 auto task = Aws::MakeShared< std::packaged_task< UpdateFunctionEventInvokeConfigOutcome() > >(ALLOCATION_TAG, [this, request](){ return this->UpdateFunctionEventInvokeConfig(request); } );
1983 auto packagedFunction = [task]() { (*task)(); };
1984 m_executor->Submit(packagedFunction);
1985 return task->get_future();
1986 }
1987
UpdateFunctionEventInvokeConfigAsync(const UpdateFunctionEventInvokeConfigRequest & request,const UpdateFunctionEventInvokeConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1988 void LambdaClient::UpdateFunctionEventInvokeConfigAsync(const UpdateFunctionEventInvokeConfigRequest& request, const UpdateFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1989 {
1990 m_executor->Submit( [this, request, handler, context](){ this->UpdateFunctionEventInvokeConfigAsyncHelper( request, handler, context ); } );
1991 }
1992
UpdateFunctionEventInvokeConfigAsyncHelper(const UpdateFunctionEventInvokeConfigRequest & request,const UpdateFunctionEventInvokeConfigResponseReceivedHandler & handler,const std::shared_ptr<const Aws::Client::AsyncCallerContext> & context) const1993 void LambdaClient::UpdateFunctionEventInvokeConfigAsyncHelper(const UpdateFunctionEventInvokeConfigRequest& request, const UpdateFunctionEventInvokeConfigResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const
1994 {
1995 handler(this, request, UpdateFunctionEventInvokeConfig(request), context);
1996 }
1997
1998