From e65bca3b5d5be2f1646bde4feca1388429588a19 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Mon, 16 Mar 2026 14:29:18 -0400 Subject: [PATCH 01/21] Updated waiter template to accept a templated PathMatcher per acceptor rather than per waiter --- .../include/aws/core/utils/Waiter.h | 29 ++++++++++--------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h index ed09c5ddb68..db6a6d78e84 100644 --- a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h +++ b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h @@ -27,10 +27,15 @@ using WaiterError = Aws::Client::AWSError; template using WaiterOutcome = Outcome; +template struct Acceptor { WaiterState state; MatcherType matcher; ExpectedValue expected; + std::function pathMatcher; + + Acceptor(WaiterState s, MatcherType m, ExpectedValue e, std::function pm = [](const OutcomeT&, const ExpectedValue&) { return false; }) + : state(s), matcher(m), expected(std::move(e)), pathMatcher(std::move(pm)) {} }; template @@ -38,47 +43,46 @@ using PathMatcher = std::function; template class Waiter { - bool Matches(const Acceptor& acceptor, const OutcomeT& outcome) { + bool Matches(const Acceptor& acceptor, const OutcomeT& outcome) { switch (acceptor.matcher) { case MatcherType::STATUS: { int status = GetStatusCode(outcome); - return status == acceptor.expected.get(); + return status == acceptor.expected.template get(); } case MatcherType::ERROR: { - if (acceptor.expected.holds_alternative()) { - bool expectError = acceptor.expected.get(); + if (acceptor.expected.template holds_alternative()) { + bool expectError = acceptor.expected.template get(); return outcome.IsSuccess() != expectError; } if (!outcome.IsSuccess()) { auto errorCode = outcome.GetError().GetExceptionName(); - return errorCode == acceptor.expected.get(); + return errorCode == acceptor.expected.template get(); } return false; } case MatcherType::PATH: case MatcherType::PATH_ALL: case MatcherType::PATH_ANY: - return m_pathMatcher(outcome, acceptor.expected); + return acceptor.pathMatcher ? acceptor.pathMatcher(outcome, acceptor.expected) : false; } return false; } public: - Waiter(int delay, int maxAttempts, std::vector acceptors, std::function op, - const Aws::String& waiterName = "Waiter", PathMatcher pathMatcher = [](const OutcomeT&, const ExpectedValue&) { return false; }) + Waiter(int delay, int maxAttempts, std::vector> acceptors, std::function op, + const Aws::String& waiterName = "Waiter") : m_delay(delay), m_maxAttempts(maxAttempts), m_acceptors(std::move(acceptors)), m_operation(std::move(op)), - m_name(waiterName), - m_pathMatcher(std::move(pathMatcher)) {} + m_name(waiterName) {} WaiterOutcome Wait(const RequestT& request) { for (int attempt = 0; attempt < m_maxAttempts; ++attempt) { auto outcome = m_operation(request); auto matched = std::find_if(m_acceptors.begin(), m_acceptors.end(), - [this, &outcome](const Acceptor& acceptor) -> bool { return Matches(acceptor, outcome); }); + [this, &outcome](const Acceptor& acceptor) -> bool { return Matches(acceptor, outcome); }); if (matched != m_acceptors.end()) { return WaiterOutcome(outcome); } @@ -94,10 +98,9 @@ class Waiter { private: int m_delay; int m_maxAttempts; - std::vector m_acceptors; + std::vector> m_acceptors; std::function m_operation; Aws::String m_name; - PathMatcher m_pathMatcher; /** * Returns the HTTP status code from the result or error. * Result objects use GetHttpResponseCode(), errors use GetResponseCode(). From f055c62c6b0fa4a0f1d7a773191c55c0554b737d Mon Sep 17 00:00:00 2001 From: sbaluja Date: Mon, 16 Mar 2026 14:30:03 -0400 Subject: [PATCH 02/21] Waiter codegen project --- .../smithy/cpp-codegen/build.gradle.kts | 22 +- .../smithy-cpp-codegen/build.gradle.kts | 7 + .../generators/FeatureParser.java | 2 +- .../generators/OperationData.java | 3 +- .../generators/ServiceNameUtil.java | 6 +- .../generators/ShapeUtil.java | 7 +- .../pagination/PaginationCodegenPlugin.java | 2 +- .../waiters/WaiterCodegenPlugin.java | 56 +++++ .../waiters/WaiterHeaderGenerator.java | 194 +++++++++++++++++ .../WaiterJmesPathCppCodeGenerator.java | 56 +++++ .../waiters/WaiterOperationData.java | 39 ++++ .../CollectionElementTypeResolver.java | 122 +++++++++++ .../jmespath/CollectionGetterEmitter.java | 35 +++ .../waiters/jmespath/ComparatorEmitter.java | 55 +++++ .../jmespath/ContainsProjectionInfo.java | 20 ++ .../generators/waiters/jmespath/EnumInfo.java | 18 ++ .../waiters/jmespath/EnumResolver.java | 101 +++++++++ .../jmespath/FilterOperandEmitter.java | 75 +++++++ .../jmespath/FilterPredicateEmitter.java | 62 ++++++ .../waiters/jmespath/GetterChainEmitter.java | 25 +++ .../jmespath/NestedProjectionInfo.java | 20 ++ .../waiters/jmespath/ProjectionCounter.java | 32 +++ .../waiters/jmespath/ProjectionEmitter.java | 204 ++++++++++++++++++ .../jmespath/ProjectionRightEmitter.java | 90 ++++++++ .../waiters/jmespath/ScalarEmitter.java | 78 +++++++ .../waiters/jmespath/TopLevelVisitor.java | 199 +++++++++++++++++ .../UnsupportedExpressionVisitor.java | 54 +++++ ...ware.amazon.smithy.build.SmithyBuildPlugin | 1 + 28 files changed, 1574 insertions(+), 11 deletions(-) create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterJmesPathCppCodeGenerator.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterOperationData.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionGetterEmitter.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ComparatorEmitter.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ContainsProjectionInfo.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumInfo.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterPredicateEmitter.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/GetterChainEmitter.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/NestedProjectionInfo.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionCounter.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionEmitter.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionRightEmitter.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ScalarEmitter.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/TopLevelVisitor.java create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/UnsupportedExpressionVisitor.java diff --git a/tools/code-generation/smithy/cpp-codegen/build.gradle.kts b/tools/code-generation/smithy/cpp-codegen/build.gradle.kts index 11a2caa8737..9029135e878 100644 --- a/tools/code-generation/smithy/cpp-codegen/build.gradle.kts +++ b/tools/code-generation/smithy/cpp-codegen/build.gradle.kts @@ -42,7 +42,7 @@ tasks.register("generate-smithy-build") { val models = project.file("../api-descriptions") val filteredServices: String = project.findProperty("servicesFilter")?.toString() ?: "" val filteredServiceList = filteredServices.split(",").map { it.trim() }.filter { it.isNotEmpty() } - val c2jMapStr: String = project.findProperty("c2jMap")?.toString() ?: "" + val c2jMapStr: String = project.findProperty("c2jMap")?.toString() ?: "{}" val namespaceMappings: String = project.findProperty("namespaceMappings")?.toString() ?: "" fileTree(models).filter { it.isFile }.files.forEach eachFile@{ file -> @@ -61,7 +61,11 @@ tasks.register("generate-smithy-build") { val projectionContents = Node.objectNodeBuilder() .withMember("imports", Node.fromStrings("${models.absolutePath}${File.separator}${file.name}")) .withMember("plugins", Node.objectNode() - .withMember("smithy-cpp-codegen", Node.objectNodeBuilder() + .withMember("smithy-cpp-codegen-paginators", Node.objectNodeBuilder() + .withMember("c2jMap", Node.from(c2jMapStr)) + .withMember("namespaceMappings", Node.from(namespaceMappings)) + .build()) + .withMember("smithy-cpp-codegen-waiters", Node.objectNodeBuilder() .withMember("c2jMap", Node.from(c2jMapStr)) .withMember("namespaceMappings", Node.from(namespaceMappings)) .build())) @@ -76,10 +80,14 @@ tasks.register("generate-smithy-build") { if (filteredServiceList.isEmpty() || c2jName in filteredServiceList) { val mockProjectionContents = Node.objectNodeBuilder() .withMember("plugins", Node.objectNode() - .withMember("smithy-cpp-codegen", Node.objectNodeBuilder() + .withMember("smithy-cpp-codegen-paginators", Node.objectNodeBuilder() .withMember("c2jMap", Node.from(c2jMapStr)) .withMember("namespaceMappings", Node.from(namespaceMappings)) - .build())) + .build()) + .withMember("smithy-cpp-codegen-waiters", Node.objectNodeBuilder() + .withMember("c2jMap", Node.from(c2jMapStr)) + .withMember("namespaceMappings", Node.from(namespaceMappings)) + .build())) .build() projectionsBuilder.withMember("$c2jName.mock", mockProjectionContents) } @@ -91,7 +99,11 @@ tasks.register("generate-smithy-build") { val s3CrtProjectionContents = Node.objectNodeBuilder() .withMember("imports", Node.fromStrings(s3ModelFile.absolutePath)) .withMember("plugins", Node.objectNode() - .withMember("smithy-cpp-codegen", Node.objectNodeBuilder() + .withMember("smithy-cpp-codegen-paginators", Node.objectNodeBuilder() + .withMember("c2jMap", Node.from(c2jMapStr)) + .withMember("namespaceMappings", Node.from(namespaceMappings)) + .build()) + .withMember("smithy-cpp-codegen-waiters", Node.objectNodeBuilder() .withMember("c2jMap", Node.from(c2jMapStr)) .withMember("namespaceMappings", Node.from(namespaceMappings)) .build())) diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/build.gradle.kts b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/build.gradle.kts index 6bc34e7b243..32f1be1e877 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/build.gradle.kts +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/build.gradle.kts @@ -12,7 +12,14 @@ dependencies { implementation("software.amazon.smithy:smithy-codegen-core:1.67.0") implementation("software.amazon.smithy:smithy-aws-traits:1.67.0") implementation("software.amazon.smithy:smithy-waiters:1.67.0") + implementation("software.amazon.smithy:smithy-jmespath:1.67.0") implementation("software.amazon.smithy:smithy-rules-engine:1.67.0") implementation("software.amazon.smithy:smithy-aws-endpoints:1.67.0") implementation("software.amazon.smithy:smithy-aws-iam-traits:1.67.0") + testImplementation("org.junit.jupiter:junit-jupiter:5.10.2") + testRuntimeOnly("org.junit.platform:junit-platform-launcher:1.10.2") +} + +tasks.test { + useJUnitPlatform() } diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/FeatureParser.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/FeatureParser.java index 1fe61b5caf5..ac6e8f3a1b1 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/FeatureParser.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/FeatureParser.java @@ -7,7 +7,7 @@ import software.amazon.smithy.build.PluginContext; import software.amazon.smithy.model.node.Node; import software.amazon.smithy.model.node.ObjectNode; -import software.amazon.smithy.model.shapes.*; +import software.amazon.smithy.model.shapes.ServiceShape; import software.amazon.smithy.aws.traits.ServiceTrait; import java.util.*; diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/OperationData.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/OperationData.java index 7d4c3bec889..146c9537172 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/OperationData.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/OperationData.java @@ -4,7 +4,8 @@ */ package com.amazonaws.util.awsclientsmithygenerator.generators; -import software.amazon.smithy.model.shapes.*; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ServiceShape; import software.amazon.smithy.model.traits.Trait; public class OperationData { diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/ServiceNameUtil.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/ServiceNameUtil.java index b79d3efefd1..1fb8858589b 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/ServiceNameUtil.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/ServiceNameUtil.java @@ -4,11 +4,13 @@ */ package com.amazonaws.util.awsclientsmithygenerator.generators; +import software.amazon.smithy.model.Model; import software.amazon.smithy.model.shapes.ServiceShape; import software.amazon.smithy.aws.traits.ServiceTrait; -import software.amazon.smithy.model.traits.TitleTrait; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.transform.ModelTransformer; + import java.util.Map; -import java.util.Set; public final class ServiceNameUtil { diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/ShapeUtil.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/ShapeUtil.java index 1cdfd4c3cd2..f15c16da5ac 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/ShapeUtil.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/ShapeUtil.java @@ -5,7 +5,12 @@ package com.amazonaws.util.awsclientsmithygenerator.generators; import software.amazon.smithy.model.Model; -import software.amazon.smithy.model.shapes.*; +import software.amazon.smithy.model.shapes.IntegerShape; +import software.amazon.smithy.model.shapes.LongShape; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.StructureShape; import software.amazon.smithy.model.traits.Trait; import java.util.*; diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/pagination/PaginationCodegenPlugin.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/pagination/PaginationCodegenPlugin.java index 8c208604ac2..d41aab8398b 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/pagination/PaginationCodegenPlugin.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/pagination/PaginationCodegenPlugin.java @@ -28,7 +28,7 @@ public class PaginationCodegenPlugin implements SmithyBuildPlugin { @Override public String getName() { - return "smithy-cpp-codegen"; + return "smithy-cpp-codegen-paginators"; } @Override diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java new file mode 100644 index 00000000000..653aec07b8f --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java @@ -0,0 +1,56 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters; + +import software.amazon.smithy.build.PluginContext; +import software.amazon.smithy.build.SmithyBuildPlugin; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.knowledge.TopDownIndex; +import software.amazon.smithy.waiters.WaitableTrait; +import software.amazon.smithy.model.shapes.ServiceShape; +import com.amazonaws.util.awsclientsmithygenerator.generators.ServiceNameUtil; +import com.amazonaws.util.awsclientsmithygenerator.generators.FeatureParser; +import java.util.List; +import java.util.stream.Collectors; + +public class WaiterCodegenPlugin implements SmithyBuildPlugin { + + @Override + public String getName() { + return "smithy-cpp-codegen-waiters"; + } + + @Override + public void execute(PluginContext context) { + var model = context.getModel(); + + if (context.getProjectionName().endsWith(".mock")) { + return; + } + + for (ServiceShape service : model.getServiceShapes()) { + final ServiceShape processedService = ServiceNameUtil.processS3CrtProjection(service, context.getProjectionName()); + List waiterOps = TopDownIndex.of(model).getContainedOperations(processedService).stream() + .filter(op -> op.hasTrait(WaitableTrait.class)) + .flatMap(op -> { + var trait = op.expectTrait(WaitableTrait.class); + return trait.getWaiters().entrySet().stream() + .map(entry -> new WaiterOperationData(op, entry.getKey(), entry.getValue(), processedService)); + }) + .collect(Collectors.toList()); + + if (!waiterOps.isEmpty()) { + FeatureParser parser = new FeatureParser<>(context, processedService, waiterOps, "Waiter"); + parser.run(featureParser -> { + String serviceName = ServiceNameUtil.getServiceNameUpperCamel(featureParser.getService()); + featureParser.generateClientHeader( + serviceName + "Waiter.h", + writer -> new WaiterHeaderGenerator(featureParser.getService(), featureParser.getOperations(), featureParser.getServiceMap(), model).render(writer) + ); + }); + } + } + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java new file mode 100644 index 00000000000..8c11627d251 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java @@ -0,0 +1,194 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters; + +import com.amazonaws.util.awsclientsmithygenerator.generators.BaseHeaderGenerator; +import com.amazonaws.util.awsclientsmithygenerator.generators.CppWriter; +import com.amazonaws.util.awsclientsmithygenerator.generators.ServiceNameUtil; +import com.amazonaws.util.awsclientsmithygenerator.generators.ShapeUtil; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.waiters.Acceptor; +import software.amazon.smithy.waiters.AcceptorState; +import software.amazon.smithy.waiters.Matcher; +import software.amazon.smithy.waiters.PathMatcher; +import software.amazon.smithy.waiters.PathComparator; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +public class WaiterHeaderGenerator extends BaseHeaderGenerator { + + private final Model model; + /** Cached code generation results, keyed by PathMatcher identity. */ + private final Map generatedCode = new HashMap<>(); + + public WaiterHeaderGenerator(ServiceShape service, List waiterOps, + Map serviceMap, Model model) { + super(service, waiterOps, serviceMap); + this.model = model; + } + + @Override + protected void writeSpecificIncludes(CppWriter writer, String serviceName, String smithyServiceName) { + String classPrefix = ServiceNameUtil.getServiceNameUpperCamel(service); + writer.writeInclude("aws/" + smithyServiceName + "/" + classPrefix + "Client.h"); + writer.writeInclude("aws/core/utils/Waiter.h"); + writer.writeInclude("algorithm"); + + for (WaiterOperationData data : operations) { + String opName = data.getOperation().getId().getName(); + String methodName = ShapeUtil.getOperationMethodName(opName, smithyServiceName); + writer.writeInclude("aws/" + smithyServiceName + "/model/" + methodName + "Request.h"); + writer.writeInclude("aws/" + smithyServiceName + "/model/" + methodName + (smithyServiceName.equals("ec2") ? "Response.h" : "Result.h")); + } + + // Generate all path matcher code once; cache results and collect enum includes. + Set enumIncludes = preGenerateAll(); + + for (String enumName : enumIncludes) { + writer.writeInclude("aws/" + smithyServiceName + "/model/" + enumName + ".h"); + } + writer.write(""); + } + + /** Generate code for every path matcher, cache results, return all enum includes. */ + private Set preGenerateAll() { + Set enums = new HashSet<>(); + for (WaiterOperationData data : operations) { + String outcomeType = "Model::" + ShapeUtil.getOperationMethodName( + data.getOperation().getId().getName(), smithyServiceName) + "Outcome"; + for (Acceptor acceptor : data.getWaiter().getAcceptors()) { + PathMatcher pm = extractPathMatcher(acceptor.getMatcher()); + if (pm != null) { + WaiterJmesPathCppCodeGenerator.WaiterJmesPathResult result = + WaiterJmesPathCppCodeGenerator.generate( + pm.getPath(), pm.getComparator(), outcomeType, model, data.getOperation(), + smithyServiceName); + generatedCode.put(pm, result); + enums.addAll(result.getEnumIncludes()); + } + } + } + return enums; + } + + private static PathMatcher extractPathMatcher(Matcher matcher) { + if (matcher instanceof Matcher.OutputMember) { + return ((Matcher.OutputMember) matcher).getValue(); + } else if (matcher instanceof Matcher.InputOutputMember) { + return ((Matcher.InputOutputMember) matcher).getValue(); + } + return null; + } + + @Override + protected void writeSpecificContent(CppWriter writer, String serviceName) { + String classPrefix = ServiceNameUtil.getServiceNameUpperCamel(service); + + writer.write("template"); + writer.openBlock("class " + classPrefix + "Waiter {", "};", () -> { + writer.write("public:"); + writer.write(""); + + for (WaiterOperationData data : operations) { + writeWaiterMethod(writer, data); + } + }); + } + + private void writeWaiterMethod(CppWriter writer, WaiterOperationData data) { + String opName = data.getOperation().getId().getName(); + String methodName = ShapeUtil.getOperationMethodName(opName, smithyServiceName); + String waiterFuncName = "WaitUntil" + ServiceNameUtil.capitalize(data.getWaiterName()); + String outcomeType = "Model::" + methodName + "Outcome"; + + writer.write(""); + writer.openBlock("Aws::Utils::WaiterOutcome<" + outcomeType + "> " + waiterFuncName + + "(const Model::" + methodName + "Request& request) {", "}", () -> { + + writer.write("std::vector> acceptors;"); + + for (Acceptor acceptor : data.getWaiter().getAcceptors()) { + writeAcceptor(writer, acceptor, outcomeType, data); + } + + int delay = data.getWaiter().getMinDelay(); + int maxAttempts = data.getWaiter().getMaxDelay() / delay; + + writer.write(""); + writer.write("auto operation = [this](const Model::$LRequest& req) { return static_cast(this)->$L(req); };", + methodName, methodName); + writer.write("Aws::Utils::Waiter waiter(", methodName, outcomeType); + writer.write(" $L, $L, acceptors, operation, \"$L\");", delay, maxAttempts, waiterFuncName); + writer.write("return waiter.Wait(request);"); + }); + } + + private void writeAcceptor(CppWriter writer, Acceptor acceptor, String outcomeType, + WaiterOperationData data) { + String state = waiterStateToEnum(acceptor.getState()); + Matcher matcher = acceptor.getMatcher(); + + if (matcher instanceof Matcher.SuccessMember) { + boolean expectSuccess = ((Matcher.SuccessMember) matcher).getValue(); + writer.write("acceptors.push_back({"); + writer.write(" $L,", state); + writer.write(" Aws::Utils::MatcherType::ERROR,"); + writer.write(" $L", expectSuccess ? "false" : "true"); + writer.write("});"); + } else if (matcher instanceof Matcher.ErrorTypeMember) { + String errorType = ((Matcher.ErrorTypeMember) matcher).getValue(); + writer.write("acceptors.push_back({"); + writer.write(" $L,", state); + writer.write(" Aws::Utils::MatcherType::ERROR,"); + writer.write(" Aws::String(\"$L\")", errorType); + writer.write("});"); + } else if (matcher instanceof Matcher.OutputMember) { + writePathAcceptor(writer, ((Matcher.OutputMember) matcher).getValue(), + state, outcomeType, data); + } else if (matcher instanceof Matcher.InputOutputMember) { + writePathAcceptor(writer, ((Matcher.InputOutputMember) matcher).getValue(), + state, outcomeType, data); + } else { + throw new UnsupportedOperationException("Unsupported matcher type: " + matcher.getClass().getSimpleName()); + } + } + + private void writePathAcceptor(CppWriter writer, PathMatcher pathMatcher, + String state, String outcomeType, WaiterOperationData data) { + String expected = pathMatcher.getExpected(); + PathComparator comparator = pathMatcher.getComparator(); + + writer.write("acceptors.push_back({"); + writer.write(" $L,", state); + writer.write(" Aws::Utils::MatcherType::PATH,"); + + if ("true".equals(expected) || "false".equals(expected)) { + writer.write(" $L,", expected); + } else { + try { + Integer.parseInt(expected); + writer.write(" $L,", expected); + } catch (NumberFormatException e) { + writer.write(" Aws::String(\"$L\"),", expected); + } + } + + writer.write(generatedCode.get(pathMatcher).getCode()); + writer.write("});"); + } + + private static String waiterStateToEnum(AcceptorState state) { + switch (state) { + case SUCCESS: return "Aws::Utils::WaiterState::SUCCESS"; + case FAILURE: return "Aws::Utils::WaiterState::FAILURE"; + case RETRY: return "Aws::Utils::WaiterState::RETRY"; + default: throw new UnsupportedOperationException("Unknown waiter state: " + state); + } + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterJmesPathCppCodeGenerator.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterJmesPathCppCodeGenerator.java new file mode 100644 index 00000000000..2f21c4b4d36 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterJmesPathCppCodeGenerator.java @@ -0,0 +1,56 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters; + +import com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath.TopLevelVisitor; +import software.amazon.smithy.jmespath.JmespathExpression; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.waiters.PathComparator; + +import java.util.HashSet; +import java.util.Set; + +/** + * Generates C++ lambda code for evaluating JmesPath expressions in waiter path matchers. + * + * Delegates to visitors in the {@code jmespath} subpackage. + */ +public final class WaiterJmesPathCppCodeGenerator { + + private WaiterJmesPathCppCodeGenerator() {} + + public static class WaiterJmesPathResult { + private final String code; + private final Set enumIncludes; + + WaiterJmesPathResult(String code, Set enumIncludes) { + this.code = code; + this.enumIncludes = enumIncludes; + } + + public String getCode() { return code; } + public Set getEnumIncludes() { return enumIncludes; } + } + + public static WaiterJmesPathResult generate(String jmesPath, PathComparator comparator, String outcomeType, + Model model, OperationShape operation, + String smithyServiceName) { + JmespathExpression expr = JmespathExpression.parse(jmesPath); + Set enumIncludes = new HashSet<>(); + + StringBuilder sb = new StringBuilder(); + sb.append("[](const ").append(outcomeType) + .append("& outcome, const Aws::Utils::ExpectedValue& expected) {\n"); + sb.append(" if (!outcome.IsSuccess()) return false;\n"); + sb.append(" const auto& result = outcome.GetResult();\n"); + + String body = expr.accept(new TopLevelVisitor(comparator, model, operation, enumIncludes, smithyServiceName)); + sb.append(body); + + sb.append("}"); + return new WaiterJmesPathResult(sb.toString(), enumIncludes); + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterOperationData.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterOperationData.java new file mode 100644 index 00000000000..91941827f05 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterOperationData.java @@ -0,0 +1,39 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters; + +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.ServiceShape; +import software.amazon.smithy.waiters.Waiter; + +public class WaiterOperationData { + private final OperationShape operation; + private final String waiterName; + private final Waiter waiter; + private final ServiceShape service; + + public WaiterOperationData(OperationShape operation, String waiterName, Waiter waiter, ServiceShape service) { + this.operation = operation; + this.waiterName = waiterName; + this.waiter = waiter; + this.service = service; + } + + public OperationShape getOperation() { + return operation; + } + + public String getWaiterName() { + return waiterName; + } + + public Waiter getWaiter() { + return waiter; + } + + public ServiceShape getService() { + return service; + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java new file mode 100644 index 00000000000..8916928c4ad --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java @@ -0,0 +1,122 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import software.amazon.smithy.jmespath.JmespathExpression; +import software.amazon.smithy.jmespath.ast.FieldExpression; +import software.amazon.smithy.jmespath.ast.FlattenExpression; +import software.amazon.smithy.jmespath.ast.ProjectionExpression; +import software.amazon.smithy.jmespath.ast.Subexpression; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.Shape; + +/** + * Resolves the C++ element type for a collection referenced by a JMESPath expression. + * Returns "auto" when the model is unavailable or the type cannot be determined. + */ +public class CollectionElementTypeResolver { + + /** + * Resolve the element type of the outermost collection that a projection iterates over. + * For list projections, returns "Model::ShapeName" for the list member's target. + * Returns "auto" for map projections or when the model is unavailable. + * This is because C++ 11 does not allow auto in lambdas + */ + public static String resolve(JmespathExpression expr, Model model, OperationShape operation, + String smithyServiceName) { + if (model == null || operation == null) return "auto"; + Shape outputShape = model.expectShape(operation.getOutputShape()); + return resolveFromShape(expr, outputShape, model, smithyServiceName); + } + + /** + * Resolve element type starting from a known parent shape. + */ + public static String resolveFromShape(JmespathExpression expr, Shape current, Model model, + String smithyServiceName) { + if (model == null || current == null) return "auto"; + Shape element = findFirstListElement(expr, current, model); + if (element == null || !element.isStructureShape()) return "auto"; + String shapeName = element.getId().getName(); + // EC2 renames *Result shapes to *Response + if ("ec2".equals(smithyServiceName) && shapeName.endsWith("Result")) { + shapeName = shapeName.substring(0, shapeName.length() - 6) + "Response"; + } + return "Model::" + shapeName; + } + + /** + * Finds the element shape of the first list encountered when walking the projection's + * collection path (the left side of the projection). + */ + private static Shape findFirstListElement(JmespathExpression expr, Shape current, Model model) { + if (current == null) return null; + + if (expr instanceof ProjectionExpression) { + return findFirstListInPath(((ProjectionExpression) expr).getLeft(), current, model); + } else if (expr instanceof FlattenExpression) { + return findFirstListElement(((FlattenExpression) expr).getExpression(), current, model); + } else if (expr instanceof Subexpression) { + Subexpression sub = (Subexpression) expr; + Shape afterLeft = walkFields(sub.getLeft(), current, model); + return afterLeft != null ? findFirstListElement(sub.getRight(), afterLeft, model) : null; + } + return null; + } + + /** + * Walks the left side of a projection to find the first list shape and return its element. + * Stops at the first list encountered (the collection being iterated). + */ + private static Shape findFirstListInPath(JmespathExpression expr, Shape current, Model model) { + if (current == null) return null; + + if (expr instanceof FieldExpression) { + Shape target = resolveMemberTarget(current, ((FieldExpression) expr).getName(), model); + if (target != null && target.isListShape()) { + return model.expectShape(target.asListShape().get().getMember().getTarget()); + } + return null; + } else if (expr instanceof Subexpression) { + // Walk fields until we hit a list + Subexpression sub = (Subexpression) expr; + Shape afterLeft = walkFields(sub.getLeft(), current, model); + if (afterLeft != null && afterLeft.isListShape()) { + return model.expectShape(afterLeft.asListShape().get().getMember().getTarget()); + } + return findFirstListInPath(sub.getRight(), afterLeft, model); + } else if (expr instanceof FlattenExpression) { + return findFirstListInPath(((FlattenExpression) expr).getExpression(), current, model); + } else if (expr instanceof ProjectionExpression) { + // Nested projection in the left side — find the first list + return findFirstListInPath(((ProjectionExpression) expr).getLeft(), current, model); + } + return null; + } + + /** + * Walks field/subexpression nodes to resolve the shape, without unwrapping lists. + */ + private static Shape walkFields(JmespathExpression expr, Shape current, Model model) { + if (current == null) return null; + + if (expr instanceof FieldExpression) { + return resolveMemberTarget(current, ((FieldExpression) expr).getName(), model); + } else if (expr instanceof Subexpression) { + Shape left = walkFields(((Subexpression) expr).getLeft(), current, model); + return walkFields(((Subexpression) expr).getRight(), left, model); + } + return current; + } + + private static Shape resolveMemberTarget(Shape structShape, String memberName, Model model) { + if (!structShape.isStructureShape()) return null; + return structShape.asStructureShape().get() + .getMember(memberName) + .flatMap(member -> model.getShape(member.getTarget())) + .orElse(null); + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionGetterEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionGetterEmitter.java new file mode 100644 index 00000000000..8b7755e8758 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionGetterEmitter.java @@ -0,0 +1,35 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import com.amazonaws.util.awsclientsmithygenerator.generators.ServiceNameUtil; +import software.amazon.smithy.jmespath.ast.FieldExpression; +import software.amazon.smithy.jmespath.ast.ObjectProjectionExpression; +import software.amazon.smithy.jmespath.ast.ProjectionExpression; +import software.amazon.smithy.jmespath.ast.Subexpression; +import software.amazon.smithy.jmespath.ast.FlattenExpression; +import software.amazon.smithy.jmespath.ast.CurrentExpression; + +/** + * Extracts a collection getter chain from JmesPath AST nodes, stripping projections. + */ +public class CollectionGetterEmitter extends UnsupportedExpressionVisitor { + @Override public String visitField(FieldExpression e) { + return ".Get" + ServiceNameUtil.capitalize(e.getName()) + "()"; + } + @Override public String visitSubexpression(Subexpression e) { + return e.getLeft().accept(this) + e.getRight().accept(this); + } + @Override public String visitProjection(ProjectionExpression e) { + return e.getLeft().accept(this); + } + @Override public String visitObjectProjection(ObjectProjectionExpression e) { + return e.getLeft().accept(this); + } + @Override public String visitFlatten(FlattenExpression e) { + return e.getExpression().accept(this); + } + @Override public String visitCurrentNode(CurrentExpression e) { return ""; } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ComparatorEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ComparatorEmitter.java new file mode 100644 index 00000000000..623e2858107 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ComparatorEmitter.java @@ -0,0 +1,55 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import software.amazon.smithy.jmespath.ast.AndExpression; +import software.amazon.smithy.jmespath.ast.ComparatorExpression; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.OperationShape; + +/** + * Emits code for comparator expressions like {@code length(Items[]) > `0`}. + */ +public class ComparatorEmitter extends UnsupportedExpressionVisitor { + private final Model model; + private final OperationShape operation; + private final String smithyServiceName; + + public ComparatorEmitter() { + this(null, null, null); + } + + public ComparatorEmitter(Model model, OperationShape operation, String smithyServiceName) { + this.model = model; + this.operation = operation; + this.smithyServiceName = smithyServiceName; + } + + @Override + public String visitAnd(AndExpression expression) { + String left = expression.getLeft().accept(this); + String right = expression.getRight().accept(this); + return "(" + left + " && " + right + ")"; + } + + @Override + public String visitComparator(ComparatorExpression expression) { + ScalarEmitter scalar = new ScalarEmitter(model, operation, smithyServiceName); + String left = expression.getLeft().accept(scalar); + String right = expression.getRight().accept(scalar); + + String op; + switch (expression.getComparator()) { + case GREATER_THAN: op = " > "; break; + case GREATER_THAN_EQUAL: op = " >= "; break; + case LESS_THAN: op = " < "; break; + case LESS_THAN_EQUAL: op = " <= "; break; + case EQUAL: op = " == "; break; + case NOT_EQUAL: op = " != "; break; + default: throw new UnsupportedOperationException("Unsupported comparator: " + expression.getComparator()); + } + return "(" + left + op + right + ")"; + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ContainsProjectionInfo.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ContainsProjectionInfo.java new file mode 100644 index 00000000000..17397a1c731 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ContainsProjectionInfo.java @@ -0,0 +1,20 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import software.amazon.smithy.jmespath.JmespathExpression; + +/** + * Holds the collection getter and comparator extracted from a contains() projection pattern. + */ +public class ContainsProjectionInfo { + final String collectionGetter; + final JmespathExpression comparator; + + ContainsProjectionInfo(String collectionGetter, JmespathExpression comparator) { + this.collectionGetter = collectionGetter; + this.comparator = comparator; + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumInfo.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumInfo.java new file mode 100644 index 00000000000..77682d8c00e --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumInfo.java @@ -0,0 +1,18 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +/** + * Holds information about an enum-typed leaf in a JmesPath expression. + */ +public class EnumInfo { + final String shapeName; + + EnumInfo(String shapeName) { this.shapeName = shapeName; } + + String wrapAccess(String access) { + return "Model::" + shapeName + "Mapper::GetNameFor" + shapeName + "(" + access + ")"; + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java new file mode 100644 index 00000000000..d6cfce69762 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java @@ -0,0 +1,101 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import software.amazon.smithy.jmespath.JmespathExpression; +import software.amazon.smithy.jmespath.ast.CurrentExpression; +import software.amazon.smithy.jmespath.ast.FieldExpression; +import software.amazon.smithy.jmespath.ast.FlattenExpression; +import software.amazon.smithy.jmespath.ast.ObjectProjectionExpression; +import software.amazon.smithy.jmespath.ast.ProjectionExpression; +import software.amazon.smithy.jmespath.ast.Subexpression; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.Shape; + +/** + * Walks the Smithy model along the JmesPath field path to determine if the leaf + * targets an enum shape. Returns null if not an enum or model is unavailable. + * + * This is a read-only pass — it does not produce code. + */ +public class EnumResolver { + /** + * Walk the model from the output shape along the expression's field path. + * Returns EnumInfo if the leaf is an enum, null otherwise. + */ + public static EnumInfo resolveEnumInfo(JmespathExpression expr, Model model, OperationShape operation) { + if (model == null || operation == null) return null; + Shape current = model.expectShape(operation.getOutputShape()); + current = walkExpression(expr, current, model); + if (current != null && current.isEnumShape()) { + return new EnumInfo(current.getId().getName()); + } + return null; + } + + private static Shape walkExpression(JmespathExpression expr, Shape current, Model model) { + if (current == null) return null; + if (expr instanceof FieldExpression) { + return resolveMemberTarget(current, ((FieldExpression) expr).getName(), model); + } else if (expr instanceof Subexpression) { + Shape left = walkExpression(((Subexpression) expr).getLeft(), current, model); + return walkExpression(((Subexpression) expr).getRight(), left, model); + } else if (expr instanceof ObjectProjectionExpression) { + ObjectProjectionExpression objProj = (ObjectProjectionExpression) expr; + Shape afterLeft = walkExpression(objProj.getLeft(), current, model); + if (afterLeft != null && afterLeft.isMapShape()) { + afterLeft = model.expectShape(afterLeft.asMapShape().get().getValue().getTarget()); + } + if (objProj.getRight() != null && !(objProj.getRight() instanceof CurrentExpression)) { + return walkExpression(objProj.getRight(), afterLeft, model); + } + return afterLeft; + } else if (expr instanceof ProjectionExpression) { + ProjectionExpression proj = (ProjectionExpression) expr; + Shape afterLeft = walkProjectionLeft(proj.getLeft(), current, model); + if (afterLeft != null && afterLeft.isListShape()) { + afterLeft = model.expectShape(afterLeft.asListShape().get().getMember().getTarget()); + } + if (proj.getRight() != null && !(proj.getRight() instanceof CurrentExpression)) { + return walkExpression(proj.getRight(), afterLeft, model); + } + return afterLeft; + } else if (expr instanceof FlattenExpression) { + return walkExpression(((FlattenExpression) expr).getExpression(), current, model); + } + return current; + } + + private static Shape walkProjectionLeft(JmespathExpression expr, Shape current, Model model) { + if (current == null) return null; + if (expr instanceof FieldExpression) { + return resolveMemberTarget(current, ((FieldExpression) expr).getName(), model); + } else if (expr instanceof FlattenExpression) { + JmespathExpression inner = ((FlattenExpression) expr).getExpression(); + if (inner instanceof ProjectionExpression) { + ProjectionExpression innerProj = (ProjectionExpression) inner; + Shape afterLeft = walkProjectionLeft(innerProj.getLeft(), current, model); + if (afterLeft != null && afterLeft.isListShape()) { + afterLeft = model.expectShape(afterLeft.asListShape().get().getMember().getTarget()); + } + if (innerProj.getRight() != null && !(innerProj.getRight() instanceof CurrentExpression)) { + return walkExpression(innerProj.getRight(), afterLeft, model); + } + return afterLeft; + } + return walkProjectionLeft(inner, current, model); + } + return current; + } + + private static Shape resolveMemberTarget(Shape structShape, String memberName, Model model) { + if (!structShape.isStructureShape()) return null; + return structShape.asStructureShape().get() + .getMember(memberName) + .flatMap(member -> model.getShape(member.getTarget())) + .orElse(null); + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java new file mode 100644 index 00000000000..d6fbad9e382 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java @@ -0,0 +1,75 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import com.amazonaws.util.awsclientsmithygenerator.generators.ServiceNameUtil; +import software.amazon.smithy.jmespath.JmespathExpression; +import software.amazon.smithy.jmespath.ast.FieldExpression; +import software.amazon.smithy.jmespath.ast.FilterProjectionExpression; +import software.amazon.smithy.jmespath.ast.FunctionExpression; +import software.amazon.smithy.jmespath.ast.LiteralExpression; +import software.amazon.smithy.jmespath.ast.Subexpression; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.OperationShape; + +/** + * Emits operands within a filter predicate — fields resolve relative to the item, + * not to "result". + */ +public class FilterOperandEmitter extends UnsupportedExpressionVisitor { + private final String itemVar; + private final Model model; + private final OperationShape operation; + + FilterOperandEmitter(String itemVar) { + this(itemVar, null, null); + } + + FilterOperandEmitter(String itemVar, Model model, OperationShape operation) { + this.itemVar = itemVar; + this.model = model; + this.operation = operation; + } + + @Override + public String visitField(FieldExpression expression) { + return itemVar + ".Get" + ServiceNameUtil.capitalize(expression.getName()) + "()"; + } + + @Override + public String visitSubexpression(Subexpression expression) { + return expression.getLeft().accept(this) + expression.getRight().accept(new GetterChainEmitter()); + } + + @Override + public String visitLiteral(LiteralExpression expression) { + if (expression.isNumberValue()) return String.valueOf(expression.expectNumberValue().intValue()); + if (expression.isStringValue()) return "\"" + expression.expectStringValue() + "\""; + if (expression.isBooleanValue()) return expression.expectBooleanValue() ? "true" : "false"; + throw new UnsupportedOperationException("Unsupported literal type"); + } + + @Override + public String visitFunction(FunctionExpression expression) { + if ("length".equals(expression.getName())) { + JmespathExpression arg = expression.getArguments().get(0); + if (arg instanceof FilterProjectionExpression) { + return emitItemCountIf((FilterProjectionExpression) arg); + } + String collection = arg.accept(this); + return collection + ".size()"; + } + throw new UnsupportedOperationException("Unsupported function: " + expression.getName()); + } + + private String emitItemCountIf(FilterProjectionExpression filterExpr) { + String collection = itemVar + filterExpr.getLeft().accept(new CollectionGetterEmitter()); + String predicate = filterExpr.getComparison().accept(new FilterPredicateEmitter("inner")); + // For nested count_if inside a filter, the collection is relative to the item, + // so type resolution would need the item's shape context. Fall back to auto for now. + return "std::count_if(" + collection + ".begin(), " + collection + ".end(), " + + "[](const auto& inner) { return " + predicate + "; })"; + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterPredicateEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterPredicateEmitter.java new file mode 100644 index 00000000000..9ee7b82ddf9 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterPredicateEmitter.java @@ -0,0 +1,62 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import com.amazonaws.util.awsclientsmithygenerator.generators.ServiceNameUtil; +import software.amazon.smithy.jmespath.JmespathExpression; +import software.amazon.smithy.jmespath.ast.AndExpression; +import software.amazon.smithy.jmespath.ast.ComparatorExpression; +import software.amazon.smithy.jmespath.ast.NotExpression; +import software.amazon.smithy.jmespath.ast.OrExpression; + +/** + * Emits a boolean predicate for use inside a filter projection lambda. + * Handles Or, And, Comparator with field/literal operands relative to the lambda parameter. + */ +public class FilterPredicateEmitter extends UnsupportedExpressionVisitor { + private final String itemVar; + + FilterPredicateEmitter(String itemVar) { + this.itemVar = itemVar; + } + + @Override + public String visitNot(NotExpression expression) { + String inner = expression.getExpression().accept(this); + return "!" + inner; + } + + @Override + public String visitOr(OrExpression expression) { + String left = expression.getLeft().accept(this); + String right = expression.getRight().accept(this); + return "(" + left + " || " + right + ")"; + } + + @Override + public String visitAnd(AndExpression expression) { + String left = expression.getLeft().accept(this); + String right = expression.getRight().accept(this); + return "(" + left + " && " + right + ")"; + } + + @Override + public String visitComparator(ComparatorExpression expression) { + String left = expression.getLeft().accept(new FilterOperandEmitter(itemVar)); + String right = expression.getRight().accept(new FilterOperandEmitter(itemVar)); + + String op; + switch (expression.getComparator()) { + case GREATER_THAN: op = " > "; break; + case GREATER_THAN_EQUAL: op = " >= "; break; + case LESS_THAN: op = " < "; break; + case LESS_THAN_EQUAL: op = " <= "; break; + case EQUAL: op = " == "; break; + case NOT_EQUAL: op = " != "; break; + default: throw new UnsupportedOperationException("Unsupported comparator: " + expression.getComparator()); + } + return "(" + left + op + right + ")"; + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/GetterChainEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/GetterChainEmitter.java new file mode 100644 index 00000000000..215d26e42cf --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/GetterChainEmitter.java @@ -0,0 +1,25 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import com.amazonaws.util.awsclientsmithygenerator.generators.ServiceNameUtil; +import software.amazon.smithy.jmespath.ast.FieldExpression; +import software.amazon.smithy.jmespath.ast.FlattenExpression; +import software.amazon.smithy.jmespath.ast.Subexpression; + +/** + * Emits a getter chain for non-projection field access (e.g. ".GetCluster().GetStatus()"). + */ +public class GetterChainEmitter extends UnsupportedExpressionVisitor { + @Override public String visitField(FieldExpression e) { + return ".Get" + ServiceNameUtil.capitalize(e.getName()) + "()"; + } + @Override public String visitSubexpression(Subexpression e) { + return e.getLeft().accept(this) + e.getRight().accept(this); + } + @Override public String visitFlatten(FlattenExpression e) { + return e.getExpression().accept(this); + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/NestedProjectionInfo.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/NestedProjectionInfo.java new file mode 100644 index 00000000000..c67431a568d --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/NestedProjectionInfo.java @@ -0,0 +1,20 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +/** + * Info extracted from a nested projection's left side. + * For Reservations[].Instances[]: outerCollectionGetter=".GetReservations()", + * innerCollectionGetter=".GetInstances()". + */ +public class NestedProjectionInfo { + final String outerCollectionGetter; + final String innerCollectionGetter; + + NestedProjectionInfo(String outer, String inner) { + this.outerCollectionGetter = outer; + this.innerCollectionGetter = inner; + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionCounter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionCounter.java new file mode 100644 index 00000000000..60d1045f128 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionCounter.java @@ -0,0 +1,32 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import software.amazon.smithy.jmespath.ast.FlattenExpression; +import software.amazon.smithy.jmespath.ast.ObjectProjectionExpression; +import software.amazon.smithy.jmespath.ast.ProjectionExpression; +import software.amazon.smithy.jmespath.ast.Subexpression; +import software.amazon.smithy.jmespath.ast.FieldExpression; +import software.amazon.smithy.jmespath.ast.CurrentExpression; + +/** + * Counts projection levels in an expression. + * Determines whether to use "item" (1 level) or "item0"/"item1" (multi-level). + */ +public class ProjectionCounter extends UnsupportedExpressionVisitor { + @Override public Integer visitProjection(ProjectionExpression e) { + return 1 + e.getLeft().accept(this) + + (e.getRight() != null ? e.getRight().accept(this) : 0); + } + @Override public Integer visitObjectProjection(ObjectProjectionExpression e) { + return visitProjection(e); + } + @Override public Integer visitFlatten(FlattenExpression e) { return e.getExpression().accept(this); } + @Override public Integer visitSubexpression(Subexpression e) { + return e.getLeft().accept(this) + e.getRight().accept(this); + } + @Override public Integer visitField(FieldExpression e) { return 0; } + @Override public Integer visitCurrentNode(CurrentExpression e) { return 0; } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionEmitter.java new file mode 100644 index 00000000000..cc750d0e238 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionEmitter.java @@ -0,0 +1,204 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import software.amazon.smithy.jmespath.JmespathExpression; +import software.amazon.smithy.jmespath.ast.CurrentExpression; +import software.amazon.smithy.jmespath.ast.FlattenExpression; +import software.amazon.smithy.jmespath.ast.ObjectProjectionExpression; +import software.amazon.smithy.jmespath.ast.ProjectionExpression; +import software.amazon.smithy.jmespath.ast.Subexpression; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.Shape; + +/** + * Emits std::all_of/any_of blocks for projection expressions. + * + * Each projection level creates a new ProjectionEmitter with an incremented depth, + * avoiding mutable shared state. + * + * For ObjectProjectionExpression (map wildcard), iterates map entries and accesses + * .second to get the value from each std::pair. + */ +public class ProjectionEmitter extends UnsupportedExpressionVisitor { + private final String algo; + private final int totalLevels; + private final EnumInfo enumInfo; + private final int depth; + private final Model model; + private final OperationShape operation; + private final String smithyServiceName; + + ProjectionEmitter(String algo, int totalLevels, EnumInfo enumInfo, int depth, + Model model, OperationShape operation, String smithyServiceName) { + this.algo = algo; + this.totalLevels = totalLevels; + this.enumInfo = enumInfo; + this.depth = depth; + this.model = model; + this.operation = operation; + this.smithyServiceName = smithyServiceName; + } + + ProjectionEmitter(String algo, int totalLevels, EnumInfo enumInfo, int depth) { + this(algo, totalLevels, enumInfo, depth, null, null, null); + } + + private String itemVar(int d) { return totalLevels == 1 ? "item" : "item" + d; } + + @Override + public String visitProjection(ProjectionExpression expression) { + NestedProjectionInfo nested = extractNestedProjection(expression.getLeft()); + if (nested != null) { + return emitProjectionLevel( + nested.outerCollectionGetter, + expression, + nested); + } + String collectionGetter = expression.getLeft().accept(new CollectionGetterEmitter()); + String elementType = CollectionElementTypeResolver.resolve(expression, model, operation, smithyServiceName); + return emitSimpleProjection(collectionGetter, expression.getRight(), elementType); + } + + String emitSimpleProjection(String collectionGetter, JmespathExpression right, String elementType) { + String collectionPrefix = depth == 0 + ? "result" + collectionGetter + : itemVar(depth - 1) + collectionGetter; + + String indent = " ".repeat(depth + 1); + String itemName = itemVar(depth); + + StringBuilder sb = new StringBuilder(); + sb.append(indent).append("return ").append(algo).append("(") + .append(collectionPrefix).append(".begin(), ") + .append(collectionPrefix).append(".end(),\n"); + sb.append(indent).append(" [&](const ").append(elementType).append("& ").append(itemName).append(") {\n"); + + if (right != null && !(right instanceof CurrentExpression)) { + sb.append(right.accept(new ProjectionRightEmitter(algo, totalLevels, enumInfo, depth, model, operation, smithyServiceName))); + } + + sb.append(indent).append(" });\n"); + return sb.toString(); + } + + private String emitProjectionLevel(String outerGetter, + ProjectionExpression outerExpr, + NestedProjectionInfo nested) { + String collectionPrefix = depth == 0 + ? "result" + outerGetter + : itemVar(depth - 1) + outerGetter; + + String indent = " ".repeat(depth + 1); + String itemName = itemVar(depth); + String outerElementType = CollectionElementTypeResolver.resolve(outerExpr, model, operation, smithyServiceName); + + StringBuilder sb = new StringBuilder(); + sb.append(indent).append("return ").append(algo).append("(") + .append(collectionPrefix).append(".begin(), ") + .append(collectionPrefix).append(".end(),\n"); + sb.append(indent).append(" [&](const ").append(outerElementType).append("& ").append(itemName).append(") {\n"); + + // Resolve inner element type: walk from the outer element shape through the inner collection getter + String innerElementType = resolveInnerElementType(outerExpr); + + ProjectionEmitter innerEmitter = new ProjectionEmitter(algo, totalLevels, enumInfo, depth + 1, model, operation, smithyServiceName); + sb.append(innerEmitter.emitSimpleProjection(nested.innerCollectionGetter, outerExpr.getRight(), innerElementType)); + + sb.append(indent).append(" });\n"); + return sb.toString(); + } + + /** + * For nested projections like Outer[].Inner[].Field, resolves the inner collection's element type. + * First resolves the outer element shape, then resolves the inner collection's element from it. + */ + private String resolveInnerElementType(ProjectionExpression outerExpr) { + if (model == null || operation == null) return "auto"; + JmespathExpression left = outerExpr.getLeft(); + if (!(left instanceof FlattenExpression)) return "auto"; + JmespathExpression inner = ((FlattenExpression) left).getExpression(); + if (!(inner instanceof ProjectionExpression)) return "auto"; + ProjectionExpression innerProj = (ProjectionExpression) inner; + + // Resolve the outer element shape (e.g. Reservation) + Shape outputShape = model.expectShape(operation.getOutputShape()); + String outerType = CollectionElementTypeResolver.resolveFromShape(innerProj, outputShape, model, smithyServiceName); + if ("auto".equals(outerType)) return "auto"; + + // Find the outer element shape in the model by name + String outerShapeName = outerType.replace("Model::", ""); + Shape outerElementShape = model.shapes() + .filter(s -> s.getId().getName().equals(outerShapeName) && s.isStructureShape()) + .findFirst().orElse(null); + if (outerElementShape == null) return "auto"; + + // The inner collection is accessed via innerProj.getRight() (e.g. Field("Instances")) + // Wrap it as a projection to resolve its element type from the outer element shape + JmespathExpression innerRight = innerProj.getRight(); + if (innerRight == null) return "auto"; + JmespathExpression syntheticProj = new ProjectionExpression( + new FlattenExpression(innerRight), new CurrentExpression()); + return CollectionElementTypeResolver.resolveFromShape(syntheticProj, outerElementShape, model, smithyServiceName); + } + + @Override + public String visitObjectProjection(ObjectProjectionExpression expression) { + String mapGetter = expression.getLeft().accept(new CollectionGetterEmitter()); + return emitMapProjection(mapGetter, expression.getRight()); + } + + String emitMapProjection(String mapGetter, JmespathExpression right) { + String mapPrefix = depth == 0 + ? "result" + mapGetter + : itemVar(depth - 1) + mapGetter; + + String indent = " ".repeat(depth + 1); + String pairName = "pair" + depth; + String itemName = itemVar(depth); + + StringBuilder sb = new StringBuilder(); + sb.append(indent).append("return ").append(algo).append("(") + .append(mapPrefix).append(".begin(), ") + .append(mapPrefix).append(".end(),\n"); + sb.append(indent).append(" [&](const auto& ").append(pairName).append(") {\n"); + sb.append(indent).append(" const auto& ").append(itemName) + .append(" = ").append(pairName).append(".second;\n"); + + if (right != null && !(right instanceof CurrentExpression)) { + sb.append(right.accept(new ProjectionRightEmitter(algo, totalLevels, enumInfo, depth, model, operation, smithyServiceName))); + } + + sb.append(indent).append(" });\n"); + return sb.toString(); + } + + private NestedProjectionInfo extractNestedProjection(JmespathExpression left) { + if (!(left instanceof FlattenExpression)) return null; + JmespathExpression inner = ((FlattenExpression) left).getExpression(); + if (!(inner instanceof ProjectionExpression)) return null; + ProjectionExpression innerProj = (ProjectionExpression) inner; + String outerGetter = innerProj.getLeft().accept(new CollectionGetterEmitter()); + String innerGetter = innerProj.getRight() != null + ? innerProj.getRight().accept(new CollectionGetterEmitter()) + : ""; + return new NestedProjectionInfo(outerGetter, innerGetter); + } + + @Override + public String visitFlatten(FlattenExpression expression) { + return expression.getExpression().accept(this); + } + + @Override + public String visitSubexpression(Subexpression expression) { + return expression.getLeft().accept(this); + } + + Model getModel() { return model; } + OperationShape getOperation() { return operation; } + String getSmithyServiceName() { return smithyServiceName; } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionRightEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionRightEmitter.java new file mode 100644 index 00000000000..80e0fb431ad --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ProjectionRightEmitter.java @@ -0,0 +1,90 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import com.amazonaws.util.awsclientsmithygenerator.generators.ServiceNameUtil; +import software.amazon.smithy.jmespath.ast.CurrentExpression; +import software.amazon.smithy.jmespath.ast.FieldExpression; +import software.amazon.smithy.jmespath.ast.FlattenExpression; +import software.amazon.smithy.jmespath.ast.ObjectProjectionExpression; +import software.amazon.smithy.jmespath.ast.ProjectionExpression; +import software.amazon.smithy.jmespath.ast.Subexpression; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.OperationShape; + +/** + * Visits the right side of a projection. If it encounters another projection + * (via flatten), it creates a new ProjectionEmitter at the next depth. + * Otherwise it emits the leaf comparison. + */ +class ProjectionRightEmitter extends UnsupportedExpressionVisitor { + private final String algo; + private final int totalLevels; + private final EnumInfo enumInfo; + private final int parentDepth; + private final Model model; + private final OperationShape operation; + private final String smithyServiceName; + + ProjectionRightEmitter(String algo, int totalLevels, EnumInfo enumInfo, int parentDepth, + Model model, OperationShape operation, String smithyServiceName) { + this.algo = algo; + this.totalLevels = totalLevels; + this.enumInfo = enumInfo; + this.parentDepth = parentDepth; + this.model = model; + this.operation = operation; + this.smithyServiceName = smithyServiceName; + } + + ProjectionRightEmitter(String algo, int totalLevels, EnumInfo enumInfo, int parentDepth) { + this(algo, totalLevels, enumInfo, parentDepth, null, null, null); + } + + private String itemVar() { return totalLevels == 1 ? "item" : "item" + parentDepth; } + + @Override + public String visitField(FieldExpression e) { + return emitLeafComparison(".Get" + ServiceNameUtil.capitalize(e.getName()) + "()"); + } + + @Override + public String visitSubexpression(Subexpression e) { + int innerProjections = e.accept(new ProjectionCounter()); + if (innerProjections > 0) { + return e.accept(new ProjectionEmitter(algo, totalLevels, enumInfo, parentDepth + 1, model, operation, smithyServiceName)); + } + String getters = e.accept(new GetterChainEmitter()); + return emitLeafComparison(getters); + } + + @Override + public String visitFlatten(FlattenExpression e) { + return e.getExpression().accept( + new ProjectionEmitter(algo, totalLevels, enumInfo, parentDepth + 1, model, operation, smithyServiceName)); + } + + @Override + public String visitProjection(ProjectionExpression e) { + return e.accept(new ProjectionEmitter(algo, totalLevels, enumInfo, parentDepth + 1, model, operation, smithyServiceName)); + } + + @Override + public String visitObjectProjection(ObjectProjectionExpression e) { + return e.accept(new ProjectionEmitter(algo, totalLevels, enumInfo, parentDepth + 1, model, operation, smithyServiceName)); + } + + @Override + public String visitCurrentNode(CurrentExpression e) { return ""; } + + private String emitLeafComparison(String getterChain) { + String indent = " ".repeat(parentDepth + 2); + String access = itemVar() + getterChain; + if (enumInfo != null) { + access = enumInfo.wrapAccess(access); + } + return indent + "return " + access + " == expected.get();\n"; + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ScalarEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ScalarEmitter.java new file mode 100644 index 00000000000..68a1f566696 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ScalarEmitter.java @@ -0,0 +1,78 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import com.amazonaws.util.awsclientsmithygenerator.generators.ServiceNameUtil; +import software.amazon.smithy.jmespath.JmespathExpression; +import software.amazon.smithy.jmespath.ast.CurrentExpression; +import software.amazon.smithy.jmespath.ast.FieldExpression; +import software.amazon.smithy.jmespath.ast.FilterProjectionExpression; +import software.amazon.smithy.jmespath.ast.FunctionExpression; +import software.amazon.smithy.jmespath.ast.LiteralExpression; +import software.amazon.smithy.jmespath.ast.ProjectionExpression; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.OperationShape; + +/** + * Emits scalar operands in comparisons: length(), literals, and field access. + */ +public class ScalarEmitter extends UnsupportedExpressionVisitor { + private final Model model; + private final OperationShape operation; + private final String smithyServiceName; + + public ScalarEmitter() { + this(null, null, null); + } + + public ScalarEmitter(Model model, OperationShape operation, String smithyServiceName) { + this.model = model; + this.operation = operation; + this.smithyServiceName = smithyServiceName; + } + + @Override + public String visitFunction(FunctionExpression expression) { + if ("length".equals(expression.getName())) { + JmespathExpression arg = expression.getArguments().get(0); + if (arg instanceof FilterProjectionExpression) { + return emitCountIf((FilterProjectionExpression) arg); + } + String collection = arg.accept(new CollectionGetterEmitter()); + return "result" + collection + ".size()"; + } + throw new UnsupportedOperationException("Unsupported function: " + expression.getName()); + } + + private String emitCountIf(FilterProjectionExpression filterExpr) { + String collection = "result" + filterExpr.getLeft().accept(new CollectionGetterEmitter()); + String predicate = filterExpr.getComparison().accept(new FilterPredicateEmitter("item")); + String elementType = resolveFilterElementType(filterExpr); + return "std::count_if(" + collection + ".begin(), " + collection + ".end(), " + + "[](const " + elementType + "& item) { return " + predicate + "; })"; + } + + private String resolveFilterElementType(FilterProjectionExpression filterExpr) { + if (model == null || operation == null) return "auto"; + // The left side of the filter projection is the collection (e.g. Flatten(Field("Items"))) + // Wrap it as a projection to resolve the element type + JmespathExpression syntheticProj = new ProjectionExpression( + filterExpr.getLeft(), new CurrentExpression()); + return CollectionElementTypeResolver.resolve(syntheticProj, model, operation, smithyServiceName); + } + + @Override + public String visitLiteral(LiteralExpression expression) { + if (expression.isNumberValue()) return String.valueOf(expression.expectNumberValue().intValue()); + if (expression.isStringValue()) return "\"" + expression.expectStringValue() + "\""; + if (expression.isBooleanValue()) return expression.expectBooleanValue() ? "true" : "false"; + throw new UnsupportedOperationException("Unsupported literal type"); + } + + @Override + public String visitField(FieldExpression expression) { + return "result.Get" + ServiceNameUtil.capitalize(expression.getName()) + "()"; + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/TopLevelVisitor.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/TopLevelVisitor.java new file mode 100644 index 00000000000..1858ad4fc6a --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/TopLevelVisitor.java @@ -0,0 +1,199 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import software.amazon.smithy.jmespath.JmespathExpression; +import software.amazon.smithy.jmespath.ast.AndExpression; +import software.amazon.smithy.jmespath.ast.ComparatorExpression; +import software.amazon.smithy.jmespath.ast.FieldExpression; +import software.amazon.smithy.jmespath.ast.FlattenExpression; +import software.amazon.smithy.jmespath.ast.FunctionExpression; +import software.amazon.smithy.jmespath.ast.LiteralExpression; +import software.amazon.smithy.jmespath.ast.MultiSelectListExpression; +import software.amazon.smithy.jmespath.ast.ObjectProjectionExpression; +import software.amazon.smithy.jmespath.ast.ProjectionExpression; +import software.amazon.smithy.jmespath.ast.Subexpression; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.waiters.PathComparator; + +import java.util.Set; + +/** + * Top-level visitor that dispatches to the appropriate code emitter based on + * expression type. Integrates comparator handling into the visitor dispatch. + */ +public class TopLevelVisitor extends UnsupportedExpressionVisitor { + private final PathComparator comparator; + private final Model model; + private final OperationShape operation; + private final Set enumIncludes; + private final String smithyServiceName; + + public TopLevelVisitor(PathComparator comparator, Model model, OperationShape operation, + Set enumIncludes, String smithyServiceName) { + this.comparator = comparator; + this.model = model; + this.operation = operation; + this.enumIncludes = enumIncludes; + this.smithyServiceName = smithyServiceName; + } + + @Override + public String visitFunction(FunctionExpression expression) { + if ("contains".equals(expression.getName())) { + return emitContains(expression); + } + throw new UnsupportedOperationException("Unsupported top-level function: " + expression.getName()); + } + + @Override + public String visitComparator(ComparatorExpression expression) { + String cmpCode = expression.accept(new ComparatorEmitter(model, operation, smithyServiceName)); + return " return " + cmpCode + " == expected.get();\n"; + } + + @Override + public String visitAnd(AndExpression expression) { + if (comparator != PathComparator.BOOLEAN_EQUALS) { + throw new UnsupportedOperationException( + "AND expressions only supported with BOOLEAN_EQUALS comparator, got: " + comparator); + } + String andCode = expression.accept(new ComparatorEmitter(model, operation, smithyServiceName)); + return " return " + andCode + " == expected.get();\n"; + } + + @Override + public String visitField(FieldExpression expression) { + return emitPathCode(expression); + } + + @Override + public String visitSubexpression(Subexpression expression) { + return emitPathCode(expression); + } + + @Override + public String visitProjection(ProjectionExpression expression) { + return emitPathCode(expression); + } + + @Override + public String visitObjectProjection(ObjectProjectionExpression expression) { + return emitPathCode(expression); + } + + @Override + public String visitFlatten(FlattenExpression expression) { + return emitPathCode(expression); + } + + /** + * Emits contains(projection, literal) as std::any_of. + * + * Pattern: contains(Collection[].[comparatorExpr][], `false`) + * The projection produces a bool per item; contains checks if the literal is among them. + * contains(..., false) → any_of where condition is negated + * contains(..., true) → any_of where condition is kept + */ + private String emitContains(FunctionExpression expression) { + JmespathExpression collectionArg = expression.getArguments().get(0); + JmespathExpression searchArg = expression.getArguments().get(1); + + boolean searchForFalse = (searchArg instanceof LiteralExpression) + && ((LiteralExpression) searchArg).isBooleanValue() + && !((LiteralExpression) searchArg).expectBooleanValue(); + + // Unwrap: Projection(Flatten(Projection(Flatten(Field), MultiSelectList([cmp]))), Current) + // We need the collection field and the comparator inside the multi-select. + ContainsProjectionInfo info = extractContainsProjection(collectionArg); + if (info == null) { + throw new UnsupportedOperationException( + "contains() only supported with projection/multi-select pattern"); + } + + String collection = "result" + info.collectionGetter; + String condition = info.comparator.accept(new FilterPredicateEmitter("item")); + if (searchForFalse) { + condition = "!" + condition; + } + + // Resolve the element type of the collection for the lambda parameter + String elementType = resolveContainsElementType(collectionArg); + + StringBuilder sb = new StringBuilder(); + sb.append(" return std::any_of(").append(collection).append(".begin(), ") + .append(collection).append(".end(),\n"); + sb.append(" [](const ").append(elementType).append("& item) {\n"); + sb.append(" return ").append(condition).append(";\n"); + sb.append(" }) == expected.get();\n"); + return sb.toString(); + } + + /** + * Extracts collection getter and comparator from the contains() projection pattern: + * Projection(Flatten(Projection(Flatten(Field), MultiSelectList([cmp]))), Current) + */ + private ContainsProjectionInfo extractContainsProjection(JmespathExpression expr) { + // Outer: Projection(left=Flatten(...), right=Current) + if (!(expr instanceof ProjectionExpression)) return null; + ProjectionExpression outerProj = (ProjectionExpression) expr; + + // Unwrap outer flatten + JmespathExpression outerLeft = outerProj.getLeft(); + if (!(outerLeft instanceof FlattenExpression)) return null; + JmespathExpression innerExpr = ((FlattenExpression) outerLeft).getExpression(); + + // Inner: Projection(left=Flatten(Field), right=MultiSelectList) + if (!(innerExpr instanceof ProjectionExpression)) return null; + ProjectionExpression innerProj = (ProjectionExpression) innerExpr; + + // Collection getter from inner left + String collectionGetter = innerProj.getLeft().accept(new CollectionGetterEmitter()); + + // MultiSelectList with single comparator expression + JmespathExpression innerRight = innerProj.getRight(); + if (!(innerRight instanceof MultiSelectListExpression)) return null; + MultiSelectListExpression multiSelect = (MultiSelectListExpression) innerRight; + if (multiSelect.getExpressions().size() != 1) return null; + + return new ContainsProjectionInfo(collectionGetter, multiSelect.getExpressions().get(0)); + } + + /** + * Resolves the element type for the collection in a contains() expression. + */ + private String resolveContainsElementType(JmespathExpression collectionArg) { + if (model == null || operation == null) return "auto"; + // collectionArg is: Projection(Flatten(Projection(Flatten(Field), MultiSelectList)), Current) + // The actual collection is accessed via the inner projection's left side. + if (!(collectionArg instanceof ProjectionExpression)) return "auto"; + JmespathExpression outerLeft = ((ProjectionExpression) collectionArg).getLeft(); + if (!(outerLeft instanceof FlattenExpression)) return "auto"; + JmespathExpression innerExpr = ((FlattenExpression) outerLeft).getExpression(); + if (!(innerExpr instanceof ProjectionExpression)) return "auto"; + // Resolve element type of the inner projection + return CollectionElementTypeResolver.resolve(innerExpr, model, operation, smithyServiceName); + } + + private String emitPathCode(JmespathExpression expr) { + int projectionLevels = expr.accept(new ProjectionCounter()); + EnumInfo enumInfo = EnumResolver.resolveEnumInfo(expr, model, operation); + + if (projectionLevels == 0) { + String access = "result" + expr.accept(new GetterChainEmitter()); + if (enumInfo != null) { + access = enumInfo.wrapAccess(access); + enumIncludes.add(enumInfo.shapeName); + } + String expectedType = comparator == PathComparator.BOOLEAN_EQUALS ? "bool" : "Aws::String"; + return " return " + access + " == expected.get<" + expectedType + ">();\n"; + } else { + String algo = comparator == PathComparator.ALL_STRING_EQUALS ? "std::all_of" : "std::any_of"; + if (enumInfo != null) enumIncludes.add(enumInfo.shapeName); + return expr.accept(new ProjectionEmitter(algo, projectionLevels, enumInfo, 0, model, operation, smithyServiceName)); + } + } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/UnsupportedExpressionVisitor.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/UnsupportedExpressionVisitor.java new file mode 100644 index 00000000000..83267deaa11 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/UnsupportedExpressionVisitor.java @@ -0,0 +1,54 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; + +import software.amazon.smithy.jmespath.ExpressionVisitor; +import software.amazon.smithy.jmespath.JmespathExpression; +import software.amazon.smithy.jmespath.ast.AndExpression; +import software.amazon.smithy.jmespath.ast.ComparatorExpression; +import software.amazon.smithy.jmespath.ast.CurrentExpression; +import software.amazon.smithy.jmespath.ast.ExpressionTypeExpression; +import software.amazon.smithy.jmespath.ast.FieldExpression; +import software.amazon.smithy.jmespath.ast.FilterProjectionExpression; +import software.amazon.smithy.jmespath.ast.FlattenExpression; +import software.amazon.smithy.jmespath.ast.FunctionExpression; +import software.amazon.smithy.jmespath.ast.IndexExpression; +import software.amazon.smithy.jmespath.ast.LiteralExpression; +import software.amazon.smithy.jmespath.ast.MultiSelectHashExpression; +import software.amazon.smithy.jmespath.ast.MultiSelectListExpression; +import software.amazon.smithy.jmespath.ast.NotExpression; +import software.amazon.smithy.jmespath.ast.ObjectProjectionExpression; +import software.amazon.smithy.jmespath.ast.OrExpression; +import software.amazon.smithy.jmespath.ast.ProjectionExpression; +import software.amazon.smithy.jmespath.ast.SliceExpression; +import software.amazon.smithy.jmespath.ast.Subexpression; + +/** + * Base visitor that throws {@link UnsupportedOperationException} for every node type. + * Concrete visitors override only the methods they handle. + */ +public abstract class UnsupportedExpressionVisitor implements ExpressionVisitor { + private T fail(JmespathExpression e) { + throw new UnsupportedOperationException("Unsupported expression: " + e.getClass().getSimpleName()); + } + @Override public T visitComparator(ComparatorExpression e) { return fail(e); } + @Override public T visitCurrentNode(CurrentExpression e) { return fail(e); } + @Override public T visitExpressionType(ExpressionTypeExpression e) { return fail(e); } + @Override public T visitField(FieldExpression e) { return fail(e); } + @Override public T visitFilterProjection(FilterProjectionExpression e) { return fail(e); } + @Override public T visitFlatten(FlattenExpression e) { return fail(e); } + @Override public T visitFunction(FunctionExpression e) { return fail(e); } + @Override public T visitIndex(IndexExpression e) { return fail(e); } + @Override public T visitLiteral(LiteralExpression e) { return fail(e); } + @Override public T visitMultiSelectHash(MultiSelectHashExpression e) { return fail(e); } + @Override public T visitMultiSelectList(MultiSelectListExpression e) { return fail(e); } + @Override public T visitAnd(AndExpression e) { return fail(e); } + @Override public T visitOr(OrExpression e) { return fail(e); } + @Override public T visitNot(NotExpression e) { return fail(e); } + @Override public T visitObjectProjection(ObjectProjectionExpression e) { return fail(e); } + @Override public T visitProjection(ProjectionExpression e) { return fail(e); } + @Override public T visitSlice(SliceExpression e) { return fail(e); } + @Override public T visitSubexpression(Subexpression e) { return fail(e); } +} diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/resources/META-INF/services/software.amazon.smithy.build.SmithyBuildPlugin b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/resources/META-INF/services/software.amazon.smithy.build.SmithyBuildPlugin index d1ade5942e3..3bb1b09e44c 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/resources/META-INF/services/software.amazon.smithy.build.SmithyBuildPlugin +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/resources/META-INF/services/software.amazon.smithy.build.SmithyBuildPlugin @@ -1 +1,2 @@ com.amazonaws.util.awsclientsmithygenerator.generators.pagination.PaginationCodegenPlugin +com.amazonaws.util.awsclientsmithygenerator.generators.waiters.WaiterCodegenPlugin From 5ee519a7f0dc06fab6b0717d3534cbd51e0cfad0 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Mon, 16 Mar 2026 14:30:17 -0400 Subject: [PATCH 03/21] Waiter codegen tests --- .../WaiterJmesPathCppCodeGeneratorTest.java | 727 ++++++++++++++++++ 1 file changed, 727 insertions(+) create mode 100644 tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/test/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterJmesPathCppCodeGeneratorTest.java diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/test/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterJmesPathCppCodeGeneratorTest.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/test/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterJmesPathCppCodeGeneratorTest.java new file mode 100644 index 00000000000..1bb6b05fa49 --- /dev/null +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/test/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterJmesPathCppCodeGeneratorTest.java @@ -0,0 +1,727 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ +package com.amazonaws.util.awsclientsmithygenerator.generators.waiters; + +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.EnumShape; +import software.amazon.smithy.model.shapes.StructureShape; +import software.amazon.smithy.model.shapes.ListShape; +import software.amazon.smithy.model.shapes.ShapeId; +import software.amazon.smithy.model.shapes.MapShape; +import software.amazon.smithy.waiters.PathComparator; + +import java.util.Set; + +import static org.junit.jupiter.api.Assertions.*; + +class WaiterJmesPathCppCodeGeneratorTest { + + private final String OUTCOME = "Model::TestOutcome"; + + private String gen(String jmesPath, PathComparator comparator) { + return WaiterJmesPathCppCodeGenerator.generate(jmesPath, comparator, OUTCOME, null, null, "testService").getCode(); + } + + // ── Full code generation tests (no model) ──────────────────────────── + + @Nested + class GenerateTests { + + @Test + void lambdaHasCorrectSignature() { + String code = gen("Items[].Status", PathComparator.ALL_STRING_EQUALS); + assertTrue(code.startsWith("[](const " + OUTCOME + "& outcome, const Aws::Utils::ExpectedValue& expected) {")); + assertTrue(code.endsWith("}")); + } + + @Test + void lambdaChecksSuccess() { + assertContains(gen("Items[].Status", PathComparator.ALL_STRING_EQUALS), + "if (!outcome.IsSuccess()) return false;"); + } + + @Test + void lambdaGetsResult() { + assertContains(gen("Items[].Status", PathComparator.ALL_STRING_EQUALS), + "const auto& result = outcome.GetResult();"); + } + + @Test + void allStringEquals_singleProjection() { + String code = gen("BundleTasks[].State", PathComparator.ALL_STRING_EQUALS); + assertContains(code, "std::all_of(result.GetBundleTasks().begin(), result.GetBundleTasks().end(),"); + assertContains(code, "item.GetState() == expected.get()"); + } + + @Test + void allStringEquals_projectionWithNestedFields() { + String code = gen("ImportSnapshotTasks[].SnapshotTaskDetail.Status", PathComparator.ALL_STRING_EQUALS); + assertContains(code, "std::all_of(result.GetImportSnapshotTasks().begin()"); + assertContains(code, "item.GetSnapshotTaskDetail().GetStatus() == expected.get()"); + } + + @Test + void allStringEquals_nestedFieldBeforeProjection() { + String code = gen("Certificate.DomainValidationOptions[].ValidationStatus", PathComparator.ALL_STRING_EQUALS); + assertContains(code, "std::all_of(result.GetCertificate().GetDomainValidationOptions().begin()"); + assertContains(code, "item.GetValidationStatus() == expected.get()"); + } + + @Test + void allStringEquals_nestedProjection() { + String code = gen("Reservations[].Instances[].State.Name", PathComparator.ALL_STRING_EQUALS); + assertContains(code, "std::all_of(result.GetReservations().begin(), result.GetReservations().end(),"); + assertContains(code, "std::all_of(item0.GetInstances().begin(), item0.GetInstances().end(),"); + assertContains(code, "item1.GetState().GetName() == expected.get()"); + } + + @Test + void anyStringEquals_singleProjection() { + String code = gen("BundleTasks[].State", PathComparator.ANY_STRING_EQUALS); + assertContains(code, "std::any_of(result.GetBundleTasks().begin(), result.GetBundleTasks().end(),"); + } + + @Test + void stringEquals_directField() { + assertContains(gen("Status", PathComparator.STRING_EQUALS), + "return result.GetStatus() == expected.get();"); + } + + @Test + void stringEquals_nestedField() { + assertContains(gen("Cluster.Status", PathComparator.STRING_EQUALS), + "return result.GetCluster().GetStatus() == expected.get();"); + } + + @Test + void stringEquals_deeplyNestedField() { + assertContains(gen("Cluster.Config.Status", PathComparator.STRING_EQUALS), + "return result.GetCluster().GetConfig().GetStatus() == expected.get();"); + } + + @Test + void booleanEquals_directField() { + assertContains(gen("Enabled", PathComparator.BOOLEAN_EQUALS), + "return result.GetEnabled() == expected.get();"); + } + + @Test + void lengthOfProjection_greaterThanZero() { + assertContains(gen("length(Images[]) > `0`", PathComparator.BOOLEAN_EQUALS), + "return (result.GetImages().size() > 0) == expected.get();"); + } + + @Test + void lengthOfProjection_equalsZero() { + assertContains(gen("length(SecurityGroupVpcAssociations[]) == `0`", PathComparator.BOOLEAN_EQUALS), + "return (result.GetSecurityGroupVpcAssociations().size() == 0) == expected.get();"); + } + + @Test + void lengthOfField_greaterThanZero() { + assertContains(gen("length(PasswordData) > `0`", PathComparator.BOOLEAN_EQUALS), + "return (result.GetPasswordData().size() > 0) == expected.get();"); + } + + @Test + void lengthOfProjectionWithField_greaterThanZero() { + String code = gen("length(KeyPairs[].KeyName) > `0`", PathComparator.BOOLEAN_EQUALS); + assertContains(code, "result.GetKeyPairs().size() > 0"); + assertContains(code, "== expected.get();"); + } + + @Test + void lengthOfNestedField_greaterThanZero() { + assertContains(gen("length(InternetGateways[].InternetGatewayId) > `0`", PathComparator.BOOLEAN_EQUALS), + "result.GetInternetGateways().size() > 0"); + } + + @Test + void noModel_returnsEmptyEnumIncludes() { + var result = WaiterJmesPathCppCodeGenerator.generate( + "Items[].State", PathComparator.ALL_STRING_EQUALS, OUTCOME, null, null, "testService"); + assertTrue(result.getEnumIncludes().isEmpty()); + } + } + + // ── Enum resolution tests ──────────────────────────────────────────── + + @Nested + class EnumResolutionTests { + + private Model buildSimpleEnumModel() { + EnumShape enumShape = EnumShape.builder() + .id("test.ns#ItemState") + .addMember("active", "active") + .addMember("inactive", "inactive") + .build(); + StructureShape itemShape = StructureShape.builder() + .id("test.ns#Item") + .addMember("State", enumShape.getId()) + .build(); + ListShape listShape = ListShape.builder() + .id("test.ns#ItemList") + .member(itemShape.getId()) + .build(); + StructureShape outputShape = StructureShape.builder() + .id("test.ns#DescribeItemsOutput") + .addMember("Items", listShape.getId()) + .build(); + StructureShape inputShape = StructureShape.builder() + .id("test.ns#DescribeItemsInput") + .build(); + OperationShape opShape = OperationShape.builder() + .id("test.ns#DescribeItems") + .input(inputShape.getId()) + .output(outputShape.getId()) + .build(); + return Model.builder() + .addShapes(enumShape, itemShape, listShape, outputShape, inputShape, opShape) + .build(); + } + + private Model buildNestedEnumModel() { + EnumShape enumShape = EnumShape.builder() + .id("test.ns#DetailStatus") + .addMember("ok", "ok") + .addMember("error", "error") + .build(); + StructureShape detailShape = StructureShape.builder() + .id("test.ns#Detail") + .addMember("Status", enumShape.getId()) + .build(); + StructureShape itemShape = StructureShape.builder() + .id("test.ns#Item") + .addMember("Detail", detailShape.getId()) + .build(); + ListShape listShape = ListShape.builder() + .id("test.ns#ItemList") + .member(itemShape.getId()) + .build(); + StructureShape outputShape = StructureShape.builder() + .id("test.ns#DescribeItemsOutput") + .addMember("Items", listShape.getId()) + .build(); + StructureShape inputShape = StructureShape.builder() + .id("test.ns#DescribeItemsInput") + .build(); + OperationShape opShape = OperationShape.builder() + .id("test.ns#DescribeItems") + .input(inputShape.getId()) + .output(outputShape.getId()) + .build(); + return Model.builder() + .addShapes(enumShape, detailShape, itemShape, listShape, outputShape, inputShape, opShape) + .build(); + } + + private Model buildStringLeafModel() { + StructureShape itemShape = StructureShape.builder() + .id("test.ns#Item") + .addMember("Name", ShapeId.from("smithy.api#String")) + .build(); + ListShape listShape = ListShape.builder() + .id("test.ns#ItemList") + .member(itemShape.getId()) + .build(); + StructureShape outputShape = StructureShape.builder() + .id("test.ns#DescribeItemsOutput") + .addMember("Items", listShape.getId()) + .build(); + StructureShape inputShape = StructureShape.builder() + .id("test.ns#DescribeItemsInput") + .build(); + OperationShape opShape = OperationShape.builder() + .id("test.ns#DescribeItems") + .input(inputShape.getId()) + .output(outputShape.getId()) + .build(); + return Model.builder() + .addShapes(itemShape, listShape, outputShape, inputShape, opShape) + .build(); + } + + private Model buildNestedProjectionEnumModel() { + EnumShape enumShape = EnumShape.builder() + .id("test.ns#MyStatus") + .addMember("running", "running") + .addMember("stopped", "stopped") + .build(); + StructureShape infoShape = StructureShape.builder() + .id("test.ns#Info") + .addMember("Status", enumShape.getId()) + .build(); + StructureShape innerShape = StructureShape.builder() + .id("test.ns#Inner") + .addMember("Info", infoShape.getId()) + .build(); + ListShape innerList = ListShape.builder() + .id("test.ns#InnerList") + .member(innerShape.getId()) + .build(); + StructureShape outerShape = StructureShape.builder() + .id("test.ns#Outer") + .addMember("Inner", innerList.getId()) + .build(); + ListShape outerList = ListShape.builder() + .id("test.ns#OuterList") + .member(outerShape.getId()) + .build(); + StructureShape outputShape = StructureShape.builder() + .id("test.ns#DescribeOutput") + .addMember("Outer", outerList.getId()) + .build(); + StructureShape inputShape = StructureShape.builder() + .id("test.ns#DescribeInput") + .build(); + OperationShape opShape = OperationShape.builder() + .id("test.ns#Describe") + .input(inputShape.getId()) + .output(outputShape.getId()) + .build(); + return Model.builder() + .addShapes(enumShape, infoShape, innerShape, innerList, outerShape, outerList, + outputShape, inputShape, opShape) + .build(); + } + + private Model buildCountIfModel() { + StructureShape itemShape = StructureShape.builder() + .id("test.ns#Item") + .addMember("Status", ShapeId.from("smithy.api#String")) + .build(); + ListShape listShape = ListShape.builder() + .id("test.ns#ItemList") + .member(itemShape.getId()) + .build(); + StructureShape outputShape = StructureShape.builder() + .id("test.ns#DescribeItemsOutput") + .addMember("Items", listShape.getId()) + .build(); + StructureShape inputShape = StructureShape.builder() + .id("test.ns#DescribeItemsInput") + .build(); + OperationShape opShape = OperationShape.builder() + .id("test.ns#DescribeItems") + .input(inputShape.getId()) + .output(outputShape.getId()) + .build(); + return Model.builder() + .addShapes(itemShape, listShape, outputShape, inputShape, opShape) + .build(); + } + + private OperationShape getOp(Model model, String name) { + return model.expectShape(ShapeId.from("test.ns#" + name), OperationShape.class); + } + + @Test + void enumLeaf_wrapsInMapper() { + Model model = buildSimpleEnumModel(); + OperationShape op = getOp(model, "DescribeItems"); + var result = WaiterJmesPathCppCodeGenerator.generate( + "Items[].State", PathComparator.ALL_STRING_EQUALS, OUTCOME, model, op, "testService"); + + assertContains(result.getCode(), + "ItemStateMapper::GetNameForItemState(item.GetState()) == expected.get()"); + assertEquals(Set.of("ItemState"), result.getEnumIncludes()); + } + + @Test + void enumLeaf_nestedStruct_wrapsInMapper() { + Model model = buildNestedEnumModel(); + OperationShape op = getOp(model, "DescribeItems"); + var result = WaiterJmesPathCppCodeGenerator.generate( + "Items[].Detail.Status", PathComparator.ALL_STRING_EQUALS, OUTCOME, model, op, "testService"); + + assertContains(result.getCode(), + "DetailStatusMapper::GetNameForDetailStatus(item.GetDetail().GetStatus()) == expected.get()"); + assertEquals(Set.of("DetailStatus"), result.getEnumIncludes()); + } + + @Test + void stringLeaf_noMapperWrapping() { + Model model = buildStringLeafModel(); + OperationShape op = getOp(model, "DescribeItems"); + var result = WaiterJmesPathCppCodeGenerator.generate( + "Items[].Name", PathComparator.ALL_STRING_EQUALS, OUTCOME, model, op, "testService"); + + assertContains(result.getCode(), "item.GetName() == expected.get()"); + assertFalse(result.getCode().contains("Mapper")); + assertTrue(result.getEnumIncludes().isEmpty()); + } + + @Test + void nestedProjection_enumLeaf_wrapsInMapper() { + Model model = buildNestedProjectionEnumModel(); + OperationShape op = getOp(model, "Describe"); + var result = WaiterJmesPathCppCodeGenerator.generate( + "Outer[].Inner[].Info.Status", PathComparator.ALL_STRING_EQUALS, OUTCOME, model, op, "testService"); + + assertContains(result.getCode(), + "MyStatusMapper::GetNameForMyStatus(item1.GetInfo().GetStatus()) == expected.get()"); + assertEquals(Set.of("MyStatus"), result.getEnumIncludes()); + } + + @Test + void enumLeaf_anyStringEquals_wrapsInMapper() { + Model model = buildSimpleEnumModel(); + OperationShape op = getOp(model, "DescribeItems"); + var result = WaiterJmesPathCppCodeGenerator.generate( + "Items[].State", PathComparator.ANY_STRING_EQUALS, OUTCOME, model, op, "testService"); + + assertContains(result.getCode(), "std::any_of"); + assertContains(result.getCode(), "ItemStateMapper::GetNameForItemState(item.GetState())"); + } + + @Test + void nullModel_noEnumResolution() { + var result = WaiterJmesPathCppCodeGenerator.generate( + "Items[].State", PathComparator.ALL_STRING_EQUALS, OUTCOME, null, null, "testService"); + assertFalse(result.getCode().contains("Mapper")); + assertTrue(result.getEnumIncludes().isEmpty()); + } + + @Test + void withModel_usesConcreteTypeInLambda() { + Model model = buildSimpleEnumModel(); + OperationShape op = getOp(model, "DescribeItems"); + var result = WaiterJmesPathCppCodeGenerator.generate( + "Items[].State", PathComparator.ALL_STRING_EQUALS, OUTCOME, model, op, "testService"); + assertContains(result.getCode(), "(const Model::Item& item)"); + assertFalse(result.getCode().contains("const auto& item")); + } + + @Test + void withoutModel_usesAutoInLambda() { + var result = WaiterJmesPathCppCodeGenerator.generate( + "Items[].State", PathComparator.ALL_STRING_EQUALS, OUTCOME, null, null, "testService"); + assertContains(result.getCode(), "(const auto& item)"); + } + + @Test + void nestedProjection_withModel_usesConcreteTypes() { + Model model = buildNestedProjectionEnumModel(); + OperationShape op = getOp(model, "Describe"); + var result = WaiterJmesPathCppCodeGenerator.generate( + "Outer[].Inner[].Info.Status", PathComparator.ALL_STRING_EQUALS, OUTCOME, model, op, "testService"); + assertContains(result.getCode(), "(const Model::Outer& item0)"); + assertContains(result.getCode(), "(const Model::Inner& item1)"); + } + + @Test + void countIf_withModel_usesConcreteType() { + Model model = buildCountIfModel(); + OperationShape op = getOp(model, "DescribeItems"); + var result = WaiterJmesPathCppCodeGenerator.generate( + "length(Items[?Status == 'DISABLED']) == `0`", + PathComparator.BOOLEAN_EQUALS, OUTCOME, model, op, "testService"); + assertContains(result.getCode(), "(const Model::Item& item)"); + } + } + + // ── Brace-balancing tests ──────────────────────────────────────────── + + @Nested + class BraceBalancingTests { + + @Test + void singleProjection() { assertBalanced("Items[].Status", PathComparator.ALL_STRING_EQUALS); } + @Test + void nestedProjection() { assertBalanced("Reservations[].Instances[].State.Name", PathComparator.ALL_STRING_EQUALS); } + @Test + void comparison() { assertBalanced("length(Images[]) > `0`", PathComparator.BOOLEAN_EQUALS); } + @Test + void directField() { assertBalanced("Status", PathComparator.STRING_EQUALS); } + + private void assertBalanced(String jmesPath, PathComparator comparator) { + String code = gen(jmesPath, comparator); + int braces = 0, parens = 0; + for (char c : code.toCharArray()) { + if (c == '{') braces++; + else if (c == '}') braces--; + else if (c == '(') parens++; + else if (c == ')') parens--; + } + assertEquals(0, braces, "Unbalanced braces in:\n" + code); + assertEquals(0, parens, "Unbalanced parens in:\n" + code); + } + } + + // ── Real EC2 waiter expressions ────────────────────────────────────── + + @Nested + class Ec2WaiterExpressionTests { + + @ParameterizedTest(name = "{0} ({1})") + @CsvSource({ + "BundleTasks[].State, ALL_STRING_EQUALS", + "ConversionTasks[].State, ALL_STRING_EQUALS", + "CustomerGateways[].State, ALL_STRING_EQUALS", + "ExportTasks[].State, ALL_STRING_EQUALS", + "Images[].State, ALL_STRING_EQUALS", + "NatGateways[].State, ALL_STRING_EQUALS", + "NetworkInterfaces[].Status, ALL_STRING_EQUALS", + "Snapshots[].State, ALL_STRING_EQUALS", + "Subnets[].State, ALL_STRING_EQUALS", + "Volumes[].State, ALL_STRING_EQUALS", + "Vpcs[].State, ALL_STRING_EQUALS", + "VpnConnections[].State, ALL_STRING_EQUALS", + "BundleTasks[].State, ANY_STRING_EQUALS", + "NatGateways[].State, ANY_STRING_EQUALS", + "VpnConnections[].State, ANY_STRING_EQUALS", + "ImportSnapshotTasks[].SnapshotTaskDetail.Status, ALL_STRING_EQUALS", + "InstanceStatuses[].InstanceStatus.Status, ALL_STRING_EQUALS", + "InstanceStatuses[].SystemStatus.Status, ALL_STRING_EQUALS", + "SpotInstanceRequests[].Status.Code, ALL_STRING_EQUALS", + "VpcPeeringConnections[].Status.Code, ALL_STRING_EQUALS", + "Reservations[].Instances[].State.Name, ALL_STRING_EQUALS", + "Reservations[].Instances[].State.Name, ANY_STRING_EQUALS", + }) + void pathExpression_generatesValidCode(String jmesPath, String comparator) { + var result = WaiterJmesPathCppCodeGenerator.generate( + jmesPath, PathComparator.valueOf(comparator), OUTCOME, null, null, "testService"); + String code = result.getCode(); + + assertNotNull(code); + assertContains(code, "outcome.IsSuccess()"); + assertContains(code, "outcome.GetResult()"); + if (comparator.equals("ALL_STRING_EQUALS")) { + assertContains(code, "std::all_of"); + } else { + assertContains(code, "std::any_of"); + } + } + + @ParameterizedTest(name = "{0}") + @CsvSource({ + "length(Images[]) > `0`", + "length(InternetGateways[].InternetGatewayId) > `0`", + "length(KeyPairs[].KeyName) > `0`", + "length(PasswordData) > `0`", + "length(Reservations[]) > `0`", + "length(SecurityGroupVpcAssociations[]) == `0`", + "length(SecurityGroups[].GroupId) > `0`", + }) + void comparisonExpression_generatesValidCode(String jmesPath) { + String code = WaiterJmesPathCppCodeGenerator.generate( + jmesPath, PathComparator.BOOLEAN_EQUALS, OUTCOME, null, null, "testService").getCode(); + + assertNotNull(code); + assertContains(code, ".size()"); + assertContains(code, "expected.get()"); + } + } + + // ── AND expression tests ────────────────────────────────────────────── + + @Nested + class AndExpressionTests { + + @Test + void andExpression_twoComparators() { + String code = gen("status != 'CANCELLING' && status != 'CANCELLED'", PathComparator.BOOLEAN_EQUALS); + assertContains(code, "result.GetStatus() != \"CANCELLING\""); + assertContains(code, "result.GetStatus() != \"CANCELLED\""); + assertContains(code, "&&"); + assertContains(code, "== expected.get();"); + } + + @Test + void andExpression_bracesBalanced() { + assertBalanced("status != 'CANCELLING' && status != 'CANCELLED'", PathComparator.BOOLEAN_EQUALS); + } + + @Test + void filterProjectionComparison_withoutAnd() { + String expr = "length(Items[?Status == 'DISABLED' || Status == 'FAILED']) == length(Items)"; + String code = gen(expr, PathComparator.BOOLEAN_EQUALS); + assertContains(code, "std::count_if"); + assertContains(code, "item.GetStatus() == \"DISABLED\""); + assertContains(code, "item.GetStatus() == \"FAILED\""); + assertContains(code, "result.GetItems().size()"); + assertContains(code, "== expected.get();"); + } + + @Test + void filterProjection_notWithLengthAndFieldComparison() { + String expr = "length(services[?!(length(deployments) == `1` && runningCount == desiredCount)]) == `0`"; + String code = gen(expr, PathComparator.BOOLEAN_EQUALS); + assertContains(code, "std::count_if"); + assertContains(code, "item.GetDeployments().size() == 1"); + assertContains(code, "item.GetRunningCount() == item.GetDesiredCount()"); + assertContains(code, "!"); + assertContains(code, "== 0"); + assertContains(code, "== expected.get();"); + } + + @Test + void andExpression_lengthWithFilterProjection() { + String expr = "length(KinesisDataStreamDestinations) > `0` && " + + "length(KinesisDataStreamDestinations[?DestinationStatus == 'DISABLED' " + + "|| DestinationStatus == 'ENABLE_FAILED']) == length(KinesisDataStreamDestinations)"; + String code = gen(expr, PathComparator.BOOLEAN_EQUALS); + assertContains(code, "result.GetKinesisDataStreamDestinations().size() > 0"); + assertContains(code, "std::count_if"); + assertContains(code, "item.GetDestinationStatus() == \"DISABLED\""); + assertContains(code, "item.GetDestinationStatus() == \"ENABLE_FAILED\""); + assertContains(code, "||"); + assertContains(code, "== expected.get();"); + assertBalanced(expr, PathComparator.BOOLEAN_EQUALS); + } + + private void assertBalanced(String jmesPath, PathComparator comparator) { + String code = gen(jmesPath, comparator); + int braces = 0, parens = 0; + for (char c : code.toCharArray()) { + if (c == '{') braces++; + else if (c == '}') braces--; + else if (c == '(') parens++; + else if (c == ')') parens--; + } + assertEquals(0, braces, "Unbalanced braces in:\n" + code); + assertEquals(0, parens, "Unbalanced parens in:\n" + code); + } + } + + // ── contains() expression tests ─────────────────────────────────── + + @Nested + class ContainsExpressionTests { + + @Test + void contains_autoScalingGroupMinSize() { + String expr = "contains(AutoScalingGroups[].[length(Instances[?LifecycleState=='InService']) >= MinSize][], `false`)"; + String code = gen(expr, PathComparator.BOOLEAN_EQUALS); + assertContains(code, "std::any_of(result.GetAutoScalingGroups().begin()"); + assertContains(code, "std::count_if(item.GetInstances().begin(), item.GetInstances().end()"); + assertContains(code, "inner.GetLifecycleState() == \"InService\""); + assertContains(code, ">= item.GetMinSize()"); + assertContains(code, "== expected.get();"); + } + + @Test + void contains_bracesBalanced() { + String expr = "contains(AutoScalingGroups[].[length(Instances[?LifecycleState=='InService']) >= MinSize][], `false`)"; + String code = gen(expr, PathComparator.BOOLEAN_EQUALS); + int braces = 0, parens = 0; + for (char c : code.toCharArray()) { + if (c == '{') braces++; + else if (c == '}') braces--; + else if (c == '(') parens++; + else if (c == ')') parens--; + } + assertEquals(0, braces, "Unbalanced braces in:\n" + code); + assertEquals(0, parens, "Unbalanced parens in:\n" + code); + } + } + + // ── Object projection (map wildcard) tests ────────────────────────── + + @Nested + class ObjectProjectionTests { + + @Test + void objectProjection_simpleMapWildcard() { + // VerificationAttributes.*.VerificationStatus + String code = gen("VerificationAttributes.*.VerificationStatus", PathComparator.ALL_STRING_EQUALS); + assertContains(code, "std::all_of(result.GetVerificationAttributes().begin(), result.GetVerificationAttributes().end(),"); + assertContains(code, ".second"); + assertContains(code, ".GetVerificationStatus() == expected.get()"); + } + + @Test + void objectProjection_anyStringEquals() { + String code = gen("VerificationAttributes.*.VerificationStatus", PathComparator.ANY_STRING_EQUALS); + assertContains(code, "std::any_of"); + assertContains(code, ".second"); + } + + @Test + void objectProjection_enumLeaf_wrapsInMapper() { + // Models SES: VerificationAttributes.*.VerificationStatus where VerificationStatus is an enum + EnumShape enumShape = EnumShape.builder() + .id("test.ns#VerificationStatus") + .addMember("Success", "Success") + .addMember("Pending", "Pending") + .addMember("Failed", "Failed") + .build(); + StructureShape attrShape = StructureShape.builder() + .id("test.ns#IdentityVerificationAttributes") + .addMember("VerificationStatus", enumShape.getId()) + .build(); + MapShape mapShape = MapShape.builder() + .id("test.ns#VerificationAttributesMap") + .key(ShapeId.from("smithy.api#String")) + .value(attrShape.getId()) + .build(); + StructureShape outputShape = StructureShape.builder() + .id("test.ns#GetIdentityVerificationAttributesOutput") + .addMember("VerificationAttributes", mapShape.getId()) + .build(); + StructureShape inputShape = StructureShape.builder() + .id("test.ns#GetIdentityVerificationAttributesInput") + .build(); + OperationShape opShape = OperationShape.builder() + .id("test.ns#GetIdentityVerificationAttributes") + .input(inputShape.getId()) + .output(outputShape.getId()) + .build(); + Model model = Model.builder() + .addShapes(enumShape, attrShape, mapShape, outputShape, inputShape, opShape) + .build(); + OperationShape op = model.expectShape( + ShapeId.from("test.ns#GetIdentityVerificationAttributes"), OperationShape.class); + + var result = WaiterJmesPathCppCodeGenerator.generate( + "VerificationAttributes.*.VerificationStatus", + PathComparator.ALL_STRING_EQUALS, OUTCOME, model, op, "testService"); + + assertContains(result.getCode(), + "VerificationStatusMapper::GetNameForVerificationStatus(item.GetVerificationStatus())"); + assertContains(result.getCode(), ".second"); + assertEquals(Set.of("VerificationStatus"), result.getEnumIncludes()); + } + + @Test + void objectProjection_bracesBalanced() { + String code = gen("VerificationAttributes.*.VerificationStatus", PathComparator.ALL_STRING_EQUALS); + int braces = 0, parens = 0; + for (char c : code.toCharArray()) { + if (c == '{') braces++; + else if (c == '}') braces--; + else if (c == '(') parens++; + else if (c == ')') parens--; + } + assertEquals(0, braces, "Unbalanced braces in:\n" + code); + assertEquals(0, parens, "Unbalanced parens in:\n" + code); + } + } + + // ── Error handling ─────────────────────────────────────────────────── + + @Nested + class ErrorHandlingTests { + + @Test + void unsupportedFunction_throws() { + assertThrows(UnsupportedOperationException.class, () -> + WaiterJmesPathCppCodeGenerator.generate( + "sort(Items[]) > `0`", PathComparator.BOOLEAN_EQUALS, OUTCOME, null, null, "testService")); + } + } + + // ── Helpers ────────────────────────────────────────────────────────── + + private void assertContains(String haystack, String needle) { + assertTrue(haystack.contains(needle), + "Expected to find:\n " + needle + "\nin:\n" + haystack); + } +} From 6e1ee56251beb51f598a727164b530986b7fb12c Mon Sep 17 00:00:00 2001 From: sbaluja Date: Mon, 16 Mar 2026 15:41:54 -0400 Subject: [PATCH 04/21] Update crtp client inheritance & python script for smithy codegen --- .../velocity/cpp/cbor/CborServiceClientHeader.vm | 8 ++++++++ .../velocity/cpp/json/JsonServiceClientHeader.vm | 3 ++- .../awsclientgenerator/velocity/cpp/s3/S3ClientHeader.vm | 3 ++- .../velocity/cpp/smithy/SmithyClientHeader.vm | 3 ++- .../velocity/cpp/xml/XmlServiceClientHeader.vm | 3 ++- tools/scripts/codegen/smithy_cpp_gen.py | 8 +++++--- 6 files changed, 21 insertions(+), 7 deletions(-) diff --git a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/cbor/CborServiceClientHeader.vm b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/cbor/CborServiceClientHeader.vm index f8163a2cf7a..ccec9bafb25 100644 --- a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/cbor/CborServiceClientHeader.vm +++ b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/cbor/CborServiceClientHeader.vm @@ -11,6 +11,10 @@ \#include \#include \#include +#if(!$serviceModel.disableSmithyGeneration) +\#include +\#include +#end namespace ${rootNamespace} { @@ -25,7 +29,11 @@ namespace ${serviceNamespace} #if($serviceModel.enableVirtualOperations) #set($finalClass = "") #end +#if(!$serviceModel.disableSmithyGeneration) +class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}${finalClass} : public Aws::Client::AWSRpcV2CborClient, public Aws::Client::ClientWithAsyncTemplateMethods<${className}>, public ${metadata.classNamePrefix}PaginationBase<${className}>, public ${metadata.classNamePrefix}Waiter<${className}> +#else class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}${finalClass} : public Aws::Client::AWSRpcV2CborClient, public Aws::Client::ClientWithAsyncTemplateMethods<${className}> +#end { public: typedef Aws::Client::AWSRpcV2CborClient BASECLASS; diff --git a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/json/JsonServiceClientHeader.vm b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/json/JsonServiceClientHeader.vm index 7443ba3fcc0..bcb23eed6b2 100644 --- a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/json/JsonServiceClientHeader.vm +++ b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/json/JsonServiceClientHeader.vm @@ -13,6 +13,7 @@ \#include #if(!$serviceModel.disableSmithyGeneration) \#include +\#include #end namespace ${rootNamespace} @@ -29,7 +30,7 @@ namespace ${serviceNamespace} #set($finalClass = "") #end #if(!$serviceModel.disableSmithyGeneration) - class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}${finalClass} : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<${className}>, public ${metadata.classNamePrefix}PaginationBase<${className}> + class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}${finalClass} : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<${className}>, public ${metadata.classNamePrefix}PaginationBase<${className}>, public ${metadata.classNamePrefix}Waiter<${className}> #else class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}${finalClass} : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods<${className}> #end diff --git a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/s3/S3ClientHeader.vm b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/s3/S3ClientHeader.vm index c36eba7b142..0f145d575aa 100644 --- a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/s3/S3ClientHeader.vm +++ b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/s3/S3ClientHeader.vm @@ -24,6 +24,7 @@ \#include #if(!$serviceModel.disableSmithyGeneration) \#include +\#include #end #if($serviceNamespace == "S3Crt") \#include @@ -98,7 +99,7 @@ namespace ${rootNamespace} #set($finalClass = "") #end #if(!$serviceModel.disableSmithyGeneration) - class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}${finalClass} : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<${className}>, public ${metadata.classNamePrefix}PaginationBase<${className}> + class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}${finalClass} : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<${className}>, public ${metadata.classNamePrefix}PaginationBase<${className}>, public ${metadata.classNamePrefix}Waiter<${className}> #else class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}${finalClass} : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<${className}> #end diff --git a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/smithy/SmithyClientHeader.vm b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/smithy/SmithyClientHeader.vm index 5d82e5f1334..4ff3b61fdce 100644 --- a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/smithy/SmithyClientHeader.vm +++ b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/smithy/SmithyClientHeader.vm @@ -19,6 +19,7 @@ \#include #if(!$serviceModel.disableSmithyGeneration) \#include +\#include #end \#include #if($serviceModel.hasBearerAuth()) @@ -61,7 +62,7 @@ namespace ${serviceNamespace} smithy::client::$serializer, smithy::client::$serializerOutcome, Aws::Client::${metadata.classNamePrefix}ErrorMarshaller>, - public ${metadata.classNamePrefix}PaginationBase<${className}> + public ${metadata.classNamePrefix}PaginationBase<${className}>, public ${metadata.classNamePrefix}Waiter<${className}> #else class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}${finalClass} : Aws::Client::ClientWithAsyncTemplateMethods<${className}>, public smithy::client::AwsSmithyClientT<${rootNamespace}::${serviceNamespace}::SERVICE_NAME, diff --git a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/xml/XmlServiceClientHeader.vm b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/xml/XmlServiceClientHeader.vm index cf41f98ab1a..0e0d60a29bc 100644 --- a/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/xml/XmlServiceClientHeader.vm +++ b/tools/code-generation/generator/src/main/resources/com/amazonaws/util/awsclientgenerator/velocity/cpp/xml/XmlServiceClientHeader.vm @@ -14,6 +14,7 @@ \#include #if(!$serviceModel.disableSmithyGeneration) \#include +\#include #end namespace ${rootNamespace} @@ -30,7 +31,7 @@ namespace ${serviceNamespace} #set($finalClass = "") #end #if(!$serviceModel.disableSmithyGeneration) - class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}$finalClass : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<${className}>, public ${metadata.classNamePrefix}PaginationBase<${className}> + class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}$finalClass : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<${className}>, public ${metadata.classNamePrefix}PaginationBase<${className}>, public ${metadata.classNamePrefix}Waiter<${className}> #else class ${CppViewHelper.computeExportValue($metadata.classNamePrefix)} ${className}$finalClass : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods<${className}> #end diff --git a/tools/scripts/codegen/smithy_cpp_gen.py b/tools/scripts/codegen/smithy_cpp_gen.py index 3ddbfbe43c5..a9aa0adfd7b 100644 --- a/tools/scripts/codegen/smithy_cpp_gen.py +++ b/tools/scripts/codegen/smithy_cpp_gen.py @@ -38,7 +38,7 @@ def generate(self, clients_to_build: set): target_dir = os.path.abspath("generated/src") self._copy_cpp_codegen_contents( os.path.abspath("tools/code-generation/smithy/cpp-codegen"), - "smithy-cpp-codegen", + ["smithy-cpp-codegen-paginators", "smithy-cpp-codegen-waiters"], target_dir ) return 0 @@ -75,7 +75,7 @@ def _generate_pagination(self, smithy_services: List[str], smithy_c2j_data: str) print(f"Command failed: {e.returncode}\nError: {e.stderr}") return False - def _copy_cpp_codegen_contents(self, top_level_dir: str, plugin_name: str, target_dir: str): + def _copy_cpp_codegen_contents(self, top_level_dir: str, plugin_names: List[str], target_dir: str): # Walk output directory to find generated code output_dir = os.path.join(top_level_dir, "output") # TODO: Verify if this check is still needed after Smithy generator always creates output @@ -85,7 +85,9 @@ def _copy_cpp_codegen_contents(self, top_level_dir: str, plugin_name: str, targe return for root, dirs, files in os.walk(output_dir): - if plugin_name in dirs: + for plugin_name in plugin_names: + if plugin_name not in dirs: + continue source_dir = os.path.join(root, plugin_name) # Extract service name from the projection directory From 9847658cb797378cc89ed801051292337bb9c929 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Mon, 16 Mar 2026 17:19:36 -0400 Subject: [PATCH 05/21] Add proper state chaining in Waiter.h --- src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h index db6a6d78e84..c1981b1ad30 100644 --- a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h +++ b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h @@ -84,7 +84,15 @@ class Waiter { auto matched = std::find_if(m_acceptors.begin(), m_acceptors.end(), [this, &outcome](const Acceptor& acceptor) -> bool { return Matches(acceptor, outcome); }); if (matched != m_acceptors.end()) { - return WaiterOutcome(outcome); + switch (matched->state) { + case WaiterState::SUCCESS: + return WaiterOutcome(outcome); + case WaiterState::FAILURE: + return WaiterOutcome(WaiterError(WaiterErrors::INVALID_ACTION, "", + "Waiter matched a failure acceptor", false /*retryable*/)); + case WaiterState::RETRY: + break; // continue polling + } } if (attempt < m_maxAttempts - 1) { From 42c2d31c8af10de51e205f84e489ec550c255c2b Mon Sep 17 00:00:00 2001 From: sbaluja Date: Mon, 16 Mar 2026 17:32:52 -0400 Subject: [PATCH 06/21] Add mapping for lost c2j errors to error code --- .../waiters/WaiterHeaderGenerator.java | 29 +++++++++++++++---- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java index 8c11627d251..f29278160c2 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java @@ -33,6 +33,16 @@ public WaiterHeaderGenerator(ServiceShape service, List wai this.model = model; } + /** + * This is a map of error types that are not present in the smithy models but are present in the C2J models. + * We map them to the error codes and rely on a STATUS matcher instead + */ + + private static final Map C2J_LOST_ERRORS = new HashMap<>(); + static { + C2J_LOST_ERRORS.put("NotFound", 404); //S3 + } + @Override protected void writeSpecificIncludes(CppWriter writer, String serviceName, String smithyServiceName) { String classPrefix = ServiceNameUtil.getServiceNameUpperCamel(service); @@ -143,11 +153,20 @@ private void writeAcceptor(CppWriter writer, Acceptor acceptor, String outcomeTy writer.write("});"); } else if (matcher instanceof Matcher.ErrorTypeMember) { String errorType = ((Matcher.ErrorTypeMember) matcher).getValue(); - writer.write("acceptors.push_back({"); - writer.write(" $L,", state); - writer.write(" Aws::Utils::MatcherType::ERROR,"); - writer.write(" Aws::String(\"$L\")", errorType); - writer.write("});"); + if(!C2J_LOST_ERRORS.containsKey(errorType)) { + writer.write("acceptors.push_back({"); + writer.write(" $L,", state); + writer.write(" Aws::Utils::MatcherType::ERROR,"); + writer.write(" Aws::String(\"$L\")", errorType); + writer.write("});"); + } else { + int statusCode = C2J_LOST_ERRORS.get(errorType); + writer.write("acceptors.push_back({"); + writer.write(" $L,", state); + writer.write(" Aws::Utils::MatcherType::STATUS,"); + writer.write(" $L", statusCode); + writer.write("});"); + } } else if (matcher instanceof Matcher.OutputMember) { writePathAcceptor(writer, ((Matcher.OutputMember) matcher).getValue(), state, outcomeType, data); From 8957fc9d5f37e990b15777f1527f1849b8d67ae8 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Tue, 17 Mar 2026 13:39:08 -0400 Subject: [PATCH 07/21] Updated clients --- .../aws/AWSMigrationHub/MigrationHubClient.h | 4 +- .../aws/accessanalyzer/AccessAnalyzerClient.h | 4 +- .../include/aws/account/AccountClient.h | 4 +- .../include/aws/acm-pca/ACMPCAClient.h | 4 +- .../include/aws/acm-pca/ACMPCAWaiter.h | 80 + .../include/aws/acm/ACMClient.h | 4 +- .../include/aws/acm/ACMWaiter.h | 62 + .../include/aws/aiops/AIOpsClient.h | 4 +- .../include/aws/amp/PrometheusServiceClient.h | 4 +- .../include/aws/amp/PrometheusServiceWaiter.h | 163 ++ .../include/aws/amplify/AmplifyClient.h | 4 +- .../aws/amplifybackend/AmplifyBackendClient.h | 4 +- .../amplifyuibuilder/AmplifyUIBuilderClient.h | 4 +- .../include/aws/apigateway/APIGatewayClient.h | 4 +- .../ApiGatewayManagementApiClient.h | 4 +- .../aws/apigatewayv2/ApiGatewayV2Client.h | 4 +- .../include/aws/appconfig/AppConfigClient.h | 4 +- .../include/aws/appconfig/AppConfigWaiter.h | 83 + .../aws/appconfigdata/AppConfigDataClient.h | 4 +- .../include/aws/appfabric/AppFabricClient.h | 4 +- .../include/aws/appflow/AppflowClient.h | 4 +- .../AppIntegrationsServiceClient.h | 4 +- .../ApplicationAutoScalingClient.h | 4 +- .../ApplicationInsightsClient.h | 4 +- .../ApplicationSignalsClient.h | 4 +- .../ApplicationCostProfilerClient.h | 4 +- .../include/aws/appmesh/AppMeshClient.h | 4 +- .../include/aws/apprunner/AppRunnerClient.h | 4 +- .../include/aws/appstream/AppStreamClient.h | 4 +- .../include/aws/appstream/AppStreamWaiter.h | 88 ++ .../include/aws/appsync/AppSyncClient.h | 4 +- .../arc-region-switch/ARCRegionswitchClient.h | 4 +- .../arc-region-switch/ARCRegionswitchWaiter.h | 102 ++ .../aws/arc-zonal-shift/ARCZonalShiftClient.h | 4 +- .../include/aws/artifact/ArtifactClient.h | 4 +- .../include/aws/athena/AthenaClient.h | 4 +- .../aws/auditmanager/AuditManagerClient.h | 4 +- .../AutoScalingPlansClient.h | 4 +- .../aws/autoscaling/AutoScalingClient.h | 4 +- .../aws/autoscaling/AutoScalingWaiter.h | 105 ++ .../include/aws/awstransfer/TransferClient.h | 4 +- .../include/aws/awstransfer/TransferWaiter.h | 64 + .../include/aws/b2bi/B2BIClient.h | 4 +- .../include/aws/b2bi/B2BIWaiter.h | 48 + .../aws/backup-gateway/BackupGatewayClient.h | 4 +- .../include/aws/backup/BackupClient.h | 4 +- .../aws/backupsearch/BackupSearchClient.h | 4 +- .../include/aws/batch/BatchClient.h | 4 +- .../aws/bcm-dashboards/BCMDashboardsClient.h | 4 +- .../bcm-data-exports/BCMDataExportsClient.h | 4 +- .../BCMPricingCalculatorClient.h | 4 +- .../BCMRecommendedActionsClient.h | 4 +- .../BedrockAgentRuntimeClient.h | 4 +- .../aws/bedrock-agent/BedrockAgentClient.h | 4 +- .../BedrockAgentCoreControlClient.h | 4 +- .../BedrockAgentCoreControlWaiter.h | 220 +++ .../BedrockAgentCoreClient.h | 4 +- .../BedrockDataAutomationRuntimeClient.h | 4 +- .../BedrockDataAutomationClient.h | 4 +- .../bedrock-runtime/BedrockRuntimeClient.h | 4 +- .../include/aws/bedrock/BedrockClient.h | 4 +- .../include/aws/billing/BillingClient.h | 4 +- .../billingconductor/BillingConductorClient.h | 4 +- .../include/aws/braket/BraketClient.h | 4 +- .../include/aws/budgets/BudgetsClient.h | 4 +- .../include/aws/ce/CostExplorerClient.h | 4 +- .../include/aws/chatbot/ChatbotClient.h | 4 +- .../ChimeSDKIdentityClient.h | 4 +- .../ChimeSDKMediaPipelinesClient.h | 4 +- .../ChimeSDKMeetingsClient.h | 4 +- .../ChimeSDKMessagingClient.h | 4 +- .../aws/chime-sdk-voice/ChimeSDKVoiceClient.h | 4 +- .../include/aws/chime/ChimeClient.h | 4 +- .../include/aws/cleanrooms/CleanRoomsClient.h | 4 +- .../aws/cleanroomsml/CleanRoomsMLClient.h | 4 +- .../include/aws/cloud9/Cloud9Client.h | 4 +- .../aws/cloudcontrol/CloudControlApiClient.h | 4 +- .../aws/cloudcontrol/CloudControlApiWaiter.h | 51 + .../aws/clouddirectory/CloudDirectoryClient.h | 4 +- .../aws/cloudformation/CloudFormationClient.h | 4 +- .../aws/cloudformation/CloudFormationWaiter.h | 497 ++++++ .../CloudFrontKeyValueStoreClient.h | 4 +- .../include/aws/cloudfront/CloudFrontClient.h | 4 +- .../include/aws/cloudfront/CloudFrontWaiter.h | 102 ++ .../include/aws/cloudhsm/CloudHSMClient.h | 4 +- .../include/aws/cloudhsmv2/CloudHSMV2Client.h | 4 +- .../aws/cloudsearch/CloudSearchClient.h | 4 +- .../CloudSearchDomainClient.h | 4 +- .../cloudtrail-data/CloudTrailDataClient.h | 4 +- .../include/aws/cloudtrail/CloudTrailClient.h | 4 +- .../aws/codeartifact/CodeArtifactClient.h | 4 +- .../include/aws/codebuild/CodeBuildClient.h | 4 +- .../aws/codecatalyst/CodeCatalystClient.h | 4 +- .../include/aws/codecommit/CodeCommitClient.h | 4 +- .../codeconnections/CodeConnectionsClient.h | 4 +- .../include/aws/codedeploy/CodeDeployClient.h | 4 +- .../include/aws/codedeploy/CodeDeployWaiter.h | 52 + .../CodeGuruReviewerClient.h | 4 +- .../CodeGuruReviewerWaiter.h | 91 ++ .../CodeGuruSecurityClient.h | 4 +- .../codeguruprofiler/CodeGuruProfilerClient.h | 4 +- .../aws/codepipeline/CodePipelineClient.h | 4 +- .../CodeStarconnectionsClient.h | 4 +- .../CodeStarNotificationsClient.h | 4 +- .../cognito-identity/CognitoIdentityClient.h | 4 +- .../CognitoIdentityProviderClient.h | 4 +- .../aws/cognito-sync/CognitoSyncClient.h | 4 +- .../include/aws/comprehend/ComprehendClient.h | 4 +- .../ComprehendMedicalClient.h | 4 +- .../ComputeOptimizerAutomationClient.h | 4 +- .../ComputeOptimizerClient.h | 4 +- .../include/aws/config/ConfigServiceClient.h | 4 +- .../ConnectContactLensClient.h | 4 +- .../include/aws/connect/ConnectClient.h | 4 +- .../connectcampaigns/ConnectCampaignsClient.h | 4 +- .../ConnectCampaignsV2Client.h | 4 +- .../aws/connectcases/ConnectCasesClient.h | 4 +- .../aws/connecthealth/ConnectHealthClient.h | 4 +- .../ConnectParticipantClient.h | 4 +- .../aws/controlcatalog/ControlCatalogClient.h | 4 +- .../aws/controltower/ControlTowerClient.h | 4 +- .../CostOptimizationHubClient.h | 4 +- .../aws/cur/CostandUsageReportServiceClient.h | 4 +- .../CustomerProfilesClient.h | 4 +- .../include/aws/databrew/GlueDataBrewClient.h | 4 +- .../aws/dataexchange/DataExchangeClient.h | 4 +- .../aws/datapipeline/DataPipelineClient.h | 4 +- .../include/aws/datasync/DataSyncClient.h | 4 +- .../include/aws/datazone/DataZoneClient.h | 4 +- .../include/aws/dax/DAXClient.h | 4 +- .../include/aws/deadline/DeadlineClient.h | 4 +- .../include/aws/deadline/DeadlineWaiter.h | 327 ++++ .../include/aws/detective/DetectiveClient.h | 4 +- .../include/aws/devicefarm/DeviceFarmClient.h | 4 +- .../aws/devops-guru/DevOpsGuruClient.h | 4 +- .../aws/directconnect/DirectConnectClient.h | 4 +- .../DirectoryServiceDataClient.h | 4 +- .../ApplicationDiscoveryServiceClient.h | 4 +- .../include/aws/dlm/DLMClient.h | 4 +- .../aws/dms/DatabaseMigrationServiceClient.h | 4 +- .../aws/dms/DatabaseMigrationServiceWaiter.h | 457 ++++++ .../aws/docdb-elastic/DocDBElasticClient.h | 4 +- .../include/aws/docdb/DocDBClient.h | 4 +- .../include/aws/docdb/DocDBWaiter.h | 134 ++ .../include/aws/drs/DrsClient.h | 4 +- .../include/aws/ds/DirectoryServiceClient.h | 4 +- .../include/aws/ds/DirectoryServiceWaiter.h | 51 + .../include/aws/dsql/DSQLClient.h | 4 +- .../include/aws/dsql/DSQLWaiter.h | 45 + .../include/aws/dynamodb/DynamoDBClient.h | 4 +- .../include/aws/dynamodb/DynamoDBWaiter.h | 175 +++ .../dynamodbstreams/DynamoDBStreamsClient.h | 4 +- .../include/aws/ebs/EBSClient.h | 4 +- .../EC2InstanceConnectClient.h | 4 +- .../include/aws/ec2/EC2Client.h | 4 +- .../include/aws/ec2/EC2Waiter.h | 1343 +++++++++++++++++ .../include/aws/ecr-public/ECRPublicClient.h | 4 +- .../include/aws/ecr/ECRClient.h | 4 +- .../include/aws/ecr/ECRWaiter.h | 77 + .../include/aws/ecs/ECSClient.h | 4 +- .../include/aws/ecs/ECSWaiter.h | 130 ++ .../include/aws/eks-auth/EKSAuthClient.h | 4 +- .../include/aws/eks/EKSClient.h | 4 +- .../include/aws/eks/EKSWaiter.h | 229 +++ .../aws/elasticache/ElastiCacheClient.h | 4 +- .../aws/elasticache/ElastiCacheWaiter.h | 201 +++ .../elasticbeanstalk/ElasticBeanstalkClient.h | 4 +- .../elasticbeanstalk/ElasticBeanstalkWaiter.h | 118 ++ .../include/aws/elasticfilesystem/EFSClient.h | 4 +- .../ElasticLoadBalancingClient.h | 4 +- .../ElasticLoadBalancingWaiter.h | 83 + .../ElasticLoadBalancingv2Client.h | 4 +- .../ElasticLoadBalancingv2Waiter.h | 141 ++ .../include/aws/elasticmapreduce/EMRClient.h | 4 +- .../include/aws/elasticmapreduce/EMRWaiter.h | 121 ++ .../ElementalInferenceClient.h | 4 +- .../ElementalInferenceWaiter.h | 45 + .../include/aws/email/SESClient.h | 4 +- .../include/aws/email/SESWaiter.h | 45 + .../aws/emr-containers/EMRContainersClient.h | 4 +- .../aws/emr-serverless/EMRServerlessClient.h | 4 +- .../entityresolution/EntityResolutionClient.h | 4 +- .../aws/es/ElasticsearchServiceClient.h | 4 +- .../aws/eventbridge/EventBridgeClient.h | 4 +- .../aws/events/CloudWatchEventsClient.h | 4 +- .../include/aws/evs/EVSClient.h | 4 +- .../aws/finspace-data/FinSpaceDataClient.h | 4 +- .../include/aws/finspace/FinspaceClient.h | 4 +- .../include/aws/firehose/FirehoseClient.h | 4 +- .../include/aws/fis/FISClient.h | 4 +- .../include/aws/fms/FMSClient.h | 4 +- .../aws/forecast/ForecastServiceClient.h | 4 +- .../ForecastQueryServiceClient.h | 4 +- .../aws/frauddetector/FraudDetectorClient.h | 4 +- .../include/aws/freetier/FreeTierClient.h | 4 +- .../include/aws/fsx/FSxClient.h | 4 +- .../include/aws/gamelift/GameLiftClient.h | 4 +- .../gameliftstreams/GameLiftStreamsClient.h | 4 +- .../gameliftstreams/GameLiftStreamsWaiter.h | 131 ++ .../include/aws/geo-maps/GeoMapsClient.h | 4 +- .../include/aws/geo-places/GeoPlacesClient.h | 4 +- .../include/aws/geo-routes/GeoRoutesClient.h | 4 +- .../include/aws/glacier/GlacierClient.h | 4 +- .../include/aws/glacier/GlacierWaiter.h | 43 + .../GlobalAcceleratorClient.h | 4 +- .../include/aws/glue/GlueClient.h | 4 +- .../aws/grafana/ManagedGrafanaClient.h | 4 +- .../include/aws/greengrass/GreengrassClient.h | 4 +- .../aws/greengrassv2/GreengrassV2Client.h | 4 +- .../aws/groundstation/GroundStationClient.h | 4 +- .../aws/groundstation/GroundStationWaiter.h | 45 + .../include/aws/guardduty/GuardDutyClient.h | 4 +- .../include/aws/health/HealthClient.h | 4 +- .../include/aws/healthlake/HealthLakeClient.h | 4 +- .../include/aws/healthlake/HealthLakeWaiter.h | 159 ++ .../include/aws/iam/IAMClient.h | 4 +- .../include/aws/iam/IAMWaiter.h | 71 + .../aws/identitystore/IdentityStoreClient.h | 4 +- .../aws/imagebuilder/ImagebuilderClient.h | 4 +- .../aws/importexport/ImportExportClient.h | 4 +- .../aws/inspector-scan/InspectorscanClient.h | 4 +- .../include/aws/inspector/InspectorClient.h | 4 +- .../include/aws/inspector2/Inspector2Client.h | 4 +- .../internetmonitor/InternetMonitorClient.h | 4 +- .../include/aws/invoicing/InvoicingClient.h | 4 +- .../include/aws/iot-data/IoTDataPlaneClient.h | 4 +- .../iot-jobs-data/IoTJobsDataPlaneClient.h | 4 +- .../IoTManagedIntegrationsClient.h | 4 +- .../include/aws/iot/IoTClient.h | 4 +- .../iotdeviceadvisor/IoTDeviceAdvisorClient.h | 4 +- .../aws/iotevents-data/IoTEventsDataClient.h | 4 +- .../include/aws/iotevents/IoTEventsClient.h | 4 +- .../aws/iotfleetwise/IoTFleetWiseClient.h | 4 +- .../IoTSecureTunnelingClient.h | 4 +- .../aws/iotsitewise/IoTSiteWiseClient.h | 4 +- .../aws/iotsitewise/IoTSiteWiseWaiter.h | 125 ++ .../aws/iotthingsgraph/IoTThingsGraphClient.h | 4 +- .../aws/iottwinmaker/IoTTwinMakerClient.h | 4 +- .../aws/iotwireless/IoTWirelessClient.h | 4 +- .../aws/ivs-realtime/IvsrealtimeClient.h | 4 +- .../include/aws/ivs/IVSClient.h | 4 +- .../include/aws/ivschat/IvschatClient.h | 4 +- .../include/aws/kafka/KafkaClient.h | 4 +- .../aws/kafkaconnect/KafkaConnectClient.h | 4 +- .../aws/kendra-ranking/KendraRankingClient.h | 4 +- .../include/aws/kendra/KendraClient.h | 4 +- .../include/aws/keyspaces/KeyspacesClient.h | 4 +- .../keyspacesstreams/KeyspacesStreamsClient.h | 4 +- .../KinesisVideoArchivedMediaClient.h | 4 +- .../KinesisVideoMediaClient.h | 4 +- .../KinesisVideoSignalingChannelsClient.h | 4 +- .../KinesisVideoWebRTCStorageClient.h | 4 +- .../include/aws/kinesis/KinesisClient.h | 4 +- .../include/aws/kinesis/KinesisWaiter.h | 48 + .../kinesisanalytics/KinesisAnalyticsClient.h | 4 +- .../KinesisAnalyticsV2Client.h | 4 +- .../aws/kinesisvideo/KinesisVideoClient.h | 4 +- .../include/aws/kms/KMSClient.h | 4 +- .../aws/lakeformation/LakeFormationClient.h | 4 +- .../include/aws/lambda/LambdaClient.h | 4 +- .../include/aws/lambda/LambdaWaiter.h | 185 +++ .../aws/launch-wizard/LaunchWizardClient.h | 4 +- .../LexModelBuildingServiceClient.h | 4 +- .../include/aws/lex/LexRuntimeServiceClient.h | 4 +- .../aws/lexv2-models/LexModelsV2Client.h | 4 +- .../aws/lexv2-models/LexModelsV2Waiter.h | 321 ++++ .../aws/lexv2-runtime/LexRuntimeV2Client.h | 4 +- .../LicenseManagerLinuxSubscriptionsClient.h | 4 +- .../LicenseManagerUserSubscriptionsClient.h | 4 +- .../license-manager/LicenseManagerClient.h | 4 +- .../include/aws/lightsail/LightsailClient.h | 4 +- .../aws/location/LocationServiceClient.h | 4 +- .../include/aws/logs/CloudWatchLogsClient.h | 4 +- .../lookoutequipment/LookoutEquipmentClient.h | 4 +- .../aws/m2/MainframeModernizationClient.h | 4 +- .../machinelearning/MachineLearningClient.h | 4 +- .../machinelearning/MachineLearningWaiter.h | 137 ++ .../include/aws/macie2/Macie2Client.h | 4 +- .../include/aws/macie2/Macie2Waiter.h | 48 + .../aws/mailmanager/MailManagerClient.h | 4 +- .../ManagedBlockchainQueryClient.h | 4 +- .../ManagedBlockchainClient.h | 4 +- .../AgreementServiceClient.h | 4 +- .../MarketplaceCatalogClient.h | 4 +- .../MarketplaceDeploymentClient.h | 4 +- .../MarketplaceEntitlementServiceClient.h | 4 +- .../MarketplaceReportingClient.h | 4 +- .../MarketplaceCommerceAnalyticsClient.h | 4 +- .../aws/mediaconnect/MediaConnectClient.h | 4 +- .../aws/mediaconnect/MediaConnectWaiter.h | 378 +++++ .../aws/mediaconvert/MediaConvertClient.h | 4 +- .../include/aws/medialive/MediaLiveClient.h | 4 +- .../include/aws/medialive/MediaLiveWaiter.h | 643 ++++++++ .../mediapackage-vod/MediaPackageVodClient.h | 4 +- .../aws/mediapackage/MediaPackageClient.h | 4 +- .../aws/mediapackagev2/Mediapackagev2Client.h | 4 +- .../aws/mediapackagev2/Mediapackagev2Waiter.h | 66 + .../mediastore-data/MediaStoreDataClient.h | 4 +- .../include/aws/mediastore/MediaStoreClient.h | 4 +- .../aws/mediatailor/MediaTailorClient.h | 4 +- .../medical-imaging/MedicalImagingClient.h | 4 +- .../include/aws/memorydb/MemoryDBClient.h | 4 +- .../MarketplaceMeteringClient.h | 4 +- .../include/aws/mgn/MgnClient.h | 4 +- .../MigrationHubRefactorSpacesClient.h | 4 +- .../MigrationHubConfigClient.h | 4 +- .../MigrationHubOrchestratorClient.h | 4 +- ...igrationHubStrategyRecommendationsClient.h | 4 +- .../include/aws/monitoring/CloudWatchClient.h | 6 +- .../include/aws/monitoring/CloudWatchWaiter.h | 64 + .../include/aws/mpa/MPAClient.h | 4 +- .../aws-cpp-sdk-mq/include/aws/mq/MQClient.h | 4 +- .../include/aws/mturk-requester/MTurkClient.h | 4 +- .../mwaa-serverless/MWAAServerlessClient.h | 4 +- .../include/aws/mwaa/MWAAClient.h | 4 +- .../aws/neptune-graph/NeptuneGraphClient.h | 4 +- .../aws/neptune-graph/NeptuneGraphWaiter.h | 321 ++++ .../include/aws/neptune/NeptuneClient.h | 4 +- .../include/aws/neptune/NeptuneWaiter.h | 134 ++ .../aws/neptunedata/NeptunedataClient.h | 4 +- .../network-firewall/NetworkFirewallClient.h | 4 +- .../NetworkFlowMonitorClient.h | 4 +- .../aws/networkmanager/NetworkManagerClient.h | 4 +- .../aws/networkmonitor/NetworkMonitorClient.h | 4 +- .../aws/notifications/NotificationsClient.h | 4 +- .../NotificationsContactsClient.h | 4 +- .../include/aws/nova-act/NovaActClient.h | 4 +- .../include/aws/oam/OAMClient.h | 4 +- .../ObservabilityAdminClient.h | 4 +- .../include/aws/odb/OdbClient.h | 4 +- .../include/aws/omics/OmicsClient.h | 4 +- .../include/aws/omics/OmicsWaiter.h | 754 +++++++++ .../aws/opensearch/OpenSearchServiceClient.h | 4 +- .../OpenSearchServerlessClient.h | 4 +- .../aws/organizations/OrganizationsClient.h | 4 +- .../include/aws/osis/OSISClient.h | 4 +- .../include/aws/outposts/OutpostsClient.h | 4 +- .../include/aws/panorama/PanoramaClient.h | 4 +- .../PartnerCentralAccountClient.h | 4 +- .../PartnerCentralBenefitsClient.h | 4 +- .../PartnerCentralChannelClient.h | 4 +- .../PartnerCentralSellingClient.h | 4 +- .../PaymentCryptographyDataClient.h | 4 +- .../PaymentCryptographyClient.h | 4 +- .../pca-connector-ad/PcaConnectorAdClient.h | 4 +- .../PcaConnectorScepClient.h | 4 +- .../include/aws/pcs/PCSClient.h | 4 +- .../PersonalizeEventsClient.h | 4 +- .../PersonalizeRuntimeClient.h | 4 +- .../aws/personalize/PersonalizeClient.h | 4 +- .../aws-cpp-sdk-pi/include/aws/pi/PIClient.h | 4 +- .../aws/pinpoint-email/PinpointEmailClient.h | 4 +- .../PinpointSMSVoiceV2Client.h | 4 +- .../include/aws/pinpoint/PinpointClient.h | 4 +- .../include/aws/pipes/PipesClient.h | 4 +- .../include/aws/polly/PollyClient.h | 4 +- .../include/aws/pricing/PricingClient.h | 4 +- .../include/aws/proton/ProtonClient.h | 4 +- .../include/aws/proton/ProtonWaiter.h | 279 ++++ .../include/aws/qapps/QAppsClient.h | 4 +- .../include/aws/qbusiness/QBusinessClient.h | 4 +- .../include/aws/qconnect/QConnectClient.h | 4 +- .../include/aws/quicksight/QuickSightClient.h | 4 +- .../include/aws/ram/RAMClient.h | 4 +- .../include/aws/rbin/RecycleBinClient.h | 4 +- .../aws/rds-data/RDSDataServiceClient.h | 4 +- .../include/aws/rds/RDSWaiter.h | 534 +++++++ .../RedshiftDataAPIServiceClient.h | 4 +- .../RedshiftServerlessClient.h | 4 +- .../include/aws/redshift/RedshiftClient.h | 4 +- .../include/aws/redshift/RedshiftWaiter.h | 133 ++ .../aws/rekognition/RekognitionClient.h | 4 +- .../aws/rekognition/RekognitionWaiter.h | 86 ++ .../aws/repostspace/RepostspaceClient.h | 4 +- .../aws/repostspace/RepostspaceWaiter.h | 136 ++ .../aws/resiliencehub/ResilienceHubClient.h | 4 +- .../ResourceExplorer2Client.h | 4 +- .../resource-groups/ResourceGroupsClient.h | 4 +- .../ResourceGroupsTaggingAPIClient.h | 4 +- .../aws/rolesanywhere/RolesAnywhereClient.h | 4 +- .../Route53RecoveryClusterClient.h | 4 +- .../Route53RecoveryControlConfigClient.h | 4 +- .../Route53RecoveryControlConfigWaiter.h | 161 ++ .../Route53RecoveryReadinessClient.h | 4 +- .../include/aws/route53/Route53Client.h | 4 +- .../include/aws/route53/Route53Waiter.h | 38 + .../aws/route53domains/Route53DomainsClient.h | 4 +- .../Route53GlobalResolverClient.h | 4 +- .../route53profiles/Route53ProfilesClient.h | 4 +- .../route53resolver/Route53ResolverClient.h | 4 +- .../include/aws/rtbfabric/RTBFabricClient.h | 4 +- .../include/aws/rtbfabric/RTBFabricWaiter.h | 305 ++++ .../include/aws/rum/CloudWatchRUMClient.h | 4 +- .../include/aws/s3-crt/S3CrtClient.h | 4 +- .../include/aws/s3-crt/S3CrtWaiter.h | 61 + .../aws-cpp-sdk-s3/include/aws/s3/S3Client.h | 4 +- .../aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h | 61 + .../include/aws/s3outposts/S3OutpostsClient.h | 4 +- .../include/aws/s3tables/S3TablesClient.h | 4 +- .../include/aws/s3vectors/S3VectorsClient.h | 4 +- .../AugmentedAIRuntimeClient.h | 4 +- .../SagemakerEdgeManagerClient.h | 4 +- .../SageMakerFeatureStoreRuntimeClient.h | 4 +- .../SageMakerGeospatialClient.h | 4 +- .../SageMakerMetricsClient.h | 4 +- .../SageMakerRuntimeHTTP2Client.h | 4 +- .../SageMakerRuntimeClient.h | 4 +- .../include/aws/sagemaker/SageMakerClient.h | 4 +- .../include/aws/sagemaker/SageMakerWaiter.h | 364 +++++ .../aws/savingsplans/SavingsPlansClient.h | 4 +- .../include/aws/scheduler/SchedulerClient.h | 4 +- .../include/aws/schemas/SchemasClient.h | 4 +- .../include/aws/schemas/SchemasWaiter.h | 56 + .../include/aws/sdb/SimpleDBClient.h | 4 +- .../aws/secretsmanager/SecretsManagerClient.h | 4 +- .../aws/security-ir/SecurityIRClient.h | 4 +- .../aws/securityhub/SecurityHubClient.h | 4 +- .../aws/securitylake/SecurityLakeClient.h | 4 +- .../ServerlessApplicationRepositoryClient.h | 4 +- .../aws/service-quotas/ServiceQuotasClient.h | 4 +- .../AppRegistryClient.h | 4 +- .../aws/servicecatalog/ServiceCatalogClient.h | 4 +- .../servicediscovery/ServiceDiscoveryClient.h | 4 +- .../include/aws/sesv2/SESV2Client.h | 4 +- .../include/aws/shield/ShieldClient.h | 4 +- .../aws/signer-data/SignerDataClient.h | 4 +- .../include/aws/signer/SignerClient.h | 4 +- .../include/aws/signer/SignerWaiter.h | 47 + .../include/aws/signin/SigninClient.h | 4 +- .../include/aws/simpledbv2/SimpleDBv2Client.h | 4 +- .../include/aws/simpledbv2/SimpleDBv2Waiter.h | 44 + .../aws/simspaceweaver/SimSpaceWeaverClient.h | 4 +- .../aws/sms-voice/PinpointSMSVoiceClient.h | 4 +- .../SnowDeviceManagementClient.h | 4 +- .../include/aws/snowball/SnowballClient.h | 4 +- .../include/aws/sns/SNSClient.h | 4 +- .../socialmessaging/SocialMessagingClient.h | 4 +- .../include/aws/sqs/SQSClient.h | 4 +- .../aws/ssm-contacts/SSMContactsClient.h | 4 +- .../aws/ssm-guiconnect/SSMGuiConnectClient.h | 4 +- .../aws/ssm-incidents/SSMIncidentsClient.h | 4 +- .../aws/ssm-incidents/SSMIncidentsWaiter.h | 82 + .../aws/ssm-quicksetup/SSMQuickSetupClient.h | 4 +- .../include/aws/ssm-sap/SsmSapClient.h | 4 +- .../include/aws/ssm/SSMClient.h | 4 +- .../include/aws/ssm/SSMWaiter.h | 91 ++ .../include/aws/sso-admin/SSOAdminClient.h | 4 +- .../include/aws/sso-oidc/SSOOIDCClient.h | 4 +- .../include/aws/sso/SSOClient.h | 4 +- .../include/aws/states/SFNClient.h | 4 +- .../aws/storagegateway/StorageGatewayClient.h | 4 +- .../include/aws/sts/STSClient.h | 4 +- .../aws/supplychain/SupplyChainClient.h | 4 +- .../aws/support-app/SupportAppClient.h | 4 +- .../include/aws/support/SupportClient.h | 4 +- .../include/aws/swf/SWFClient.h | 4 +- .../include/aws/synthetics/SyntheticsClient.h | 4 +- .../aws/taxsettings/TaxSettingsClient.h | 4 +- .../include/aws/textract/TextractClient.h | 4 +- .../TimestreamInfluxDBClient.h | 4 +- .../timestream-query/TimestreamQueryClient.h | 4 +- .../timestream-write/TimestreamWriteClient.h | 4 +- .../include/aws/tnb/TnbClient.h | 4 +- .../aws/transcribe/TranscribeServiceClient.h | 4 +- .../aws/transcribe/TranscribeServiceWaiter.h | 217 +++ .../TranscribeStreamingServiceClient.h | 4 +- .../include/aws/translate/TranslateClient.h | 4 +- .../aws/trustedadvisor/TrustedAdvisorClient.h | 4 +- .../VerifiedPermissionsClient.h | 4 +- .../include/aws/voice-id/VoiceIDClient.h | 4 +- .../aws/vpc-lattice/VPCLatticeClient.h | 4 +- .../aws/waf-regional/WAFRegionalClient.h | 4 +- .../include/aws/waf/WAFClient.h | 4 +- .../include/aws/wafv2/WAFV2Client.h | 4 +- .../wellarchitected/WellArchitectedClient.h | 4 +- .../include/aws/wickr/WickrClient.h | 4 +- .../aws/wisdom/ConnectWisdomServiceClient.h | 4 +- .../include/aws/workdocs/WorkDocsClient.h | 4 +- .../include/aws/workmail/WorkMailClient.h | 4 +- .../WorkMailMessageFlowClient.h | 4 +- .../WorkspacesInstancesClient.h | 4 +- .../WorkSpacesThinClientClient.h | 4 +- .../aws/workspaces-web/WorkSpacesWebClient.h | 4 +- .../include/aws/workspaces/WorkSpacesClient.h | 4 +- .../include/aws/xray/XRayClient.h | 4 +- 485 files changed, 13154 insertions(+), 418 deletions(-) create mode 100644 generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h create mode 100644 generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h create mode 100644 generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h create mode 100644 generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h create mode 100644 generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h create mode 100644 generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h create mode 100644 generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h create mode 100644 generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h create mode 100644 generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h create mode 100644 generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h create mode 100644 generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h create mode 100644 generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h create mode 100644 generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h create mode 100644 generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h create mode 100644 generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h create mode 100644 generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h create mode 100644 generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h create mode 100644 generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h create mode 100644 generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h create mode 100644 generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h create mode 100644 generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h create mode 100644 generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h create mode 100644 generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h create mode 100644 generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h create mode 100644 generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h create mode 100644 generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h create mode 100644 generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h create mode 100644 generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h create mode 100644 generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h create mode 100644 generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h create mode 100644 generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h create mode 100644 generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h diff --git a/generated/src/aws-cpp-sdk-AWSMigrationHub/include/aws/AWSMigrationHub/MigrationHubClient.h b/generated/src/aws-cpp-sdk-AWSMigrationHub/include/aws/AWSMigrationHub/MigrationHubClient.h index f98c14499de..d1cff383d34 100644 --- a/generated/src/aws-cpp-sdk-AWSMigrationHub/include/aws/AWSMigrationHub/MigrationHubClient.h +++ b/generated/src/aws-cpp-sdk-AWSMigrationHub/include/aws/AWSMigrationHub/MigrationHubClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -24,7 +25,8 @@ namespace MigrationHub { */ class AWS_MIGRATIONHUB_API MigrationHubClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MigrationHubPaginationBase { + public MigrationHubPaginationBase, + public MigrationHubWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerClient.h b/generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerClient.h index dfb016e741a..d78070931dc 100644 --- a/generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerClient.h +++ b/generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -49,7 +50,8 @@ namespace AccessAnalyzer { */ class AWS_ACCESSANALYZER_API AccessAnalyzerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AccessAnalyzerPaginationBase { + public AccessAnalyzerPaginationBase, + public AccessAnalyzerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-account/include/aws/account/AccountClient.h b/generated/src/aws-cpp-sdk-account/include/aws/account/AccountClient.h index f42fa133840..e9d916ac50e 100644 --- a/generated/src/aws-cpp-sdk-account/include/aws/account/AccountClient.h +++ b/generated/src/aws-cpp-sdk-account/include/aws/account/AccountClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -19,7 +20,8 @@ namespace Account { */ class AWS_ACCOUNT_API AccountClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AccountPaginationBase { + public AccountPaginationBase, + public AccountWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAClient.h b/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAClient.h index dc00203ac97..a7590d74294 100644 --- a/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAClient.h +++ b/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -40,7 +41,8 @@ namespace ACMPCA { */ class AWS_ACMPCA_API ACMPCAClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ACMPCAPaginationBase { + public ACMPCAPaginationBase, + public ACMPCAWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h b/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h new file mode 100644 index 00000000000..057dfc9bfc5 --- /dev/null +++ b/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h @@ -0,0 +1,80 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace ACMPCA { + +template +class ACMPCAWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilAuditReportCreated( + const Model::DescribeCertificateAuthorityAuditReportRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCESS"), + [](const Model::DescribeCertificateAuthorityAuditReportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AuditReportStatusMapper::GetNameForAuditReportStatus(result.GetAuditReportStatus()) == expected.get(); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeCertificateAuthorityAuditReportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AuditReportStatusMapper::GetNameForAuditReportStatus(result.GetAuditReportStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("AccessDeniedException")}); + + auto operation = [this](const Model::DescribeCertificateAuthorityAuditReportRequest& req) { + return static_cast(this)->DescribeCertificateAuthorityAuditReport(req); + }; + Aws::Utils::Waiter waiter( + 3, 60, acceptors, operation, "WaitUntilAuditReportCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilCertificateIssued(const Model::GetCertificateRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("RequestInProgressException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("AccessDeniedException")}); + + auto operation = [this](const Model::GetCertificateRequest& req) { return static_cast(this)->GetCertificate(req); }; + Aws::Utils::Waiter waiter(1, 60, acceptors, operation, + "WaitUntilCertificateIssued"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilCertificateAuthorityCSRCreated( + const Model::GetCertificateAuthorityCsrRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("RequestInProgressException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("AccessDeniedException")}); + + auto operation = [this](const Model::GetCertificateAuthorityCsrRequest& req) { + return static_cast(this)->GetCertificateAuthorityCsr(req); + }; + Aws::Utils::Waiter waiter( + 3, 60, acceptors, operation, "WaitUntilCertificateAuthorityCSRCreated"); + return waiter.Wait(request); + } +}; +} // namespace ACMPCA +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMClient.h b/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMClient.h index 39f37c83522..73b48caf83b 100644 --- a/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMClient.h +++ b/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -23,7 +24,8 @@ namespace ACM { */ class AWS_ACM_API ACMClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ACMPaginationBase { + public ACMPaginationBase, + public ACMWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h b/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h new file mode 100644 index 00000000000..240e3870d29 --- /dev/null +++ b/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h @@ -0,0 +1,62 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace ACM { + +template +class ACMWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilCertificateValidated( + const Model::DescribeCertificateRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCESS"), + [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetCertificate().GetDomainValidationOptions().begin(), + result.GetCertificate().GetDomainValidationOptions().end(), + [&](const Model::DomainValidation& item) { + return item.GetValidationStatus() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING_VALIDATION"), + [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCertificate().GetDomainValidationOptions().begin(), + result.GetCertificate().GetDomainValidationOptions().end(), + [&](const Model::DomainValidation& item) { + return item.GetValidationStatus() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CertificateStatusMapper::GetNameForCertificateStatus(result.GetCertificate().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeCertificateRequest& req) { + return static_cast(this)->DescribeCertificate(req); + }; + Aws::Utils::Waiter waiter(60, 2, acceptors, operation, + "WaitUntilCertificateValidated"); + return waiter.Wait(request); + } +}; +} // namespace ACM +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-aiops/include/aws/aiops/AIOpsClient.h b/generated/src/aws-cpp-sdk-aiops/include/aws/aiops/AIOpsClient.h index f2a5bd64c3e..e4f597046c4 100644 --- a/generated/src/aws-cpp-sdk-aiops/include/aws/aiops/AIOpsClient.h +++ b/generated/src/aws-cpp-sdk-aiops/include/aws/aiops/AIOpsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -25,7 +26,8 @@ namespace AIOps { */ class AWS_AIOPS_API AIOpsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AIOpsPaginationBase { + public AIOpsPaginationBase, + public AIOpsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceClient.h b/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceClient.h index 21cc61901f9..110734a12b6 100644 --- a/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceClient.h +++ b/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -34,7 +35,8 @@ namespace PrometheusService { */ class AWS_PROMETHEUSSERVICE_API PrometheusServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PrometheusServicePaginationBase { + public PrometheusServicePaginationBase, + public PrometheusServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h b/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h new file mode 100644 index 00000000000..09c83a8ac72 --- /dev/null +++ b/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h @@ -0,0 +1,163 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace PrometheusService { + +template +class PrometheusServiceWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilAnomalyDetectorActive( + const Model::DescribeAnomalyDetectorRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( + result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( + result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), + [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( + result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeAnomalyDetectorRequest& req) { + return static_cast(this)->DescribeAnomalyDetector(req); + }; + Aws::Utils::Waiter waiter( + 2, 60, acceptors, operation, "WaitUntilAnomalyDetectorActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilAnomalyDetectorDeleted( + const Model::DescribeAnomalyDetectorRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( + result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeAnomalyDetectorRequest& req) { + return static_cast(this)->DescribeAnomalyDetector(req); + }; + Aws::Utils::Waiter waiter( + 2, 60, acceptors, operation, "WaitUntilAnomalyDetectorDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilScraperActive(const Model::DescribeScraperRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATION_FAILED"), + [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); + }}); + + auto operation = [this](const Model::DescribeScraperRequest& req) { return static_cast(this)->DescribeScraper(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, + "WaitUntilScraperActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilScraperDeleted(const Model::DescribeScraperRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETION_FAILED"), + [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); + }}); + + auto operation = [this](const Model::DescribeScraperRequest& req) { return static_cast(this)->DescribeScraper(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, + "WaitUntilScraperDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilWorkspaceActive(const Model::DescribeWorkspaceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), + [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + }}); + + auto operation = [this](const Model::DescribeWorkspaceRequest& req) { + return static_cast(this)->DescribeWorkspace(req); + }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, + "WaitUntilWorkspaceActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilWorkspaceDeleted(const Model::DescribeWorkspaceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + }}); + + auto operation = [this](const Model::DescribeWorkspaceRequest& req) { + return static_cast(this)->DescribeWorkspace(req); + }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, + "WaitUntilWorkspaceDeleted"); + return waiter.Wait(request); + } +}; +} // namespace PrometheusService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-amplify/include/aws/amplify/AmplifyClient.h b/generated/src/aws-cpp-sdk-amplify/include/aws/amplify/AmplifyClient.h index cf4a846d368..5c927beb0cd 100644 --- a/generated/src/aws-cpp-sdk-amplify/include/aws/amplify/AmplifyClient.h +++ b/generated/src/aws-cpp-sdk-amplify/include/aws/amplify/AmplifyClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -26,7 +27,8 @@ namespace Amplify { */ class AWS_AMPLIFY_API AmplifyClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AmplifyPaginationBase { + public AmplifyPaginationBase, + public AmplifyWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-amplifybackend/include/aws/amplifybackend/AmplifyBackendClient.h b/generated/src/aws-cpp-sdk-amplifybackend/include/aws/amplifybackend/AmplifyBackendClient.h index 9d526464ffd..99d0ee24b6e 100644 --- a/generated/src/aws-cpp-sdk-amplifybackend/include/aws/amplifybackend/AmplifyBackendClient.h +++ b/generated/src/aws-cpp-sdk-amplifybackend/include/aws/amplifybackend/AmplifyBackendClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -19,7 +20,8 @@ namespace AmplifyBackend { */ class AWS_AMPLIFYBACKEND_API AmplifyBackendClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AmplifyBackendPaginationBase { + public AmplifyBackendPaginationBase, + public AmplifyBackendWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-amplifyuibuilder/include/aws/amplifyuibuilder/AmplifyUIBuilderClient.h b/generated/src/aws-cpp-sdk-amplifyuibuilder/include/aws/amplifyuibuilder/AmplifyUIBuilderClient.h index 23d3b77699a..ebac6cd9529 100644 --- a/generated/src/aws-cpp-sdk-amplifyuibuilder/include/aws/amplifyuibuilder/AmplifyUIBuilderClient.h +++ b/generated/src/aws-cpp-sdk-amplifyuibuilder/include/aws/amplifyuibuilder/AmplifyUIBuilderClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -32,7 +33,8 @@ namespace AmplifyUIBuilder { */ class AWS_AMPLIFYUIBUILDER_API AmplifyUIBuilderClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AmplifyUIBuilderPaginationBase { + public AmplifyUIBuilderPaginationBase, + public AmplifyUIBuilderWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-apigateway/include/aws/apigateway/APIGatewayClient.h b/generated/src/aws-cpp-sdk-apigateway/include/aws/apigateway/APIGatewayClient.h index 727af67abc2..e7e64ce178b 100644 --- a/generated/src/aws-cpp-sdk-apigateway/include/aws/apigateway/APIGatewayClient.h +++ b/generated/src/aws-cpp-sdk-apigateway/include/aws/apigateway/APIGatewayClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -23,7 +24,8 @@ namespace APIGateway { */ class AWS_APIGATEWAY_API APIGatewayClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public APIGatewayPaginationBase { + public APIGatewayPaginationBase, + public APIGatewayWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-apigatewaymanagementapi/include/aws/apigatewaymanagementapi/ApiGatewayManagementApiClient.h b/generated/src/aws-cpp-sdk-apigatewaymanagementapi/include/aws/apigatewaymanagementapi/ApiGatewayManagementApiClient.h index d67670a460c..9df18395a30 100644 --- a/generated/src/aws-cpp-sdk-apigatewaymanagementapi/include/aws/apigatewaymanagementapi/ApiGatewayManagementApiClient.h +++ b/generated/src/aws-cpp-sdk-apigatewaymanagementapi/include/aws/apigatewaymanagementapi/ApiGatewayManagementApiClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -25,7 +26,8 @@ namespace ApiGatewayManagementApi { class AWS_APIGATEWAYMANAGEMENTAPI_API ApiGatewayManagementApiClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ApiGatewayManagementApiPaginationBase { + public ApiGatewayManagementApiPaginationBase, + public ApiGatewayManagementApiWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-apigatewayv2/include/aws/apigatewayv2/ApiGatewayV2Client.h b/generated/src/aws-cpp-sdk-apigatewayv2/include/aws/apigatewayv2/ApiGatewayV2Client.h index 99eaec8acbb..ea79cb98511 100644 --- a/generated/src/aws-cpp-sdk-apigatewayv2/include/aws/apigatewayv2/ApiGatewayV2Client.h +++ b/generated/src/aws-cpp-sdk-apigatewayv2/include/aws/apigatewayv2/ApiGatewayV2Client.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -19,7 +20,8 @@ namespace ApiGatewayV2 { */ class AWS_APIGATEWAYV2_API ApiGatewayV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ApiGatewayV2PaginationBase { + public ApiGatewayV2PaginationBase, + public ApiGatewayV2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigClient.h b/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigClient.h index 38a880a49d5..82bd262a639 100644 --- a/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigClient.h +++ b/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -112,7 +113,8 @@ namespace AppConfig { */ class AWS_APPCONFIG_API AppConfigClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AppConfigPaginationBase { + public AppConfigPaginationBase, + public AppConfigWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h b/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h new file mode 100644 index 00000000000..fc68f897c4d --- /dev/null +++ b/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h @@ -0,0 +1,83 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace AppConfig { + +template +class AppConfigWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilDeploymentComplete(const Model::GetDeploymentRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETE"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStateMapper::GetNameForDeploymentState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLED_BACK"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStateMapper::GetNameForDeploymentState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REVERTED"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStateMapper::GetNameForDeploymentState(result.GetState()) == expected.get(); + }}); + + auto operation = [this](const Model::GetDeploymentRequest& req) { return static_cast(this)->GetDeployment(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilDeploymentComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilEnvironmentReadyForDeployment( + const Model::GetEnvironmentRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ReadyForDeployment"), + [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EnvironmentStateMapper::GetNameForEnvironmentState(result.GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("RolledBack"), + [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EnvironmentStateMapper::GetNameForEnvironmentState(result.GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Reverted"), + [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EnvironmentStateMapper::GetNameForEnvironmentState(result.GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetEnvironmentRequest& req) { return static_cast(this)->GetEnvironment(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilEnvironmentReadyForDeployment"); + return waiter.Wait(request); + } +}; +} // namespace AppConfig +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-appconfigdata/include/aws/appconfigdata/AppConfigDataClient.h b/generated/src/aws-cpp-sdk-appconfigdata/include/aws/appconfigdata/AppConfigDataClient.h index c6f0077bd8f..15b24ca7a5a 100644 --- a/generated/src/aws-cpp-sdk-appconfigdata/include/aws/appconfigdata/AppConfigDataClient.h +++ b/generated/src/aws-cpp-sdk-appconfigdata/include/aws/appconfigdata/AppConfigDataClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -58,7 +59,8 @@ namespace AppConfigData { */ class AWS_APPCONFIGDATA_API AppConfigDataClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AppConfigDataPaginationBase { + public AppConfigDataPaginationBase, + public AppConfigDataWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-appfabric/include/aws/appfabric/AppFabricClient.h b/generated/src/aws-cpp-sdk-appfabric/include/aws/appfabric/AppFabricClient.h index e2c5fbf932d..4d1346e378f 100644 --- a/generated/src/aws-cpp-sdk-appfabric/include/aws/appfabric/AppFabricClient.h +++ b/generated/src/aws-cpp-sdk-appfabric/include/aws/appfabric/AppFabricClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -30,7 +31,8 @@ namespace AppFabric { */ class AWS_APPFABRIC_API AppFabricClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AppFabricPaginationBase { + public AppFabricPaginationBase, + public AppFabricWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-appflow/include/aws/appflow/AppflowClient.h b/generated/src/aws-cpp-sdk-appflow/include/aws/appflow/AppflowClient.h index 44560ac43c5..d87354e4009 100644 --- a/generated/src/aws-cpp-sdk-appflow/include/aws/appflow/AppflowClient.h +++ b/generated/src/aws-cpp-sdk-appflow/include/aws/appflow/AppflowClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -45,7 +46,8 @@ namespace Appflow { */ class AWS_APPFLOW_API AppflowClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AppflowPaginationBase { + public AppflowPaginationBase, + public AppflowWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-appintegrations/include/aws/appintegrations/AppIntegrationsServiceClient.h b/generated/src/aws-cpp-sdk-appintegrations/include/aws/appintegrations/AppIntegrationsServiceClient.h index f63922cf4ce..f43a1da4676 100644 --- a/generated/src/aws-cpp-sdk-appintegrations/include/aws/appintegrations/AppIntegrationsServiceClient.h +++ b/generated/src/aws-cpp-sdk-appintegrations/include/aws/appintegrations/AppIntegrationsServiceClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -33,7 +34,8 @@ namespace AppIntegrationsService { class AWS_APPINTEGRATIONSSERVICE_API AppIntegrationsServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AppIntegrationsServicePaginationBase { + public AppIntegrationsServicePaginationBase, + public AppIntegrationsServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-application-autoscaling/include/aws/application-autoscaling/ApplicationAutoScalingClient.h b/generated/src/aws-cpp-sdk-application-autoscaling/include/aws/application-autoscaling/ApplicationAutoScalingClient.h index 8e56a98edb6..ad20ed680f5 100644 --- a/generated/src/aws-cpp-sdk-application-autoscaling/include/aws/application-autoscaling/ApplicationAutoScalingClient.h +++ b/generated/src/aws-cpp-sdk-application-autoscaling/include/aws/application-autoscaling/ApplicationAutoScalingClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -52,7 +53,8 @@ namespace ApplicationAutoScaling { class AWS_APPLICATIONAUTOSCALING_API ApplicationAutoScalingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ApplicationAutoScalingPaginationBase { + public ApplicationAutoScalingPaginationBase, + public ApplicationAutoScalingWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-application-insights/include/aws/application-insights/ApplicationInsightsClient.h b/generated/src/aws-cpp-sdk-application-insights/include/aws/application-insights/ApplicationInsightsClient.h index 3dbb14c1d09..2eb37e7994f 100644 --- a/generated/src/aws-cpp-sdk-application-insights/include/aws/application-insights/ApplicationInsightsClient.h +++ b/generated/src/aws-cpp-sdk-application-insights/include/aws/application-insights/ApplicationInsightsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -31,7 +32,8 @@ namespace ApplicationInsights { */ class AWS_APPLICATIONINSIGHTS_API ApplicationInsightsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ApplicationInsightsPaginationBase { + public ApplicationInsightsPaginationBase, + public ApplicationInsightsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-application-signals/include/aws/application-signals/ApplicationSignalsClient.h b/generated/src/aws-cpp-sdk-application-signals/include/aws/application-signals/ApplicationSignalsClient.h index b95b88d8d8c..dd9ba796083 100644 --- a/generated/src/aws-cpp-sdk-application-signals/include/aws/application-signals/ApplicationSignalsClient.h +++ b/generated/src/aws-cpp-sdk-application-signals/include/aws/application-signals/ApplicationSignalsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -35,7 +36,8 @@ namespace ApplicationSignals { */ class AWS_APPLICATIONSIGNALS_API ApplicationSignalsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ApplicationSignalsPaginationBase { + public ApplicationSignalsPaginationBase, + public ApplicationSignalsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-applicationcostprofiler/include/aws/applicationcostprofiler/ApplicationCostProfilerClient.h b/generated/src/aws-cpp-sdk-applicationcostprofiler/include/aws/applicationcostprofiler/ApplicationCostProfilerClient.h index 2fd1604881f..35059d2956b 100644 --- a/generated/src/aws-cpp-sdk-applicationcostprofiler/include/aws/applicationcostprofiler/ApplicationCostProfilerClient.h +++ b/generated/src/aws-cpp-sdk-applicationcostprofiler/include/aws/applicationcostprofiler/ApplicationCostProfilerClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -26,7 +27,8 @@ namespace ApplicationCostProfiler { class AWS_APPLICATIONCOSTPROFILER_API ApplicationCostProfilerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ApplicationCostProfilerPaginationBase { + public ApplicationCostProfilerPaginationBase, + public ApplicationCostProfilerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-appmesh/include/aws/appmesh/AppMeshClient.h b/generated/src/aws-cpp-sdk-appmesh/include/aws/appmesh/AppMeshClient.h index e7f1f7cb192..9b54416e8ad 100644 --- a/generated/src/aws-cpp-sdk-appmesh/include/aws/appmesh/AppMeshClient.h +++ b/generated/src/aws-cpp-sdk-appmesh/include/aws/appmesh/AppMeshClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -34,7 +35,8 @@ namespace AppMesh { */ class AWS_APPMESH_API AppMeshClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AppMeshPaginationBase { + public AppMeshPaginationBase, + public AppMeshWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-apprunner/include/aws/apprunner/AppRunnerClient.h b/generated/src/aws-cpp-sdk-apprunner/include/aws/apprunner/AppRunnerClient.h index b537ad107c7..00b1a766f31 100644 --- a/generated/src/aws-cpp-sdk-apprunner/include/aws/apprunner/AppRunnerClient.h +++ b/generated/src/aws-cpp-sdk-apprunner/include/aws/apprunner/AppRunnerClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -38,7 +39,8 @@ namespace AppRunner { */ class AWS_APPRUNNER_API AppRunnerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AppRunnerPaginationBase { + public AppRunnerPaginationBase, + public AppRunnerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamClient.h b/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamClient.h index 3fcbc866f1d..4e4d1828c32 100644 --- a/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamClient.h +++ b/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -37,7 +38,8 @@ namespace AppStream { */ class AWS_APPSTREAM_API AppStreamClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AppStreamPaginationBase { + public AppStreamPaginationBase, + public AppStreamWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h b/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h new file mode 100644 index 00000000000..6b76f6b7882 --- /dev/null +++ b/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h @@ -0,0 +1,88 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace AppStream { + +template +class AppStreamWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilFleetStarted(const Model::DescribeFleetsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeFleetsRequest& req) { return static_cast(this)->DescribeFleets(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilFleetStarted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFleetStopped(const Model::DescribeFleetsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeFleetsRequest& req) { return static_cast(this)->DescribeFleets(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilFleetStopped"); + return waiter.Wait(request); + } +}; +} // namespace AppStream +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-appsync/include/aws/appsync/AppSyncClient.h b/generated/src/aws-cpp-sdk-appsync/include/aws/appsync/AppSyncClient.h index 78c69b6b12d..02504c80456 100644 --- a/generated/src/aws-cpp-sdk-appsync/include/aws/appsync/AppSyncClient.h +++ b/generated/src/aws-cpp-sdk-appsync/include/aws/appsync/AppSyncClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -20,7 +21,8 @@ namespace AppSync { */ class AWS_APPSYNC_API AppSyncClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AppSyncPaginationBase { + public AppSyncPaginationBase, + public AppSyncWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchClient.h b/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchClient.h index 41eac8d36bd..b05d674f582 100644 --- a/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchClient.h +++ b/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -29,7 +30,8 @@ namespace ARCRegionswitch { */ class AWS_ARCREGIONSWITCH_API ARCRegionswitchClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ARCRegionswitchPaginationBase { + public ARCRegionswitchPaginationBase, + public ARCRegionswitchWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h b/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h new file mode 100644 index 00000000000..aa3e2de2fd9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h @@ -0,0 +1,102 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace ARCRegionswitch { + +template +class ARCRegionswitchWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilPlanEvaluationStatusPassed( + const Model::GetPlanEvaluationStatusRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("passed"), + [](const Model::GetPlanEvaluationStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EvaluationStatusMapper::GetNameForEvaluationStatus(result.GetEvaluationState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("actionRequired"), + [](const Model::GetPlanEvaluationStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EvaluationStatusMapper::GetNameForEvaluationStatus(result.GetEvaluationState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("pendingEvaluation"), + [](const Model::GetPlanEvaluationStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EvaluationStatusMapper::GetNameForEvaluationStatus(result.GetEvaluationState()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetPlanEvaluationStatusRequest& req) { + return static_cast(this)->GetPlanEvaluationStatus(req); + }; + Aws::Utils::Waiter waiter( + 30, 4, acceptors, operation, "WaitUntilPlanEvaluationStatusPassed"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPlanExecutionCompleted(const Model::GetPlanExecutionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), + [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completedWithExceptions"), + [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("canceled"), + [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("planExecutionTimedOut"), + [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetPlanExecutionRequest& req) { return static_cast(this)->GetPlanExecution(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilPlanExecutionCompleted"); + return waiter.Wait(request); + } +}; +} // namespace ARCRegionswitch +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/ARCZonalShiftClient.h b/generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/ARCZonalShiftClient.h index da04d7be525..e24ada78248 100644 --- a/generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/ARCZonalShiftClient.h +++ b/generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/ARCZonalShiftClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -34,7 +35,8 @@ namespace ARCZonalShift { */ class AWS_ARCZONALSHIFT_API ARCZonalShiftClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ARCZonalShiftPaginationBase { + public ARCZonalShiftPaginationBase, + public ARCZonalShiftWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-artifact/include/aws/artifact/ArtifactClient.h b/generated/src/aws-cpp-sdk-artifact/include/aws/artifact/ArtifactClient.h index d5d7e570292..abd08f60b43 100644 --- a/generated/src/aws-cpp-sdk-artifact/include/aws/artifact/ArtifactClient.h +++ b/generated/src/aws-cpp-sdk-artifact/include/aws/artifact/ArtifactClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -20,7 +21,8 @@ namespace Artifact { */ class AWS_ARTIFACT_API ArtifactClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ArtifactPaginationBase { + public ArtifactPaginationBase, + public ArtifactWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-athena/include/aws/athena/AthenaClient.h b/generated/src/aws-cpp-sdk-athena/include/aws/athena/AthenaClient.h index a1c98c12e76..8d622bab51e 100644 --- a/generated/src/aws-cpp-sdk-athena/include/aws/athena/AthenaClient.h +++ b/generated/src/aws-cpp-sdk-athena/include/aws/athena/AthenaClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -32,7 +33,8 @@ namespace Athena { */ class AWS_ATHENA_API AthenaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AthenaPaginationBase { + public AthenaPaginationBase, + public AthenaWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-auditmanager/include/aws/auditmanager/AuditManagerClient.h b/generated/src/aws-cpp-sdk-auditmanager/include/aws/auditmanager/AuditManagerClient.h index 511fe1d445f..95653044b14 100644 --- a/generated/src/aws-cpp-sdk-auditmanager/include/aws/auditmanager/AuditManagerClient.h +++ b/generated/src/aws-cpp-sdk-auditmanager/include/aws/auditmanager/AuditManagerClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -43,7 +44,8 @@ namespace AuditManager { */ class AWS_AUDITMANAGER_API AuditManagerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AuditManagerPaginationBase { + public AuditManagerPaginationBase, + public AuditManagerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-autoscaling-plans/include/aws/autoscaling-plans/AutoScalingPlansClient.h b/generated/src/aws-cpp-sdk-autoscaling-plans/include/aws/autoscaling-plans/AutoScalingPlansClient.h index 7ccc62761a2..385b3405966 100644 --- a/generated/src/aws-cpp-sdk-autoscaling-plans/include/aws/autoscaling-plans/AutoScalingPlansClient.h +++ b/generated/src/aws-cpp-sdk-autoscaling-plans/include/aws/autoscaling-plans/AutoScalingPlansClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -33,7 +34,8 @@ namespace AutoScalingPlans { */ class AWS_AUTOSCALINGPLANS_API AutoScalingPlansClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AutoScalingPlansPaginationBase { + public AutoScalingPlansPaginationBase, + public AutoScalingPlansWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingClient.h b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingClient.h index 0712c0579a0..ac5d3605569 100644 --- a/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingClient.h +++ b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -33,7 +34,8 @@ namespace AutoScaling { */ class AWS_AUTOSCALING_API AutoScalingClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AutoScalingPaginationBase { + public AutoScalingPaginationBase, + public AutoScalingWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h new file mode 100644 index 00000000000..e4fe7116045 --- /dev/null +++ b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h @@ -0,0 +1,105 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include + +#include + +namespace Aws { +namespace AutoScaling { + +template +class AutoScalingWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilGroupExists( + const Model::DescribeAutoScalingGroupsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetAutoScalingGroups().size() > 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, false, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetAutoScalingGroups().size() > 0) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeAutoScalingGroupsRequest& req) { + return static_cast(this)->DescribeAutoScalingGroups(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilGroupExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilGroupInService( + const Model::DescribeAutoScalingGroupsRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, false, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), + [](const Model::AutoScalingGroup& item) { + return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const auto& inner) { + return (inner.GetLifecycleState() == "InService"); + }) >= item.GetMinSize()); + }) == expected.get(); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), + [](const Model::AutoScalingGroup& item) { + return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const auto& inner) { + return (inner.GetLifecycleState() == "InService"); + }) >= item.GetMinSize()); + }) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeAutoScalingGroupsRequest& req) { + return static_cast(this)->DescribeAutoScalingGroups(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilGroupInService"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilGroupNotExists( + const Model::DescribeAutoScalingGroupsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, false, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetAutoScalingGroups().size() > 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetAutoScalingGroups().size() > 0) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeAutoScalingGroupsRequest& req) { + return static_cast(this)->DescribeAutoScalingGroups(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilGroupNotExists"); + return waiter.Wait(request); + } +}; +} // namespace AutoScaling +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferClient.h b/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferClient.h index 298dd0404dc..b5b87c8b3d1 100644 --- a/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferClient.h +++ b/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -30,7 +31,8 @@ namespace Transfer { */ class AWS_TRANSFER_API TransferClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public TransferPaginationBase { + public TransferPaginationBase, + public TransferWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h b/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h new file mode 100644 index 00000000000..770ba82aa6f --- /dev/null +++ b/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h @@ -0,0 +1,64 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Transfer { + +template +class TransferWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilServerOffline(const Model::DescribeServerRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("OFFLINE"), + [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STOP_FAILED"), + [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeServerRequest& req) { return static_cast(this)->DescribeServer(req); }; + Aws::Utils::Waiter waiter(30, 120, acceptors, operation, + "WaitUntilServerOffline"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilServerOnline(const Model::DescribeServerRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ONLINE"), + [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("START_FAILED"), + [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeServerRequest& req) { return static_cast(this)->DescribeServer(req); }; + Aws::Utils::Waiter waiter(30, 120, acceptors, operation, + "WaitUntilServerOnline"); + return waiter.Wait(request); + } +}; +} // namespace Transfer +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIClient.h b/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIClient.h index b2e17a70f64..568a0ec8f4f 100644 --- a/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIClient.h +++ b/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -31,7 +32,8 @@ namespace B2BI { */ class AWS_B2BI_API B2BIClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public B2BIPaginationBase { + public B2BIPaginationBase, + public B2BIWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h b/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h new file mode 100644 index 00000000000..d2155574ea9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h @@ -0,0 +1,48 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace B2BI { + +template +class B2BIWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilTransformerJobSucceeded( + const Model::GetTransformerJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("succeeded"), + [](const Model::GetTransformerJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TransformerJobStatusMapper::GetNameForTransformerJobStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::GetTransformerJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TransformerJobStatusMapper::GetNameForTransformerJobStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetTransformerJobRequest& req) { + return static_cast(this)->GetTransformerJob(req); + }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilTransformerJobSucceeded"); + return waiter.Wait(request); + } +}; +} // namespace B2BI +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-backup-gateway/include/aws/backup-gateway/BackupGatewayClient.h b/generated/src/aws-cpp-sdk-backup-gateway/include/aws/backup-gateway/BackupGatewayClient.h index 99a5bd0ffd4..962c6a6aec9 100644 --- a/generated/src/aws-cpp-sdk-backup-gateway/include/aws/backup-gateway/BackupGatewayClient.h +++ b/generated/src/aws-cpp-sdk-backup-gateway/include/aws/backup-gateway/BackupGatewayClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -29,7 +30,8 @@ namespace BackupGateway { */ class AWS_BACKUPGATEWAY_API BackupGatewayClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BackupGatewayPaginationBase { + public BackupGatewayPaginationBase, + public BackupGatewayWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-backup/include/aws/backup/BackupClient.h b/generated/src/aws-cpp-sdk-backup/include/aws/backup/BackupClient.h index f27f212599b..874a429df20 100644 --- a/generated/src/aws-cpp-sdk-backup/include/aws/backup/BackupClient.h +++ b/generated/src/aws-cpp-sdk-backup/include/aws/backup/BackupClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -22,7 +23,8 @@ namespace Backup { */ class AWS_BACKUP_API BackupClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BackupPaginationBase { + public BackupPaginationBase, + public BackupWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-backupsearch/include/aws/backupsearch/BackupSearchClient.h b/generated/src/aws-cpp-sdk-backupsearch/include/aws/backupsearch/BackupSearchClient.h index 3d604691c7d..fa4c8fab24d 100644 --- a/generated/src/aws-cpp-sdk-backupsearch/include/aws/backupsearch/BackupSearchClient.h +++ b/generated/src/aws-cpp-sdk-backupsearch/include/aws/backupsearch/BackupSearchClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -25,7 +26,8 @@ namespace BackupSearch { */ class AWS_BACKUPSEARCH_API BackupSearchClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BackupSearchPaginationBase { + public BackupSearchPaginationBase, + public BackupSearchWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-batch/include/aws/batch/BatchClient.h b/generated/src/aws-cpp-sdk-batch/include/aws/batch/BatchClient.h index e4411ef3b43..7a378cbeb57 100644 --- a/generated/src/aws-cpp-sdk-batch/include/aws/batch/BatchClient.h +++ b/generated/src/aws-cpp-sdk-batch/include/aws/batch/BatchClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -32,7 +33,8 @@ namespace Batch { */ class AWS_BATCH_API BatchClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BatchPaginationBase { + public BatchPaginationBase, + public BatchWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-bcm-dashboards/include/aws/bcm-dashboards/BCMDashboardsClient.h b/generated/src/aws-cpp-sdk-bcm-dashboards/include/aws/bcm-dashboards/BCMDashboardsClient.h index 87da6e62994..528bd5f747c 100644 --- a/generated/src/aws-cpp-sdk-bcm-dashboards/include/aws/bcm-dashboards/BCMDashboardsClient.h +++ b/generated/src/aws-cpp-sdk-bcm-dashboards/include/aws/bcm-dashboards/BCMDashboardsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -28,7 +29,8 @@ namespace BCMDashboards { */ class AWS_BCMDASHBOARDS_API BCMDashboardsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BCMDashboardsPaginationBase { + public BCMDashboardsPaginationBase, + public BCMDashboardsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-bcm-data-exports/include/aws/bcm-data-exports/BCMDataExportsClient.h b/generated/src/aws-cpp-sdk-bcm-data-exports/include/aws/bcm-data-exports/BCMDataExportsClient.h index 53a45f41211..d9dcfaa55e6 100644 --- a/generated/src/aws-cpp-sdk-bcm-data-exports/include/aws/bcm-data-exports/BCMDataExportsClient.h +++ b/generated/src/aws-cpp-sdk-bcm-data-exports/include/aws/bcm-data-exports/BCMDataExportsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -23,7 +24,8 @@ namespace BCMDataExports { */ class AWS_BCMDATAEXPORTS_API BCMDataExportsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BCMDataExportsPaginationBase { + public BCMDataExportsPaginationBase, + public BCMDataExportsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-bcm-pricing-calculator/include/aws/bcm-pricing-calculator/BCMPricingCalculatorClient.h b/generated/src/aws-cpp-sdk-bcm-pricing-calculator/include/aws/bcm-pricing-calculator/BCMPricingCalculatorClient.h index ced910438e1..bb2ae394d12 100644 --- a/generated/src/aws-cpp-sdk-bcm-pricing-calculator/include/aws/bcm-pricing-calculator/BCMPricingCalculatorClient.h +++ b/generated/src/aws-cpp-sdk-bcm-pricing-calculator/include/aws/bcm-pricing-calculator/BCMPricingCalculatorClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -25,7 +26,8 @@ namespace BCMPricingCalculator { class AWS_BCMPRICINGCALCULATOR_API BCMPricingCalculatorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BCMPricingCalculatorPaginationBase { + public BCMPricingCalculatorPaginationBase, + public BCMPricingCalculatorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-bcm-recommended-actions/include/aws/bcm-recommended-actions/BCMRecommendedActionsClient.h b/generated/src/aws-cpp-sdk-bcm-recommended-actions/include/aws/bcm-recommended-actions/BCMRecommendedActionsClient.h index 4498818c89e..548e9252a00 100644 --- a/generated/src/aws-cpp-sdk-bcm-recommended-actions/include/aws/bcm-recommended-actions/BCMRecommendedActionsClient.h +++ b/generated/src/aws-cpp-sdk-bcm-recommended-actions/include/aws/bcm-recommended-actions/BCMRecommendedActionsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -24,7 +25,8 @@ namespace BCMRecommendedActions { class AWS_BCMRECOMMENDEDACTIONS_API BCMRecommendedActionsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BCMRecommendedActionsPaginationBase { + public BCMRecommendedActionsPaginationBase, + public BCMRecommendedActionsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-bedrock-agent-runtime/include/aws/bedrock-agent-runtime/BedrockAgentRuntimeClient.h b/generated/src/aws-cpp-sdk-bedrock-agent-runtime/include/aws/bedrock-agent-runtime/BedrockAgentRuntimeClient.h index d468a91ecd2..266da9e10fa 100644 --- a/generated/src/aws-cpp-sdk-bedrock-agent-runtime/include/aws/bedrock-agent-runtime/BedrockAgentRuntimeClient.h +++ b/generated/src/aws-cpp-sdk-bedrock-agent-runtime/include/aws/bedrock-agent-runtime/BedrockAgentRuntimeClient.h @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -28,7 +29,8 @@ class AWS_BEDROCKAGENTRUNTIME_API BedrockAgentRuntimeClient Aws::BedrockAgentRuntime::SERVICE_NAME, Aws::BedrockAgentRuntime::BedrockAgentRuntimeClientConfiguration, smithy::AuthSchemeResolverBase<>, Aws::Crt::Variant, BedrockAgentRuntimeEndpointProviderBase, smithy::client::JsonOutcomeSerializer, smithy::client::JsonOutcome, Aws::Client::BedrockAgentRuntimeErrorMarshaller>, - public BedrockAgentRuntimePaginationBase { + public BedrockAgentRuntimePaginationBase, + public BedrockAgentRuntimeWaiter { public: static const char* GetServiceName(); static const char* GetAllocationTag(); diff --git a/generated/src/aws-cpp-sdk-bedrock-agent/include/aws/bedrock-agent/BedrockAgentClient.h b/generated/src/aws-cpp-sdk-bedrock-agent/include/aws/bedrock-agent/BedrockAgentClient.h index 4a70fc618d6..8f69dc188df 100644 --- a/generated/src/aws-cpp-sdk-bedrock-agent/include/aws/bedrock-agent/BedrockAgentClient.h +++ b/generated/src/aws-cpp-sdk-bedrock-agent/include/aws/bedrock-agent/BedrockAgentClient.h @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -28,7 +29,8 @@ class AWS_BEDROCKAGENT_API BedrockAgentClient smithy::AuthSchemeResolverBase<>, Aws::Crt::Variant, BedrockAgentEndpointProviderBase, smithy::client::JsonOutcomeSerializer, smithy::client::JsonOutcome, Aws::Client::BedrockAgentErrorMarshaller>, - public BedrockAgentPaginationBase { + public BedrockAgentPaginationBase, + public BedrockAgentWaiter { public: static const char* GetServiceName(); static const char* GetAllocationTag(); diff --git a/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlClient.h b/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlClient.h index 3b1a0adbb11..2e16f02886e 100644 --- a/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlClient.h +++ b/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -22,7 +23,8 @@ namespace BedrockAgentCoreControl { class AWS_BEDROCKAGENTCORECONTROL_API BedrockAgentCoreControlClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BedrockAgentCoreControlPaginationBase { + public BedrockAgentCoreControlPaginationBase, + public BedrockAgentCoreControlWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h b/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h new file mode 100644 index 00000000000..abf208d9925 --- /dev/null +++ b/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h @@ -0,0 +1,220 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace BedrockAgentCoreControl { + +template +class BedrockAgentCoreControlWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilMemoryCreated(const Model::GetMemoryRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::GetMemoryOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MemoryStatusMapper::GetNameForMemoryStatus(result.GetMemory().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetMemoryOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MemoryStatusMapper::GetNameForMemoryStatus(result.GetMemory().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetMemoryOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MemoryStatusMapper::GetNameForMemoryStatus(result.GetMemory().GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetMemoryRequest& req) { return static_cast(this)->GetMemory(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilMemoryCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPolicyActive(const Model::GetPolicyRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetPolicyRequest& req) { return static_cast(this)->GetPolicy(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilPolicyActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPolicyDeleted(const Model::GetPolicyRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetPolicyRequest& req) { return static_cast(this)->GetPolicy(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilPolicyDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPolicyEngineActive(const Model::GetPolicyEngineRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetPolicyEngineRequest& req) { return static_cast(this)->GetPolicyEngine(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilPolicyEngineActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPolicyEngineDeleted(const Model::GetPolicyEngineRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetPolicyEngineRequest& req) { return static_cast(this)->GetPolicyEngine(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, + "WaitUntilPolicyEngineDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPolicyGenerationCompleted( + const Model::GetPolicyGenerationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("GENERATED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("GENERATING"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("GENERATE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetPolicyGenerationRequest& req) { + return static_cast(this)->GetPolicyGeneration(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilPolicyGenerationCompleted"); + return waiter.Wait(request); + } +}; +} // namespace BedrockAgentCoreControl +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bedrock-agentcore/include/aws/bedrock-agentcore/BedrockAgentCoreClient.h b/generated/src/aws-cpp-sdk-bedrock-agentcore/include/aws/bedrock-agentcore/BedrockAgentCoreClient.h index c83fe0df38f..d69ccb4bbbd 100644 --- a/generated/src/aws-cpp-sdk-bedrock-agentcore/include/aws/bedrock-agentcore/BedrockAgentCoreClient.h +++ b/generated/src/aws-cpp-sdk-bedrock-agentcore/include/aws/bedrock-agentcore/BedrockAgentCoreClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -21,7 +22,8 @@ namespace BedrockAgentCore { */ class AWS_BEDROCKAGENTCORE_API BedrockAgentCoreClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BedrockAgentCorePaginationBase { + public BedrockAgentCorePaginationBase, + public BedrockAgentCoreWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-bedrock-data-automation-runtime/include/aws/bedrock-data-automation-runtime/BedrockDataAutomationRuntimeClient.h b/generated/src/aws-cpp-sdk-bedrock-data-automation-runtime/include/aws/bedrock-data-automation-runtime/BedrockDataAutomationRuntimeClient.h index c3f4e90d933..d4eede6f2d1 100644 --- a/generated/src/aws-cpp-sdk-bedrock-data-automation-runtime/include/aws/bedrock-data-automation-runtime/BedrockDataAutomationRuntimeClient.h +++ b/generated/src/aws-cpp-sdk-bedrock-data-automation-runtime/include/aws/bedrock-data-automation-runtime/BedrockDataAutomationRuntimeClient.h @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -28,7 +29,8 @@ class AWS_BEDROCKDATAAUTOMATIONRUNTIME_API BedrockDataAutomationRuntimeClient smithy::AuthSchemeResolverBase<>, Aws::Crt::Variant, BedrockDataAutomationRuntimeEndpointProviderBase, smithy::client::JsonOutcomeSerializer, smithy::client::JsonOutcome, Aws::Client::BedrockDataAutomationRuntimeErrorMarshaller>, - public BedrockDataAutomationRuntimePaginationBase { + public BedrockDataAutomationRuntimePaginationBase, + public BedrockDataAutomationRuntimeWaiter { public: static const char* GetServiceName(); static const char* GetAllocationTag(); diff --git a/generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/BedrockDataAutomationClient.h b/generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/BedrockDataAutomationClient.h index 8c2a3dc621a..15cf05e2604 100644 --- a/generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/BedrockDataAutomationClient.h +++ b/generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/BedrockDataAutomationClient.h @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -27,7 +28,8 @@ class AWS_BEDROCKDATAAUTOMATION_API BedrockDataAutomationClient Aws::BedrockDataAutomation::SERVICE_NAME, Aws::BedrockDataAutomation::BedrockDataAutomationClientConfiguration, smithy::AuthSchemeResolverBase<>, Aws::Crt::Variant, BedrockDataAutomationEndpointProviderBase, smithy::client::JsonOutcomeSerializer, smithy::client::JsonOutcome, Aws::Client::BedrockDataAutomationErrorMarshaller>, - public BedrockDataAutomationPaginationBase { + public BedrockDataAutomationPaginationBase, + public BedrockDataAutomationWaiter { public: static const char* GetServiceName(); static const char* GetAllocationTag(); diff --git a/generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/BedrockRuntimeClient.h b/generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/BedrockRuntimeClient.h index 0295b1dcc5e..b97252ddc92 100644 --- a/generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/BedrockRuntimeClient.h +++ b/generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/BedrockRuntimeClient.h @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -29,7 +30,8 @@ class AWS_BEDROCKRUNTIME_API BedrockRuntimeClient Aws::BedrockRuntime::SERVICE_NAME, Aws::BedrockRuntime::BedrockRuntimeClientConfiguration, smithy::AuthSchemeResolverBase<>, Aws::Crt::Variant, BedrockRuntimeEndpointProviderBase, smithy::client::JsonOutcomeSerializer, smithy::client::JsonOutcome, Aws::Client::BedrockRuntimeErrorMarshaller>, - public BedrockRuntimePaginationBase { + public BedrockRuntimePaginationBase, + public BedrockRuntimeWaiter { public: static const char* GetServiceName(); static const char* GetAllocationTag(); diff --git a/generated/src/aws-cpp-sdk-bedrock/include/aws/bedrock/BedrockClient.h b/generated/src/aws-cpp-sdk-bedrock/include/aws/bedrock/BedrockClient.h index 870765edafc..c5d8019ccd2 100644 --- a/generated/src/aws-cpp-sdk-bedrock/include/aws/bedrock/BedrockClient.h +++ b/generated/src/aws-cpp-sdk-bedrock/include/aws/bedrock/BedrockClient.h @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -29,7 +30,8 @@ class AWS_BEDROCK_API BedrockClient Aws::Bedrock::SERVICE_NAME, Aws::Bedrock::BedrockClientConfiguration, smithy::AuthSchemeResolverBase<>, Aws::Crt::Variant, BedrockEndpointProviderBase, smithy::client::JsonOutcomeSerializer, smithy::client::JsonOutcome, Aws::Client::BedrockErrorMarshaller>, - public BedrockPaginationBase { + public BedrockPaginationBase, + public BedrockWaiter { public: static const char* GetServiceName(); static const char* GetAllocationTag(); diff --git a/generated/src/aws-cpp-sdk-billing/include/aws/billing/BillingClient.h b/generated/src/aws-cpp-sdk-billing/include/aws/billing/BillingClient.h index 5b7113c4116..737a4c42f6a 100644 --- a/generated/src/aws-cpp-sdk-billing/include/aws/billing/BillingClient.h +++ b/generated/src/aws-cpp-sdk-billing/include/aws/billing/BillingClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -22,7 +23,8 @@ namespace Billing { */ class AWS_BILLING_API BillingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BillingPaginationBase { + public BillingPaginationBase, + public BillingWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-billingconductor/include/aws/billingconductor/BillingConductorClient.h b/generated/src/aws-cpp-sdk-billingconductor/include/aws/billingconductor/BillingConductorClient.h index 4d53cd3bea6..d322ce4be5a 100644 --- a/generated/src/aws-cpp-sdk-billingconductor/include/aws/billingconductor/BillingConductorClient.h +++ b/generated/src/aws-cpp-sdk-billingconductor/include/aws/billingconductor/BillingConductorClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -37,7 +38,8 @@ namespace BillingConductor { */ class AWS_BILLINGCONDUCTOR_API BillingConductorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BillingConductorPaginationBase { + public BillingConductorPaginationBase, + public BillingConductorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-braket/include/aws/braket/BraketClient.h b/generated/src/aws-cpp-sdk-braket/include/aws/braket/BraketClient.h index 0cfc9e4914e..9298f7ddf81 100644 --- a/generated/src/aws-cpp-sdk-braket/include/aws/braket/BraketClient.h +++ b/generated/src/aws-cpp-sdk-braket/include/aws/braket/BraketClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -54,7 +55,8 @@ namespace Braket { */ class AWS_BRAKET_API BraketClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BraketPaginationBase { + public BraketPaginationBase, + public BraketWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-budgets/include/aws/budgets/BudgetsClient.h b/generated/src/aws-cpp-sdk-budgets/include/aws/budgets/BudgetsClient.h index 5ba6618740a..f432315b9b3 100644 --- a/generated/src/aws-cpp-sdk-budgets/include/aws/budgets/BudgetsClient.h +++ b/generated/src/aws-cpp-sdk-budgets/include/aws/budgets/BudgetsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -44,7 +45,8 @@ namespace Budgets { */ class AWS_BUDGETS_API BudgetsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public BudgetsPaginationBase { + public BudgetsPaginationBase, + public BudgetsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ce/include/aws/ce/CostExplorerClient.h b/generated/src/aws-cpp-sdk-ce/include/aws/ce/CostExplorerClient.h index 13067679c18..fd2d578d3ba 100644 --- a/generated/src/aws-cpp-sdk-ce/include/aws/ce/CostExplorerClient.h +++ b/generated/src/aws-cpp-sdk-ce/include/aws/ce/CostExplorerClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -28,7 +29,8 @@ namespace CostExplorer { */ class AWS_COSTEXPLORER_API CostExplorerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CostExplorerPaginationBase { + public CostExplorerPaginationBase, + public CostExplorerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-chatbot/include/aws/chatbot/ChatbotClient.h b/generated/src/aws-cpp-sdk-chatbot/include/aws/chatbot/ChatbotClient.h index 457ddb70355..d53c4aafbcd 100644 --- a/generated/src/aws-cpp-sdk-chatbot/include/aws/chatbot/ChatbotClient.h +++ b/generated/src/aws-cpp-sdk-chatbot/include/aws/chatbot/ChatbotClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -29,7 +30,8 @@ namespace chatbot { */ class AWS_CHATBOT_API ChatbotClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ChatbotPaginationBase { + public ChatbotPaginationBase, + public ChatbotWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-chime-sdk-identity/include/aws/chime-sdk-identity/ChimeSDKIdentityClient.h b/generated/src/aws-cpp-sdk-chime-sdk-identity/include/aws/chime-sdk-identity/ChimeSDKIdentityClient.h index a98433f89f0..1571a1574ab 100644 --- a/generated/src/aws-cpp-sdk-chime-sdk-identity/include/aws/chime-sdk-identity/ChimeSDKIdentityClient.h +++ b/generated/src/aws-cpp-sdk-chime-sdk-identity/include/aws/chime-sdk-identity/ChimeSDKIdentityClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -24,7 +25,8 @@ namespace ChimeSDKIdentity { */ class AWS_CHIMESDKIDENTITY_API ChimeSDKIdentityClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ChimeSDKIdentityPaginationBase { + public ChimeSDKIdentityPaginationBase, + public ChimeSDKIdentityWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-chime-sdk-media-pipelines/include/aws/chime-sdk-media-pipelines/ChimeSDKMediaPipelinesClient.h b/generated/src/aws-cpp-sdk-chime-sdk-media-pipelines/include/aws/chime-sdk-media-pipelines/ChimeSDKMediaPipelinesClient.h index 5591287d273..02c57928a01 100644 --- a/generated/src/aws-cpp-sdk-chime-sdk-media-pipelines/include/aws/chime-sdk-media-pipelines/ChimeSDKMediaPipelinesClient.h +++ b/generated/src/aws-cpp-sdk-chime-sdk-media-pipelines/include/aws/chime-sdk-media-pipelines/ChimeSDKMediaPipelinesClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -25,7 +26,8 @@ namespace ChimeSDKMediaPipelines { class AWS_CHIMESDKMEDIAPIPELINES_API ChimeSDKMediaPipelinesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ChimeSDKMediaPipelinesPaginationBase { + public ChimeSDKMediaPipelinesPaginationBase, + public ChimeSDKMediaPipelinesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-chime-sdk-meetings/include/aws/chime-sdk-meetings/ChimeSDKMeetingsClient.h b/generated/src/aws-cpp-sdk-chime-sdk-meetings/include/aws/chime-sdk-meetings/ChimeSDKMeetingsClient.h index e27e9d01afc..a4fdddf9563 100644 --- a/generated/src/aws-cpp-sdk-chime-sdk-meetings/include/aws/chime-sdk-meetings/ChimeSDKMeetingsClient.h +++ b/generated/src/aws-cpp-sdk-chime-sdk-meetings/include/aws/chime-sdk-meetings/ChimeSDKMeetingsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -24,7 +25,8 @@ namespace ChimeSDKMeetings { */ class AWS_CHIMESDKMEETINGS_API ChimeSDKMeetingsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ChimeSDKMeetingsPaginationBase { + public ChimeSDKMeetingsPaginationBase, + public ChimeSDKMeetingsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-chime-sdk-messaging/include/aws/chime-sdk-messaging/ChimeSDKMessagingClient.h b/generated/src/aws-cpp-sdk-chime-sdk-messaging/include/aws/chime-sdk-messaging/ChimeSDKMessagingClient.h index aabd6ce203d..676855bcbd8 100644 --- a/generated/src/aws-cpp-sdk-chime-sdk-messaging/include/aws/chime-sdk-messaging/ChimeSDKMessagingClient.h +++ b/generated/src/aws-cpp-sdk-chime-sdk-messaging/include/aws/chime-sdk-messaging/ChimeSDKMessagingClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -24,7 +25,8 @@ namespace ChimeSDKMessaging { */ class AWS_CHIMESDKMESSAGING_API ChimeSDKMessagingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ChimeSDKMessagingPaginationBase { + public ChimeSDKMessagingPaginationBase, + public ChimeSDKMessagingWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-chime-sdk-voice/include/aws/chime-sdk-voice/ChimeSDKVoiceClient.h b/generated/src/aws-cpp-sdk-chime-sdk-voice/include/aws/chime-sdk-voice/ChimeSDKVoiceClient.h index 57cf6501fc5..77c80226138 100644 --- a/generated/src/aws-cpp-sdk-chime-sdk-voice/include/aws/chime-sdk-voice/ChimeSDKVoiceClient.h +++ b/generated/src/aws-cpp-sdk-chime-sdk-voice/include/aws/chime-sdk-voice/ChimeSDKVoiceClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -23,7 +24,8 @@ namespace ChimeSDKVoice { */ class AWS_CHIMESDKVOICE_API ChimeSDKVoiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ChimeSDKVoicePaginationBase { + public ChimeSDKVoicePaginationBase, + public ChimeSDKVoiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-chime/include/aws/chime/ChimeClient.h b/generated/src/aws-cpp-sdk-chime/include/aws/chime/ChimeClient.h index 96410b6259b..9998a510147 100644 --- a/generated/src/aws-cpp-sdk-chime/include/aws/chime/ChimeClient.h +++ b/generated/src/aws-cpp-sdk-chime/include/aws/chime/ChimeClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -60,7 +61,8 @@ namespace Chime { */ class AWS_CHIME_API ChimeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ChimePaginationBase { + public ChimePaginationBase, + public ChimeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cleanrooms/include/aws/cleanrooms/CleanRoomsClient.h b/generated/src/aws-cpp-sdk-cleanrooms/include/aws/cleanrooms/CleanRoomsClient.h index 44f7ea40fad..528d662b6cb 100644 --- a/generated/src/aws-cpp-sdk-cleanrooms/include/aws/cleanrooms/CleanRoomsClient.h +++ b/generated/src/aws-cpp-sdk-cleanrooms/include/aws/cleanrooms/CleanRoomsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -30,7 +31,8 @@ namespace CleanRooms { */ class AWS_CLEANROOMS_API CleanRoomsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CleanRoomsPaginationBase { + public CleanRoomsPaginationBase, + public CleanRoomsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cleanroomsml/include/aws/cleanroomsml/CleanRoomsMLClient.h b/generated/src/aws-cpp-sdk-cleanroomsml/include/aws/cleanroomsml/CleanRoomsMLClient.h index ababcb04489..f2de95cb6f2 100644 --- a/generated/src/aws-cpp-sdk-cleanroomsml/include/aws/cleanroomsml/CleanRoomsMLClient.h +++ b/generated/src/aws-cpp-sdk-cleanroomsml/include/aws/cleanroomsml/CleanRoomsMLClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -32,7 +33,8 @@ namespace CleanRoomsML { */ class AWS_CLEANROOMSML_API CleanRoomsMLClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CleanRoomsMLPaginationBase { + public CleanRoomsMLPaginationBase, + public CleanRoomsMLWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloud9/include/aws/cloud9/Cloud9Client.h b/generated/src/aws-cpp-sdk-cloud9/include/aws/cloud9/Cloud9Client.h index da86e6560ac..0c2b1d0771f 100644 --- a/generated/src/aws-cpp-sdk-cloud9/include/aws/cloud9/Cloud9Client.h +++ b/generated/src/aws-cpp-sdk-cloud9/include/aws/cloud9/Cloud9Client.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -47,7 +48,8 @@ namespace Cloud9 { */ class AWS_CLOUD9_API Cloud9Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Cloud9PaginationBase { + public Cloud9PaginationBase, + public Cloud9Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiClient.h b/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiClient.h index 19275b5f2ab..dcced06d7d6 100644 --- a/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiClient.h +++ b/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -21,7 +22,8 @@ namespace CloudControlApi { */ class AWS_CLOUDCONTROLAPI_API CloudControlApiClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudControlApiPaginationBase { + public CloudControlApiPaginationBase, + public CloudControlApiWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h b/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h new file mode 100644 index 00000000000..4ad56fdd5b6 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h @@ -0,0 +1,51 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include + +#include + +namespace Aws { +namespace CloudControlApi { + +template +class CloudControlApiWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilResourceRequestSuccess( + const Model::GetResourceRequestStatusRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCESS"), + [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetProgressEvent().GetOperationStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetProgressEvent().GetOperationStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCEL_COMPLETE"), + [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetProgressEvent().GetOperationStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetResourceRequestStatusRequest& req) { + return static_cast(this)->GetResourceRequestStatus(req); + }; + Aws::Utils::Waiter waiter( + 5, 24, acceptors, operation, "WaitUntilResourceRequestSuccess"); + return waiter.Wait(request); + } +}; +} // namespace CloudControlApi +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-clouddirectory/include/aws/clouddirectory/CloudDirectoryClient.h b/generated/src/aws-cpp-sdk-clouddirectory/include/aws/clouddirectory/CloudDirectoryClient.h index 3ff287f27a3..29503405c4a 100644 --- a/generated/src/aws-cpp-sdk-clouddirectory/include/aws/clouddirectory/CloudDirectoryClient.h +++ b/generated/src/aws-cpp-sdk-clouddirectory/include/aws/clouddirectory/CloudDirectoryClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -28,7 +29,8 @@ namespace CloudDirectory { */ class AWS_CLOUDDIRECTORY_API CloudDirectoryClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudDirectoryPaginationBase { + public CloudDirectoryPaginationBase, + public CloudDirectoryWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationClient.h b/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationClient.h index 912739e5d69..1015f5c8ea6 100644 --- a/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationClient.h +++ b/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -36,7 +37,8 @@ namespace CloudFormation { */ class AWS_CLOUDFORMATION_API CloudFormationClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudFormationPaginationBase { + public CloudFormationPaginationBase, + public CloudFormationWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h b/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h new file mode 100644 index 00000000000..01b745f9b35 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h @@ -0,0 +1,497 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace CloudFormation { + +template +class CloudFormationWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilChangeSetCreateComplete( + const Model::DescribeChangeSetRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorStatusMapper::GetNameForStackRefactorStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeChangeSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChangeSetStatusMapper::GetNameForChangeSetStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + + auto operation = [this](const Model::DescribeChangeSetRequest& req) { + return static_cast(this)->DescribeChangeSet(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilChangeSetCreateComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStackRefactorCreateComplete( + const Model::DescribeStackRefactorRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorStatusMapper::GetNameForStackRefactorStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorStatusMapper::GetNameForStackRefactorStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + + auto operation = [this](const Model::DescribeStackRefactorRequest& req) { + return static_cast(this)->DescribeStackRefactor(req); + }; + Aws::Utils::Waiter waiter( + 5, 24, acceptors, operation, "WaitUntilStackRefactorCreateComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStackRefactorExecuteComplete( + const Model::DescribeStackRefactorRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("EXECUTE_COMPLETE"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorExecutionStatusMapper::GetNameForStackRefactorExecutionStatus( + result.GetExecutionStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("EXECUTE_FAILED"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorExecutionStatusMapper::GetNameForStackRefactorExecutionStatus( + result.GetExecutionStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_COMPLETE"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorExecutionStatusMapper::GetNameForStackRefactorExecutionStatus( + result.GetExecutionStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + + auto operation = [this](const Model::DescribeStackRefactorRequest& req) { + return static_cast(this)->DescribeStackRefactor(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilStackRefactorExecuteComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStackCreateComplete(const Model::DescribeStacksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, + Aws::String("UPDATE_COMPLETE_CLEANUP_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, + Aws::String("UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + + auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilStackCreateComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStackDeleteComplete(const Model::DescribeStacksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilStackDeleteComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStackExists(const Model::DescribeStacksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + + auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilStackExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStackImportComplete(const Model::DescribeStacksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("IMPORT_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("IMPORT_ROLLBACK_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("IMPORT_ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("IMPORT_ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + + auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilStackImportComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStackRollbackComplete(const Model::DescribeStacksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + + auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilStackRollbackComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStackUpdateComplete(const Model::DescribeStacksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + + auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilStackUpdateComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTypeRegistrationComplete( + const Model::DescribeTypeRegistrationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETE"), + [](const Model::DescribeTypeRegistrationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RegistrationStatusMapper::GetNameForRegistrationStatus(result.GetProgressStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeTypeRegistrationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RegistrationStatusMapper::GetNameForRegistrationStatus(result.GetProgressStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeTypeRegistrationRequest& req) { + return static_cast(this)->DescribeTypeRegistration(req); + }; + Aws::Utils::Waiter waiter( + 30, 4, acceptors, operation, "WaitUntilTypeRegistrationComplete"); + return waiter.Wait(request); + } +}; +} // namespace CloudFormation +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cloudfront-keyvaluestore/include/aws/cloudfront-keyvaluestore/CloudFrontKeyValueStoreClient.h b/generated/src/aws-cpp-sdk-cloudfront-keyvaluestore/include/aws/cloudfront-keyvaluestore/CloudFrontKeyValueStoreClient.h index 002f738f213..a73f4881b0f 100644 --- a/generated/src/aws-cpp-sdk-cloudfront-keyvaluestore/include/aws/cloudfront-keyvaluestore/CloudFrontKeyValueStoreClient.h +++ b/generated/src/aws-cpp-sdk-cloudfront-keyvaluestore/include/aws/cloudfront-keyvaluestore/CloudFrontKeyValueStoreClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -21,7 +22,8 @@ namespace CloudFrontKeyValueStore { class AWS_CLOUDFRONTKEYVALUESTORE_API CloudFrontKeyValueStoreClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudFrontKeyValueStorePaginationBase { + public CloudFrontKeyValueStorePaginationBase, + public CloudFrontKeyValueStoreWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontClient.h b/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontClient.h index 81cd007529e..72c39a2195e 100644 --- a/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontClient.h +++ b/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -25,7 +26,8 @@ namespace CloudFront { */ class AWS_CLOUDFRONT_API CloudFrontClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudFrontPaginationBase { + public CloudFrontPaginationBase, + public CloudFrontWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h b/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h new file mode 100644 index 00000000000..bc1472ee733 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h @@ -0,0 +1,102 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace CloudFront { + +template +class CloudFrontWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilDistributionDeployed( + const Model::GetDistribution2020_05_31Request& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Deployed"), + [](const Model::GetDistribution2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetDistribution().GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetDistribution2020_05_31Request& req) { + return static_cast(this)->GetDistribution2020_05_31(req); + }; + Aws::Utils::Waiter waiter( + 60, 35, acceptors, operation, "WaitUntilDistributionDeployed"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInvalidationCompleted( + const Model::GetInvalidation2020_05_31Request& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), + [](const Model::GetInvalidationForDistributionTenant2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetInvalidation().GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetInvalidation2020_05_31Request& req) { + return static_cast(this)->GetInvalidation2020_05_31(req); + }; + Aws::Utils::Waiter waiter( + 20, 30, acceptors, operation, "WaitUntilInvalidationCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome + WaitUntilInvalidationForDistributionTenantCompleted(const Model::GetInvalidationForDistributionTenant2020_05_31Request& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), + [](const Model::GetInvalidationForDistributionTenant2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetInvalidation().GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetInvalidationForDistributionTenant2020_05_31Request& req) { + return static_cast(this)->GetInvalidationForDistributionTenant2020_05_31(req); + }; + Aws::Utils::Waiter + waiter(20, 30, acceptors, operation, "WaitUntilInvalidationForDistributionTenantCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStreamingDistributionDeployed( + const Model::GetStreamingDistribution2020_05_31Request& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Deployed"), + [](const Model::GetStreamingDistribution2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStreamingDistribution().GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetStreamingDistribution2020_05_31Request& req) { + return static_cast(this)->GetStreamingDistribution2020_05_31(req); + }; + Aws::Utils::Waiter waiter( + 60, 25, acceptors, operation, "WaitUntilStreamingDistributionDeployed"); + return waiter.Wait(request); + } +}; +} // namespace CloudFront +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cloudhsm/include/aws/cloudhsm/CloudHSMClient.h b/generated/src/aws-cpp-sdk-cloudhsm/include/aws/cloudhsm/CloudHSMClient.h index cc25bce0fb9..d18021441e5 100644 --- a/generated/src/aws-cpp-sdk-cloudhsm/include/aws/cloudhsm/CloudHSMClient.h +++ b/generated/src/aws-cpp-sdk-cloudhsm/include/aws/cloudhsm/CloudHSMClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -32,7 +33,8 @@ namespace CloudHSM { */ class AWS_CLOUDHSM_API CloudHSMClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudHSMPaginationBase { + public CloudHSMPaginationBase, + public CloudHSMWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloudhsmv2/include/aws/cloudhsmv2/CloudHSMV2Client.h b/generated/src/aws-cpp-sdk-cloudhsmv2/include/aws/cloudhsmv2/CloudHSMV2Client.h index c7175ac03c4..7ef3165c195 100644 --- a/generated/src/aws-cpp-sdk-cloudhsmv2/include/aws/cloudhsmv2/CloudHSMV2Client.h +++ b/generated/src/aws-cpp-sdk-cloudhsmv2/include/aws/cloudhsmv2/CloudHSMV2Client.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -22,7 +23,8 @@ namespace CloudHSMV2 { */ class AWS_CLOUDHSMV2_API CloudHSMV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudHSMV2PaginationBase { + public CloudHSMV2PaginationBase, + public CloudHSMV2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloudsearch/include/aws/cloudsearch/CloudSearchClient.h b/generated/src/aws-cpp-sdk-cloudsearch/include/aws/cloudsearch/CloudSearchClient.h index a036385996f..4931bf3ee21 100644 --- a/generated/src/aws-cpp-sdk-cloudsearch/include/aws/cloudsearch/CloudSearchClient.h +++ b/generated/src/aws-cpp-sdk-cloudsearch/include/aws/cloudsearch/CloudSearchClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -30,7 +31,8 @@ namespace CloudSearch { */ class AWS_CLOUDSEARCH_API CloudSearchClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudSearchPaginationBase { + public CloudSearchPaginationBase, + public CloudSearchWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloudsearchdomain/include/aws/cloudsearchdomain/CloudSearchDomainClient.h b/generated/src/aws-cpp-sdk-cloudsearchdomain/include/aws/cloudsearchdomain/CloudSearchDomainClient.h index 99d6a8b8437..d7237280854 100644 --- a/generated/src/aws-cpp-sdk-cloudsearchdomain/include/aws/cloudsearchdomain/CloudSearchDomainClient.h +++ b/generated/src/aws-cpp-sdk-cloudsearchdomain/include/aws/cloudsearchdomain/CloudSearchDomainClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -28,7 +29,8 @@ namespace CloudSearchDomain { */ class AWS_CLOUDSEARCHDOMAIN_API CloudSearchDomainClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudSearchDomainPaginationBase { + public CloudSearchDomainPaginationBase, + public CloudSearchDomainWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloudtrail-data/include/aws/cloudtrail-data/CloudTrailDataClient.h b/generated/src/aws-cpp-sdk-cloudtrail-data/include/aws/cloudtrail-data/CloudTrailDataClient.h index 2f3ae607172..2817c152af1 100644 --- a/generated/src/aws-cpp-sdk-cloudtrail-data/include/aws/cloudtrail-data/CloudTrailDataClient.h +++ b/generated/src/aws-cpp-sdk-cloudtrail-data/include/aws/cloudtrail-data/CloudTrailDataClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -26,7 +27,8 @@ namespace CloudTrailData { */ class AWS_CLOUDTRAILDATA_API CloudTrailDataClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudTrailDataPaginationBase { + public CloudTrailDataPaginationBase, + public CloudTrailDataWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cloudtrail/include/aws/cloudtrail/CloudTrailClient.h b/generated/src/aws-cpp-sdk-cloudtrail/include/aws/cloudtrail/CloudTrailClient.h index 2ad42b5c20b..f0d9ef7e4ee 100644 --- a/generated/src/aws-cpp-sdk-cloudtrail/include/aws/cloudtrail/CloudTrailClient.h +++ b/generated/src/aws-cpp-sdk-cloudtrail/include/aws/cloudtrail/CloudTrailClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -37,7 +38,8 @@ namespace CloudTrail { */ class AWS_CLOUDTRAIL_API CloudTrailClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudTrailPaginationBase { + public CloudTrailPaginationBase, + public CloudTrailWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codeartifact/include/aws/codeartifact/CodeArtifactClient.h b/generated/src/aws-cpp-sdk-codeartifact/include/aws/codeartifact/CodeArtifactClient.h index e8b07adf61c..d75929055e4 100644 --- a/generated/src/aws-cpp-sdk-codeartifact/include/aws/codeartifact/CodeArtifactClient.h +++ b/generated/src/aws-cpp-sdk-codeartifact/include/aws/codeartifact/CodeArtifactClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -173,7 +174,8 @@ namespace CodeArtifact { */ class AWS_CODEARTIFACT_API CodeArtifactClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodeArtifactPaginationBase { + public CodeArtifactPaginationBase, + public CodeArtifactWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/CodeBuildClient.h b/generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/CodeBuildClient.h index 8a27b2d81f4..a3c8b9bcea1 100644 --- a/generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/CodeBuildClient.h +++ b/generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/CodeBuildClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -29,7 +30,8 @@ namespace CodeBuild { */ class AWS_CODEBUILD_API CodeBuildClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodeBuildPaginationBase { + public CodeBuildPaginationBase, + public CodeBuildWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codecatalyst/include/aws/codecatalyst/CodeCatalystClient.h b/generated/src/aws-cpp-sdk-codecatalyst/include/aws/codecatalyst/CodeCatalystClient.h index a580b53058b..2f53b47c0a0 100644 --- a/generated/src/aws-cpp-sdk-codecatalyst/include/aws/codecatalyst/CodeCatalystClient.h +++ b/generated/src/aws-cpp-sdk-codecatalyst/include/aws/codecatalyst/CodeCatalystClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -85,7 +86,8 @@ namespace CodeCatalyst { */ class AWS_CODECATALYST_API CodeCatalystClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodeCatalystPaginationBase { + public CodeCatalystPaginationBase, + public CodeCatalystWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codecommit/include/aws/codecommit/CodeCommitClient.h b/generated/src/aws-cpp-sdk-codecommit/include/aws/codecommit/CodeCommitClient.h index ff8004af2c3..dbc4bb2aa0e 100644 --- a/generated/src/aws-cpp-sdk-codecommit/include/aws/codecommit/CodeCommitClient.h +++ b/generated/src/aws-cpp-sdk-codecommit/include/aws/codecommit/CodeCommitClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -180,7 +181,8 @@ namespace CodeCommit { */ class AWS_CODECOMMIT_API CodeCommitClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodeCommitPaginationBase { + public CodeCommitPaginationBase, + public CodeCommitWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codeconnections/include/aws/codeconnections/CodeConnectionsClient.h b/generated/src/aws-cpp-sdk-codeconnections/include/aws/codeconnections/CodeConnectionsClient.h index 155e3acf8f4..a21c6eca321 100644 --- a/generated/src/aws-cpp-sdk-codeconnections/include/aws/codeconnections/CodeConnectionsClient.h +++ b/generated/src/aws-cpp-sdk-codeconnections/include/aws/codeconnections/CodeConnectionsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -58,7 +59,8 @@ namespace CodeConnections { */ class AWS_CODECONNECTIONS_API CodeConnectionsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodeConnectionsPaginationBase { + public CodeConnectionsPaginationBase, + public CodeConnectionsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployClient.h b/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployClient.h index 2207e9b4889..0056d6a9637 100644 --- a/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployClient.h +++ b/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -73,7 +74,8 @@ namespace CodeDeploy { */ class AWS_CODEDEPLOY_API CodeDeployClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodeDeployPaginationBase { + public CodeDeployPaginationBase, + public CodeDeployWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h b/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h new file mode 100644 index 00000000000..f5058c67956 --- /dev/null +++ b/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h @@ -0,0 +1,52 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace CodeDeploy { + +template +class CodeDeployWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilDeploymentSuccessful(const Model::GetDeploymentRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Succeeded"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetDeploymentInfo().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetDeploymentInfo().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Stopped"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetDeploymentInfo().GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetDeploymentRequest& req) { return static_cast(this)->GetDeployment(req); }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilDeploymentSuccessful"); + return waiter.Wait(request); + } +}; +} // namespace CodeDeploy +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerClient.h b/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerClient.h index 96c06377924..50ad67da108 100644 --- a/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerClient.h +++ b/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -34,7 +35,8 @@ namespace CodeGuruReviewer { */ class AWS_CODEGURUREVIEWER_API CodeGuruReviewerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodeGuruReviewerPaginationBase { + public CodeGuruReviewerPaginationBase, + public CodeGuruReviewerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h b/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h new file mode 100644 index 00000000000..694f5f5118e --- /dev/null +++ b/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h @@ -0,0 +1,91 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace CodeGuruReviewer { + +template +class CodeGuruReviewerWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilCodeReviewCompleted( + const Model::DescribeCodeReviewRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), + [](const Model::DescribeCodeReviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStateMapper::GetNameForJobState(result.GetCodeReview().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeCodeReviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStateMapper::GetNameForJobState(result.GetCodeReview().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Pending"), + [](const Model::DescribeCodeReviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStateMapper::GetNameForJobState(result.GetCodeReview().GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeCodeReviewRequest& req) { + return static_cast(this)->DescribeCodeReview(req); + }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilCodeReviewCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilRepositoryAssociationSucceeded( + const Model::DescribeRepositoryAssociationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Associated"), + [](const Model::DescribeRepositoryAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RepositoryAssociationStateMapper::GetNameForRepositoryAssociationState( + result.GetRepositoryAssociation().GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeRepositoryAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RepositoryAssociationStateMapper::GetNameForRepositoryAssociationState( + result.GetRepositoryAssociation().GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Associating"), + [](const Model::DescribeRepositoryAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RepositoryAssociationStateMapper::GetNameForRepositoryAssociationState( + result.GetRepositoryAssociation().GetState()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeRepositoryAssociationRequest& req) { + return static_cast(this)->DescribeRepositoryAssociation(req); + }; + Aws::Utils::Waiter waiter( + 10, 12, acceptors, operation, "WaitUntilRepositoryAssociationSucceeded"); + return waiter.Wait(request); + } +}; +} // namespace CodeGuruReviewer +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codeguru-security/include/aws/codeguru-security/CodeGuruSecurityClient.h b/generated/src/aws-cpp-sdk-codeguru-security/include/aws/codeguru-security/CodeGuruSecurityClient.h index 6edf4276880..f3b6644a37b 100644 --- a/generated/src/aws-cpp-sdk-codeguru-security/include/aws/codeguru-security/CodeGuruSecurityClient.h +++ b/generated/src/aws-cpp-sdk-codeguru-security/include/aws/codeguru-security/CodeGuruSecurityClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -32,7 +33,8 @@ namespace CodeGuruSecurity { */ class AWS_CODEGURUSECURITY_API CodeGuruSecurityClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodeGuruSecurityPaginationBase { + public CodeGuruSecurityPaginationBase, + public CodeGuruSecurityWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codeguruprofiler/include/aws/codeguruprofiler/CodeGuruProfilerClient.h b/generated/src/aws-cpp-sdk-codeguruprofiler/include/aws/codeguruprofiler/CodeGuruProfilerClient.h index 23494211f4d..b53694bcc8e 100644 --- a/generated/src/aws-cpp-sdk-codeguruprofiler/include/aws/codeguruprofiler/CodeGuruProfilerClient.h +++ b/generated/src/aws-cpp-sdk-codeguruprofiler/include/aws/codeguruprofiler/CodeGuruProfilerClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -35,7 +36,8 @@ namespace CodeGuruProfiler { */ class AWS_CODEGURUPROFILER_API CodeGuruProfilerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodeGuruProfilerPaginationBase { + public CodeGuruProfilerPaginationBase, + public CodeGuruProfilerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codepipeline/include/aws/codepipeline/CodePipelineClient.h b/generated/src/aws-cpp-sdk-codepipeline/include/aws/codepipeline/CodePipelineClient.h index e35aa144dc3..b8b8d4a2ce1 100644 --- a/generated/src/aws-cpp-sdk-codepipeline/include/aws/codepipeline/CodePipelineClient.h +++ b/generated/src/aws-cpp-sdk-codepipeline/include/aws/codepipeline/CodePipelineClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -97,7 +98,8 @@ namespace CodePipeline { */ class AWS_CODEPIPELINE_API CodePipelineClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodePipelinePaginationBase { + public CodePipelinePaginationBase, + public CodePipelineWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codestar-connections/include/aws/codestar-connections/CodeStarconnectionsClient.h b/generated/src/aws-cpp-sdk-codestar-connections/include/aws/codestar-connections/CodeStarconnectionsClient.h index 9c968dd9df0..e68b9b4d6b8 100644 --- a/generated/src/aws-cpp-sdk-codestar-connections/include/aws/codestar-connections/CodeStarconnectionsClient.h +++ b/generated/src/aws-cpp-sdk-codestar-connections/include/aws/codestar-connections/CodeStarconnectionsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -59,7 +60,8 @@ namespace CodeStarconnections { */ class AWS_CODESTARCONNECTIONS_API CodeStarconnectionsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodeStarconnectionsPaginationBase { + public CodeStarconnectionsPaginationBase, + public CodeStarconnectionsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsClient.h b/generated/src/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsClient.h index ac05fb15ec6..c8ff3403ad1 100644 --- a/generated/src/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsClient.h +++ b/generated/src/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -47,7 +48,8 @@ namespace CodeStarNotifications { class AWS_CODESTARNOTIFICATIONS_API CodeStarNotificationsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CodeStarNotificationsPaginationBase { + public CodeStarNotificationsPaginationBase, + public CodeStarNotificationsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cognito-identity/include/aws/cognito-identity/CognitoIdentityClient.h b/generated/src/aws-cpp-sdk-cognito-identity/include/aws/cognito-identity/CognitoIdentityClient.h index 02e9be09e48..3b3a9616ff8 100644 --- a/generated/src/aws-cpp-sdk-cognito-identity/include/aws/cognito-identity/CognitoIdentityClient.h +++ b/generated/src/aws-cpp-sdk-cognito-identity/include/aws/cognito-identity/CognitoIdentityClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -34,7 +35,8 @@ namespace CognitoIdentity { */ class AWS_COGNITOIDENTITY_API CognitoIdentityClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CognitoIdentityPaginationBase { + public CognitoIdentityPaginationBase, + public CognitoIdentityWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cognito-idp/include/aws/cognito-idp/CognitoIdentityProviderClient.h b/generated/src/aws-cpp-sdk-cognito-idp/include/aws/cognito-idp/CognitoIdentityProviderClient.h index 09d3afb209f..bfdfdd51032 100644 --- a/generated/src/aws-cpp-sdk-cognito-idp/include/aws/cognito-idp/CognitoIdentityProviderClient.h +++ b/generated/src/aws-cpp-sdk-cognito-idp/include/aws/cognito-idp/CognitoIdentityProviderClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -55,7 +56,8 @@ namespace CognitoIdentityProvider { class AWS_COGNITOIDENTITYPROVIDER_API CognitoIdentityProviderClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CognitoIdentityProviderPaginationBase { + public CognitoIdentityProviderPaginationBase, + public CognitoIdentityProviderWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cognito-sync/include/aws/cognito-sync/CognitoSyncClient.h b/generated/src/aws-cpp-sdk-cognito-sync/include/aws/cognito-sync/CognitoSyncClient.h index c99f1a2b37a..df4ea6100dc 100644 --- a/generated/src/aws-cpp-sdk-cognito-sync/include/aws/cognito-sync/CognitoSyncClient.h +++ b/generated/src/aws-cpp-sdk-cognito-sync/include/aws/cognito-sync/CognitoSyncClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -38,7 +39,8 @@ namespace CognitoSync { */ class AWS_COGNITOSYNC_API CognitoSyncClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CognitoSyncPaginationBase { + public CognitoSyncPaginationBase, + public CognitoSyncWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-comprehend/include/aws/comprehend/ComprehendClient.h b/generated/src/aws-cpp-sdk-comprehend/include/aws/comprehend/ComprehendClient.h index 8651142c370..20637415cd6 100644 --- a/generated/src/aws-cpp-sdk-comprehend/include/aws/comprehend/ComprehendClient.h +++ b/generated/src/aws-cpp-sdk-comprehend/include/aws/comprehend/ComprehendClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -22,7 +23,8 @@ namespace Comprehend { */ class AWS_COMPREHEND_API ComprehendClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ComprehendPaginationBase { + public ComprehendPaginationBase, + public ComprehendWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-comprehendmedical/include/aws/comprehendmedical/ComprehendMedicalClient.h b/generated/src/aws-cpp-sdk-comprehendmedical/include/aws/comprehendmedical/ComprehendMedicalClient.h index f4c22ad03df..f43dd37d395 100644 --- a/generated/src/aws-cpp-sdk-comprehendmedical/include/aws/comprehendmedical/ComprehendMedicalClient.h +++ b/generated/src/aws-cpp-sdk-comprehendmedical/include/aws/comprehendmedical/ComprehendMedicalClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -25,7 +26,8 @@ namespace ComprehendMedical { */ class AWS_COMPREHENDMEDICAL_API ComprehendMedicalClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ComprehendMedicalPaginationBase { + public ComprehendMedicalPaginationBase, + public ComprehendMedicalWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-compute-optimizer-automation/include/aws/compute-optimizer-automation/ComputeOptimizerAutomationClient.h b/generated/src/aws-cpp-sdk-compute-optimizer-automation/include/aws/compute-optimizer-automation/ComputeOptimizerAutomationClient.h index 3fe4aa0438b..5261e22c13a 100644 --- a/generated/src/aws-cpp-sdk-compute-optimizer-automation/include/aws/compute-optimizer-automation/ComputeOptimizerAutomationClient.h +++ b/generated/src/aws-cpp-sdk-compute-optimizer-automation/include/aws/compute-optimizer-automation/ComputeOptimizerAutomationClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -30,7 +31,8 @@ namespace ComputeOptimizerAutomation { class AWS_COMPUTEOPTIMIZERAUTOMATION_API ComputeOptimizerAutomationClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ComputeOptimizerAutomationPaginationBase { + public ComputeOptimizerAutomationPaginationBase, + public ComputeOptimizerAutomationWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-compute-optimizer/include/aws/compute-optimizer/ComputeOptimizerClient.h b/generated/src/aws-cpp-sdk-compute-optimizer/include/aws/compute-optimizer/ComputeOptimizerClient.h index 5b635b4cc44..74fac1e3a87 100644 --- a/generated/src/aws-cpp-sdk-compute-optimizer/include/aws/compute-optimizer/ComputeOptimizerClient.h +++ b/generated/src/aws-cpp-sdk-compute-optimizer/include/aws/compute-optimizer/ComputeOptimizerClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -33,7 +34,8 @@ namespace ComputeOptimizer { */ class AWS_COMPUTEOPTIMIZER_API ComputeOptimizerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ComputeOptimizerPaginationBase { + public ComputeOptimizerPaginationBase, + public ComputeOptimizerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-config/include/aws/config/ConfigServiceClient.h b/generated/src/aws-cpp-sdk-config/include/aws/config/ConfigServiceClient.h index d71b5b2a290..8aa6cb0d3e0 100644 --- a/generated/src/aws-cpp-sdk-config/include/aws/config/ConfigServiceClient.h +++ b/generated/src/aws-cpp-sdk-config/include/aws/config/ConfigServiceClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -41,7 +42,8 @@ namespace ConfigService { */ class AWS_CONFIGSERVICE_API ConfigServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ConfigServicePaginationBase { + public ConfigServicePaginationBase, + public ConfigServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-connect-contact-lens/include/aws/connect-contact-lens/ConnectContactLensClient.h b/generated/src/aws-cpp-sdk-connect-contact-lens/include/aws/connect-contact-lens/ConnectContactLensClient.h index 5b5f53ac699..9acdeda92c4 100644 --- a/generated/src/aws-cpp-sdk-connect-contact-lens/include/aws/connect-contact-lens/ConnectContactLensClient.h +++ b/generated/src/aws-cpp-sdk-connect-contact-lens/include/aws/connect-contact-lens/ConnectContactLensClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -32,7 +33,8 @@ namespace ConnectContactLens { */ class AWS_CONNECTCONTACTLENS_API ConnectContactLensClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ConnectContactLensPaginationBase { + public ConnectContactLensPaginationBase, + public ConnectContactLensWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-connect/include/aws/connect/ConnectClient.h b/generated/src/aws-cpp-sdk-connect/include/aws/connect/ConnectClient.h index 073fb8b5e0e..47001f01072 100644 --- a/generated/src/aws-cpp-sdk-connect/include/aws/connect/ConnectClient.h +++ b/generated/src/aws-cpp-sdk-connect/include/aws/connect/ConnectClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -37,7 +38,8 @@ namespace Connect { */ class AWS_CONNECT_API ConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ConnectPaginationBase { + public ConnectPaginationBase, + public ConnectWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-connectcampaigns/include/aws/connectcampaigns/ConnectCampaignsClient.h b/generated/src/aws-cpp-sdk-connectcampaigns/include/aws/connectcampaigns/ConnectCampaignsClient.h index 16ffc4f7517..07564319dad 100644 --- a/generated/src/aws-cpp-sdk-connectcampaigns/include/aws/connectcampaigns/ConnectCampaignsClient.h +++ b/generated/src/aws-cpp-sdk-connectcampaigns/include/aws/connectcampaigns/ConnectCampaignsClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -19,7 +20,8 @@ namespace ConnectCampaigns { */ class AWS_CONNECTCAMPAIGNS_API ConnectCampaignsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ConnectCampaignsPaginationBase { + public ConnectCampaignsPaginationBase, + public ConnectCampaignsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-connectcampaignsv2/include/aws/connectcampaignsv2/ConnectCampaignsV2Client.h b/generated/src/aws-cpp-sdk-connectcampaignsv2/include/aws/connectcampaignsv2/ConnectCampaignsV2Client.h index 977113df8fd..ac746beca87 100644 --- a/generated/src/aws-cpp-sdk-connectcampaignsv2/include/aws/connectcampaignsv2/ConnectCampaignsV2Client.h +++ b/generated/src/aws-cpp-sdk-connectcampaignsv2/include/aws/connectcampaignsv2/ConnectCampaignsV2Client.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -19,7 +20,8 @@ namespace ConnectCampaignsV2 { */ class AWS_CONNECTCAMPAIGNSV2_API ConnectCampaignsV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ConnectCampaignsV2PaginationBase { + public ConnectCampaignsV2PaginationBase, + public ConnectCampaignsV2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-connectcases/include/aws/connectcases/ConnectCasesClient.h b/generated/src/aws-cpp-sdk-connectcases/include/aws/connectcases/ConnectCasesClient.h index 0e6cb48f719..dcb10862f6c 100644 --- a/generated/src/aws-cpp-sdk-connectcases/include/aws/connectcases/ConnectCasesClient.h +++ b/generated/src/aws-cpp-sdk-connectcases/include/aws/connectcases/ConnectCasesClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -29,7 +30,8 @@ namespace ConnectCases { */ class AWS_CONNECTCASES_API ConnectCasesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ConnectCasesPaginationBase { + public ConnectCasesPaginationBase, + public ConnectCasesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-connecthealth/include/aws/connecthealth/ConnectHealthClient.h b/generated/src/aws-cpp-sdk-connecthealth/include/aws/connecthealth/ConnectHealthClient.h index c8dbbee9832..3099a1dffa0 100644 --- a/generated/src/aws-cpp-sdk-connecthealth/include/aws/connecthealth/ConnectHealthClient.h +++ b/generated/src/aws-cpp-sdk-connecthealth/include/aws/connecthealth/ConnectHealthClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -19,7 +20,8 @@ namespace ConnectHealth { */ class AWS_CONNECTHEALTH_API ConnectHealthClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ConnectHealthPaginationBase { + public ConnectHealthPaginationBase, + public ConnectHealthWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantClient.h b/generated/src/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantClient.h index f4c70602b88..8ec38f36472 100644 --- a/generated/src/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantClient.h +++ b/generated/src/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -32,7 +33,8 @@ namespace ConnectParticipant { */ class AWS_CONNECTPARTICIPANT_API ConnectParticipantClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ConnectParticipantPaginationBase { + public ConnectParticipantPaginationBase, + public ConnectParticipantWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-controlcatalog/include/aws/controlcatalog/ControlCatalogClient.h b/generated/src/aws-cpp-sdk-controlcatalog/include/aws/controlcatalog/ControlCatalogClient.h index fe25086b2fd..b35f18ce2bd 100644 --- a/generated/src/aws-cpp-sdk-controlcatalog/include/aws/controlcatalog/ControlCatalogClient.h +++ b/generated/src/aws-cpp-sdk-controlcatalog/include/aws/controlcatalog/ControlCatalogClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -36,7 +37,8 @@ namespace ControlCatalog { */ class AWS_CONTROLCATALOG_API ControlCatalogClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ControlCatalogPaginationBase { + public ControlCatalogPaginationBase, + public ControlCatalogWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-controltower/include/aws/controltower/ControlTowerClient.h b/generated/src/aws-cpp-sdk-controltower/include/aws/controltower/ControlTowerClient.h index 930ae1b64e8..a2259ca3255 100644 --- a/generated/src/aws-cpp-sdk-controltower/include/aws/controltower/ControlTowerClient.h +++ b/generated/src/aws-cpp-sdk-controltower/include/aws/controltower/ControlTowerClient.h @@ -6,6 +6,7 @@ #pragma once #include #include +#include #include #include #include @@ -213,7 +214,8 @@ namespace ControlTower { */ class AWS_CONTROLTOWER_API ControlTowerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ControlTowerPaginationBase { + public ControlTowerPaginationBase, + public ControlTowerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cost-optimization-hub/include/aws/cost-optimization-hub/CostOptimizationHubClient.h b/generated/src/aws-cpp-sdk-cost-optimization-hub/include/aws/cost-optimization-hub/CostOptimizationHubClient.h index 2ee0a25a2e2..90b163f6825 100644 --- a/generated/src/aws-cpp-sdk-cost-optimization-hub/include/aws/cost-optimization-hub/CostOptimizationHubClient.h +++ b/generated/src/aws-cpp-sdk-cost-optimization-hub/include/aws/cost-optimization-hub/CostOptimizationHubClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace CostOptimizationHub { */ class AWS_COSTOPTIMIZATIONHUB_API CostOptimizationHubClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CostOptimizationHubPaginationBase { + public CostOptimizationHubPaginationBase, + public CostOptimizationHubWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-cur/include/aws/cur/CostandUsageReportServiceClient.h b/generated/src/aws-cpp-sdk-cur/include/aws/cur/CostandUsageReportServiceClient.h index 2c976e2028f..4394cd81d46 100644 --- a/generated/src/aws-cpp-sdk-cur/include/aws/cur/CostandUsageReportServiceClient.h +++ b/generated/src/aws-cpp-sdk-cur/include/aws/cur/CostandUsageReportServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace CostandUsageReportService { class AWS_COSTANDUSAGEREPORTSERVICE_API CostandUsageReportServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CostandUsageReportServicePaginationBase { + public CostandUsageReportServicePaginationBase, + public CostandUsageReportServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-customer-profiles/include/aws/customer-profiles/CustomerProfilesClient.h b/generated/src/aws-cpp-sdk-customer-profiles/include/aws/customer-profiles/CustomerProfilesClient.h index 42da81e73f6..98c3dfb2463 100644 --- a/generated/src/aws-cpp-sdk-customer-profiles/include/aws/customer-profiles/CustomerProfilesClient.h +++ b/generated/src/aws-cpp-sdk-customer-profiles/include/aws/customer-profiles/CustomerProfilesClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -31,7 +32,8 @@ namespace CustomerProfiles { */ class AWS_CUSTOMERPROFILES_API CustomerProfilesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CustomerProfilesPaginationBase { + public CustomerProfilesPaginationBase, + public CustomerProfilesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-databrew/include/aws/databrew/GlueDataBrewClient.h b/generated/src/aws-cpp-sdk-databrew/include/aws/databrew/GlueDataBrewClient.h index ce8fa3a5401..9d57bd9f479 100644 --- a/generated/src/aws-cpp-sdk-databrew/include/aws/databrew/GlueDataBrewClient.h +++ b/generated/src/aws-cpp-sdk-databrew/include/aws/databrew/GlueDataBrewClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace GlueDataBrew { */ class AWS_GLUEDATABREW_API GlueDataBrewClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GlueDataBrewPaginationBase { + public GlueDataBrewPaginationBase, + public GlueDataBrewWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-dataexchange/include/aws/dataexchange/DataExchangeClient.h b/generated/src/aws-cpp-sdk-dataexchange/include/aws/dataexchange/DataExchangeClient.h index e306df211b9..4f90b632fc1 100644 --- a/generated/src/aws-cpp-sdk-dataexchange/include/aws/dataexchange/DataExchangeClient.h +++ b/generated/src/aws-cpp-sdk-dataexchange/include/aws/dataexchange/DataExchangeClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -36,7 +37,8 @@ namespace DataExchange { */ class AWS_DATAEXCHANGE_API DataExchangeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DataExchangePaginationBase { + public DataExchangePaginationBase, + public DataExchangeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-datapipeline/include/aws/datapipeline/DataPipelineClient.h b/generated/src/aws-cpp-sdk-datapipeline/include/aws/datapipeline/DataPipelineClient.h index 46f432c1648..5067812b859 100644 --- a/generated/src/aws-cpp-sdk-datapipeline/include/aws/datapipeline/DataPipelineClient.h +++ b/generated/src/aws-cpp-sdk-datapipeline/include/aws/datapipeline/DataPipelineClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -36,7 +37,8 @@ namespace DataPipeline { */ class AWS_DATAPIPELINE_API DataPipelineClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DataPipelinePaginationBase { + public DataPipelinePaginationBase, + public DataPipelineWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-datasync/include/aws/datasync/DataSyncClient.h b/generated/src/aws-cpp-sdk-datasync/include/aws/datasync/DataSyncClient.h index acafebd2f86..cf980506808 100644 --- a/generated/src/aws-cpp-sdk-datasync/include/aws/datasync/DataSyncClient.h +++ b/generated/src/aws-cpp-sdk-datasync/include/aws/datasync/DataSyncClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace DataSync { */ class AWS_DATASYNC_API DataSyncClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DataSyncPaginationBase { + public DataSyncPaginationBase, + public DataSyncWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-datazone/include/aws/datazone/DataZoneClient.h b/generated/src/aws-cpp-sdk-datazone/include/aws/datazone/DataZoneClient.h index a963e325182..29031b9b27d 100644 --- a/generated/src/aws-cpp-sdk-datazone/include/aws/datazone/DataZoneClient.h +++ b/generated/src/aws-cpp-sdk-datazone/include/aws/datazone/DataZoneClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace DataZone { */ class AWS_DATAZONE_API DataZoneClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DataZonePaginationBase { + public DataZonePaginationBase, + public DataZoneWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-dax/include/aws/dax/DAXClient.h b/generated/src/aws-cpp-sdk-dax/include/aws/dax/DAXClient.h index c5d1c607ddc..4805b102cb4 100644 --- a/generated/src/aws-cpp-sdk-dax/include/aws/dax/DAXClient.h +++ b/generated/src/aws-cpp-sdk-dax/include/aws/dax/DAXClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace DAX { */ class AWS_DAX_API DAXClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DAXPaginationBase { + public DAXPaginationBase, + public DAXWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineClient.h b/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineClient.h index 729dfebed28..42e3bfa2ef5 100644 --- a/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineClient.h +++ b/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace deadline { */ class AWS_DEADLINE_API DeadlineClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DeadlinePaginationBase { + public DeadlinePaginationBase, + public DeadlineWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h b/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h new file mode 100644 index 00000000000..e9e2fca5432 --- /dev/null +++ b/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h @@ -0,0 +1,327 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace deadline { + +template +class DeadlineWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilFleetActive(const Model::GetFleetRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), + [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetFleetRequest& req) { return static_cast(this)->GetFleet(req); }; + Aws::Utils::Waiter waiter(5, 180, acceptors, operation, "WaitUntilFleetActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilJobCreateComplete(const Model::GetJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_IN_PROGRESS"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_SUCCEEDED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPLOAD_FAILED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetJobRequest& req) { return static_cast(this)->GetJob(req); }; + Aws::Utils::Waiter waiter(1, 120, acceptors, operation, "WaitUntilJobCreateComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilJobComplete(const Model::GetJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUSPENDED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("NOT_COMPATIBLE"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ARCHIVED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetJobRequest& req) { return static_cast(this)->GetJob(req); }; + Aws::Utils::Waiter waiter(15, 240, acceptors, operation, "WaitUntilJobComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilJobSucceeded(const Model::GetJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("SUSPENDED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("NOT_COMPATIBLE"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ARCHIVED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetJobRequest& req) { return static_cast(this)->GetJob(req); }; + Aws::Utils::Waiter waiter(15, 240, acceptors, operation, "WaitUntilJobSucceeded"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilLicenseEndpointValid( + const Model::GetLicenseEndpointRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("READY"), + [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("NOT_READY"), + [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetLicenseEndpointRequest& req) { + return static_cast(this)->GetLicenseEndpoint(req); + }; + Aws::Utils::Waiter waiter(10, 114, acceptors, operation, + "WaitUntilLicenseEndpointValid"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilLicenseEndpointDeleted( + const Model::GetLicenseEndpointRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("NOT_READY"), + [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetLicenseEndpointRequest& req) { + return static_cast(this)->GetLicenseEndpoint(req); + }; + Aws::Utils::Waiter waiter(10, 234, acceptors, operation, + "WaitUntilLicenseEndpointDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilQueueSchedulingBlocked(const Model::GetQueueRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SCHEDULING_BLOCKED"), + [](const Model::GetQueueOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::QueueStatusMapper::GetNameForQueueStatus(result.GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetQueueRequest& req) { return static_cast(this)->GetQueue(req); }; + Aws::Utils::Waiter waiter(10, 30, acceptors, operation, + "WaitUntilQueueSchedulingBlocked"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilQueueScheduling(const Model::GetQueueRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SCHEDULING"), + [](const Model::GetQueueOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::QueueStatusMapper::GetNameForQueueStatus(result.GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetQueueRequest& req) { return static_cast(this)->GetQueue(req); }; + Aws::Utils::Waiter waiter(10, 70, acceptors, operation, "WaitUntilQueueScheduling"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilQueueFleetAssociationStopped( + const Model::GetQueueFleetAssociationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), + [](const Model::GetQueueLimitAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::QueueLimitAssociationStatusMapper::GetNameForQueueLimitAssociationStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetQueueFleetAssociationRequest& req) { + return static_cast(this)->GetQueueFleetAssociation(req); + }; + Aws::Utils::Waiter waiter( + 10, 60, acceptors, operation, "WaitUntilQueueFleetAssociationStopped"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilQueueLimitAssociationStopped( + const Model::GetQueueLimitAssociationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), + [](const Model::GetQueueLimitAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::QueueLimitAssociationStatusMapper::GetNameForQueueLimitAssociationStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetQueueLimitAssociationRequest& req) { + return static_cast(this)->GetQueueLimitAssociation(req); + }; + Aws::Utils::Waiter waiter( + 10, 60, acceptors, operation, "WaitUntilQueueLimitAssociationStopped"); + return waiter.Wait(request); + } +}; +} // namespace deadline +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-detective/include/aws/detective/DetectiveClient.h b/generated/src/aws-cpp-sdk-detective/include/aws/detective/DetectiveClient.h index db4ebe9b4be..4de611d70f5 100644 --- a/generated/src/aws-cpp-sdk-detective/include/aws/detective/DetectiveClient.h +++ b/generated/src/aws-cpp-sdk-detective/include/aws/detective/DetectiveClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -63,7 +64,8 @@ namespace Detective { */ class AWS_DETECTIVE_API DetectiveClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DetectivePaginationBase { + public DetectivePaginationBase, + public DetectiveWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-devicefarm/include/aws/devicefarm/DeviceFarmClient.h b/generated/src/aws-cpp-sdk-devicefarm/include/aws/devicefarm/DeviceFarmClient.h index 14d5bcb8cdc..3e2112fe440 100644 --- a/generated/src/aws-cpp-sdk-devicefarm/include/aws/devicefarm/DeviceFarmClient.h +++ b/generated/src/aws-cpp-sdk-devicefarm/include/aws/devicefarm/DeviceFarmClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace DeviceFarm { */ class AWS_DEVICEFARM_API DeviceFarmClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DeviceFarmPaginationBase { + public DeviceFarmPaginationBase, + public DeviceFarmWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-devops-guru/include/aws/devops-guru/DevOpsGuruClient.h b/generated/src/aws-cpp-sdk-devops-guru/include/aws/devops-guru/DevOpsGuruClient.h index ba32b266783..8e240874f9f 100644 --- a/generated/src/aws-cpp-sdk-devops-guru/include/aws/devops-guru/DevOpsGuruClient.h +++ b/generated/src/aws-cpp-sdk-devops-guru/include/aws/devops-guru/DevOpsGuruClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -36,7 +37,8 @@ namespace DevOpsGuru { */ class AWS_DEVOPSGURU_API DevOpsGuruClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DevOpsGuruPaginationBase { + public DevOpsGuruPaginationBase, + public DevOpsGuruWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/DirectConnectClient.h b/generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/DirectConnectClient.h index f4330c6ae19..6cf56da72f2 100644 --- a/generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/DirectConnectClient.h +++ b/generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/DirectConnectClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -27,7 +28,8 @@ namespace DirectConnect { */ class AWS_DIRECTCONNECT_API DirectConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DirectConnectPaginationBase { + public DirectConnectPaginationBase, + public DirectConnectWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-directory-service-data/include/aws/directory-service-data/DirectoryServiceDataClient.h b/generated/src/aws-cpp-sdk-directory-service-data/include/aws/directory-service-data/DirectoryServiceDataClient.h index 3c6b1be0057..0ce90249f72 100644 --- a/generated/src/aws-cpp-sdk-directory-service-data/include/aws/directory-service-data/DirectoryServiceDataClient.h +++ b/generated/src/aws-cpp-sdk-directory-service-data/include/aws/directory-service-data/DirectoryServiceDataClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -68,7 +69,8 @@ namespace DirectoryServiceData { class AWS_DIRECTORYSERVICEDATA_API DirectoryServiceDataClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DirectoryServiceDataPaginationBase { + public DirectoryServiceDataPaginationBase, + public DirectoryServiceDataWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-discovery/include/aws/discovery/ApplicationDiscoveryServiceClient.h b/generated/src/aws-cpp-sdk-discovery/include/aws/discovery/ApplicationDiscoveryServiceClient.h index c88f80e33f0..b18af678f13 100644 --- a/generated/src/aws-cpp-sdk-discovery/include/aws/discovery/ApplicationDiscoveryServiceClient.h +++ b/generated/src/aws-cpp-sdk-discovery/include/aws/discovery/ApplicationDiscoveryServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -79,7 +80,8 @@ namespace ApplicationDiscoveryService { class AWS_APPLICATIONDISCOVERYSERVICE_API ApplicationDiscoveryServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ApplicationDiscoveryServicePaginationBase { + public ApplicationDiscoveryServicePaginationBase, + public ApplicationDiscoveryServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-dlm/include/aws/dlm/DLMClient.h b/generated/src/aws-cpp-sdk-dlm/include/aws/dlm/DLMClient.h index 8709688862c..4341170d816 100644 --- a/generated/src/aws-cpp-sdk-dlm/include/aws/dlm/DLMClient.h +++ b/generated/src/aws-cpp-sdk-dlm/include/aws/dlm/DLMClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace DLM { */ class AWS_DLM_API DLMClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DLMPaginationBase { + public DLMPaginationBase, + public DLMWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceClient.h b/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceClient.h index 58afb991299..4b4a12a8897 100644 --- a/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceClient.h +++ b/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace DatabaseMigrationService { class AWS_DATABASEMIGRATIONSERVICE_API DatabaseMigrationServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DatabaseMigrationServicePaginationBase { + public DatabaseMigrationServicePaginationBase, + public DatabaseMigrationServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h b/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h new file mode 100644 index 00000000000..51ee2c15659 --- /dev/null +++ b/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h @@ -0,0 +1,457 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace DatabaseMigrationService { + +template +class DatabaseMigrationServiceWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilTestConnectionSucceeds( + const Model::DescribeConnectionsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("successful"), + [](const Model::DescribeConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetConnections().begin(), result.GetConnections().end(), + [&](const Model::Connection& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetConnections().begin(), result.GetConnections().end(), + [&](const Model::Connection& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeConnectionsRequest& req) { + return static_cast(this)->DescribeConnections(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilTestConnectionSucceeds"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilEndpointDeleted(const Model::DescribeEndpointsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundFault")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("active"), + [](const Model::DescribeEndpointsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetEndpoints().begin(), result.GetEndpoints().end(), + [&](const Model::Endpoint& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeEndpointsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetEndpoints().begin(), result.GetEndpoints().end(), + [&](const Model::Endpoint& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeEndpointsRequest& req) { + return static_cast(this)->DescribeEndpoints(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilEndpointDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReplicationInstanceAvailable( + const Model::DescribeReplicationInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { + return item.GetReplicationInstanceStatus() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { + return item.GetReplicationInstanceStatus() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-credentials"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { + return item.GetReplicationInstanceStatus() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-network"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { + return item.GetReplicationInstanceStatus() == expected.get(); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("inaccessible-encryption-credentials"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeReplicationInstancesRequest& req) { + return static_cast(this)->DescribeReplicationInstances(req); + }; + Aws::Utils::Waiter waiter( + 60, 2, acceptors, operation, "WaitUntilReplicationInstanceAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReplicationInstanceDeleted( + const Model::DescribeReplicationInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { + return item.GetReplicationInstanceStatus() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundFault")}); + + auto operation = [this](const Model::DescribeReplicationInstancesRequest& req) { + return static_cast(this)->DescribeReplicationInstances(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilReplicationInstanceDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReplicationTaskDeleted( + const Model::DescribeReplicationTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ready"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopped"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("running"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundFault")}); + + auto operation = [this](const Model::DescribeReplicationTasksRequest& req) { + return static_cast(this)->DescribeReplicationTasks(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilReplicationTaskDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReplicationTaskReady( + const Model::DescribeReplicationTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ready"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("starting"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("running"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopping"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopped"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("testing"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeReplicationTasksRequest& req) { + return static_cast(this)->DescribeReplicationTasks(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilReplicationTaskReady"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReplicationTaskRunning( + const Model::DescribeReplicationTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("running"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ready"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopping"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopped"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("testing"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeReplicationTasksRequest& req) { + return static_cast(this)->DescribeReplicationTasks(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilReplicationTaskRunning"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReplicationTaskStopped( + const Model::DescribeReplicationTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("stopped"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ready"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("starting"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("testing"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeReplicationTasksRequest& req) { + return static_cast(this)->DescribeReplicationTasks(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilReplicationTaskStopped"); + return waiter.Wait(request); + } +}; +} // namespace DatabaseMigrationService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-docdb-elastic/include/aws/docdb-elastic/DocDBElasticClient.h b/generated/src/aws-cpp-sdk-docdb-elastic/include/aws/docdb-elastic/DocDBElasticClient.h index debcb3dce4a..4ca014490cc 100644 --- a/generated/src/aws-cpp-sdk-docdb-elastic/include/aws/docdb-elastic/DocDBElasticClient.h +++ b/generated/src/aws-cpp-sdk-docdb-elastic/include/aws/docdb-elastic/DocDBElasticClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace DocDBElastic { */ class AWS_DOCDBELASTIC_API DocDBElasticClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DocDBElasticPaginationBase { + public DocDBElasticPaginationBase, + public DocDBElasticWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBClient.h b/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBClient.h index 879885590ca..0e903cae5b0 100644 --- a/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBClient.h +++ b/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace DocDB { */ class AWS_DOCDB_API DocDBClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DocDBPaginationBase { + public DocDBPaginationBase, + public DocDBWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h b/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h new file mode 100644 index 00000000000..0dd5a1405e7 --- /dev/null +++ b/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h @@ -0,0 +1,134 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include + +#include + +namespace Aws { +namespace DocDB { + +template +class DocDBWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilDBInstanceAvailable( + const Model::DescribeDBInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBInstancesRequest& req) { + return static_cast(this)->DescribeDBInstances(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilDBInstanceAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilDBInstanceDeleted( + const Model::DescribeDBInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBInstanceNotFound")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBInstancesRequest& req) { + return static_cast(this)->DescribeDBInstances(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilDBInstanceDeleted"); + return waiter.Wait(request); + } +}; +} // namespace DocDB +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-drs/include/aws/drs/DrsClient.h b/generated/src/aws-cpp-sdk-drs/include/aws/drs/DrsClient.h index 83536b16381..f3b68d00040 100644 --- a/generated/src/aws-cpp-sdk-drs/include/aws/drs/DrsClient.h +++ b/generated/src/aws-cpp-sdk-drs/include/aws/drs/DrsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace drs { */ class AWS_DRS_API DrsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DrsPaginationBase { + public DrsPaginationBase, + public DrsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceClient.h b/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceClient.h index 1a7a361c977..7d8566183fc 100644 --- a/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceClient.h +++ b/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -34,7 +35,8 @@ namespace DirectoryService { */ class AWS_DIRECTORYSERVICE_API DirectoryServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DirectoryServicePaginationBase { + public DirectoryServicePaginationBase, + public DirectoryServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h b/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h new file mode 100644 index 00000000000..74356c6383e --- /dev/null +++ b/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h @@ -0,0 +1,51 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include + +#include + +namespace Aws { +namespace DirectoryService { + +template +class DirectoryServiceWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilHybridADUpdated( + const Model::DescribeHybridADUpdateRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Updated"), + [](const Model::DescribeHybridADUpdateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetUpdateActivities().GetSelfManagedInstances().begin(), + result.GetUpdateActivities().GetSelfManagedInstances().end(), + [&](const Model::HybridUpdateInfoEntry& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UpdateFailed"), + [](const Model::DescribeHybridADUpdateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetUpdateActivities().GetSelfManagedInstances().begin(), + result.GetUpdateActivities().GetSelfManagedInstances().end(), + [&](const Model::HybridUpdateInfoEntry& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeHybridADUpdateRequest& req) { + return static_cast(this)->DescribeHybridADUpdate(req); + }; + Aws::Utils::Waiter waiter(120, 1, acceptors, operation, + "WaitUntilHybridADUpdated"); + return waiter.Wait(request); + } +}; +} // namespace DirectoryService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLClient.h b/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLClient.h index 161f6e00a37..541bc12992d 100644 --- a/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLClient.h +++ b/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace DSQL { */ class AWS_DSQL_API DSQLClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DSQLPaginationBase { + public DSQLPaginationBase, + public DSQLWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h b/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h new file mode 100644 index 00000000000..6086aa48447 --- /dev/null +++ b/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h @@ -0,0 +1,45 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace DSQL { + +template +class DSQLWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilClusterActive(const Model::GetClusterRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetClusterRequest& req) { return static_cast(this)->GetCluster(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilClusterActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilClusterNotExists(const Model::GetClusterRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::GetClusterRequest& req) { return static_cast(this)->GetCluster(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilClusterNotExists"); + return waiter.Wait(request); + } +}; +} // namespace DSQL +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBClient.h b/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBClient.h index c3fed7fc02a..1db83c01548 100644 --- a/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBClient.h +++ b/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBClient.h @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -42,7 +43,8 @@ class AWS_DYNAMODB_API DynamoDBClient smithy::AuthSchemeResolverBase<>, Aws::Crt::Variant, DynamoDBEndpointProviderBase, smithy::client::JsonOutcomeSerializer, smithy::client::JsonOutcome, Aws::Client::DynamoDBErrorMarshaller>, - public DynamoDBPaginationBase { + public DynamoDBPaginationBase, + public DynamoDBWaiter { public: static const char* GetServiceName(); static const char* GetAllocationTag(); diff --git a/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h b/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h new file mode 100644 index 00000000000..ab044c80c62 --- /dev/null +++ b/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h @@ -0,0 +1,175 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace DynamoDB { + +template +class DynamoDBWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilContributorInsightsEnabled( + const Model::DescribeContributorInsightsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ENABLED"), + [](const Model::DescribeContributorInsightsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ContributorInsightsStatusMapper::GetNameForContributorInsightsStatus( + result.GetContributorInsightsStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeContributorInsightsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ContributorInsightsStatusMapper::GetNameForContributorInsightsStatus( + result.GetContributorInsightsStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeContributorInsightsRequest& req) { + return static_cast(this)->DescribeContributorInsights(req); + }; + Aws::Utils::Waiter waiter( + 20, 6, acceptors, operation, "WaitUntilContributorInsightsEnabled"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilExportCompleted(const Model::DescribeExportRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportDescription().GetExportStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportDescription().GetExportStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeExportRequest& req) { return static_cast(this)->DescribeExport(req); }; + Aws::Utils::Waiter waiter(20, 6, acceptors, operation, + "WaitUntilExportCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilImportCompleted(const Model::DescribeImportRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportTableDescription().GetImportStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportTableDescription().GetImportStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportTableDescription().GetImportStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeImportRequest& req) { return static_cast(this)->DescribeImport(req); }; + Aws::Utils::Waiter waiter(20, 6, acceptors, operation, + "WaitUntilImportCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilKinesisStreamingDestinationActive( + const Model::DescribeKinesisStreamingDestinationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeKinesisStreamingDestinationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetKinesisDataStreamDestinations().begin(), result.GetKinesisDataStreamDestinations().end(), + [&](const Model::KinesisDataStreamDestination& item) { + return Model::DestinationStatusMapper::GetNameForDestinationStatus(item.GetDestinationStatus()) == + expected.get(); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeKinesisStreamingDestinationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return ((result.GetKinesisDataStreamDestinations().size() > 0) && + (std::count_if(result.GetKinesisDataStreamDestinations().begin(), result.GetKinesisDataStreamDestinations().end(), + [](const Model::KinesisDataStreamDestination& item) { + return ((item.GetDestinationStatus() == "DISABLED") || + (item.GetDestinationStatus() == "ENABLE_FAILED")); + }) == result.GetKinesisDataStreamDestinations().size())) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeKinesisStreamingDestinationRequest& req) { + return static_cast(this)->DescribeKinesisStreamingDestination(req); + }; + Aws::Utils::Waiter waiter( + 20, 6, acceptors, operation, "WaitUntilKinesisStreamingDestinationActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTableExists(const Model::DescribeTableRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeTableOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TableStatusMapper::GetNameForTableStatus(result.GetTable().GetTableStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeTableRequest& req) { return static_cast(this)->DescribeTable(req); }; + Aws::Utils::Waiter waiter(20, 6, acceptors, operation, + "WaitUntilTableExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTableNotExists(const Model::DescribeTableRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeTableRequest& req) { return static_cast(this)->DescribeTable(req); }; + Aws::Utils::Waiter waiter(20, 6, acceptors, operation, + "WaitUntilTableNotExists"); + return waiter.Wait(request); + } +}; +} // namespace DynamoDB +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-dynamodbstreams/include/aws/dynamodbstreams/DynamoDBStreamsClient.h b/generated/src/aws-cpp-sdk-dynamodbstreams/include/aws/dynamodbstreams/DynamoDBStreamsClient.h index 9b3cb2158a3..03955b8d406 100644 --- a/generated/src/aws-cpp-sdk-dynamodbstreams/include/aws/dynamodbstreams/DynamoDBStreamsClient.h +++ b/generated/src/aws-cpp-sdk-dynamodbstreams/include/aws/dynamodbstreams/DynamoDBStreamsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace DynamoDBStreams { */ class AWS_DYNAMODBSTREAMS_API DynamoDBStreamsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public DynamoDBStreamsPaginationBase { + public DynamoDBStreamsPaginationBase, + public DynamoDBStreamsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ebs/include/aws/ebs/EBSClient.h b/generated/src/aws-cpp-sdk-ebs/include/aws/ebs/EBSClient.h index 53be932bee9..58f324f5702 100644 --- a/generated/src/aws-cpp-sdk-ebs/include/aws/ebs/EBSClient.h +++ b/generated/src/aws-cpp-sdk-ebs/include/aws/ebs/EBSClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -43,7 +44,8 @@ namespace EBS { */ class AWS_EBS_API EBSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EBSPaginationBase { + public EBSPaginationBase, + public EBSWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ec2-instance-connect/include/aws/ec2-instance-connect/EC2InstanceConnectClient.h b/generated/src/aws-cpp-sdk-ec2-instance-connect/include/aws/ec2-instance-connect/EC2InstanceConnectClient.h index 56542b31566..1917af8868f 100644 --- a/generated/src/aws-cpp-sdk-ec2-instance-connect/include/aws/ec2-instance-connect/EC2InstanceConnectClient.h +++ b/generated/src/aws-cpp-sdk-ec2-instance-connect/include/aws/ec2-instance-connect/EC2InstanceConnectClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace EC2InstanceConnect { */ class AWS_EC2INSTANCECONNECT_API EC2InstanceConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EC2InstanceConnectPaginationBase { + public EC2InstanceConnectPaginationBase, + public EC2InstanceConnectWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Client.h b/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Client.h index 3ed0fdf6922..863525785eb 100644 --- a/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Client.h +++ b/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Client.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace EC2 { */ class AWS_EC2_API EC2Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EC2PaginationBase { + public EC2PaginationBase, + public EC2Waiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h b/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h new file mode 100644 index 00000000000..351ad6000b9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h @@ -0,0 +1,1343 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace EC2 { + +template +class EC2Waiter { + public: + Aws::Utils::WaiterOutcome WaitUntilBundleTaskComplete( + const Model::DescribeBundleTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("complete"), + [](const Model::DescribeBundleTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetBundleTasks().begin(), result.GetBundleTasks().end(), [&](const Model::BundleTask& item) { + return Model::BundleTaskStateMapper::GetNameForBundleTaskState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeBundleTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetBundleTasks().begin(), result.GetBundleTasks().end(), [&](const Model::BundleTask& item) { + return Model::BundleTaskStateMapper::GetNameForBundleTaskState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeBundleTasksRequest& req) { + return static_cast(this)->DescribeBundleTasks(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilBundleTaskComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilConversionTaskCancelled( + const Model::DescribeConversionTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("cancelled"), + [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetConversionTasks().begin(), result.GetConversionTasks().end(), + [&](const Model::ConversionTask& item) { + return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == + expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeConversionTasksRequest& req) { + return static_cast(this)->DescribeConversionTasks(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilConversionTaskCancelled"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilConversionTaskCompleted( + const Model::DescribeConversionTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), + [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetConversionTasks().begin(), result.GetConversionTasks().end(), + [&](const Model::ConversionTask& item) { + return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == + expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("cancelled"), + [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetConversionTasks().begin(), result.GetConversionTasks().end(), + [&](const Model::ConversionTask& item) { + return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == + expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("cancelling"), + [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetConversionTasks().begin(), result.GetConversionTasks().end(), + [&](const Model::ConversionTask& item) { + return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == + expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeConversionTasksRequest& req) { + return static_cast(this)->DescribeConversionTasks(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilConversionTaskCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilConversionTaskDeleted( + const Model::DescribeConversionTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetConversionTasks().begin(), result.GetConversionTasks().end(), + [&](const Model::ConversionTask& item) { + return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == + expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeConversionTasksRequest& req) { + return static_cast(this)->DescribeConversionTasks(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilConversionTaskDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilCustomerGatewayAvailable( + const Model::DescribeCustomerGatewaysRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeCustomerGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetCustomerGateways().begin(), result.GetCustomerGateways().end(), + [&](const Model::CustomerGateway& item) { return item.GetState() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeCustomerGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetCustomerGateways().begin(), result.GetCustomerGateways().end(), + [&](const Model::CustomerGateway& item) { return item.GetState() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeCustomerGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetCustomerGateways().begin(), result.GetCustomerGateways().end(), + [&](const Model::CustomerGateway& item) { return item.GetState() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeCustomerGatewaysRequest& req) { + return static_cast(this)->DescribeCustomerGateways(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilCustomerGatewayAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilExportTaskCancelled( + const Model::DescribeExportTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("cancelled"), + [](const Model::DescribeExportTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetExportTasks().begin(), result.GetExportTasks().end(), [&](const Model::ExportTask& item) { + return Model::ExportTaskStateMapper::GetNameForExportTaskState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeExportTasksRequest& req) { + return static_cast(this)->DescribeExportTasks(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilExportTaskCancelled"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilExportTaskCompleted( + const Model::DescribeExportTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), + [](const Model::DescribeExportTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetExportTasks().begin(), result.GetExportTasks().end(), [&](const Model::ExportTask& item) { + return Model::ExportTaskStateMapper::GetNameForExportTaskState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeExportTasksRequest& req) { + return static_cast(this)->DescribeExportTasks(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilExportTaskCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilImageAvailable(const Model::DescribeImagesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeImagesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetImages().begin(), result.GetImages().end(), [&](const Model::Image& item) { + return Model::ImageStateMapper::GetNameForImageState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeImagesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetImages().begin(), result.GetImages().end(), [&](const Model::Image& item) { + return Model::ImageStateMapper::GetNameForImageState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeImagesRequest& req) { return static_cast(this)->DescribeImages(req); }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilImageAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilImageExists(const Model::DescribeImagesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeImagesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetImages().size() > 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidAMIID.NotFound")}); + + auto operation = [this](const Model::DescribeImagesRequest& req) { return static_cast(this)->DescribeImages(req); }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilImageExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilImageUsageReportAvailable( + const Model::DescribeImageUsageReportsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeImageUsageReportsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetImageUsageReports().begin(), result.GetImageUsageReports().end(), + [&](const Model::ImageUsageReport& item) { return item.GetState() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeImageUsageReportsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetImageUsageReports().begin(), result.GetImageUsageReports().end(), + [&](const Model::ImageUsageReport& item) { return item.GetState() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeImageUsageReportsRequest& req) { + return static_cast(this)->DescribeImageUsageReports(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilImageUsageReportAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSnapshotImported( + const Model::DescribeImportSnapshotTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), + [](const Model::DescribeImportSnapshotTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetImportSnapshotTasks().begin(), result.GetImportSnapshotTasks().end(), + [&](const Model::ImportSnapshotTask& item) { + return item.GetSnapshotTaskDetail().GetStatus() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("error"), + [](const Model::DescribeImportSnapshotTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetImportSnapshotTasks().begin(), result.GetImportSnapshotTasks().end(), + [&](const Model::ImportSnapshotTask& item) { + return item.GetSnapshotTaskDetail().GetStatus() == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeImportSnapshotTasksRequest& req) { + return static_cast(this)->DescribeImportSnapshotTasks(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilSnapshotImported"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInstanceExists(const Model::DescribeInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetReservations().size() > 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstanceID.NotFound")}); + + auto operation = [this](const Model::DescribeInstancesRequest& req) { + return static_cast(this)->DescribeInstances(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilInstanceExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInstanceRunning(const Model::DescribeInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("running"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::all_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == + expected.get(); + }); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("shutting-down"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == + expected.get(); + }); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("terminated"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == + expected.get(); + }); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopping"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == + expected.get(); + }); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstanceID.NotFound")}); + + auto operation = [this](const Model::DescribeInstancesRequest& req) { + return static_cast(this)->DescribeInstances(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilInstanceRunning"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInstanceStopped(const Model::DescribeInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("stopped"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::all_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == + expected.get(); + }); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("pending"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == + expected.get(); + }); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("terminated"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == + expected.get(); + }); + }); + }}); + + auto operation = [this](const Model::DescribeInstancesRequest& req) { + return static_cast(this)->DescribeInstances(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilInstanceStopped"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInstanceTerminated(const Model::DescribeInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("terminated"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::all_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == + expected.get(); + }); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("pending"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == + expected.get(); + }); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopping"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == + expected.get(); + }); + }); + }}); + + auto operation = [this](const Model::DescribeInstancesRequest& req) { + return static_cast(this)->DescribeInstances(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilInstanceTerminated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInstanceStatusOk( + const Model::DescribeInstanceStatusRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ok"), + [](const Model::DescribeInstanceStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetInstanceStatuses().begin(), result.GetInstanceStatuses().end(), + [&](const Model::InstanceStatus& item) { + return Model::SummaryStatusMapper::GetNameForSummaryStatus( + item.GetInstanceStatus().GetStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstanceID.NotFound")}); + + auto operation = [this](const Model::DescribeInstanceStatusRequest& req) { + return static_cast(this)->DescribeInstanceStatus(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilInstanceStatusOk"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSystemStatusOk( + const Model::DescribeInstanceStatusRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ok"), + [](const Model::DescribeInstanceStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetInstanceStatuses().begin(), result.GetInstanceStatuses().end(), + [&](const Model::InstanceStatus& item) { + return Model::SummaryStatusMapper::GetNameForSummaryStatus( + item.GetSystemStatus().GetStatus()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeInstanceStatusRequest& req) { + return static_cast(this)->DescribeInstanceStatus(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilSystemStatusOk"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInternetGatewayExists( + const Model::DescribeInternetGatewaysRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeInternetGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetInternetGateways().size() > 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInternetGateway.NotFound")}); + + auto operation = [this](const Model::DescribeInternetGatewaysRequest& req) { + return static_cast(this)->DescribeInternetGateways(req); + }; + Aws::Utils::Waiter waiter( + 5, 24, acceptors, operation, "WaitUntilInternetGatewayExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilKeyPairExists(const Model::DescribeKeyPairsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeKeyPairsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetKeyPairs().size() > 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidKeyPair.NotFound")}); + + auto operation = [this](const Model::DescribeKeyPairsRequest& req) { return static_cast(this)->DescribeKeyPairs(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilKeyPairExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilNatGatewayAvailable( + const Model::DescribeNatGatewaysRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { + return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { + return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { + return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { + return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NatGatewayNotFound")}); + + auto operation = [this](const Model::DescribeNatGatewaysRequest& req) { + return static_cast(this)->DescribeNatGateways(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilNatGatewayAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilNatGatewayDeleted( + const Model::DescribeNatGatewaysRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { + return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("NatGatewayNotFound")}); + + auto operation = [this](const Model::DescribeNatGatewaysRequest& req) { + return static_cast(this)->DescribeNatGateways(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilNatGatewayDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilNetworkInterfaceAvailable( + const Model::DescribeNetworkInterfacesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeNetworkInterfacesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetNetworkInterfaces().begin(), result.GetNetworkInterfaces().end(), + [&](const Model::NetworkInterface& item) { + return Model::NetworkInterfaceStatusMapper::GetNameForNetworkInterfaceStatus( + item.GetStatus()) == expected.get(); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidNetworkInterfaceID.NotFound")}); + + auto operation = [this](const Model::DescribeNetworkInterfacesRequest& req) { + return static_cast(this)->DescribeNetworkInterfaces(req); + }; + Aws::Utils::Waiter waiter( + 20, 6, acceptors, operation, "WaitUntilNetworkInterfaceAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSecondaryNetworkCreateComplete( + const Model::DescribeSecondaryNetworksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("create-complete"), + [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), + [&](const Model::SecondaryNetwork& item) { + return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState( + item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("create-failed"), + [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), + [&](const Model::SecondaryNetwork& item) { + return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState( + item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidSecondaryNetworkId.NotFound")}); + + auto operation = [this](const Model::DescribeSecondaryNetworksRequest& req) { + return static_cast(this)->DescribeSecondaryNetworks(req); + }; + Aws::Utils::Waiter waiter( + 10, 12, acceptors, operation, "WaitUntilSecondaryNetworkCreateComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSecondaryNetworkDeleteComplete( + const Model::DescribeSecondaryNetworksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("delete-complete"), + [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), + [&](const Model::SecondaryNetwork& item) { + return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState( + item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("delete-failed"), + [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), + [&](const Model::SecondaryNetwork& item) { + return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState( + item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeSecondaryNetworksRequest& req) { + return static_cast(this)->DescribeSecondaryNetworks(req); + }; + Aws::Utils::Waiter waiter( + 10, 12, acceptors, operation, "WaitUntilSecondaryNetworkDeleteComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSecondarySubnetCreateComplete( + const Model::DescribeSecondarySubnetsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("create-complete"), + [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), + [&](const Model::SecondarySubnet& item) { + return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == + expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("delete-failed"), + [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), + [&](const Model::SecondarySubnet& item) { + return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == + expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidSecondarySubnetId.NotFound")}); + + auto operation = [this](const Model::DescribeSecondarySubnetsRequest& req) { + return static_cast(this)->DescribeSecondarySubnets(req); + }; + Aws::Utils::Waiter waiter( + 10, 12, acceptors, operation, "WaitUntilSecondarySubnetCreateComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSecondarySubnetDeleteComplete( + const Model::DescribeSecondarySubnetsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("delete-complete"), + [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), + [&](const Model::SecondarySubnet& item) { + return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == + expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("delete-failed"), + [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), + [&](const Model::SecondarySubnet& item) { + return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == + expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeSecondarySubnetsRequest& req) { + return static_cast(this)->DescribeSecondarySubnets(req); + }; + Aws::Utils::Waiter waiter( + 10, 12, acceptors, operation, "WaitUntilSecondarySubnetDeleteComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSecurityGroupExists( + const Model::DescribeSecurityGroupsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeSecurityGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetSecurityGroups().size() > 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidGroup.NotFound")}); + + auto operation = [this](const Model::DescribeSecurityGroupsRequest& req) { + return static_cast(this)->DescribeSecurityGroups(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilSecurityGroupExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSecurityGroupVpcAssociationAssociated( + const Model::DescribeSecurityGroupVpcAssociationsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("associated"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("associating"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("association-failed"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeSecurityGroupVpcAssociationsRequest& req) { + return static_cast(this)->DescribeSecurityGroupVpcAssociations(req); + }; + Aws::Utils::Waiter waiter( + 10, 12, acceptors, operation, "WaitUntilSecurityGroupVpcAssociationAssociated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSecurityGroupVpcAssociationDisassociated( + const Model::DescribeSecurityGroupVpcAssociationsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("disassociated"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("disassociating"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("disassociation-failed"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetSecurityGroupVpcAssociations().size() == 0) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeSecurityGroupVpcAssociationsRequest& req) { + return static_cast(this)->DescribeSecurityGroupVpcAssociations(req); + }; + Aws::Utils::Waiter waiter( + 10, 12, acceptors, operation, "WaitUntilSecurityGroupVpcAssociationDisassociated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSnapshotCompleted(const Model::DescribeSnapshotsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), + [](const Model::DescribeSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), [&](const Model::Snapshot& item) { + return Model::SnapshotStateMapper::GetNameForSnapshotState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("error"), + [](const Model::DescribeSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), [&](const Model::Snapshot& item) { + return Model::SnapshotStateMapper::GetNameForSnapshotState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeSnapshotsRequest& req) { + return static_cast(this)->DescribeSnapshots(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilSnapshotCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSpotInstanceRequestFulfilled( + const Model::DescribeSpotInstanceRequestsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("fulfilled"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { + return item.GetStatus().GetCode() == expected.get(); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("request-canceled-and-instance-running"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { return item.GetStatus().GetCode() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("schedule-expired"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { + return item.GetStatus().GetCode() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("canceled-before-fulfillment"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { + return item.GetStatus().GetCode() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("bad-parameters"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { + return item.GetStatus().GetCode() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("system-error"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { + return item.GetStatus().GetCode() == expected.get(); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidSpotInstanceRequestID.NotFound")}); + + auto operation = [this](const Model::DescribeSpotInstanceRequestsRequest& req) { + return static_cast(this)->DescribeSpotInstanceRequests(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilSpotInstanceRequestFulfilled"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStoreImageTaskComplete( + const Model::DescribeStoreImageTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), + [](const Model::DescribeStoreImageTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStoreImageTaskResults().begin(), result.GetStoreImageTaskResults().end(), + [&](const Model::StoreImageTaskResponse& item) { + return item.GetStoreTaskState() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeStoreImageTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStoreImageTaskResults().begin(), result.GetStoreImageTaskResults().end(), + [&](const Model::StoreImageTaskResponse& item) { + return item.GetStoreTaskState() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("InProgress"), + [](const Model::DescribeStoreImageTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStoreImageTaskResults().begin(), result.GetStoreImageTaskResults().end(), + [&](const Model::StoreImageTaskResponse& item) { + return item.GetStoreTaskState() == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeStoreImageTasksRequest& req) { + return static_cast(this)->DescribeStoreImageTasks(req); + }; + Aws::Utils::Waiter waiter( + 5, 24, acceptors, operation, "WaitUntilStoreImageTaskComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSubnetAvailable(const Model::DescribeSubnetsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeSubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSubnets().begin(), result.GetSubnets().end(), [&](const Model::Subnet& item) { + return Model::SubnetStateMapper::GetNameForSubnetState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeSubnetsRequest& req) { return static_cast(this)->DescribeSubnets(req); }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilSubnetAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVolumeAvailable(const Model::DescribeVolumesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { + return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { + return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeVolumesRequest& req) { return static_cast(this)->DescribeVolumes(req); }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilVolumeAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVolumeDeleted(const Model::DescribeVolumesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { + return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidVolume.NotFound")}); + + auto operation = [this](const Model::DescribeVolumesRequest& req) { return static_cast(this)->DescribeVolumes(req); }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilVolumeDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVolumeInUse(const Model::DescribeVolumesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("in-use"), + [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { + return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { + return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeVolumesRequest& req) { return static_cast(this)->DescribeVolumes(req); }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilVolumeInUse"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVpcPeeringConnectionDeleted( + const Model::DescribeVpcPeeringConnectionsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeVpcPeeringConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetVpcPeeringConnections().begin(), result.GetVpcPeeringConnections().end(), + [&](const Model::VpcPeeringConnection& item) { + return Model::VpcPeeringConnectionStateReasonCodeMapper::GetNameForVpcPeeringConnectionStateReasonCode( + item.GetStatus().GetCode()) == expected.get(); + }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidVpcPeeringConnectionID.NotFound")}); + + auto operation = [this](const Model::DescribeVpcPeeringConnectionsRequest& req) { + return static_cast(this)->DescribeVpcPeeringConnections(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilVpcPeeringConnectionDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVpcPeeringConnectionExists( + const Model::DescribeVpcPeeringConnectionsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back( + {Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidVpcPeeringConnectionID.NotFound")}); + + auto operation = [this](const Model::DescribeVpcPeeringConnectionsRequest& req) { + return static_cast(this)->DescribeVpcPeeringConnections(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilVpcPeeringConnectionExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVpcAvailable(const Model::DescribeVpcsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeVpcsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVpcs().begin(), result.GetVpcs().end(), [&](const Model::Vpc& item) { + return Model::VpcStateMapper::GetNameForVpcState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeVpcsRequest& req) { return static_cast(this)->DescribeVpcs(req); }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, "WaitUntilVpcAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVpcExists(const Model::DescribeVpcsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidVpcID.NotFound")}); + + auto operation = [this](const Model::DescribeVpcsRequest& req) { return static_cast(this)->DescribeVpcs(req); }; + Aws::Utils::Waiter waiter(1, 120, acceptors, operation, "WaitUntilVpcExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVpnConnectionAvailable( + const Model::DescribeVpnConnectionsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { + return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { + return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { + return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeVpnConnectionsRequest& req) { + return static_cast(this)->DescribeVpnConnections(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilVpnConnectionAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVpnConnectionDeleted( + const Model::DescribeVpnConnectionsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { + return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("pending"), + [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { + return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeVpnConnectionsRequest& req) { + return static_cast(this)->DescribeVpnConnections(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilVpnConnectionDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPasswordDataAvailable(const Model::GetPasswordDataRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::GetPasswordDataOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetPasswordData().size() > 0) == expected.get(); + }}); + + auto operation = [this](const Model::GetPasswordDataRequest& req) { return static_cast(this)->GetPasswordData(req); }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilPasswordDataAvailable"); + return waiter.Wait(request); + } +}; +} // namespace EC2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ecr-public/include/aws/ecr-public/ECRPublicClient.h b/generated/src/aws-cpp-sdk-ecr-public/include/aws/ecr-public/ECRPublicClient.h index cf1272aacf9..e9bf93f6bc7 100644 --- a/generated/src/aws-cpp-sdk-ecr-public/include/aws/ecr-public/ECRPublicClient.h +++ b/generated/src/aws-cpp-sdk-ecr-public/include/aws/ecr-public/ECRPublicClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -28,7 +29,8 @@ namespace ECRPublic { */ class AWS_ECRPUBLIC_API ECRPublicClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ECRPublicPaginationBase { + public ECRPublicPaginationBase, + public ECRPublicWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRClient.h b/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRClient.h index 22bcf68279d..7ae71c49ec9 100644 --- a/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRClient.h +++ b/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace ECR { */ class AWS_ECR_API ECRClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ECRPaginationBase { + public ECRPaginationBase, + public ECRWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h b/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h new file mode 100644 index 00000000000..714f57d6621 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h @@ -0,0 +1,77 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace ECR { + +template +class ECRWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilImageScanComplete( + const Model::DescribeImageScanFindingsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETE"), + [](const Model::DescribeImageScanFindingsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ScanStatusMapper::GetNameForScanStatus(result.GetImageScanStatus().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeImageScanFindingsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ScanStatusMapper::GetNameForScanStatus(result.GetImageScanStatus().GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeImageScanFindingsRequest& req) { + return static_cast(this)->DescribeImageScanFindings(req); + }; + Aws::Utils::Waiter waiter( + 5, 24, acceptors, operation, "WaitUntilImageScanComplete"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilLifecyclePolicyPreviewComplete( + const Model::GetLifecyclePolicyPreviewRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETE"), + [](const Model::GetLifecyclePolicyPreviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LifecyclePolicyPreviewStatusMapper::GetNameForLifecyclePolicyPreviewStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetLifecyclePolicyPreviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LifecyclePolicyPreviewStatusMapper::GetNameForLifecyclePolicyPreviewStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetLifecyclePolicyPreviewRequest& req) { + return static_cast(this)->GetLifecyclePolicyPreview(req); + }; + Aws::Utils::Waiter waiter( + 5, 24, acceptors, operation, "WaitUntilLifecyclePolicyPreviewComplete"); + return waiter.Wait(request); + } +}; +} // namespace ECR +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSClient.h b/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSClient.h index c2b5f97a2d7..38b684b6313 100644 --- a/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSClient.h +++ b/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -33,7 +34,8 @@ namespace ECS { */ class AWS_ECS_API ECSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ECSPaginationBase { + public ECSPaginationBase, + public ECSWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h b/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h new file mode 100644 index 00000000000..82c7823d2ac --- /dev/null +++ b/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h @@ -0,0 +1,130 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace ECS { + +template +class ECSWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilServicesInactive(const Model::DescribeServicesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("MISSING"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFailures().begin(), result.GetFailures().end(), + [&](const Model::Failure& item) { return item.GetReason() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("INACTIVE"), + [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetServices().begin(), result.GetServices().end(), + [&](const Model::Service& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeServicesRequest& req) { return static_cast(this)->DescribeServices(req); }; + Aws::Utils::Waiter waiter(15, 40, acceptors, operation, + "WaitUntilServicesInactive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilServicesStable(const Model::DescribeServicesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("MISSING"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFailures().begin(), result.GetFailures().end(), + [&](const Model::Failure& item) { return item.GetReason() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DRAINING"), + [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetServices().begin(), result.GetServices().end(), + [&](const Model::Service& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("INACTIVE"), + [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetServices().begin(), result.GetServices().end(), + [&](const Model::Service& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (std::count_if(result.GetServices().begin(), result.GetServices().end(), [](const Model::Service& item) { + return !((item.GetDeployments().size() == 1) && (item.GetRunningCount() == item.GetDesiredCount())); + }) == 0) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeServicesRequest& req) { return static_cast(this)->DescribeServices(req); }; + Aws::Utils::Waiter waiter(15, 40, acceptors, operation, + "WaitUntilServicesStable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTasksRunning(const Model::DescribeTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetTasks().begin(), result.GetTasks().end(), + [&](const Model::Task& item) { return item.GetLastStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("MISSING"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFailures().begin(), result.GetFailures().end(), + [&](const Model::Failure& item) { return item.GetReason() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetTasks().begin(), result.GetTasks().end(), + [&](const Model::Task& item) { return item.GetLastStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeTasksRequest& req) { return static_cast(this)->DescribeTasks(req); }; + Aws::Utils::Waiter waiter(6, 100, acceptors, operation, + "WaitUntilTasksRunning"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTasksStopped(const Model::DescribeTasksRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetTasks().begin(), result.GetTasks().end(), + [&](const Model::Task& item) { return item.GetLastStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeTasksRequest& req) { return static_cast(this)->DescribeTasks(req); }; + Aws::Utils::Waiter waiter(6, 100, acceptors, operation, + "WaitUntilTasksStopped"); + return waiter.Wait(request); + } +}; +} // namespace ECS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-eks-auth/include/aws/eks-auth/EKSAuthClient.h b/generated/src/aws-cpp-sdk-eks-auth/include/aws/eks-auth/EKSAuthClient.h index 64716958df6..81c9ce39b52 100644 --- a/generated/src/aws-cpp-sdk-eks-auth/include/aws/eks-auth/EKSAuthClient.h +++ b/generated/src/aws-cpp-sdk-eks-auth/include/aws/eks-auth/EKSAuthClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace EKSAuth { */ class AWS_EKSAUTH_API EKSAuthClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EKSAuthPaginationBase { + public EKSAuthPaginationBase, + public EKSAuthWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSClient.h b/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSClient.h index 4de475c86d5..6343e3a54b7 100644 --- a/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSClient.h +++ b/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace EKS { */ class AWS_EKS_API EKSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EKSPaginationBase { + public EKSPaginationBase, + public EKSWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h b/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h new file mode 100644 index 00000000000..98b64e430d3 --- /dev/null +++ b/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h @@ -0,0 +1,229 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace EKS { + +template +class EKSWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilAddonActive(const Model::DescribeAddonRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DEGRADED"), + [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeAddonRequest& req) { return static_cast(this)->DescribeAddon(req); }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilAddonActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilAddonDeleted(const Model::DescribeAddonRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeAddonRequest& req) { return static_cast(this)->DescribeAddon(req); }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilAddonDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilClusterActive(const Model::DescribeClusterRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilClusterActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClusterRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilClusterDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFargateProfileActive( + const Model::DescribeFargateProfileRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeFargateProfileOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FargateProfileStatusMapper::GetNameForFargateProfileStatus( + result.GetFargateProfile().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeFargateProfileOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FargateProfileStatusMapper::GetNameForFargateProfileStatus( + result.GetFargateProfile().GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeFargateProfileRequest& req) { + return static_cast(this)->DescribeFargateProfile(req); + }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilFargateProfileActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFargateProfileDeleted( + const Model::DescribeFargateProfileRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::DescribeFargateProfileOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FargateProfileStatusMapper::GetNameForFargateProfileStatus( + result.GetFargateProfile().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeFargateProfileRequest& req) { + return static_cast(this)->DescribeFargateProfile(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilFargateProfileDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilNodegroupActive(const Model::DescribeNodegroupRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeNodegroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodegroupStatusMapper::GetNameForNodegroupStatus(result.GetNodegroup().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeNodegroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodegroupStatusMapper::GetNameForNodegroupStatus(result.GetNodegroup().GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeNodegroupRequest& req) { + return static_cast(this)->DescribeNodegroup(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilNodegroupActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilNodegroupDeleted(const Model::DescribeNodegroupRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::DescribeNodegroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodegroupStatusMapper::GetNameForNodegroupStatus(result.GetNodegroup().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeNodegroupRequest& req) { + return static_cast(this)->DescribeNodegroup(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilNodegroupDeleted"); + return waiter.Wait(request); + } +}; +} // namespace EKS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheClient.h b/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheClient.h index f1f8811b8f0..31de904a552 100644 --- a/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheClient.h +++ b/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -28,7 +29,8 @@ namespace ElastiCache { */ class AWS_ELASTICACHE_API ElastiCacheClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ElastiCachePaginationBase { + public ElastiCachePaginationBase, + public ElastiCacheWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h b/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h new file mode 100644 index 00000000000..89a35f1d6ff --- /dev/null +++ b/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h @@ -0,0 +1,201 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace ElastiCache { + +template +class ElastiCacheWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilCacheClusterAvailable( + const Model::DescribeCacheClustersRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-network"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("restore-failed"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeCacheClustersRequest& req) { + return static_cast(this)->DescribeCacheClusters(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilCacheClusterAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilCacheClusterDeleted( + const Model::DescribeCacheClustersRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("CacheClusterNotFound")}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-network"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("restore-failed"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + acceptors.push_back( + {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("snapshotting"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeCacheClustersRequest& req) { + return static_cast(this)->DescribeCacheClusters(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilCacheClusterDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReplicationGroupAvailable( + const Model::DescribeReplicationGroupsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), + [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), + [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeReplicationGroupsRequest& req) { + return static_cast(this)->DescribeReplicationGroups(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilReplicationGroupAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReplicationGroupDeleted( + const Model::DescribeReplicationGroupsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), + [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), + [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ReplicationGroupNotFoundFault")}); + + auto operation = [this](const Model::DescribeReplicationGroupsRequest& req) { + return static_cast(this)->DescribeReplicationGroups(req); + }; + Aws::Utils::Waiter waiter( + 15, 8, acceptors, operation, "WaitUntilReplicationGroupDeleted"); + return waiter.Wait(request); + } +}; +} // namespace ElastiCache +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkClient.h b/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkClient.h index 1cf8fd7ac1a..6f01ad10c84 100644 --- a/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkClient.h +++ b/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -33,7 +34,8 @@ namespace ElasticBeanstalk { */ class AWS_ELASTICBEANSTALK_API ElasticBeanstalkClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ElasticBeanstalkPaginationBase { + public ElasticBeanstalkPaginationBase, + public ElasticBeanstalkWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h b/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h new file mode 100644 index 00000000000..a36fedc4ae5 --- /dev/null +++ b/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h @@ -0,0 +1,118 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace ElasticBeanstalk { + +template +class ElasticBeanstalkWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilEnvironmentExists( + const Model::DescribeEnvironmentsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Ready"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), + [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == + expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Launching"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), + [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == + expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeEnvironmentsRequest& req) { + return static_cast(this)->DescribeEnvironments(req); + }; + Aws::Utils::Waiter waiter(20, 6, acceptors, operation, + "WaitUntilEnvironmentExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilEnvironmentTerminated( + const Model::DescribeEnvironmentsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Terminated"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), + [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == + expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Terminating"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), + [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == + expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeEnvironmentsRequest& req) { + return static_cast(this)->DescribeEnvironments(req); + }; + Aws::Utils::Waiter waiter(20, 6, acceptors, operation, + "WaitUntilEnvironmentTerminated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilEnvironmentUpdated( + const Model::DescribeEnvironmentsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Ready"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), + [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == + expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Updating"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), + [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == + expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeEnvironmentsRequest& req) { + return static_cast(this)->DescribeEnvironments(req); + }; + Aws::Utils::Waiter waiter(20, 6, acceptors, operation, + "WaitUntilEnvironmentUpdated"); + return waiter.Wait(request); + } +}; +} // namespace ElasticBeanstalk +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-elasticfilesystem/include/aws/elasticfilesystem/EFSClient.h b/generated/src/aws-cpp-sdk-elasticfilesystem/include/aws/elasticfilesystem/EFSClient.h index 053c431339c..a1519af4b9f 100644 --- a/generated/src/aws-cpp-sdk-elasticfilesystem/include/aws/elasticfilesystem/EFSClient.h +++ b/generated/src/aws-cpp-sdk-elasticfilesystem/include/aws/elasticfilesystem/EFSClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -28,7 +29,8 @@ namespace EFS { */ class AWS_EFS_API EFSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EFSPaginationBase { + public EFSPaginationBase, + public EFSWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingClient.h b/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingClient.h index e6816334bb7..ac4b198fe2a 100644 --- a/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingClient.h +++ b/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -40,7 +41,8 @@ namespace ElasticLoadBalancing { class AWS_ELASTICLOADBALANCING_API ElasticLoadBalancingClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ElasticLoadBalancingPaginationBase { + public ElasticLoadBalancingPaginationBase, + public ElasticLoadBalancingWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h b/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h new file mode 100644 index 00000000000..d127584435a --- /dev/null +++ b/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h @@ -0,0 +1,83 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include + +#include + +namespace Aws { +namespace ElasticLoadBalancing { + +template +class ElasticLoadBalancingWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilAnyInstanceInService( + const Model::DescribeInstanceHealthRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("InService"), + [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetInstanceStates().begin(), result.GetInstanceStates().end(), + [&](const Model::InstanceState& item) { return item.GetState() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeInstanceHealthRequest& req) { + return static_cast(this)->DescribeInstanceHealth(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilAnyInstanceInService"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInstanceDeregistered( + const Model::DescribeInstanceHealthRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("OutOfService"), + [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetInstanceStates().begin(), result.GetInstanceStates().end(), + [&](const Model::InstanceState& item) { return item.GetState() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstance")}); + + auto operation = [this](const Model::DescribeInstanceHealthRequest& req) { + return static_cast(this)->DescribeInstanceHealth(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilInstanceDeregistered"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInstanceInService( + const Model::DescribeInstanceHealthRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("InService"), + [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetInstanceStates().begin(), result.GetInstanceStates().end(), + [&](const Model::InstanceState& item) { return item.GetState() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstance")}); + + auto operation = [this](const Model::DescribeInstanceHealthRequest& req) { + return static_cast(this)->DescribeInstanceHealth(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilInstanceInService"); + return waiter.Wait(request); + } +}; +} // namespace ElasticLoadBalancing +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Client.h b/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Client.h index c5b710e92d9..87c153d85e1 100644 --- a/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Client.h +++ b/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Client.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -42,7 +43,8 @@ namespace ElasticLoadBalancingv2 { class AWS_ELASTICLOADBALANCINGV2_API ElasticLoadBalancingv2Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ElasticLoadBalancingv2PaginationBase { + public ElasticLoadBalancingv2PaginationBase, + public ElasticLoadBalancingv2Waiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h b/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h new file mode 100644 index 00000000000..86320ef300c --- /dev/null +++ b/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h @@ -0,0 +1,141 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace ElasticLoadBalancingv2 { + +template +class ElasticLoadBalancingv2Waiter { + public: + Aws::Utils::WaiterOutcome WaitUntilLoadBalancerAvailable( + const Model::DescribeLoadBalancersRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("active"), + [](const Model::DescribeLoadBalancersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetLoadBalancers().begin(), result.GetLoadBalancers().end(), [&](const Model::LoadBalancer& item) { + return Model::LoadBalancerStateEnumMapper::GetNameForLoadBalancerStateEnum(item.GetState().GetCode()) == + expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("provisioning"), + [](const Model::DescribeLoadBalancersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetLoadBalancers().begin(), result.GetLoadBalancers().end(), [&](const Model::LoadBalancer& item) { + return Model::LoadBalancerStateEnumMapper::GetNameForLoadBalancerStateEnum(item.GetState().GetCode()) == + expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("LoadBalancerNotFound")}); + + auto operation = [this](const Model::DescribeLoadBalancersRequest& req) { + return static_cast(this)->DescribeLoadBalancers(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilLoadBalancerAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilLoadBalancerExists( + const Model::DescribeLoadBalancersRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("LoadBalancerNotFound")}); + + auto operation = [this](const Model::DescribeLoadBalancersRequest& req) { + return static_cast(this)->DescribeLoadBalancers(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilLoadBalancerExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilLoadBalancersDeleted( + const Model::DescribeLoadBalancersRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("active"), + [](const Model::DescribeLoadBalancersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetLoadBalancers().begin(), result.GetLoadBalancers().end(), [&](const Model::LoadBalancer& item) { + return Model::LoadBalancerStateEnumMapper::GetNameForLoadBalancerStateEnum(item.GetState().GetCode()) == + expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("LoadBalancerNotFound")}); + + auto operation = [this](const Model::DescribeLoadBalancersRequest& req) { + return static_cast(this)->DescribeLoadBalancers(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilLoadBalancersDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTargetDeregistered( + const Model::DescribeTargetHealthRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidTarget")}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("unused"), + [](const Model::DescribeTargetHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetTargetHealthDescriptions().begin(), result.GetTargetHealthDescriptions().end(), + [&](const Model::TargetHealthDescription& item) { + return Model::TargetHealthStateEnumMapper::GetNameForTargetHealthStateEnum( + item.GetTargetHealth().GetState()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeTargetHealthRequest& req) { + return static_cast(this)->DescribeTargetHealth(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilTargetDeregistered"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTargetInService( + const Model::DescribeTargetHealthRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("healthy"), + [](const Model::DescribeTargetHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetTargetHealthDescriptions().begin(), result.GetTargetHealthDescriptions().end(), + [&](const Model::TargetHealthDescription& item) { + return Model::TargetHealthStateEnumMapper::GetNameForTargetHealthStateEnum( + item.GetTargetHealth().GetState()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstance")}); + + auto operation = [this](const Model::DescribeTargetHealthRequest& req) { + return static_cast(this)->DescribeTargetHealth(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilTargetInService"); + return waiter.Wait(request); + } +}; +} // namespace ElasticLoadBalancingv2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRClient.h b/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRClient.h index 264617e0329..b359cb941b1 100644 --- a/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRClient.h +++ b/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace EMR { */ class AWS_EMR_API EMRClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EMRPaginationBase { + public EMRPaginationBase, + public EMRWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h b/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h new file mode 100644 index 00000000000..def18de2786 --- /dev/null +++ b/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h @@ -0,0 +1,121 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace EMR { + +template +class EMRWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilClusterRunning(const Model::DescribeClusterRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("WAITING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TERMINATING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TERMINATED"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TERMINATED_WITH_ERRORS"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilClusterRunning"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilClusterTerminated(const Model::DescribeClusterRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("TERMINATED"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TERMINATED_WITH_ERRORS"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilClusterTerminated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStepComplete(const Model::DescribeStepRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::DescribeStepOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StepStateMapper::GetNameForStepState(result.GetStep().GetStatus().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeStepOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StepStateMapper::GetNameForStepState(result.GetStep().GetStatus().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::DescribeStepOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StepStateMapper::GetNameForStepState(result.GetStep().GetStatus().GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeStepRequest& req) { return static_cast(this)->DescribeStep(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, "WaitUntilStepComplete"); + return waiter.Wait(request); + } +}; +} // namespace EMR +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceClient.h b/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceClient.h index 6796c726bd9..6417736b331 100644 --- a/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceClient.h +++ b/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace ElementalInference { */ class AWS_ELEMENTALINFERENCE_API ElementalInferenceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ElementalInferencePaginationBase { + public ElementalInferencePaginationBase, + public ElementalInferenceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h b/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h new file mode 100644 index 00000000000..dfe8a036f90 --- /dev/null +++ b/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h @@ -0,0 +1,45 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace ElementalInference { + +template +class ElementalInferenceWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilFeedDeleted(const Model::GetFeedRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetFeedOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FeedStatusMapper::GetNameForFeedStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetFeedOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FeedStatusMapper::GetNameForFeedStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("TooManyRequestException")}); + + auto operation = [this](const Model::GetFeedRequest& req) { return static_cast(this)->GetFeed(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, "WaitUntilFeedDeleted"); + return waiter.Wait(request); + } +}; +} // namespace ElementalInference +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-email/include/aws/email/SESClient.h b/generated/src/aws-cpp-sdk-email/include/aws/email/SESClient.h index 2e845e6b213..58f742e92f4 100644 --- a/generated/src/aws-cpp-sdk-email/include/aws/email/SESClient.h +++ b/generated/src/aws-cpp-sdk-email/include/aws/email/SESClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -39,7 +40,8 @@ namespace SES { */ class AWS_SES_API SESClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SESPaginationBase { + public SESPaginationBase, + public SESWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h b/generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h new file mode 100644 index 00000000000..ce44d60c2b9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h @@ -0,0 +1,45 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace SES { + +template +class SESWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilIdentityExists( + const Model::GetIdentityVerificationAttributesRequest& request) { + std::vector> acceptors; + acceptors.push_back( + {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Success"), + [](const Model::GetIdentityVerificationAttributesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVerificationAttributes().begin(), result.GetVerificationAttributes().end(), [&](const auto& pair0) { + const auto& item = pair0.second; + return Model::VerificationStatusMapper::GetNameForVerificationStatus(item.GetVerificationStatus()) == + expected.get(); + }); + }}); + + auto operation = [this](const Model::GetIdentityVerificationAttributesRequest& req) { + return static_cast(this)->GetIdentityVerificationAttributes(req); + }; + Aws::Utils::Waiter waiter( + 3, 40, acceptors, operation, "WaitUntilIdentityExists"); + return waiter.Wait(request); + } +}; +} // namespace SES +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-emr-containers/include/aws/emr-containers/EMRContainersClient.h b/generated/src/aws-cpp-sdk-emr-containers/include/aws/emr-containers/EMRContainersClient.h index 7bb6654cf36..9f09c73aea9 100644 --- a/generated/src/aws-cpp-sdk-emr-containers/include/aws/emr-containers/EMRContainersClient.h +++ b/generated/src/aws-cpp-sdk-emr-containers/include/aws/emr-containers/EMRContainersClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -39,7 +40,8 @@ namespace EMRContainers { */ class AWS_EMRCONTAINERS_API EMRContainersClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EMRContainersPaginationBase { + public EMRContainersPaginationBase, + public EMRContainersWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-emr-serverless/include/aws/emr-serverless/EMRServerlessClient.h b/generated/src/aws-cpp-sdk-emr-serverless/include/aws/emr-serverless/EMRServerlessClient.h index 2b042b2ace7..3a7f51be712 100644 --- a/generated/src/aws-cpp-sdk-emr-serverless/include/aws/emr-serverless/EMRServerlessClient.h +++ b/generated/src/aws-cpp-sdk-emr-serverless/include/aws/emr-serverless/EMRServerlessClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -34,7 +35,8 @@ namespace EMRServerless { */ class AWS_EMRSERVERLESS_API EMRServerlessClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EMRServerlessPaginationBase { + public EMRServerlessPaginationBase, + public EMRServerlessWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-entityresolution/include/aws/entityresolution/EntityResolutionClient.h b/generated/src/aws-cpp-sdk-entityresolution/include/aws/entityresolution/EntityResolutionClient.h index 078eb9cff51..634c06d7e63 100644 --- a/generated/src/aws-cpp-sdk-entityresolution/include/aws/entityresolution/EntityResolutionClient.h +++ b/generated/src/aws-cpp-sdk-entityresolution/include/aws/entityresolution/EntityResolutionClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -31,7 +32,8 @@ namespace EntityResolution { */ class AWS_ENTITYRESOLUTION_API EntityResolutionClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EntityResolutionPaginationBase { + public EntityResolutionPaginationBase, + public EntityResolutionWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-es/include/aws/es/ElasticsearchServiceClient.h b/generated/src/aws-cpp-sdk-es/include/aws/es/ElasticsearchServiceClient.h index 0551eb68a2d..4d81bbd55db 100644 --- a/generated/src/aws-cpp-sdk-es/include/aws/es/ElasticsearchServiceClient.h +++ b/generated/src/aws-cpp-sdk-es/include/aws/es/ElasticsearchServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -32,7 +33,8 @@ namespace ElasticsearchService { class AWS_ELASTICSEARCHSERVICE_API ElasticsearchServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ElasticsearchServicePaginationBase { + public ElasticsearchServicePaginationBase, + public ElasticsearchServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-eventbridge/include/aws/eventbridge/EventBridgeClient.h b/generated/src/aws-cpp-sdk-eventbridge/include/aws/eventbridge/EventBridgeClient.h index 26b69c81bd0..86bb447ef98 100644 --- a/generated/src/aws-cpp-sdk-eventbridge/include/aws/eventbridge/EventBridgeClient.h +++ b/generated/src/aws-cpp-sdk-eventbridge/include/aws/eventbridge/EventBridgeClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -32,7 +33,8 @@ namespace EventBridge { */ class AWS_EVENTBRIDGE_API EventBridgeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EventBridgePaginationBase { + public EventBridgePaginationBase, + public EventBridgeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-events/include/aws/events/CloudWatchEventsClient.h b/generated/src/aws-cpp-sdk-events/include/aws/events/CloudWatchEventsClient.h index a285fe11273..bc7c94d5893 100644 --- a/generated/src/aws-cpp-sdk-events/include/aws/events/CloudWatchEventsClient.h +++ b/generated/src/aws-cpp-sdk-events/include/aws/events/CloudWatchEventsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -32,7 +33,8 @@ namespace CloudWatchEvents { */ class AWS_CLOUDWATCHEVENTS_API CloudWatchEventsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudWatchEventsPaginationBase { + public CloudWatchEventsPaginationBase, + public CloudWatchEventsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-evs/include/aws/evs/EVSClient.h b/generated/src/aws-cpp-sdk-evs/include/aws/evs/EVSClient.h index 2c245c610d4..ef8288d6a73 100644 --- a/generated/src/aws-cpp-sdk-evs/include/aws/evs/EVSClient.h +++ b/generated/src/aws-cpp-sdk-evs/include/aws/evs/EVSClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace EVS { */ class AWS_EVS_API EVSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public EVSPaginationBase { + public EVSPaginationBase, + public EVSWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-finspace-data/include/aws/finspace-data/FinSpaceDataClient.h b/generated/src/aws-cpp-sdk-finspace-data/include/aws/finspace-data/FinSpaceDataClient.h index ef2c2a069e1..aa5c42258ec 100644 --- a/generated/src/aws-cpp-sdk-finspace-data/include/aws/finspace-data/FinSpaceDataClient.h +++ b/generated/src/aws-cpp-sdk-finspace-data/include/aws/finspace-data/FinSpaceDataClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace FinSpaceData { */ class AWS_FINSPACEDATA_API FinSpaceDataClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public FinSpaceDataPaginationBase { + public FinSpaceDataPaginationBase, + public FinSpaceDataWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-finspace/include/aws/finspace/FinspaceClient.h b/generated/src/aws-cpp-sdk-finspace/include/aws/finspace/FinspaceClient.h index 7e60a868dcd..fa5b46103e4 100644 --- a/generated/src/aws-cpp-sdk-finspace/include/aws/finspace/FinspaceClient.h +++ b/generated/src/aws-cpp-sdk-finspace/include/aws/finspace/FinspaceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace finspace { */ class AWS_FINSPACE_API FinspaceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public FinspacePaginationBase { + public FinspacePaginationBase, + public FinspaceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-firehose/include/aws/firehose/FirehoseClient.h b/generated/src/aws-cpp-sdk-firehose/include/aws/firehose/FirehoseClient.h index 055729ba5bd..1588f759c9b 100644 --- a/generated/src/aws-cpp-sdk-firehose/include/aws/firehose/FirehoseClient.h +++ b/generated/src/aws-cpp-sdk-firehose/include/aws/firehose/FirehoseClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace Firehose { */ class AWS_FIREHOSE_API FirehoseClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public FirehosePaginationBase { + public FirehosePaginationBase, + public FirehoseWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-fis/include/aws/fis/FISClient.h b/generated/src/aws-cpp-sdk-fis/include/aws/fis/FISClient.h index 862eb8b24e8..c369bd2f64c 100644 --- a/generated/src/aws-cpp-sdk-fis/include/aws/fis/FISClient.h +++ b/generated/src/aws-cpp-sdk-fis/include/aws/fis/FISClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace FIS { */ class AWS_FIS_API FISClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public FISPaginationBase { + public FISPaginationBase, + public FISWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-fms/include/aws/fms/FMSClient.h b/generated/src/aws-cpp-sdk-fms/include/aws/fms/FMSClient.h index c9abb8cbc7a..557ef54a94b 100644 --- a/generated/src/aws-cpp-sdk-fms/include/aws/fms/FMSClient.h +++ b/generated/src/aws-cpp-sdk-fms/include/aws/fms/FMSClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -27,7 +28,8 @@ namespace FMS { */ class AWS_FMS_API FMSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public FMSPaginationBase { + public FMSPaginationBase, + public FMSWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-forecast/include/aws/forecast/ForecastServiceClient.h b/generated/src/aws-cpp-sdk-forecast/include/aws/forecast/ForecastServiceClient.h index 6cfa6032f8b..c7a6a4abaf7 100644 --- a/generated/src/aws-cpp-sdk-forecast/include/aws/forecast/ForecastServiceClient.h +++ b/generated/src/aws-cpp-sdk-forecast/include/aws/forecast/ForecastServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace ForecastService { */ class AWS_FORECASTSERVICE_API ForecastServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ForecastServicePaginationBase { + public ForecastServicePaginationBase, + public ForecastServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-forecastquery/include/aws/forecastquery/ForecastQueryServiceClient.h b/generated/src/aws-cpp-sdk-forecastquery/include/aws/forecastquery/ForecastQueryServiceClient.h index f1a6e9d16bd..c554ef32626 100644 --- a/generated/src/aws-cpp-sdk-forecastquery/include/aws/forecastquery/ForecastQueryServiceClient.h +++ b/generated/src/aws-cpp-sdk-forecastquery/include/aws/forecastquery/ForecastQueryServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace ForecastQueryService { class AWS_FORECASTQUERYSERVICE_API ForecastQueryServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ForecastQueryServicePaginationBase { + public ForecastQueryServicePaginationBase, + public ForecastQueryServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-frauddetector/include/aws/frauddetector/FraudDetectorClient.h b/generated/src/aws-cpp-sdk-frauddetector/include/aws/frauddetector/FraudDetectorClient.h index c91d0d55b35..8ad92b8f948 100644 --- a/generated/src/aws-cpp-sdk-frauddetector/include/aws/frauddetector/FraudDetectorClient.h +++ b/generated/src/aws-cpp-sdk-frauddetector/include/aws/frauddetector/FraudDetectorClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -36,7 +37,8 @@ namespace FraudDetector { */ class AWS_FRAUDDETECTOR_API FraudDetectorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public FraudDetectorPaginationBase { + public FraudDetectorPaginationBase, + public FraudDetectorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-freetier/include/aws/freetier/FreeTierClient.h b/generated/src/aws-cpp-sdk-freetier/include/aws/freetier/FreeTierClient.h index 26a121d4661..201b5231016 100644 --- a/generated/src/aws-cpp-sdk-freetier/include/aws/freetier/FreeTierClient.h +++ b/generated/src/aws-cpp-sdk-freetier/include/aws/freetier/FreeTierClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace FreeTier { */ class AWS_FREETIER_API FreeTierClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public FreeTierPaginationBase { + public FreeTierPaginationBase, + public FreeTierWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-fsx/include/aws/fsx/FSxClient.h b/generated/src/aws-cpp-sdk-fsx/include/aws/fsx/FSxClient.h index 00e7a67ba42..98ef0b5821a 100644 --- a/generated/src/aws-cpp-sdk-fsx/include/aws/fsx/FSxClient.h +++ b/generated/src/aws-cpp-sdk-fsx/include/aws/fsx/FSxClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace FSx { */ class AWS_FSX_API FSxClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public FSxPaginationBase { + public FSxPaginationBase, + public FSxWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-gamelift/include/aws/gamelift/GameLiftClient.h b/generated/src/aws-cpp-sdk-gamelift/include/aws/gamelift/GameLiftClient.h index e4339c0e3ed..7412c4139cd 100644 --- a/generated/src/aws-cpp-sdk-gamelift/include/aws/gamelift/GameLiftClient.h +++ b/generated/src/aws-cpp-sdk-gamelift/include/aws/gamelift/GameLiftClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -57,7 +58,8 @@ namespace GameLift { */ class AWS_GAMELIFT_API GameLiftClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GameLiftPaginationBase { + public GameLiftPaginationBase, + public GameLiftWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsClient.h b/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsClient.h index 4378802f1e0..ca0aca41e6d 100644 --- a/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsClient.h +++ b/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -28,7 +29,8 @@ namespace GameLiftStreams { */ class AWS_GAMELIFTSTREAMS_API GameLiftStreamsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GameLiftStreamsPaginationBase { + public GameLiftStreamsPaginationBase, + public GameLiftStreamsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h b/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h new file mode 100644 index 00000000000..ef46a41c6e1 --- /dev/null +++ b/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h @@ -0,0 +1,131 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace GameLiftStreams { + +template +class GameLiftStreamsWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilApplicationReady(const Model::GetApplicationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("READY"), + [](const Model::GetApplicationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ApplicationStatusMapper::GetNameForApplicationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetApplicationRequest& req) { return static_cast(this)->GetApplication(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, + "WaitUntilApplicationReady"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilApplicationDeleted(const Model::GetApplicationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::GetApplicationRequest& req) { return static_cast(this)->GetApplication(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, + "WaitUntilApplicationDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStreamGroupActive(const Model::GetStreamGroupRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE_WITH_ERRORS"), + [](const Model::GetStreamGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamGroupStatusMapper::GetNameForStreamGroupStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetStreamGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamGroupStatusMapper::GetNameForStreamGroupStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetStreamGroupRequest& req) { return static_cast(this)->GetStreamGroup(req); }; + Aws::Utils::Waiter waiter(30, 120, acceptors, operation, + "WaitUntilStreamGroupActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStreamGroupDeleted(const Model::GetStreamGroupRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::GetStreamGroupRequest& req) { return static_cast(this)->GetStreamGroup(req); }; + Aws::Utils::Waiter waiter(30, 60, acceptors, operation, + "WaitUntilStreamGroupDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStreamSessionActive(const Model::GetStreamSessionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetStreamSessionRequest& req) { return static_cast(this)->GetStreamSession(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, + "WaitUntilStreamSessionActive"); + return waiter.Wait(request); + } +}; +} // namespace GameLiftStreams +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-geo-maps/include/aws/geo-maps/GeoMapsClient.h b/generated/src/aws-cpp-sdk-geo-maps/include/aws/geo-maps/GeoMapsClient.h index 43862430125..df4875c50ab 100644 --- a/generated/src/aws-cpp-sdk-geo-maps/include/aws/geo-maps/GeoMapsClient.h +++ b/generated/src/aws-cpp-sdk-geo-maps/include/aws/geo-maps/GeoMapsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace GeoMaps { */ class AWS_GEOMAPS_API GeoMapsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GeoMapsPaginationBase { + public GeoMapsPaginationBase, + public GeoMapsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-geo-places/include/aws/geo-places/GeoPlacesClient.h b/generated/src/aws-cpp-sdk-geo-places/include/aws/geo-places/GeoPlacesClient.h index 2088be7d8ea..988d84456ce 100644 --- a/generated/src/aws-cpp-sdk-geo-places/include/aws/geo-places/GeoPlacesClient.h +++ b/generated/src/aws-cpp-sdk-geo-places/include/aws/geo-places/GeoPlacesClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace GeoPlaces { */ class AWS_GEOPLACES_API GeoPlacesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GeoPlacesPaginationBase { + public GeoPlacesPaginationBase, + public GeoPlacesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-geo-routes/include/aws/geo-routes/GeoRoutesClient.h b/generated/src/aws-cpp-sdk-geo-routes/include/aws/geo-routes/GeoRoutesClient.h index 39febf4b75c..3fc906d5ab6 100644 --- a/generated/src/aws-cpp-sdk-geo-routes/include/aws/geo-routes/GeoRoutesClient.h +++ b/generated/src/aws-cpp-sdk-geo-routes/include/aws/geo-routes/GeoRoutesClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -28,7 +29,8 @@ namespace GeoRoutes { */ class AWS_GEOROUTES_API GeoRoutesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GeoRoutesPaginationBase { + public GeoRoutesPaginationBase, + public GeoRoutesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierClient.h b/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierClient.h index e7cd1c046c1..1bc474ea991 100644 --- a/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierClient.h +++ b/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -43,7 +44,8 @@ namespace Glacier { */ class AWS_GLACIER_API GlacierClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GlacierPaginationBase { + public GlacierPaginationBase, + public GlacierWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h b/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h new file mode 100644 index 00000000000..25bc0010ece --- /dev/null +++ b/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h @@ -0,0 +1,43 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Glacier { + +template +class GlacierWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilVaultExists(const Model::DescribeVaultRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeVaultRequest& req) { return static_cast(this)->DescribeVault(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilVaultExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVaultNotExists(const Model::DescribeVaultRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeVaultRequest& req) { return static_cast(this)->DescribeVault(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilVaultNotExists"); + return waiter.Wait(request); + } +}; +} // namespace Glacier +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-globalaccelerator/include/aws/globalaccelerator/GlobalAcceleratorClient.h b/generated/src/aws-cpp-sdk-globalaccelerator/include/aws/globalaccelerator/GlobalAcceleratorClient.h index cf508359bb1..910d7b72ab6 100644 --- a/generated/src/aws-cpp-sdk-globalaccelerator/include/aws/globalaccelerator/GlobalAcceleratorClient.h +++ b/generated/src/aws-cpp-sdk-globalaccelerator/include/aws/globalaccelerator/GlobalAcceleratorClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -70,7 +71,8 @@ namespace GlobalAccelerator { */ class AWS_GLOBALACCELERATOR_API GlobalAcceleratorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GlobalAcceleratorPaginationBase { + public GlobalAcceleratorPaginationBase, + public GlobalAcceleratorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-glue/include/aws/glue/GlueClient.h b/generated/src/aws-cpp-sdk-glue/include/aws/glue/GlueClient.h index 5c95526620b..813f79b096a 100644 --- a/generated/src/aws-cpp-sdk-glue/include/aws/glue/GlueClient.h +++ b/generated/src/aws-cpp-sdk-glue/include/aws/glue/GlueClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace Glue { */ class AWS_GLUE_API GlueClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GluePaginationBase { + public GluePaginationBase, + public GlueWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-grafana/include/aws/grafana/ManagedGrafanaClient.h b/generated/src/aws-cpp-sdk-grafana/include/aws/grafana/ManagedGrafanaClient.h index 335db8bbb5e..572d1a2f668 100644 --- a/generated/src/aws-cpp-sdk-grafana/include/aws/grafana/ManagedGrafanaClient.h +++ b/generated/src/aws-cpp-sdk-grafana/include/aws/grafana/ManagedGrafanaClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -27,7 +28,8 @@ namespace ManagedGrafana { */ class AWS_MANAGEDGRAFANA_API ManagedGrafanaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ManagedGrafanaPaginationBase { + public ManagedGrafanaPaginationBase, + public ManagedGrafanaWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-greengrass/include/aws/greengrass/GreengrassClient.h b/generated/src/aws-cpp-sdk-greengrass/include/aws/greengrass/GreengrassClient.h index 217ea193ddf..b58adf42569 100644 --- a/generated/src/aws-cpp-sdk-greengrass/include/aws/greengrass/GreengrassClient.h +++ b/generated/src/aws-cpp-sdk-greengrass/include/aws/greengrass/GreengrassClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace Greengrass { */ class AWS_GREENGRASS_API GreengrassClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GreengrassPaginationBase { + public GreengrassPaginationBase, + public GreengrassWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-greengrassv2/include/aws/greengrassv2/GreengrassV2Client.h b/generated/src/aws-cpp-sdk-greengrassv2/include/aws/greengrassv2/GreengrassV2Client.h index 0ee08702d0b..d04e8961bf0 100644 --- a/generated/src/aws-cpp-sdk-greengrassv2/include/aws/greengrassv2/GreengrassV2Client.h +++ b/generated/src/aws-cpp-sdk-greengrassv2/include/aws/greengrassv2/GreengrassV2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -32,7 +33,8 @@ namespace GreengrassV2 { */ class AWS_GREENGRASSV2_API GreengrassV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GreengrassV2PaginationBase { + public GreengrassV2PaginationBase, + public GreengrassV2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationClient.h b/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationClient.h index d04314767f4..6be0d8d1489 100644 --- a/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationClient.h +++ b/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace GroundStation { */ class AWS_GROUNDSTATION_API GroundStationClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GroundStationPaginationBase { + public GroundStationPaginationBase, + public GroundStationWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h b/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h new file mode 100644 index 00000000000..651684b06d4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h @@ -0,0 +1,45 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace GroundStation { + +template +class GroundStationWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilContactScheduled(const Model::DescribeContactRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED_TO_SCHEDULE"), + [](const Model::DescribeContactOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ContactStatusMapper::GetNameForContactStatus(result.GetContactStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SCHEDULED"), + [](const Model::DescribeContactOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ContactStatusMapper::GetNameForContactStatus(result.GetContactStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeContactRequest& req) { return static_cast(this)->DescribeContact(req); }; + Aws::Utils::Waiter waiter(5, 180, acceptors, operation, + "WaitUntilContactScheduled"); + return waiter.Wait(request); + } +}; +} // namespace GroundStation +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-guardduty/include/aws/guardduty/GuardDutyClient.h b/generated/src/aws-cpp-sdk-guardduty/include/aws/guardduty/GuardDutyClient.h index 11f5028d64f..dd43ba24639 100644 --- a/generated/src/aws-cpp-sdk-guardduty/include/aws/guardduty/GuardDutyClient.h +++ b/generated/src/aws-cpp-sdk-guardduty/include/aws/guardduty/GuardDutyClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -40,7 +41,8 @@ namespace GuardDuty { */ class AWS_GUARDDUTY_API GuardDutyClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public GuardDutyPaginationBase { + public GuardDutyPaginationBase, + public GuardDutyWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-health/include/aws/health/HealthClient.h b/generated/src/aws-cpp-sdk-health/include/aws/health/HealthClient.h index e7d59504514..0911755f228 100644 --- a/generated/src/aws-cpp-sdk-health/include/aws/health/HealthClient.h +++ b/generated/src/aws-cpp-sdk-health/include/aws/health/HealthClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -63,7 +64,8 @@ namespace Health { */ class AWS_HEALTH_API HealthClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public HealthPaginationBase { + public HealthPaginationBase, + public HealthWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeClient.h b/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeClient.h index 9293cceef0e..4fd72df11ac 100644 --- a/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeClient.h +++ b/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace HealthLake { */ class AWS_HEALTHLAKE_API HealthLakeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public HealthLakePaginationBase { + public HealthLakePaginationBase, + public HealthLakeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h b/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h new file mode 100644 index 00000000000..01c6c851498 --- /dev/null +++ b/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h @@ -0,0 +1,159 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace HealthLake { + +template +class HealthLakeWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilFHIRDatastoreActive( + const Model::DescribeFHIRDatastoreRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DatastoreStatusMapper::GetNameForDatastoreStatus( + result.GetDatastoreProperties().GetDatastoreStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DatastoreStatusMapper::GetNameForDatastoreStatus( + result.GetDatastoreProperties().GetDatastoreStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DatastoreStatusMapper::GetNameForDatastoreStatus( + result.GetDatastoreProperties().GetDatastoreStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeFHIRDatastoreRequest& req) { + return static_cast(this)->DescribeFHIRDatastore(req); + }; + Aws::Utils::Waiter waiter(60, 2, acceptors, operation, + "WaitUntilFHIRDatastoreActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFHIRDatastoreDeleted( + const Model::DescribeFHIRDatastoreRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DatastoreStatusMapper::GetNameForDatastoreStatus( + result.GetDatastoreProperties().GetDatastoreStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeFHIRDatastoreRequest& req) { + return static_cast(this)->DescribeFHIRDatastore(req); + }; + Aws::Utils::Waiter waiter(120, 1, acceptors, operation, + "WaitUntilFHIRDatastoreDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFHIRExportJobCompleted( + const Model::DescribeFHIRExportJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_ERRORS"), + [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCEL_COMPLETED"), + [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCEL_FAILED"), + [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeFHIRExportJobRequest& req) { + return static_cast(this)->DescribeFHIRExportJob(req); + }; + Aws::Utils::Waiter waiter(120, 1, acceptors, operation, + "WaitUntilFHIRExportJobCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFHIRImportJobCompleted( + const Model::DescribeFHIRImportJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::DescribeFHIRImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetImportJobProperties().GetJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_ERRORS"), + [](const Model::DescribeFHIRImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetImportJobProperties().GetJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeFHIRImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetImportJobProperties().GetJobStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeFHIRImportJobRequest& req) { + return static_cast(this)->DescribeFHIRImportJob(req); + }; + Aws::Utils::Waiter waiter(120, 1, acceptors, operation, + "WaitUntilFHIRImportJobCompleted"); + return waiter.Wait(request); + } +}; +} // namespace HealthLake +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMClient.h b/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMClient.h index f559e4eb015..b264b3e795d 100644 --- a/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMClient.h +++ b/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -28,7 +29,8 @@ namespace IAM { */ class AWS_IAM_API IAMClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IAMPaginationBase { + public IAMPaginationBase, + public IAMWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h b/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h new file mode 100644 index 00000000000..e45fe1c7d6b --- /dev/null +++ b/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h @@ -0,0 +1,71 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace IAM { + +template +class IAMWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilInstanceProfileExists( + const Model::GetInstanceProfileRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NoSuchEntityException")}); + + auto operation = [this](const Model::GetInstanceProfileRequest& req) { + return static_cast(this)->GetInstanceProfile(req); + }; + Aws::Utils::Waiter waiter(1, 120, acceptors, operation, + "WaitUntilInstanceProfileExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPolicyExists(const Model::GetPolicyRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NoSuchEntity")}); + + auto operation = [this](const Model::GetPolicyRequest& req) { return static_cast(this)->GetPolicy(req); }; + Aws::Utils::Waiter waiter(1, 120, acceptors, operation, "WaitUntilPolicyExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilRoleExists(const Model::GetRoleRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NoSuchEntity")}); + + auto operation = [this](const Model::GetRoleRequest& req) { return static_cast(this)->GetRole(req); }; + Aws::Utils::Waiter waiter(1, 120, acceptors, operation, "WaitUntilRoleExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilUserExists(const Model::GetUserRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NoSuchEntity")}); + + auto operation = [this](const Model::GetUserRequest& req) { return static_cast(this)->GetUser(req); }; + Aws::Utils::Waiter waiter(1, 120, acceptors, operation, "WaitUntilUserExists"); + return waiter.Wait(request); + } +}; +} // namespace IAM +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-identitystore/include/aws/identitystore/IdentityStoreClient.h b/generated/src/aws-cpp-sdk-identitystore/include/aws/identitystore/IdentityStoreClient.h index 0218a596a25..6cf04711b81 100644 --- a/generated/src/aws-cpp-sdk-identitystore/include/aws/identitystore/IdentityStoreClient.h +++ b/generated/src/aws-cpp-sdk-identitystore/include/aws/identitystore/IdentityStoreClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace IdentityStore { */ class AWS_IDENTITYSTORE_API IdentityStoreClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IdentityStorePaginationBase { + public IdentityStorePaginationBase, + public IdentityStoreWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-imagebuilder/include/aws/imagebuilder/ImagebuilderClient.h b/generated/src/aws-cpp-sdk-imagebuilder/include/aws/imagebuilder/ImagebuilderClient.h index 4e80dfe09e5..87b74aab327 100644 --- a/generated/src/aws-cpp-sdk-imagebuilder/include/aws/imagebuilder/ImagebuilderClient.h +++ b/generated/src/aws-cpp-sdk-imagebuilder/include/aws/imagebuilder/ImagebuilderClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace imagebuilder { */ class AWS_IMAGEBUILDER_API ImagebuilderClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ImagebuilderPaginationBase { + public ImagebuilderPaginationBase, + public ImagebuilderWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-importexport/include/aws/importexport/ImportExportClient.h b/generated/src/aws-cpp-sdk-importexport/include/aws/importexport/ImportExportClient.h index e88a55dac88..8beb531b3b4 100644 --- a/generated/src/aws-cpp-sdk-importexport/include/aws/importexport/ImportExportClient.h +++ b/generated/src/aws-cpp-sdk-importexport/include/aws/importexport/ImportExportClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace ImportExport { */ class AWS_IMPORTEXPORT_API ImportExportClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ImportExportPaginationBase { + public ImportExportPaginationBase, + public ImportExportWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-inspector-scan/include/aws/inspector-scan/InspectorscanClient.h b/generated/src/aws-cpp-sdk-inspector-scan/include/aws/inspector-scan/InspectorscanClient.h index 4d632637f4e..1a769a23890 100644 --- a/generated/src/aws-cpp-sdk-inspector-scan/include/aws/inspector-scan/InspectorscanClient.h +++ b/generated/src/aws-cpp-sdk-inspector-scan/include/aws/inspector-scan/InspectorscanClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace inspectorscan { */ class AWS_INSPECTORSCAN_API InspectorscanClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public InspectorscanPaginationBase { + public InspectorscanPaginationBase, + public InspectorscanWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-inspector/include/aws/inspector/InspectorClient.h b/generated/src/aws-cpp-sdk-inspector/include/aws/inspector/InspectorClient.h index 1f71f5ca019..145feabc5f4 100644 --- a/generated/src/aws-cpp-sdk-inspector/include/aws/inspector/InspectorClient.h +++ b/generated/src/aws-cpp-sdk-inspector/include/aws/inspector/InspectorClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace Inspector { */ class AWS_INSPECTOR_API InspectorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public InspectorPaginationBase { + public InspectorPaginationBase, + public InspectorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-inspector2/include/aws/inspector2/Inspector2Client.h b/generated/src/aws-cpp-sdk-inspector2/include/aws/inspector2/Inspector2Client.h index 58fbbecfbfc..4f9384a4f3b 100644 --- a/generated/src/aws-cpp-sdk-inspector2/include/aws/inspector2/Inspector2Client.h +++ b/generated/src/aws-cpp-sdk-inspector2/include/aws/inspector2/Inspector2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace Inspector2 { */ class AWS_INSPECTOR2_API Inspector2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Inspector2PaginationBase { + public Inspector2PaginationBase, + public Inspector2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-internetmonitor/include/aws/internetmonitor/InternetMonitorClient.h b/generated/src/aws-cpp-sdk-internetmonitor/include/aws/internetmonitor/InternetMonitorClient.h index e7abaadd1ae..00667118dc6 100644 --- a/generated/src/aws-cpp-sdk-internetmonitor/include/aws/internetmonitor/InternetMonitorClient.h +++ b/generated/src/aws-cpp-sdk-internetmonitor/include/aws/internetmonitor/InternetMonitorClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -45,7 +46,8 @@ namespace InternetMonitor { */ class AWS_INTERNETMONITOR_API InternetMonitorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public InternetMonitorPaginationBase { + public InternetMonitorPaginationBase, + public InternetMonitorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-invoicing/include/aws/invoicing/InvoicingClient.h b/generated/src/aws-cpp-sdk-invoicing/include/aws/invoicing/InvoicingClient.h index 99b0425ada7..d83ff9ef532 100644 --- a/generated/src/aws-cpp-sdk-invoicing/include/aws/invoicing/InvoicingClient.h +++ b/generated/src/aws-cpp-sdk-invoicing/include/aws/invoicing/InvoicingClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -64,7 +65,8 @@ namespace Invoicing { */ class AWS_INVOICING_API InvoicingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public InvoicingPaginationBase { + public InvoicingPaginationBase, + public InvoicingWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iot-data/include/aws/iot-data/IoTDataPlaneClient.h b/generated/src/aws-cpp-sdk-iot-data/include/aws/iot-data/IoTDataPlaneClient.h index 3d27410f85e..3650543ba70 100644 --- a/generated/src/aws-cpp-sdk-iot-data/include/aws/iot-data/IoTDataPlaneClient.h +++ b/generated/src/aws-cpp-sdk-iot-data/include/aws/iot-data/IoTDataPlaneClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace IoTDataPlane { */ class AWS_IOTDATAPLANE_API IoTDataPlaneClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTDataPlanePaginationBase { + public IoTDataPlanePaginationBase, + public IoTDataPlaneWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iot-jobs-data/include/aws/iot-jobs-data/IoTJobsDataPlaneClient.h b/generated/src/aws-cpp-sdk-iot-jobs-data/include/aws/iot-jobs-data/IoTJobsDataPlaneClient.h index 9f6589c46a2..888f570d597 100644 --- a/generated/src/aws-cpp-sdk-iot-jobs-data/include/aws/iot-jobs-data/IoTJobsDataPlaneClient.h +++ b/generated/src/aws-cpp-sdk-iot-jobs-data/include/aws/iot-jobs-data/IoTJobsDataPlaneClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -37,7 +38,8 @@ namespace IoTJobsDataPlane { */ class AWS_IOTJOBSDATAPLANE_API IoTJobsDataPlaneClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTJobsDataPlanePaginationBase { + public IoTJobsDataPlanePaginationBase, + public IoTJobsDataPlaneWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iot-managed-integrations/include/aws/iot-managed-integrations/IoTManagedIntegrationsClient.h b/generated/src/aws-cpp-sdk-iot-managed-integrations/include/aws/iot-managed-integrations/IoTManagedIntegrationsClient.h index 90828c500f5..6bcced20311 100644 --- a/generated/src/aws-cpp-sdk-iot-managed-integrations/include/aws/iot-managed-integrations/IoTManagedIntegrationsClient.h +++ b/generated/src/aws-cpp-sdk-iot-managed-integrations/include/aws/iot-managed-integrations/IoTManagedIntegrationsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace IoTManagedIntegrations { class AWS_IOTMANAGEDINTEGRATIONS_API IoTManagedIntegrationsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTManagedIntegrationsPaginationBase { + public IoTManagedIntegrationsPaginationBase, + public IoTManagedIntegrationsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iot/include/aws/iot/IoTClient.h b/generated/src/aws-cpp-sdk-iot/include/aws/iot/IoTClient.h index d13d06644a1..f73a2e90f45 100644 --- a/generated/src/aws-cpp-sdk-iot/include/aws/iot/IoTClient.h +++ b/generated/src/aws-cpp-sdk-iot/include/aws/iot/IoTClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -38,7 +39,8 @@ namespace IoT { */ class AWS_IOT_API IoTClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTPaginationBase { + public IoTPaginationBase, + public IoTWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iotdeviceadvisor/include/aws/iotdeviceadvisor/IoTDeviceAdvisorClient.h b/generated/src/aws-cpp-sdk-iotdeviceadvisor/include/aws/iotdeviceadvisor/IoTDeviceAdvisorClient.h index cb0e1781c0d..e1f7a1ee34d 100644 --- a/generated/src/aws-cpp-sdk-iotdeviceadvisor/include/aws/iotdeviceadvisor/IoTDeviceAdvisorClient.h +++ b/generated/src/aws-cpp-sdk-iotdeviceadvisor/include/aws/iotdeviceadvisor/IoTDeviceAdvisorClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace IoTDeviceAdvisor { */ class AWS_IOTDEVICEADVISOR_API IoTDeviceAdvisorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTDeviceAdvisorPaginationBase { + public IoTDeviceAdvisorPaginationBase, + public IoTDeviceAdvisorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iotevents-data/include/aws/iotevents-data/IoTEventsDataClient.h b/generated/src/aws-cpp-sdk-iotevents-data/include/aws/iotevents-data/IoTEventsDataClient.h index 3fcf2b15914..5f4ca68e795 100644 --- a/generated/src/aws-cpp-sdk-iotevents-data/include/aws/iotevents-data/IoTEventsDataClient.h +++ b/generated/src/aws-cpp-sdk-iotevents-data/include/aws/iotevents-data/IoTEventsDataClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace IoTEventsData { */ class AWS_IOTEVENTSDATA_API IoTEventsDataClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTEventsDataPaginationBase { + public IoTEventsDataPaginationBase, + public IoTEventsDataWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iotevents/include/aws/iotevents/IoTEventsClient.h b/generated/src/aws-cpp-sdk-iotevents/include/aws/iotevents/IoTEventsClient.h index ed3d0c9f5c0..be0a00dbcc7 100644 --- a/generated/src/aws-cpp-sdk-iotevents/include/aws/iotevents/IoTEventsClient.h +++ b/generated/src/aws-cpp-sdk-iotevents/include/aws/iotevents/IoTEventsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace IoTEvents { */ class AWS_IOTEVENTS_API IoTEventsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTEventsPaginationBase { + public IoTEventsPaginationBase, + public IoTEventsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iotfleetwise/include/aws/iotfleetwise/IoTFleetWiseClient.h b/generated/src/aws-cpp-sdk-iotfleetwise/include/aws/iotfleetwise/IoTFleetWiseClient.h index 3a4149c4c3a..28f3e207ee8 100644 --- a/generated/src/aws-cpp-sdk-iotfleetwise/include/aws/iotfleetwise/IoTFleetWiseClient.h +++ b/generated/src/aws-cpp-sdk-iotfleetwise/include/aws/iotfleetwise/IoTFleetWiseClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -31,7 +32,8 @@ namespace IoTFleetWise { */ class AWS_IOTFLEETWISE_API IoTFleetWiseClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTFleetWisePaginationBase { + public IoTFleetWisePaginationBase, + public IoTFleetWiseWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iotsecuretunneling/include/aws/iotsecuretunneling/IoTSecureTunnelingClient.h b/generated/src/aws-cpp-sdk-iotsecuretunneling/include/aws/iotsecuretunneling/IoTSecureTunnelingClient.h index 7c1af9447ac..05d6f3d4702 100644 --- a/generated/src/aws-cpp-sdk-iotsecuretunneling/include/aws/iotsecuretunneling/IoTSecureTunnelingClient.h +++ b/generated/src/aws-cpp-sdk-iotsecuretunneling/include/aws/iotsecuretunneling/IoTSecureTunnelingClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace IoTSecureTunneling { */ class AWS_IOTSECURETUNNELING_API IoTSecureTunnelingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTSecureTunnelingPaginationBase { + public IoTSecureTunnelingPaginationBase, + public IoTSecureTunnelingWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseClient.h b/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseClient.h index 4b1a601d445..31a81ca7877 100644 --- a/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseClient.h +++ b/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -27,7 +28,8 @@ namespace IoTSiteWise { */ class AWS_IOTSITEWISE_API IoTSiteWiseClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTSiteWisePaginationBase { + public IoTSiteWisePaginationBase, + public IoTSiteWiseWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h b/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h new file mode 100644 index 00000000000..0c44c02ec2a --- /dev/null +++ b/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h @@ -0,0 +1,125 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace IoTSiteWise { + +template +class IoTSiteWiseWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilAssetActive(const Model::DescribeAssetRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeAssetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AssetStateMapper::GetNameForAssetState(result.GetAssetStatus().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeAssetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AssetStateMapper::GetNameForAssetState(result.GetAssetStatus().GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeAssetRequest& req) { return static_cast(this)->DescribeAsset(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilAssetActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilAssetNotExists(const Model::DescribeAssetRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeAssetRequest& req) { return static_cast(this)->DescribeAsset(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilAssetNotExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilAssetModelActive(const Model::DescribeAssetModelRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeAssetModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AssetModelStateMapper::GetNameForAssetModelState(result.GetAssetModelStatus().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeAssetModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AssetModelStateMapper::GetNameForAssetModelState(result.GetAssetModelStatus().GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeAssetModelRequest& req) { + return static_cast(this)->DescribeAssetModel(req); + }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilAssetModelActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilAssetModelNotExists( + const Model::DescribeAssetModelRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeAssetModelRequest& req) { + return static_cast(this)->DescribeAssetModel(req); + }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilAssetModelNotExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPortalActive(const Model::DescribePortalRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribePortalOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PortalStateMapper::GetNameForPortalState(result.GetPortalStatus().GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribePortalRequest& req) { return static_cast(this)->DescribePortal(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilPortalActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPortalNotExists(const Model::DescribePortalRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribePortalRequest& req) { return static_cast(this)->DescribePortal(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilPortalNotExists"); + return waiter.Wait(request); + } +}; +} // namespace IoTSiteWise +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iotthingsgraph/include/aws/iotthingsgraph/IoTThingsGraphClient.h b/generated/src/aws-cpp-sdk-iotthingsgraph/include/aws/iotthingsgraph/IoTThingsGraphClient.h index 450c44fbb23..1f761ed499c 100644 --- a/generated/src/aws-cpp-sdk-iotthingsgraph/include/aws/iotthingsgraph/IoTThingsGraphClient.h +++ b/generated/src/aws-cpp-sdk-iotthingsgraph/include/aws/iotthingsgraph/IoTThingsGraphClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -27,7 +28,8 @@ namespace IoTThingsGraph { */ class AWS_IOTTHINGSGRAPH_API IoTThingsGraphClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTThingsGraphPaginationBase { + public IoTThingsGraphPaginationBase, + public IoTThingsGraphWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iottwinmaker/include/aws/iottwinmaker/IoTTwinMakerClient.h b/generated/src/aws-cpp-sdk-iottwinmaker/include/aws/iottwinmaker/IoTTwinMakerClient.h index a40891bd71e..86a247e63a6 100644 --- a/generated/src/aws-cpp-sdk-iottwinmaker/include/aws/iottwinmaker/IoTTwinMakerClient.h +++ b/generated/src/aws-cpp-sdk-iottwinmaker/include/aws/iottwinmaker/IoTTwinMakerClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace IoTTwinMaker { */ class AWS_IOTTWINMAKER_API IoTTwinMakerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTTwinMakerPaginationBase { + public IoTTwinMakerPaginationBase, + public IoTTwinMakerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-iotwireless/include/aws/iotwireless/IoTWirelessClient.h b/generated/src/aws-cpp-sdk-iotwireless/include/aws/iotwireless/IoTWirelessClient.h index c618300bba4..e5ea083e9f3 100644 --- a/generated/src/aws-cpp-sdk-iotwireless/include/aws/iotwireless/IoTWirelessClient.h +++ b/generated/src/aws-cpp-sdk-iotwireless/include/aws/iotwireless/IoTWirelessClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -41,7 +42,8 @@ namespace IoTWireless { */ class AWS_IOTWIRELESS_API IoTWirelessClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IoTWirelessPaginationBase { + public IoTWirelessPaginationBase, + public IoTWirelessWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ivs-realtime/include/aws/ivs-realtime/IvsrealtimeClient.h b/generated/src/aws-cpp-sdk-ivs-realtime/include/aws/ivs-realtime/IvsrealtimeClient.h index 202fee743ca..397aa049143 100644 --- a/generated/src/aws-cpp-sdk-ivs-realtime/include/aws/ivs-realtime/IvsrealtimeClient.h +++ b/generated/src/aws-cpp-sdk-ivs-realtime/include/aws/ivs-realtime/IvsrealtimeClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -60,7 +61,8 @@ namespace ivsrealtime { */ class AWS_IVSREALTIME_API IvsrealtimeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IvsrealtimePaginationBase { + public IvsrealtimePaginationBase, + public IvsrealtimeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ivs/include/aws/ivs/IVSClient.h b/generated/src/aws-cpp-sdk-ivs/include/aws/ivs/IVSClient.h index ffe40447fe5..4097be55468 100644 --- a/generated/src/aws-cpp-sdk-ivs/include/aws/ivs/IVSClient.h +++ b/generated/src/aws-cpp-sdk-ivs/include/aws/ivs/IVSClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -96,7 +97,8 @@ namespace IVS { */ class AWS_IVS_API IVSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IVSPaginationBase { + public IVSPaginationBase, + public IVSWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ivschat/include/aws/ivschat/IvschatClient.h b/generated/src/aws-cpp-sdk-ivschat/include/aws/ivschat/IvschatClient.h index 3d09d5dc1dc..5b463fe5c05 100644 --- a/generated/src/aws-cpp-sdk-ivschat/include/aws/ivschat/IvschatClient.h +++ b/generated/src/aws-cpp-sdk-ivschat/include/aws/ivschat/IvschatClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -90,7 +91,8 @@ namespace ivschat { */ class AWS_IVSCHAT_API IvschatClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public IvschatPaginationBase { + public IvschatPaginationBase, + public IvschatWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kafka/include/aws/kafka/KafkaClient.h b/generated/src/aws-cpp-sdk-kafka/include/aws/kafka/KafkaClient.h index 8477d1686cd..1c011f6c85e 100644 --- a/generated/src/aws-cpp-sdk-kafka/include/aws/kafka/KafkaClient.h +++ b/generated/src/aws-cpp-sdk-kafka/include/aws/kafka/KafkaClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace Kafka { */ class AWS_KAFKA_API KafkaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KafkaPaginationBase { + public KafkaPaginationBase, + public KafkaWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kafkaconnect/include/aws/kafkaconnect/KafkaConnectClient.h b/generated/src/aws-cpp-sdk-kafkaconnect/include/aws/kafkaconnect/KafkaConnectClient.h index 5b2361584b5..f44592200b8 100644 --- a/generated/src/aws-cpp-sdk-kafkaconnect/include/aws/kafkaconnect/KafkaConnectClient.h +++ b/generated/src/aws-cpp-sdk-kafkaconnect/include/aws/kafkaconnect/KafkaConnectClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace KafkaConnect { */ class AWS_KAFKACONNECT_API KafkaConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KafkaConnectPaginationBase { + public KafkaConnectPaginationBase, + public KafkaConnectWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kendra-ranking/include/aws/kendra-ranking/KendraRankingClient.h b/generated/src/aws-cpp-sdk-kendra-ranking/include/aws/kendra-ranking/KendraRankingClient.h index 907be98a093..1e4276e6ca3 100644 --- a/generated/src/aws-cpp-sdk-kendra-ranking/include/aws/kendra-ranking/KendraRankingClient.h +++ b/generated/src/aws-cpp-sdk-kendra-ranking/include/aws/kendra-ranking/KendraRankingClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace KendraRanking { */ class AWS_KENDRARANKING_API KendraRankingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KendraRankingPaginationBase { + public KendraRankingPaginationBase, + public KendraRankingWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kendra/include/aws/kendra/KendraClient.h b/generated/src/aws-cpp-sdk-kendra/include/aws/kendra/KendraClient.h index 37170b53398..c3e633ef039 100644 --- a/generated/src/aws-cpp-sdk-kendra/include/aws/kendra/KendraClient.h +++ b/generated/src/aws-cpp-sdk-kendra/include/aws/kendra/KendraClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace kendra { */ class AWS_KENDRA_API KendraClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KendraPaginationBase { + public KendraPaginationBase, + public KendraWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-keyspaces/include/aws/keyspaces/KeyspacesClient.h b/generated/src/aws-cpp-sdk-keyspaces/include/aws/keyspaces/KeyspacesClient.h index 1de7c6469d6..f0e99533973 100644 --- a/generated/src/aws-cpp-sdk-keyspaces/include/aws/keyspaces/KeyspacesClient.h +++ b/generated/src/aws-cpp-sdk-keyspaces/include/aws/keyspaces/KeyspacesClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -41,7 +42,8 @@ namespace Keyspaces { */ class AWS_KEYSPACES_API KeyspacesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KeyspacesPaginationBase { + public KeyspacesPaginationBase, + public KeyspacesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-keyspacesstreams/include/aws/keyspacesstreams/KeyspacesStreamsClient.h b/generated/src/aws-cpp-sdk-keyspacesstreams/include/aws/keyspacesstreams/KeyspacesStreamsClient.h index 09d2ecd0dc5..7c50c130c87 100644 --- a/generated/src/aws-cpp-sdk-keyspacesstreams/include/aws/keyspacesstreams/KeyspacesStreamsClient.h +++ b/generated/src/aws-cpp-sdk-keyspacesstreams/include/aws/keyspacesstreams/KeyspacesStreamsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -38,7 +39,8 @@ namespace KeyspacesStreams { */ class AWS_KEYSPACESSTREAMS_API KeyspacesStreamsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KeyspacesStreamsPaginationBase { + public KeyspacesStreamsPaginationBase, + public KeyspacesStreamsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kinesis-video-archived-media/include/aws/kinesis-video-archived-media/KinesisVideoArchivedMediaClient.h b/generated/src/aws-cpp-sdk-kinesis-video-archived-media/include/aws/kinesis-video-archived-media/KinesisVideoArchivedMediaClient.h index 15d415bba57..ba688514e0b 100644 --- a/generated/src/aws-cpp-sdk-kinesis-video-archived-media/include/aws/kinesis-video-archived-media/KinesisVideoArchivedMediaClient.h +++ b/generated/src/aws-cpp-sdk-kinesis-video-archived-media/include/aws/kinesis-video-archived-media/KinesisVideoArchivedMediaClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace KinesisVideoArchivedMedia { class AWS_KINESISVIDEOARCHIVEDMEDIA_API KinesisVideoArchivedMediaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KinesisVideoArchivedMediaPaginationBase { + public KinesisVideoArchivedMediaPaginationBase, + public KinesisVideoArchivedMediaWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kinesis-video-media/include/aws/kinesis-video-media/KinesisVideoMediaClient.h b/generated/src/aws-cpp-sdk-kinesis-video-media/include/aws/kinesis-video-media/KinesisVideoMediaClient.h index 9b1e65fc5f9..b71f03253dd 100644 --- a/generated/src/aws-cpp-sdk-kinesis-video-media/include/aws/kinesis-video-media/KinesisVideoMediaClient.h +++ b/generated/src/aws-cpp-sdk-kinesis-video-media/include/aws/kinesis-video-media/KinesisVideoMediaClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace KinesisVideoMedia { */ class AWS_KINESISVIDEOMEDIA_API KinesisVideoMediaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KinesisVideoMediaPaginationBase { + public KinesisVideoMediaPaginationBase, + public KinesisVideoMediaWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kinesis-video-signaling/include/aws/kinesis-video-signaling/KinesisVideoSignalingChannelsClient.h b/generated/src/aws-cpp-sdk-kinesis-video-signaling/include/aws/kinesis-video-signaling/KinesisVideoSignalingChannelsClient.h index a23b64403ff..3803c1f5d94 100644 --- a/generated/src/aws-cpp-sdk-kinesis-video-signaling/include/aws/kinesis-video-signaling/KinesisVideoSignalingChannelsClient.h +++ b/generated/src/aws-cpp-sdk-kinesis-video-signaling/include/aws/kinesis-video-signaling/KinesisVideoSignalingChannelsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace KinesisVideoSignalingChannels { class AWS_KINESISVIDEOSIGNALINGCHANNELS_API KinesisVideoSignalingChannelsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KinesisVideoSignalingChannelsPaginationBase { + public KinesisVideoSignalingChannelsPaginationBase, + public KinesisVideoSignalingChannelsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kinesis-video-webrtc-storage/include/aws/kinesis-video-webrtc-storage/KinesisVideoWebRTCStorageClient.h b/generated/src/aws-cpp-sdk-kinesis-video-webrtc-storage/include/aws/kinesis-video-webrtc-storage/KinesisVideoWebRTCStorageClient.h index b0a3f00cde8..d4df62f973f 100644 --- a/generated/src/aws-cpp-sdk-kinesis-video-webrtc-storage/include/aws/kinesis-video-webrtc-storage/KinesisVideoWebRTCStorageClient.h +++ b/generated/src/aws-cpp-sdk-kinesis-video-webrtc-storage/include/aws/kinesis-video-webrtc-storage/KinesisVideoWebRTCStorageClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace KinesisVideoWebRTCStorage { class AWS_KINESISVIDEOWEBRTCSTORAGE_API KinesisVideoWebRTCStorageClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KinesisVideoWebRTCStoragePaginationBase { + public KinesisVideoWebRTCStoragePaginationBase, + public KinesisVideoWebRTCStorageWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisClient.h b/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisClient.h index 047f148b6bb..b21c0abb566 100644 --- a/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisClient.h +++ b/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace Kinesis { */ class AWS_KINESIS_API KinesisClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KinesisPaginationBase { + public KinesisPaginationBase, + public KinesisWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h b/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h new file mode 100644 index 00000000000..9125b0f0b4d --- /dev/null +++ b/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h @@ -0,0 +1,48 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Kinesis { + +template +class KinesisWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilStreamExists(const Model::DescribeStreamRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeStreamOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamStatusMapper::GetNameForStreamStatus(result.GetStreamDescription().GetStreamStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeStreamRequest& req) { return static_cast(this)->DescribeStream(req); }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilStreamExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilStreamNotExists(const Model::DescribeStreamRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeStreamRequest& req) { return static_cast(this)->DescribeStream(req); }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilStreamNotExists"); + return waiter.Wait(request); + } +}; +} // namespace Kinesis +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kinesisanalytics/include/aws/kinesisanalytics/KinesisAnalyticsClient.h b/generated/src/aws-cpp-sdk-kinesisanalytics/include/aws/kinesisanalytics/KinesisAnalyticsClient.h index a6028d9aee5..bfcabdf2331 100644 --- a/generated/src/aws-cpp-sdk-kinesisanalytics/include/aws/kinesisanalytics/KinesisAnalyticsClient.h +++ b/generated/src/aws-cpp-sdk-kinesisanalytics/include/aws/kinesisanalytics/KinesisAnalyticsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace KinesisAnalytics { */ class AWS_KINESISANALYTICS_API KinesisAnalyticsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KinesisAnalyticsPaginationBase { + public KinesisAnalyticsPaginationBase, + public KinesisAnalyticsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kinesisanalyticsv2/include/aws/kinesisanalyticsv2/KinesisAnalyticsV2Client.h b/generated/src/aws-cpp-sdk-kinesisanalyticsv2/include/aws/kinesisanalyticsv2/KinesisAnalyticsV2Client.h index 2386aca1862..a3ae9e17b89 100644 --- a/generated/src/aws-cpp-sdk-kinesisanalyticsv2/include/aws/kinesisanalyticsv2/KinesisAnalyticsV2Client.h +++ b/generated/src/aws-cpp-sdk-kinesisanalyticsv2/include/aws/kinesisanalyticsv2/KinesisAnalyticsV2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace KinesisAnalyticsV2 { */ class AWS_KINESISANALYTICSV2_API KinesisAnalyticsV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KinesisAnalyticsV2PaginationBase { + public KinesisAnalyticsV2PaginationBase, + public KinesisAnalyticsV2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideoClient.h b/generated/src/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideoClient.h index 7f584c311af..0007d35624e 100644 --- a/generated/src/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideoClient.h +++ b/generated/src/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideoClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace KinesisVideo { */ class AWS_KINESISVIDEO_API KinesisVideoClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KinesisVideoPaginationBase { + public KinesisVideoPaginationBase, + public KinesisVideoWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-kms/include/aws/kms/KMSClient.h b/generated/src/aws-cpp-sdk-kms/include/aws/kms/KMSClient.h index 9fdb441bb5e..a449ca19bf4 100644 --- a/generated/src/aws-cpp-sdk-kms/include/aws/kms/KMSClient.h +++ b/generated/src/aws-cpp-sdk-kms/include/aws/kms/KMSClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -84,7 +85,8 @@ namespace KMS { */ class AWS_KMS_API KMSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public KMSPaginationBase { + public KMSPaginationBase, + public KMSWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-lakeformation/include/aws/lakeformation/LakeFormationClient.h b/generated/src/aws-cpp-sdk-lakeformation/include/aws/lakeformation/LakeFormationClient.h index d23bf017cb3..50a90f7bca5 100644 --- a/generated/src/aws-cpp-sdk-lakeformation/include/aws/lakeformation/LakeFormationClient.h +++ b/generated/src/aws-cpp-sdk-lakeformation/include/aws/lakeformation/LakeFormationClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace LakeFormation { */ class AWS_LAKEFORMATION_API LakeFormationClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LakeFormationPaginationBase { + public LakeFormationPaginationBase, + public LakeFormationWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaClient.h b/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaClient.h index 2c7e4e5712e..8663f8c6f16 100644 --- a/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaClient.h +++ b/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -70,7 +71,8 @@ namespace Lambda { */ class AWS_LAMBDA_API LambdaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LambdaPaginationBase { + public LambdaPaginationBase, + public LambdaWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h b/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h new file mode 100644 index 00000000000..68700c143c7 --- /dev/null +++ b/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h @@ -0,0 +1,185 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Lambda { + +template +class LambdaWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilFunctionActiveV2(const Model::GetFunctionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Active"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetConfiguration().GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetConfiguration().GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Pending"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetConfiguration().GetState()) == expected.get(); + }}); + + auto operation = [this](const Model::GetFunctionRequest& req) { return static_cast(this)->GetFunction(req); }; + Aws::Utils::Waiter waiter(1, 300, acceptors, operation, + "WaitUntilFunctionActiveV2"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFunctionExists(const Model::GetFunctionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::GetFunctionRequest& req) { return static_cast(this)->GetFunction(req); }; + Aws::Utils::Waiter waiter(1, 20, acceptors, operation, "WaitUntilFunctionExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFunctionUpdatedV2(const Model::GetFunctionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Successful"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus( + result.GetConfiguration().GetLastUpdateStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus( + result.GetConfiguration().GetLastUpdateStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("InProgress"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus( + result.GetConfiguration().GetLastUpdateStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetFunctionRequest& req) { return static_cast(this)->GetFunction(req); }; + Aws::Utils::Waiter waiter(1, 300, acceptors, operation, + "WaitUntilFunctionUpdatedV2"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFunctionActive( + const Model::GetFunctionConfigurationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Active"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Pending"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + }}); + + auto operation = [this](const Model::GetFunctionConfigurationRequest& req) { + return static_cast(this)->GetFunctionConfiguration(req); + }; + Aws::Utils::Waiter waiter(5, 60, acceptors, operation, + "WaitUntilFunctionActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFunctionUpdated( + const Model::GetFunctionConfigurationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Successful"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetLastUpdateStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetLastUpdateStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("InProgress"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetLastUpdateStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetFunctionConfigurationRequest& req) { + return static_cast(this)->GetFunctionConfiguration(req); + }; + Aws::Utils::Waiter waiter(5, 60, acceptors, operation, + "WaitUntilFunctionUpdated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPublishedVersionActive( + const Model::GetFunctionConfigurationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Active"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Pending"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + }}); + + auto operation = [this](const Model::GetFunctionConfigurationRequest& req) { + return static_cast(this)->GetFunctionConfiguration(req); + }; + Aws::Utils::Waiter waiter( + 5, 312, acceptors, operation, "WaitUntilPublishedVersionActive"); + return waiter.Wait(request); + } +}; +} // namespace Lambda +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-launch-wizard/include/aws/launch-wizard/LaunchWizardClient.h b/generated/src/aws-cpp-sdk-launch-wizard/include/aws/launch-wizard/LaunchWizardClient.h index 8dcaf8a26cc..2a687739fab 100644 --- a/generated/src/aws-cpp-sdk-launch-wizard/include/aws/launch-wizard/LaunchWizardClient.h +++ b/generated/src/aws-cpp-sdk-launch-wizard/include/aws/launch-wizard/LaunchWizardClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace LaunchWizard { */ class AWS_LAUNCHWIZARD_API LaunchWizardClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LaunchWizardPaginationBase { + public LaunchWizardPaginationBase, + public LaunchWizardWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-lex-models/include/aws/lex-models/LexModelBuildingServiceClient.h b/generated/src/aws-cpp-sdk-lex-models/include/aws/lex-models/LexModelBuildingServiceClient.h index efa428cd6e9..3fc8f9c8a37 100644 --- a/generated/src/aws-cpp-sdk-lex-models/include/aws/lex-models/LexModelBuildingServiceClient.h +++ b/generated/src/aws-cpp-sdk-lex-models/include/aws/lex-models/LexModelBuildingServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace LexModelBuildingService { class AWS_LEXMODELBUILDINGSERVICE_API LexModelBuildingServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LexModelBuildingServicePaginationBase { + public LexModelBuildingServicePaginationBase, + public LexModelBuildingServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-lex/include/aws/lex/LexRuntimeServiceClient.h b/generated/src/aws-cpp-sdk-lex/include/aws/lex/LexRuntimeServiceClient.h index 0488baa4eea..5ed1a4e5fcb 100644 --- a/generated/src/aws-cpp-sdk-lex/include/aws/lex/LexRuntimeServiceClient.h +++ b/generated/src/aws-cpp-sdk-lex/include/aws/lex/LexRuntimeServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace LexRuntimeService { */ class AWS_LEXRUNTIMESERVICE_API LexRuntimeServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LexRuntimeServicePaginationBase { + public LexRuntimeServicePaginationBase, + public LexRuntimeServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Client.h b/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Client.h index b2bbbcd8b94..2b8098c2be6 100644 --- a/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Client.h +++ b/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace LexModelsV2 { */ class AWS_LEXMODELSV2_API LexModelsV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LexModelsV2PaginationBase { + public LexModelsV2PaginationBase, + public LexModelsV2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h b/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h new file mode 100644 index 00000000000..41d6d1516d3 --- /dev/null +++ b/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h @@ -0,0 +1,321 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace LexModelsV2 { + +template +class LexModelsV2Waiter { + public: + Aws::Utils::WaiterOutcome WaitUntilBotAvailable(const Model::DescribeBotRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Available"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Inactive"), + [](const Model::DescribeBotOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeBotRequest& req) { return static_cast(this)->DescribeBot(req); }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, "WaitUntilBotAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilBotAliasAvailable(const Model::DescribeBotAliasRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Available"), + [](const Model::DescribeBotAliasOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotAliasStatusMapper::GetNameForBotAliasStatus(result.GetBotAliasStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeBotAliasOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotAliasStatusMapper::GetNameForBotAliasStatus(result.GetBotAliasStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), + [](const Model::DescribeBotAliasOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotAliasStatusMapper::GetNameForBotAliasStatus(result.GetBotAliasStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeBotAliasRequest& req) { return static_cast(this)->DescribeBotAlias(req); }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilBotAliasAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilBotLocaleBuilt(const Model::DescribeBotLocaleRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Built"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("NotBuilt"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeBotLocaleRequest& req) { + return static_cast(this)->DescribeBotLocale(req); + }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilBotLocaleBuilt"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilBotLocaleCreated(const Model::DescribeBotLocaleRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Built"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ReadyExpressTesting"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("NotBuilt"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeBotLocaleRequest& req) { + return static_cast(this)->DescribeBotLocale(req); + }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilBotLocaleCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilBotLocaleExpressTestingAvailable( + const Model::DescribeBotLocaleRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Built"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ReadyExpressTesting"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("NotBuilt"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeBotLocaleRequest& req) { + return static_cast(this)->DescribeBotLocale(req); + }; + Aws::Utils::Waiter waiter( + 10, 12, acceptors, operation, "WaitUntilBotLocaleExpressTestingAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilBotVersionAvailable( + const Model::DescribeBotVersionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Available"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeBotVersionRequest& req) { + return static_cast(this)->DescribeBotVersion(req); + }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilBotVersionAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilBotExportCompleted(const Model::DescribeExportRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), + [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), + [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeExportRequest& req) { return static_cast(this)->DescribeExport(req); }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilBotExportCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilBotImportCompleted(const Model::DescribeImportRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeImportRequest& req) { return static_cast(this)->DescribeImport(req); }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilBotImportCompleted"); + return waiter.Wait(request); + } +}; +} // namespace LexModelsV2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-lexv2-runtime/include/aws/lexv2-runtime/LexRuntimeV2Client.h b/generated/src/aws-cpp-sdk-lexv2-runtime/include/aws/lexv2-runtime/LexRuntimeV2Client.h index a04edf7feb7..a7beaee2caf 100644 --- a/generated/src/aws-cpp-sdk-lexv2-runtime/include/aws/lexv2-runtime/LexRuntimeV2Client.h +++ b/generated/src/aws-cpp-sdk-lexv2-runtime/include/aws/lexv2-runtime/LexRuntimeV2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace LexRuntimeV2 { */ class AWS_LEXRUNTIMEV2_API LexRuntimeV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LexRuntimeV2PaginationBase { + public LexRuntimeV2PaginationBase, + public LexRuntimeV2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-license-manager-linux-subscriptions/include/aws/license-manager-linux-subscriptions/LicenseManagerLinuxSubscriptionsClient.h b/generated/src/aws-cpp-sdk-license-manager-linux-subscriptions/include/aws/license-manager-linux-subscriptions/LicenseManagerLinuxSubscriptionsClient.h index a4d981dd3d1..5871374fb9c 100644 --- a/generated/src/aws-cpp-sdk-license-manager-linux-subscriptions/include/aws/license-manager-linux-subscriptions/LicenseManagerLinuxSubscriptionsClient.h +++ b/generated/src/aws-cpp-sdk-license-manager-linux-subscriptions/include/aws/license-manager-linux-subscriptions/LicenseManagerLinuxSubscriptionsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace LicenseManagerLinuxSubscriptions { class AWS_LICENSEMANAGERLINUXSUBSCRIPTIONS_API LicenseManagerLinuxSubscriptionsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LicenseManagerLinuxSubscriptionsPaginationBase { + public LicenseManagerLinuxSubscriptionsPaginationBase, + public LicenseManagerLinuxSubscriptionsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-license-manager-user-subscriptions/include/aws/license-manager-user-subscriptions/LicenseManagerUserSubscriptionsClient.h b/generated/src/aws-cpp-sdk-license-manager-user-subscriptions/include/aws/license-manager-user-subscriptions/LicenseManagerUserSubscriptionsClient.h index dc1019a0a87..e5f2933b97b 100644 --- a/generated/src/aws-cpp-sdk-license-manager-user-subscriptions/include/aws/license-manager-user-subscriptions/LicenseManagerUserSubscriptionsClient.h +++ b/generated/src/aws-cpp-sdk-license-manager-user-subscriptions/include/aws/license-manager-user-subscriptions/LicenseManagerUserSubscriptionsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace LicenseManagerUserSubscriptions { class AWS_LICENSEMANAGERUSERSUBSCRIPTIONS_API LicenseManagerUserSubscriptionsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LicenseManagerUserSubscriptionsPaginationBase { + public LicenseManagerUserSubscriptionsPaginationBase, + public LicenseManagerUserSubscriptionsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-license-manager/include/aws/license-manager/LicenseManagerClient.h b/generated/src/aws-cpp-sdk-license-manager/include/aws/license-manager/LicenseManagerClient.h index b2693389d95..ad11dd8f27d 100644 --- a/generated/src/aws-cpp-sdk-license-manager/include/aws/license-manager/LicenseManagerClient.h +++ b/generated/src/aws-cpp-sdk-license-manager/include/aws/license-manager/LicenseManagerClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace LicenseManager { */ class AWS_LICENSEMANAGER_API LicenseManagerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LicenseManagerPaginationBase { + public LicenseManagerPaginationBase, + public LicenseManagerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-lightsail/include/aws/lightsail/LightsailClient.h b/generated/src/aws-cpp-sdk-lightsail/include/aws/lightsail/LightsailClient.h index 1359ad97f9b..274e22986b7 100644 --- a/generated/src/aws-cpp-sdk-lightsail/include/aws/lightsail/LightsailClient.h +++ b/generated/src/aws-cpp-sdk-lightsail/include/aws/lightsail/LightsailClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -36,7 +37,8 @@ namespace Lightsail { */ class AWS_LIGHTSAIL_API LightsailClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LightsailPaginationBase { + public LightsailPaginationBase, + public LightsailWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-location/include/aws/location/LocationServiceClient.h b/generated/src/aws-cpp-sdk-location/include/aws/location/LocationServiceClient.h index fb86c11dbed..0863ab7eda7 100644 --- a/generated/src/aws-cpp-sdk-location/include/aws/location/LocationServiceClient.h +++ b/generated/src/aws-cpp-sdk-location/include/aws/location/LocationServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace LocationService { */ class AWS_LOCATIONSERVICE_API LocationServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LocationServicePaginationBase { + public LocationServicePaginationBase, + public LocationServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-logs/include/aws/logs/CloudWatchLogsClient.h b/generated/src/aws-cpp-sdk-logs/include/aws/logs/CloudWatchLogsClient.h index 7fc80bb8b72..4ad182a46f2 100644 --- a/generated/src/aws-cpp-sdk-logs/include/aws/logs/CloudWatchLogsClient.h +++ b/generated/src/aws-cpp-sdk-logs/include/aws/logs/CloudWatchLogsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -43,7 +44,8 @@ namespace CloudWatchLogs { */ class AWS_CLOUDWATCHLOGS_API CloudWatchLogsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudWatchLogsPaginationBase { + public CloudWatchLogsPaginationBase, + public CloudWatchLogsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-lookoutequipment/include/aws/lookoutequipment/LookoutEquipmentClient.h b/generated/src/aws-cpp-sdk-lookoutequipment/include/aws/lookoutequipment/LookoutEquipmentClient.h index cd3be441872..05a2d73ae8e 100644 --- a/generated/src/aws-cpp-sdk-lookoutequipment/include/aws/lookoutequipment/LookoutEquipmentClient.h +++ b/generated/src/aws-cpp-sdk-lookoutequipment/include/aws/lookoutequipment/LookoutEquipmentClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace LookoutEquipment { */ class AWS_LOOKOUTEQUIPMENT_API LookoutEquipmentClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public LookoutEquipmentPaginationBase { + public LookoutEquipmentPaginationBase, + public LookoutEquipmentWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-m2/include/aws/m2/MainframeModernizationClient.h b/generated/src/aws-cpp-sdk-m2/include/aws/m2/MainframeModernizationClient.h index fe3d7e2f951..330e674bfad 100644 --- a/generated/src/aws-cpp-sdk-m2/include/aws/m2/MainframeModernizationClient.h +++ b/generated/src/aws-cpp-sdk-m2/include/aws/m2/MainframeModernizationClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace MainframeModernization { class AWS_MAINFRAMEMODERNIZATION_API MainframeModernizationClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MainframeModernizationPaginationBase { + public MainframeModernizationPaginationBase, + public MainframeModernizationWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningClient.h b/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningClient.h index dddba46e271..4c2af282827 100644 --- a/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningClient.h +++ b/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace MachineLearning { */ class AWS_MACHINELEARNING_API MachineLearningClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MachineLearningPaginationBase { + public MachineLearningPaginationBase, + public MachineLearningWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h b/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h new file mode 100644 index 00000000000..69574a5a4c5 --- /dev/null +++ b/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h @@ -0,0 +1,137 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace MachineLearning { + +template +class MachineLearningWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilBatchPredictionAvailable( + const Model::DescribeBatchPredictionsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeBatchPredictionsRequest& req) { + return static_cast(this)->DescribeBatchPredictions(req); + }; + Aws::Utils::Waiter waiter( + 30, 4, acceptors, operation, "WaitUntilBatchPredictionAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilDataSourceAvailable( + const Model::DescribeDataSourcesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeDataSourcesRequest& req) { + return static_cast(this)->DescribeDataSources(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilDataSourceAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilEvaluationAvailable( + const Model::DescribeEvaluationsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeEvaluationsRequest& req) { + return static_cast(this)->DescribeEvaluations(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilEvaluationAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilMLModelAvailable(const Model::DescribeMLModelsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeMLModelsRequest& req) { return static_cast(this)->DescribeMLModels(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilMLModelAvailable"); + return waiter.Wait(request); + } +}; +} // namespace MachineLearning +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Client.h b/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Client.h index 58ddd193014..46570ff7c52 100644 --- a/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Client.h +++ b/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace Macie2 { */ class AWS_MACIE2_API Macie2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Macie2PaginationBase { + public Macie2PaginationBase, + public Macie2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h b/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h new file mode 100644 index 00000000000..1f254192860 --- /dev/null +++ b/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h @@ -0,0 +1,48 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Macie2 { + +template +class Macie2Waiter { + public: + Aws::Utils::WaiterOutcome WaitUntilFindingRevealed( + const Model::GetSensitiveDataOccurrencesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCESS"), + [](const Model::GetSensitiveDataOccurrencesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RevealRequestStatusMapper::GetNameForRevealRequestStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetSensitiveDataOccurrencesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RevealRequestStatusMapper::GetNameForRevealRequestStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetSensitiveDataOccurrencesRequest& req) { + return static_cast(this)->GetSensitiveDataOccurrences(req); + }; + Aws::Utils::Waiter waiter( + 2, 60, acceptors, operation, "WaitUntilFindingRevealed"); + return waiter.Wait(request); + } +}; +} // namespace Macie2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mailmanager/include/aws/mailmanager/MailManagerClient.h b/generated/src/aws-cpp-sdk-mailmanager/include/aws/mailmanager/MailManagerClient.h index ae6ded34fd2..55bf8bb7434 100644 --- a/generated/src/aws-cpp-sdk-mailmanager/include/aws/mailmanager/MailManagerClient.h +++ b/generated/src/aws-cpp-sdk-mailmanager/include/aws/mailmanager/MailManagerClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -27,7 +28,8 @@ namespace MailManager { */ class AWS_MAILMANAGER_API MailManagerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MailManagerPaginationBase { + public MailManagerPaginationBase, + public MailManagerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-managedblockchain-query/include/aws/managedblockchain-query/ManagedBlockchainQueryClient.h b/generated/src/aws-cpp-sdk-managedblockchain-query/include/aws/managedblockchain-query/ManagedBlockchainQueryClient.h index 571f0d0a1fb..db41c68ac36 100644 --- a/generated/src/aws-cpp-sdk-managedblockchain-query/include/aws/managedblockchain-query/ManagedBlockchainQueryClient.h +++ b/generated/src/aws-cpp-sdk-managedblockchain-query/include/aws/managedblockchain-query/ManagedBlockchainQueryClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -28,7 +29,8 @@ namespace ManagedBlockchainQuery { class AWS_MANAGEDBLOCKCHAINQUERY_API ManagedBlockchainQueryClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ManagedBlockchainQueryPaginationBase { + public ManagedBlockchainQueryPaginationBase, + public ManagedBlockchainQueryWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-managedblockchain/include/aws/managedblockchain/ManagedBlockchainClient.h b/generated/src/aws-cpp-sdk-managedblockchain/include/aws/managedblockchain/ManagedBlockchainClient.h index 7da90f29310..d1b46df804b 100644 --- a/generated/src/aws-cpp-sdk-managedblockchain/include/aws/managedblockchain/ManagedBlockchainClient.h +++ b/generated/src/aws-cpp-sdk-managedblockchain/include/aws/managedblockchain/ManagedBlockchainClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace ManagedBlockchain { */ class AWS_MANAGEDBLOCKCHAIN_API ManagedBlockchainClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ManagedBlockchainPaginationBase { + public ManagedBlockchainPaginationBase, + public ManagedBlockchainWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-marketplace-agreement/include/aws/marketplace-agreement/AgreementServiceClient.h b/generated/src/aws-cpp-sdk-marketplace-agreement/include/aws/marketplace-agreement/AgreementServiceClient.h index b2538616d2a..d0ebf34eabb 100644 --- a/generated/src/aws-cpp-sdk-marketplace-agreement/include/aws/marketplace-agreement/AgreementServiceClient.h +++ b/generated/src/aws-cpp-sdk-marketplace-agreement/include/aws/marketplace-agreement/AgreementServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -32,7 +33,8 @@ namespace AgreementService { */ class AWS_AGREEMENTSERVICE_API AgreementServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AgreementServicePaginationBase { + public AgreementServicePaginationBase, + public AgreementServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-marketplace-catalog/include/aws/marketplace-catalog/MarketplaceCatalogClient.h b/generated/src/aws-cpp-sdk-marketplace-catalog/include/aws/marketplace-catalog/MarketplaceCatalogClient.h index ba05f66ec3c..24e821a4451 100644 --- a/generated/src/aws-cpp-sdk-marketplace-catalog/include/aws/marketplace-catalog/MarketplaceCatalogClient.h +++ b/generated/src/aws-cpp-sdk-marketplace-catalog/include/aws/marketplace-catalog/MarketplaceCatalogClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace MarketplaceCatalog { */ class AWS_MARKETPLACECATALOG_API MarketplaceCatalogClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MarketplaceCatalogPaginationBase { + public MarketplaceCatalogPaginationBase, + public MarketplaceCatalogWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-marketplace-deployment/include/aws/marketplace-deployment/MarketplaceDeploymentClient.h b/generated/src/aws-cpp-sdk-marketplace-deployment/include/aws/marketplace-deployment/MarketplaceDeploymentClient.h index e58ede6651c..add558abf13 100644 --- a/generated/src/aws-cpp-sdk-marketplace-deployment/include/aws/marketplace-deployment/MarketplaceDeploymentClient.h +++ b/generated/src/aws-cpp-sdk-marketplace-deployment/include/aws/marketplace-deployment/MarketplaceDeploymentClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace MarketplaceDeployment { class AWS_MARKETPLACEDEPLOYMENT_API MarketplaceDeploymentClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MarketplaceDeploymentPaginationBase { + public MarketplaceDeploymentPaginationBase, + public MarketplaceDeploymentWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-marketplace-entitlement/include/aws/marketplace-entitlement/MarketplaceEntitlementServiceClient.h b/generated/src/aws-cpp-sdk-marketplace-entitlement/include/aws/marketplace-entitlement/MarketplaceEntitlementServiceClient.h index a068f25a34d..d3b17d8306a 100644 --- a/generated/src/aws-cpp-sdk-marketplace-entitlement/include/aws/marketplace-entitlement/MarketplaceEntitlementServiceClient.h +++ b/generated/src/aws-cpp-sdk-marketplace-entitlement/include/aws/marketplace-entitlement/MarketplaceEntitlementServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -28,7 +29,8 @@ namespace MarketplaceEntitlementService { class AWS_MARKETPLACEENTITLEMENTSERVICE_API MarketplaceEntitlementServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MarketplaceEntitlementServicePaginationBase { + public MarketplaceEntitlementServicePaginationBase, + public MarketplaceEntitlementServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-marketplace-reporting/include/aws/marketplace-reporting/MarketplaceReportingClient.h b/generated/src/aws-cpp-sdk-marketplace-reporting/include/aws/marketplace-reporting/MarketplaceReportingClient.h index 43c8982201d..c6778cdfa5c 100644 --- a/generated/src/aws-cpp-sdk-marketplace-reporting/include/aws/marketplace-reporting/MarketplaceReportingClient.h +++ b/generated/src/aws-cpp-sdk-marketplace-reporting/include/aws/marketplace-reporting/MarketplaceReportingClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -70,7 +71,8 @@ namespace MarketplaceReporting { class AWS_MARKETPLACEREPORTING_API MarketplaceReportingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MarketplaceReportingPaginationBase { + public MarketplaceReportingPaginationBase, + public MarketplaceReportingWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-marketplacecommerceanalytics/include/aws/marketplacecommerceanalytics/MarketplaceCommerceAnalyticsClient.h b/generated/src/aws-cpp-sdk-marketplacecommerceanalytics/include/aws/marketplacecommerceanalytics/MarketplaceCommerceAnalyticsClient.h index c6c865c5558..8d0098b564a 100644 --- a/generated/src/aws-cpp-sdk-marketplacecommerceanalytics/include/aws/marketplacecommerceanalytics/MarketplaceCommerceAnalyticsClient.h +++ b/generated/src/aws-cpp-sdk-marketplacecommerceanalytics/include/aws/marketplacecommerceanalytics/MarketplaceCommerceAnalyticsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace MarketplaceCommerceAnalytics { class AWS_MARKETPLACECOMMERCEANALYTICS_API MarketplaceCommerceAnalyticsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MarketplaceCommerceAnalyticsPaginationBase { + public MarketplaceCommerceAnalyticsPaginationBase, + public MarketplaceCommerceAnalyticsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectClient.h b/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectClient.h index 33c24f5e0fd..0653043a6ac 100644 --- a/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectClient.h +++ b/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -35,7 +36,8 @@ namespace MediaConnect { */ class AWS_MEDIACONNECT_API MediaConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MediaConnectPaginationBase { + public MediaConnectPaginationBase, + public MediaConnectWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h b/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h new file mode 100644 index 00000000000..57d50fb1769 --- /dev/null +++ b/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h @@ -0,0 +1,378 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace MediaConnect { + +template +class MediaConnectWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilFlowActive(const Model::DescribeFlowRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STANDBY"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeFlowRequest& req) { return static_cast(this)->DescribeFlow(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, "WaitUntilFlowActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFlowDeleted(const Model::DescribeFlowRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("NotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeFlowRequest& req) { return static_cast(this)->DescribeFlow(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, "WaitUntilFlowDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilFlowStandby(const Model::DescribeFlowRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STANDBY"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeFlowRequest& req) { return static_cast(this)->DescribeFlow(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, "WaitUntilFlowStandby"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInputStandby(const Model::GetRouterInputRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STANDBY"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetRouterInputRequest& req) { return static_cast(this)->GetRouterInput(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilInputStandby"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInputDeleted(const Model::GetRouterInputRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("NotFoundException")}); + + auto operation = [this](const Model::GetRouterInputRequest& req) { return static_cast(this)->GetRouterInput(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilInputDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInputActive(const Model::GetRouterInputRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("MIGRATING"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetRouterInputRequest& req) { return static_cast(this)->GetRouterInput(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilInputActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilOutputUnrouted(const Model::GetRouterOutputRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UNROUTED"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState( + result.GetRouterOutput().GetRoutedState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("ROUTING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState( + result.GetRouterOutput().GetRoutedState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + + auto operation = [this](const Model::GetRouterOutputRequest& req) { return static_cast(this)->GetRouterOutput(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilOutputUnrouted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilOutputDeleted(const Model::GetRouterOutputRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("NotFoundException")}); + + auto operation = [this](const Model::GetRouterOutputRequest& req) { return static_cast(this)->GetRouterOutput(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilOutputDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilOutputActive(const Model::GetRouterOutputRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("MIGRATING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetRouterOutputRequest& req) { return static_cast(this)->GetRouterOutput(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilOutputActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilOutputStandby(const Model::GetRouterOutputRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STANDBY"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetRouterOutputRequest& req) { return static_cast(this)->GetRouterOutput(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilOutputStandby"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilOutputRouted(const Model::GetRouterOutputRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ROUTED"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState( + result.GetRouterOutput().GetRoutedState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("ROUTING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState( + result.GetRouterOutput().GetRoutedState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + + auto operation = [this](const Model::GetRouterOutputRequest& req) { return static_cast(this)->GetRouterOutput(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilOutputRouted"); + return waiter.Wait(request); + } +}; +} // namespace MediaConnect +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mediaconvert/include/aws/mediaconvert/MediaConvertClient.h b/generated/src/aws-cpp-sdk-mediaconvert/include/aws/mediaconvert/MediaConvertClient.h index a3faeb065ae..fcc196433a6 100644 --- a/generated/src/aws-cpp-sdk-mediaconvert/include/aws/mediaconvert/MediaConvertClient.h +++ b/generated/src/aws-cpp-sdk-mediaconvert/include/aws/mediaconvert/MediaConvertClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace MediaConvert { */ class AWS_MEDIACONVERT_API MediaConvertClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MediaConvertPaginationBase { + public MediaConvertPaginationBase, + public MediaConvertWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveClient.h b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveClient.h index 65ed4cd2665..5e1ed7662e6 100644 --- a/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveClient.h +++ b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace MediaLive { */ class AWS_MEDIALIVE_API MediaLiveClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MediaLivePaginationBase { + public MediaLivePaginationBase, + public MediaLiveWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h new file mode 100644 index 00000000000..07b6395e3d8 --- /dev/null +++ b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h @@ -0,0 +1,643 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace MediaLive { + +template +class MediaLiveWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilChannelCreated(const Model::DescribeChannelRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("IDLE"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeChannelRequest& req) { return static_cast(this)->DescribeChannel(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilChannelCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilChannelDeleted(const Model::DescribeChannelRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeChannelRequest& req) { return static_cast(this)->DescribeChannel(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilChannelDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilChannelRunning(const Model::DescribeChannelRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeChannelRequest& req) { return static_cast(this)->DescribeChannel(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilChannelRunning"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilChannelStopped(const Model::DescribeChannelRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("IDLE"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeChannelRequest& req) { return static_cast(this)->DescribeChannel(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilChannelStopped"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilChannelPlacementGroupAssigned( + const Model::DescribeChannelPlacementGroupRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ASSIGNED"), + [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("ASSIGNING"), + [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeChannelPlacementGroupRequest& req) { + return static_cast(this)->DescribeChannelPlacementGroup(req); + }; + Aws::Utils::Waiter waiter( + 3, 40, acceptors, operation, "WaitUntilChannelPlacementGroupAssigned"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilChannelPlacementGroupDeleted( + const Model::DescribeChannelPlacementGroupRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeChannelPlacementGroupRequest& req) { + return static_cast(this)->DescribeChannelPlacementGroup(req); + }; + Aws::Utils::Waiter waiter( + 5, 24, acceptors, operation, "WaitUntilChannelPlacementGroupDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilChannelPlacementGroupUnassigned( + const Model::DescribeChannelPlacementGroupRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UNASSIGNED"), + [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UNASSIGNING"), + [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeChannelPlacementGroupRequest& req) { + return static_cast(this)->DescribeChannelPlacementGroup(req); + }; + Aws::Utils::Waiter waiter( + 5, 24, acceptors, operation, "WaitUntilChannelPlacementGroupUnassigned"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilClusterCreated(const Model::DescribeClusterRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilClusterCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClusterRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilClusterDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInputAttached(const Model::DescribeInputRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ATTACHED"), + [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DETACHED"), + [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeInputRequest& req) { return static_cast(this)->DescribeInput(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilInputAttached"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInputDeleted(const Model::DescribeInputRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeInputRequest& req) { return static_cast(this)->DescribeInput(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilInputDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilInputDetached(const Model::DescribeInputRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DETACHED"), + [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("ATTACHED"), + [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeInputRequest& req) { return static_cast(this)->DescribeInput(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilInputDetached"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilMultiplexCreated(const Model::DescribeMultiplexRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("IDLE"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeMultiplexRequest& req) { + return static_cast(this)->DescribeMultiplex(req); + }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilMultiplexCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilMultiplexDeleted(const Model::DescribeMultiplexRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeMultiplexRequest& req) { + return static_cast(this)->DescribeMultiplex(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilMultiplexDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilMultiplexRunning(const Model::DescribeMultiplexRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeMultiplexRequest& req) { + return static_cast(this)->DescribeMultiplex(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilMultiplexRunning"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilMultiplexStopped(const Model::DescribeMultiplexRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("IDLE"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeMultiplexRequest& req) { + return static_cast(this)->DescribeMultiplex(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilMultiplexStopped"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilNodeDeregistered(const Model::DescribeNodeRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DEREGISTERED"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DEREGISTERING"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DRAINING"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeNodeRequest& req) { return static_cast(this)->DescribeNode(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilNodeDeregistered"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilNodeRegistered(const Model::DescribeNodeRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("REGISTERING"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REGISTRATION_FAILED"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); + + auto operation = [this](const Model::DescribeNodeRequest& req) { return static_cast(this)->DescribeNode(req); }; + Aws::Utils::Waiter waiter(3, 40, acceptors, operation, + "WaitUntilNodeRegistered"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSignalMapCreated(const Model::GetSignalMapRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_IN_PROGRESS"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetSignalMapRequest& req) { return static_cast(this)->GetSignalMap(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilSignalMapCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSignalMapMonitorDeleted(const Model::GetSignalMapRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_COMPLETE"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_IN_PROGRESS"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetSignalMapRequest& req) { return static_cast(this)->GetSignalMap(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilSignalMapMonitorDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSignalMapMonitorDeployed(const Model::GetSignalMapRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DRY_RUN_DEPLOYMENT_COMPLETE"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYMENT_COMPLETE"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DRY_RUN_DEPLOYMENT_IN_PROGRESS"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYMENT_IN_PROGRESS"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DRY_RUN_DEPLOYMENT_FAILED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYMENT_FAILED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetSignalMapRequest& req) { return static_cast(this)->GetSignalMap(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilSignalMapMonitorDeployed"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSignalMapUpdated(const Model::GetSignalMapRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_COMPLETE"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_IN_PROGRESS"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_REVERTED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetSignalMapRequest& req) { return static_cast(this)->GetSignalMap(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilSignalMapUpdated"); + return waiter.Wait(request); + } +}; +} // namespace MediaLive +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mediapackage-vod/include/aws/mediapackage-vod/MediaPackageVodClient.h b/generated/src/aws-cpp-sdk-mediapackage-vod/include/aws/mediapackage-vod/MediaPackageVodClient.h index 1fe99675c51..baf02c26683 100644 --- a/generated/src/aws-cpp-sdk-mediapackage-vod/include/aws/mediapackage-vod/MediaPackageVodClient.h +++ b/generated/src/aws-cpp-sdk-mediapackage-vod/include/aws/mediapackage-vod/MediaPackageVodClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace MediaPackageVod { */ class AWS_MEDIAPACKAGEVOD_API MediaPackageVodClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MediaPackageVodPaginationBase { + public MediaPackageVodPaginationBase, + public MediaPackageVodWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mediapackage/include/aws/mediapackage/MediaPackageClient.h b/generated/src/aws-cpp-sdk-mediapackage/include/aws/mediapackage/MediaPackageClient.h index 9c04e0b82c3..2f46c4e1baa 100644 --- a/generated/src/aws-cpp-sdk-mediapackage/include/aws/mediapackage/MediaPackageClient.h +++ b/generated/src/aws-cpp-sdk-mediapackage/include/aws/mediapackage/MediaPackageClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace MediaPackage { */ class AWS_MEDIAPACKAGE_API MediaPackageClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MediaPackagePaginationBase { + public MediaPackagePaginationBase, + public MediaPackageWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Client.h b/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Client.h index 1619f1a13ad..1279eea4ae7 100644 --- a/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Client.h +++ b/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -37,7 +38,8 @@ namespace mediapackagev2 { */ class AWS_MEDIAPACKAGEV2_API Mediapackagev2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Mediapackagev2PaginationBase { + public Mediapackagev2PaginationBase, + public Mediapackagev2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h b/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h new file mode 100644 index 00000000000..fa139ae7dd1 --- /dev/null +++ b/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h @@ -0,0 +1,66 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace mediapackagev2 { + +template +class Mediapackagev2Waiter { + public: + Aws::Utils::WaiterOutcome WaitUntilHarvestJobFinished(const Model::GetHarvestJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("QUEUED"), + [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), + [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetHarvestJobRequest& req) { return static_cast(this)->GetHarvestJob(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, + "WaitUntilHarvestJobFinished"); + return waiter.Wait(request); + } +}; +} // namespace mediapackagev2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mediastore-data/include/aws/mediastore-data/MediaStoreDataClient.h b/generated/src/aws-cpp-sdk-mediastore-data/include/aws/mediastore-data/MediaStoreDataClient.h index 2373cffa543..df0809b3e74 100644 --- a/generated/src/aws-cpp-sdk-mediastore-data/include/aws/mediastore-data/MediaStoreDataClient.h +++ b/generated/src/aws-cpp-sdk-mediastore-data/include/aws/mediastore-data/MediaStoreDataClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace MediaStoreData { */ class AWS_MEDIASTOREDATA_API MediaStoreDataClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MediaStoreDataPaginationBase { + public MediaStoreDataPaginationBase, + public MediaStoreDataWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreClient.h b/generated/src/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreClient.h index 398bdbc39e7..0a8754cfdad 100644 --- a/generated/src/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreClient.h +++ b/generated/src/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace MediaStore { */ class AWS_MEDIASTORE_API MediaStoreClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MediaStorePaginationBase { + public MediaStorePaginationBase, + public MediaStoreWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mediatailor/include/aws/mediatailor/MediaTailorClient.h b/generated/src/aws-cpp-sdk-mediatailor/include/aws/mediatailor/MediaTailorClient.h index 4a5233843b0..c9c0ff2c8b8 100644 --- a/generated/src/aws-cpp-sdk-mediatailor/include/aws/mediatailor/MediaTailorClient.h +++ b/generated/src/aws-cpp-sdk-mediatailor/include/aws/mediatailor/MediaTailorClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace MediaTailor { */ class AWS_MEDIATAILOR_API MediaTailorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MediaTailorPaginationBase { + public MediaTailorPaginationBase, + public MediaTailorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-medical-imaging/include/aws/medical-imaging/MedicalImagingClient.h b/generated/src/aws-cpp-sdk-medical-imaging/include/aws/medical-imaging/MedicalImagingClient.h index 7a060014d38..fe081239ea1 100644 --- a/generated/src/aws-cpp-sdk-medical-imaging/include/aws/medical-imaging/MedicalImagingClient.h +++ b/generated/src/aws-cpp-sdk-medical-imaging/include/aws/medical-imaging/MedicalImagingClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace MedicalImaging { */ class AWS_MEDICALIMAGING_API MedicalImagingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MedicalImagingPaginationBase { + public MedicalImagingPaginationBase, + public MedicalImagingWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-memorydb/include/aws/memorydb/MemoryDBClient.h b/generated/src/aws-cpp-sdk-memorydb/include/aws/memorydb/MemoryDBClient.h index 64039f3d12e..bfd19060fe6 100644 --- a/generated/src/aws-cpp-sdk-memorydb/include/aws/memorydb/MemoryDBClient.h +++ b/generated/src/aws-cpp-sdk-memorydb/include/aws/memorydb/MemoryDBClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace MemoryDB { */ class AWS_MEMORYDB_API MemoryDBClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MemoryDBPaginationBase { + public MemoryDBPaginationBase, + public MemoryDBWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-meteringmarketplace/include/aws/meteringmarketplace/MarketplaceMeteringClient.h b/generated/src/aws-cpp-sdk-meteringmarketplace/include/aws/meteringmarketplace/MarketplaceMeteringClient.h index 4b8bd02fc39..7d417c5ae8b 100644 --- a/generated/src/aws-cpp-sdk-meteringmarketplace/include/aws/meteringmarketplace/MarketplaceMeteringClient.h +++ b/generated/src/aws-cpp-sdk-meteringmarketplace/include/aws/meteringmarketplace/MarketplaceMeteringClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -83,7 +84,8 @@ namespace MarketplaceMetering { */ class AWS_MARKETPLACEMETERING_API MarketplaceMeteringClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MarketplaceMeteringPaginationBase { + public MarketplaceMeteringPaginationBase, + public MarketplaceMeteringWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mgn/include/aws/mgn/MgnClient.h b/generated/src/aws-cpp-sdk-mgn/include/aws/mgn/MgnClient.h index 09292fda7fc..bf6272a661e 100644 --- a/generated/src/aws-cpp-sdk-mgn/include/aws/mgn/MgnClient.h +++ b/generated/src/aws-cpp-sdk-mgn/include/aws/mgn/MgnClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace mgn { */ class AWS_MGN_API MgnClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MgnPaginationBase { + public MgnPaginationBase, + public MgnWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-migration-hub-refactor-spaces/include/aws/migration-hub-refactor-spaces/MigrationHubRefactorSpacesClient.h b/generated/src/aws-cpp-sdk-migration-hub-refactor-spaces/include/aws/migration-hub-refactor-spaces/MigrationHubRefactorSpacesClient.h index 2f56062e2da..85bf8516887 100644 --- a/generated/src/aws-cpp-sdk-migration-hub-refactor-spaces/include/aws/migration-hub-refactor-spaces/MigrationHubRefactorSpacesClient.h +++ b/generated/src/aws-cpp-sdk-migration-hub-refactor-spaces/include/aws/migration-hub-refactor-spaces/MigrationHubRefactorSpacesClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -32,7 +33,8 @@ namespace MigrationHubRefactorSpaces { class AWS_MIGRATIONHUBREFACTORSPACES_API MigrationHubRefactorSpacesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MigrationHubRefactorSpacesPaginationBase { + public MigrationHubRefactorSpacesPaginationBase, + public MigrationHubRefactorSpacesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-migrationhub-config/include/aws/migrationhub-config/MigrationHubConfigClient.h b/generated/src/aws-cpp-sdk-migrationhub-config/include/aws/migrationhub-config/MigrationHubConfigClient.h index e1412b9ffa8..23dc0652803 100644 --- a/generated/src/aws-cpp-sdk-migrationhub-config/include/aws/migrationhub-config/MigrationHubConfigClient.h +++ b/generated/src/aws-cpp-sdk-migrationhub-config/include/aws/migrationhub-config/MigrationHubConfigClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace MigrationHubConfig { */ class AWS_MIGRATIONHUBCONFIG_API MigrationHubConfigClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MigrationHubConfigPaginationBase { + public MigrationHubConfigPaginationBase, + public MigrationHubConfigWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-migrationhuborchestrator/include/aws/migrationhuborchestrator/MigrationHubOrchestratorClient.h b/generated/src/aws-cpp-sdk-migrationhuborchestrator/include/aws/migrationhuborchestrator/MigrationHubOrchestratorClient.h index 800afb6d139..dde2c2bb74b 100644 --- a/generated/src/aws-cpp-sdk-migrationhuborchestrator/include/aws/migrationhuborchestrator/MigrationHubOrchestratorClient.h +++ b/generated/src/aws-cpp-sdk-migrationhuborchestrator/include/aws/migrationhuborchestrator/MigrationHubOrchestratorClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace MigrationHubOrchestrator { class AWS_MIGRATIONHUBORCHESTRATOR_API MigrationHubOrchestratorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MigrationHubOrchestratorPaginationBase { + public MigrationHubOrchestratorPaginationBase, + public MigrationHubOrchestratorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-migrationhubstrategy/include/aws/migrationhubstrategy/MigrationHubStrategyRecommendationsClient.h b/generated/src/aws-cpp-sdk-migrationhubstrategy/include/aws/migrationhubstrategy/MigrationHubStrategyRecommendationsClient.h index ccfc6e56f42..c4f1c40a341 100644 --- a/generated/src/aws-cpp-sdk-migrationhubstrategy/include/aws/migrationhubstrategy/MigrationHubStrategyRecommendationsClient.h +++ b/generated/src/aws-cpp-sdk-migrationhubstrategy/include/aws/migrationhubstrategy/MigrationHubStrategyRecommendationsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -27,7 +28,8 @@ namespace MigrationHubStrategyRecommendations { class AWS_MIGRATIONHUBSTRATEGYRECOMMENDATIONS_API MigrationHubStrategyRecommendationsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MigrationHubStrategyRecommendationsPaginationBase { + public MigrationHubStrategyRecommendationsPaginationBase, + public MigrationHubStrategyRecommendationsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchClient.h b/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchClient.h index bc893ef506e..cb3a693b2c0 100644 --- a/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchClient.h +++ b/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchClient.h @@ -8,7 +8,9 @@ #include #include #include +#include #include +#include #include namespace Aws { @@ -29,7 +31,9 @@ namespace CloudWatch { * operational health.

*/ class AWS_CLOUDWATCH_API CloudWatchClient : public Aws::Client::AWSRpcV2CborClient, - public Aws::Client::ClientWithAsyncTemplateMethods { + public Aws::Client::ClientWithAsyncTemplateMethods, + public CloudWatchPaginationBase, + public CloudWatchWaiter { public: typedef Aws::Client::AWSRpcV2CborClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h b/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h new file mode 100644 index 00000000000..bc8dc3ca072 --- /dev/null +++ b/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h @@ -0,0 +1,64 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace CloudWatch { + +template +class CloudWatchWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilAlarmExists(const Model::DescribeAlarmsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeAlarmsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetMetricAlarms().size() > 0) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeAlarmsRequest& req) { return static_cast(this)->DescribeAlarms(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilAlarmExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilCompositeAlarmExists(const Model::DescribeAlarmsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeAlarmsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetCompositeAlarms().size() > 0) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeAlarmsRequest& req) { return static_cast(this)->DescribeAlarms(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilCompositeAlarmExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilAlarmMuteRuleExists(const Model::GetAlarmMuteRuleRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::GetAlarmMuteRuleRequest& req) { return static_cast(this)->GetAlarmMuteRule(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilAlarmMuteRuleExists"); + return waiter.Wait(request); + } +}; +} // namespace CloudWatch +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mpa/include/aws/mpa/MPAClient.h b/generated/src/aws-cpp-sdk-mpa/include/aws/mpa/MPAClient.h index 94ab9103dc9..2f542eae1f8 100644 --- a/generated/src/aws-cpp-sdk-mpa/include/aws/mpa/MPAClient.h +++ b/generated/src/aws-cpp-sdk-mpa/include/aws/mpa/MPAClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -32,7 +33,8 @@ namespace MPA { */ class AWS_MPA_API MPAClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MPAPaginationBase { + public MPAPaginationBase, + public MPAWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mq/include/aws/mq/MQClient.h b/generated/src/aws-cpp-sdk-mq/include/aws/mq/MQClient.h index 8c2faa82f91..dc56027cc6c 100644 --- a/generated/src/aws-cpp-sdk-mq/include/aws/mq/MQClient.h +++ b/generated/src/aws-cpp-sdk-mq/include/aws/mq/MQClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace MQ { */ class AWS_MQ_API MQClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MQPaginationBase { + public MQPaginationBase, + public MQWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mturk-requester/include/aws/mturk-requester/MTurkClient.h b/generated/src/aws-cpp-sdk-mturk-requester/include/aws/mturk-requester/MTurkClient.h index 35d83a5414c..6c7bf4d8f06 100644 --- a/generated/src/aws-cpp-sdk-mturk-requester/include/aws/mturk-requester/MTurkClient.h +++ b/generated/src/aws-cpp-sdk-mturk-requester/include/aws/mturk-requester/MTurkClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace MTurk { */ class AWS_MTURK_API MTurkClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MTurkPaginationBase { + public MTurkPaginationBase, + public MTurkWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mwaa-serverless/include/aws/mwaa-serverless/MWAAServerlessClient.h b/generated/src/aws-cpp-sdk-mwaa-serverless/include/aws/mwaa-serverless/MWAAServerlessClient.h index 80892948ed4..bfc0f6d1134 100644 --- a/generated/src/aws-cpp-sdk-mwaa-serverless/include/aws/mwaa-serverless/MWAAServerlessClient.h +++ b/generated/src/aws-cpp-sdk-mwaa-serverless/include/aws/mwaa-serverless/MWAAServerlessClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace MWAAServerless { */ class AWS_MWAASERVERLESS_API MWAAServerlessClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MWAAServerlessPaginationBase { + public MWAAServerlessPaginationBase, + public MWAAServerlessWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-mwaa/include/aws/mwaa/MWAAClient.h b/generated/src/aws-cpp-sdk-mwaa/include/aws/mwaa/MWAAClient.h index 913cf947ff5..5f67969c18e 100644 --- a/generated/src/aws-cpp-sdk-mwaa/include/aws/mwaa/MWAAClient.h +++ b/generated/src/aws-cpp-sdk-mwaa/include/aws/mwaa/MWAAClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -52,7 +53,8 @@ namespace MWAA { */ class AWS_MWAA_API MWAAClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public MWAAPaginationBase { + public MWAAPaginationBase, + public MWAAWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphClient.h b/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphClient.h index 03bb64fcf55..2c752796737 100644 --- a/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphClient.h +++ b/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace NeptuneGraph { */ class AWS_NEPTUNEGRAPH_API NeptuneGraphClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public NeptuneGraphPaginationBase { + public NeptuneGraphPaginationBase, + public NeptuneGraphWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h b/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h new file mode 100644 index 00000000000..ace5ba6893e --- /dev/null +++ b/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h @@ -0,0 +1,321 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace NeptuneGraph { + +template +class NeptuneGraphWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilExportTaskSuccessful(const Model::GetExportTaskRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetExportTaskRequest& req) { return static_cast(this)->GetExportTask(req); }; + Aws::Utils::Waiter waiter(60, 480, acceptors, operation, + "WaitUntilExportTaskSuccessful"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilExportTaskCancelled(const Model::GetExportTaskRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return ((result.GetStatus() != "CANCELLING") && (result.GetStatus() != "CANCELLED")) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetExportTaskRequest& req) { return static_cast(this)->GetExportTask(req); }; + Aws::Utils::Waiter waiter(60, 60, acceptors, operation, + "WaitUntilExportTaskCancelled"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilGraphAvailable(const Model::GetGraphRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("AVAILABLE"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetGraphRequest& req) { return static_cast(this)->GetGraph(req); }; + Aws::Utils::Waiter waiter(60, 480, acceptors, operation, "WaitUntilGraphAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilGraphDeleted(const Model::GetGraphRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetStatus() != "DELETING") == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::GetGraphRequest& req) { return static_cast(this)->GetGraph(req); }; + Aws::Utils::Waiter waiter(60, 60, acceptors, operation, "WaitUntilGraphDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilGraphStopped(const Model::GetGraphRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), + [](const Model::GetGraphOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::GraphStatusMapper::GetNameForGraphStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, + [](const Model::GetGraphOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetStatus() != "STOPPING") == expected.get(); + }}); + + auto operation = [this](const Model::GetGraphRequest& req) { return static_cast(this)->GetGraph(req); }; + Aws::Utils::Waiter waiter(20, 90, acceptors, operation, "WaitUntilGraphStopped"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilGraphSnapshotAvailable(const Model::GetGraphSnapshotRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("AVAILABLE"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetGraphSnapshotRequest& req) { return static_cast(this)->GetGraphSnapshot(req); }; + Aws::Utils::Waiter waiter(60, 120, acceptors, operation, + "WaitUntilGraphSnapshotAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilGraphSnapshotDeleted(const Model::GetGraphSnapshotRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetStatus() != "DELETING") == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::GetGraphSnapshotRequest& req) { return static_cast(this)->GetGraphSnapshot(req); }; + Aws::Utils::Waiter waiter(60, 60, acceptors, operation, + "WaitUntilGraphSnapshotDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilImportTaskSuccessful(const Model::GetImportTaskRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLING_BACK"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetImportTaskRequest& req) { return static_cast(this)->GetImportTask(req); }; + Aws::Utils::Waiter waiter(60, 480, acceptors, operation, + "WaitUntilImportTaskSuccessful"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilImportTaskCancelled(const Model::GetImportTaskRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return ((result.GetStatus() != "CANCELLING") && (result.GetStatus() != "CANCELLED")) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetImportTaskRequest& req) { return static_cast(this)->GetImportTask(req); }; + Aws::Utils::Waiter waiter(60, 60, acceptors, operation, + "WaitUntilImportTaskCancelled"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPrivateGraphEndpointAvailable( + const Model::GetPrivateGraphEndpointRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("AVAILABLE"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetPrivateGraphEndpointRequest& req) { + return static_cast(this)->GetPrivateGraphEndpoint(req); + }; + Aws::Utils::Waiter waiter( + 10, 180, acceptors, operation, "WaitUntilPrivateGraphEndpointAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilPrivateGraphEndpointDeleted( + const Model::GetPrivateGraphEndpointRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetStatus() != "DELETING") == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::GetPrivateGraphEndpointRequest& req) { + return static_cast(this)->GetPrivateGraphEndpoint(req); + }; + Aws::Utils::Waiter waiter( + 10, 180, acceptors, operation, "WaitUntilPrivateGraphEndpointDeleted"); + return waiter.Wait(request); + } +}; +} // namespace NeptuneGraph +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneClient.h b/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneClient.h index bf908dc12df..0578d5c2d43 100644 --- a/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneClient.h +++ b/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -37,7 +38,8 @@ namespace Neptune { */ class AWS_NEPTUNE_API NeptuneClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public NeptunePaginationBase { + public NeptunePaginationBase, + public NeptuneWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h b/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h new file mode 100644 index 00000000000..f996df4f151 --- /dev/null +++ b/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h @@ -0,0 +1,134 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Neptune { + +template +class NeptuneWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilDBInstanceAvailable( + const Model::DescribeDBInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBInstancesRequest& req) { + return static_cast(this)->DescribeDBInstances(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilDBInstanceAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilDBInstanceDeleted( + const Model::DescribeDBInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBInstanceNotFound")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBInstancesRequest& req) { + return static_cast(this)->DescribeDBInstances(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilDBInstanceDeleted"); + return waiter.Wait(request); + } +}; +} // namespace Neptune +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-neptunedata/include/aws/neptunedata/NeptunedataClient.h b/generated/src/aws-cpp-sdk-neptunedata/include/aws/neptunedata/NeptunedataClient.h index 7ffd71f5559..318555c64e7 100644 --- a/generated/src/aws-cpp-sdk-neptunedata/include/aws/neptunedata/NeptunedataClient.h +++ b/generated/src/aws-cpp-sdk-neptunedata/include/aws/neptunedata/NeptunedataClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace neptunedata { */ class AWS_NEPTUNEDATA_API NeptunedataClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public NeptunedataPaginationBase { + public NeptunedataPaginationBase, + public NeptunedataWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-network-firewall/include/aws/network-firewall/NetworkFirewallClient.h b/generated/src/aws-cpp-sdk-network-firewall/include/aws/network-firewall/NetworkFirewallClient.h index 7c6c55b76cc..05a66101fcb 100644 --- a/generated/src/aws-cpp-sdk-network-firewall/include/aws/network-firewall/NetworkFirewallClient.h +++ b/generated/src/aws-cpp-sdk-network-firewall/include/aws/network-firewall/NetworkFirewallClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -81,7 +82,8 @@ namespace NetworkFirewall { */ class AWS_NETWORKFIREWALL_API NetworkFirewallClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public NetworkFirewallPaginationBase { + public NetworkFirewallPaginationBase, + public NetworkFirewallWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-networkflowmonitor/include/aws/networkflowmonitor/NetworkFlowMonitorClient.h b/generated/src/aws-cpp-sdk-networkflowmonitor/include/aws/networkflowmonitor/NetworkFlowMonitorClient.h index 51dc9f92e91..e16473c8ba7 100644 --- a/generated/src/aws-cpp-sdk-networkflowmonitor/include/aws/networkflowmonitor/NetworkFlowMonitorClient.h +++ b/generated/src/aws-cpp-sdk-networkflowmonitor/include/aws/networkflowmonitor/NetworkFlowMonitorClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -34,7 +35,8 @@ namespace NetworkFlowMonitor { */ class AWS_NETWORKFLOWMONITOR_API NetworkFlowMonitorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public NetworkFlowMonitorPaginationBase { + public NetworkFlowMonitorPaginationBase, + public NetworkFlowMonitorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-networkmanager/include/aws/networkmanager/NetworkManagerClient.h b/generated/src/aws-cpp-sdk-networkmanager/include/aws/networkmanager/NetworkManagerClient.h index f2dbd7b620b..fa2cf4dfdd1 100644 --- a/generated/src/aws-cpp-sdk-networkmanager/include/aws/networkmanager/NetworkManagerClient.h +++ b/generated/src/aws-cpp-sdk-networkmanager/include/aws/networkmanager/NetworkManagerClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace NetworkManager { */ class AWS_NETWORKMANAGER_API NetworkManagerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public NetworkManagerPaginationBase { + public NetworkManagerPaginationBase, + public NetworkManagerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-networkmonitor/include/aws/networkmonitor/NetworkMonitorClient.h b/generated/src/aws-cpp-sdk-networkmonitor/include/aws/networkmonitor/NetworkMonitorClient.h index 69974f7a46b..916d5e3f299 100644 --- a/generated/src/aws-cpp-sdk-networkmonitor/include/aws/networkmonitor/NetworkMonitorClient.h +++ b/generated/src/aws-cpp-sdk-networkmonitor/include/aws/networkmonitor/NetworkMonitorClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -35,7 +36,8 @@ namespace NetworkMonitor { */ class AWS_NETWORKMONITOR_API NetworkMonitorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public NetworkMonitorPaginationBase { + public NetworkMonitorPaginationBase, + public NetworkMonitorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-notifications/include/aws/notifications/NotificationsClient.h b/generated/src/aws-cpp-sdk-notifications/include/aws/notifications/NotificationsClient.h index af95a7b5c03..6d01631b1d3 100644 --- a/generated/src/aws-cpp-sdk-notifications/include/aws/notifications/NotificationsClient.h +++ b/generated/src/aws-cpp-sdk-notifications/include/aws/notifications/NotificationsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -36,7 +37,8 @@ namespace Notifications { */ class AWS_NOTIFICATIONS_API NotificationsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public NotificationsPaginationBase { + public NotificationsPaginationBase, + public NotificationsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-notificationscontacts/include/aws/notificationscontacts/NotificationsContactsClient.h b/generated/src/aws-cpp-sdk-notificationscontacts/include/aws/notificationscontacts/NotificationsContactsClient.h index 52048b97152..61314aec17e 100644 --- a/generated/src/aws-cpp-sdk-notificationscontacts/include/aws/notificationscontacts/NotificationsContactsClient.h +++ b/generated/src/aws-cpp-sdk-notificationscontacts/include/aws/notificationscontacts/NotificationsContactsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace NotificationsContacts { class AWS_NOTIFICATIONSCONTACTS_API NotificationsContactsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public NotificationsContactsPaginationBase { + public NotificationsContactsPaginationBase, + public NotificationsContactsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-nova-act/include/aws/nova-act/NovaActClient.h b/generated/src/aws-cpp-sdk-nova-act/include/aws/nova-act/NovaActClient.h index c423e7707f6..dd989ad82b3 100644 --- a/generated/src/aws-cpp-sdk-nova-act/include/aws/nova-act/NovaActClient.h +++ b/generated/src/aws-cpp-sdk-nova-act/include/aws/nova-act/NovaActClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace NovaAct { */ class AWS_NOVAACT_API NovaActClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public NovaActPaginationBase { + public NovaActPaginationBase, + public NovaActWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-oam/include/aws/oam/OAMClient.h b/generated/src/aws-cpp-sdk-oam/include/aws/oam/OAMClient.h index c30454d22e8..37c16cf38e1 100644 --- a/generated/src/aws-cpp-sdk-oam/include/aws/oam/OAMClient.h +++ b/generated/src/aws-cpp-sdk-oam/include/aws/oam/OAMClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -40,7 +41,8 @@ namespace OAM { */ class AWS_OAM_API OAMClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public OAMPaginationBase { + public OAMPaginationBase, + public OAMWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-observabilityadmin/include/aws/observabilityadmin/ObservabilityAdminClient.h b/generated/src/aws-cpp-sdk-observabilityadmin/include/aws/observabilityadmin/ObservabilityAdminClient.h index 026f364b895..2b9d0efa1a0 100644 --- a/generated/src/aws-cpp-sdk-observabilityadmin/include/aws/observabilityadmin/ObservabilityAdminClient.h +++ b/generated/src/aws-cpp-sdk-observabilityadmin/include/aws/observabilityadmin/ObservabilityAdminClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -32,7 +33,8 @@ namespace ObservabilityAdmin { */ class AWS_OBSERVABILITYADMIN_API ObservabilityAdminClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ObservabilityAdminPaginationBase { + public ObservabilityAdminPaginationBase, + public ObservabilityAdminWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-odb/include/aws/odb/OdbClient.h b/generated/src/aws-cpp-sdk-odb/include/aws/odb/OdbClient.h index ed0669fe8b1..9eb4c49c3ee 100644 --- a/generated/src/aws-cpp-sdk-odb/include/aws/odb/OdbClient.h +++ b/generated/src/aws-cpp-sdk-odb/include/aws/odb/OdbClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -43,7 +44,8 @@ namespace odb { */ class AWS_ODB_API OdbClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public OdbPaginationBase { + public OdbPaginationBase, + public OdbWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsClient.h b/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsClient.h index 6ad77ff6416..883b21b6c34 100644 --- a/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsClient.h +++ b/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace Omics { */ class AWS_OMICS_API OmicsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public OmicsPaginationBase { + public OmicsPaginationBase, + public OmicsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h b/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h new file mode 100644 index 00000000000..981635b0a0d --- /dev/null +++ b/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h @@ -0,0 +1,754 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Omics { + +template +class OmicsWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilAnnotationImportJobCreated( + const Model::GetAnnotationImportJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetAnnotationImportJobRequest& req) { + return static_cast(this)->GetAnnotationImportJob(req); + }; + Aws::Utils::Waiter waiter( + 30, 20, acceptors, operation, "WaitUntilAnnotationImportJobCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilAnnotationStoreCreated( + const Model::GetAnnotationStoreRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetAnnotationStoreRequest& req) { + return static_cast(this)->GetAnnotationStore(req); + }; + Aws::Utils::Waiter waiter(30, 20, acceptors, operation, + "WaitUntilAnnotationStoreCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilAnnotationStoreDeleted( + const Model::GetAnnotationStoreRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetAnnotationStoreRequest& req) { + return static_cast(this)->GetAnnotationStore(req); + }; + Aws::Utils::Waiter waiter(30, 20, acceptors, operation, + "WaitUntilAnnotationStoreDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilAnnotationStoreVersionCreated( + const Model::GetAnnotationStoreVersionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetAnnotationStoreVersionRequest& req) { + return static_cast(this)->GetAnnotationStoreVersion(req); + }; + Aws::Utils::Waiter waiter( + 30, 20, acceptors, operation, "WaitUntilAnnotationStoreVersionCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilAnnotationStoreVersionDeleted( + const Model::GetAnnotationStoreVersionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetAnnotationStoreVersionRequest& req) { + return static_cast(this)->GetAnnotationStoreVersion(req); + }; + Aws::Utils::Waiter waiter( + 30, 20, acceptors, operation, "WaitUntilAnnotationStoreVersionDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReadSetActivationJobCompleted( + const Model::GetReadSetActivationJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_FAILURES"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetReadSetActivationJobRequest& req) { + return static_cast(this)->GetReadSetActivationJob(req); + }; + Aws::Utils::Waiter waiter( + 30, 20, acceptors, operation, "WaitUntilReadSetActivationJobCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReadSetExportJobCompleted( + const Model::GetReadSetExportJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_FAILURES"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetReadSetExportJobRequest& req) { + return static_cast(this)->GetReadSetExportJob(req); + }; + Aws::Utils::Waiter waiter(30, 20, acceptors, operation, + "WaitUntilReadSetExportJobCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReadSetImportJobCompleted( + const Model::GetReadSetImportJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_FAILURES"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetReadSetImportJobRequest& req) { + return static_cast(this)->GetReadSetImportJob(req); + }; + Aws::Utils::Waiter waiter(30, 20, acceptors, operation, + "WaitUntilReadSetImportJobCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilReferenceImportJobCompleted( + const Model::GetReferenceImportJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_FAILURES"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetReferenceImportJobRequest& req) { + return static_cast(this)->GetReferenceImportJob(req); + }; + Aws::Utils::Waiter waiter( + 30, 20, acceptors, operation, "WaitUntilReferenceImportJobCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilRunRunning(const Model::GetRunRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetRunRequest& req) { return static_cast(this)->GetRun(req); }; + Aws::Utils::Waiter waiter(30, 20, acceptors, operation, "WaitUntilRunRunning"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilRunCompleted(const Model::GetRunRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetRunRequest& req) { return static_cast(this)->GetRun(req); }; + Aws::Utils::Waiter waiter(30, 20, acceptors, operation, "WaitUntilRunCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTaskRunning(const Model::GetRunTaskRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetRunTaskRequest& req) { return static_cast(this)->GetRunTask(req); }; + Aws::Utils::Waiter waiter(30, 20, acceptors, operation, "WaitUntilTaskRunning"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTaskCompleted(const Model::GetRunTaskRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetRunTaskRequest& req) { return static_cast(this)->GetRunTask(req); }; + Aws::Utils::Waiter waiter(30, 20, acceptors, operation, "WaitUntilTaskCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVariantImportJobCreated( + const Model::GetVariantImportJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetVariantImportJobRequest& req) { + return static_cast(this)->GetVariantImportJob(req); + }; + Aws::Utils::Waiter waiter(30, 20, acceptors, operation, + "WaitUntilVariantImportJobCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVariantStoreCreated(const Model::GetVariantStoreRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetVariantStoreRequest& req) { return static_cast(this)->GetVariantStore(req); }; + Aws::Utils::Waiter waiter(30, 20, acceptors, operation, + "WaitUntilVariantStoreCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVariantStoreDeleted(const Model::GetVariantStoreRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetVariantStoreRequest& req) { return static_cast(this)->GetVariantStore(req); }; + Aws::Utils::Waiter waiter(30, 20, acceptors, operation, + "WaitUntilVariantStoreDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilWorkflowActive(const Model::GetWorkflowRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetWorkflowRequest& req) { return static_cast(this)->GetWorkflow(req); }; + Aws::Utils::Waiter waiter(3, 10, acceptors, operation, "WaitUntilWorkflowActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilWorkflowVersionActive( + const Model::GetWorkflowVersionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetWorkflowVersionRequest& req) { + return static_cast(this)->GetWorkflowVersion(req); + }; + Aws::Utils::Waiter waiter(3, 10, acceptors, operation, + "WaitUntilWorkflowVersionActive"); + return waiter.Wait(request); + } +}; +} // namespace Omics +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-opensearch/include/aws/opensearch/OpenSearchServiceClient.h b/generated/src/aws-cpp-sdk-opensearch/include/aws/opensearch/OpenSearchServiceClient.h index 143c0622c0e..3013fbd3bff 100644 --- a/generated/src/aws-cpp-sdk-opensearch/include/aws/opensearch/OpenSearchServiceClient.h +++ b/generated/src/aws-cpp-sdk-opensearch/include/aws/opensearch/OpenSearchServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace OpenSearchService { */ class AWS_OPENSEARCHSERVICE_API OpenSearchServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public OpenSearchServicePaginationBase { + public OpenSearchServicePaginationBase, + public OpenSearchServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-opensearchserverless/include/aws/opensearchserverless/OpenSearchServerlessClient.h b/generated/src/aws-cpp-sdk-opensearchserverless/include/aws/opensearchserverless/OpenSearchServerlessClient.h index 84e6238154c..6de53c5f8cb 100644 --- a/generated/src/aws-cpp-sdk-opensearchserverless/include/aws/opensearchserverless/OpenSearchServerlessClient.h +++ b/generated/src/aws-cpp-sdk-opensearchserverless/include/aws/opensearchserverless/OpenSearchServerlessClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace OpenSearchServerless { class AWS_OPENSEARCHSERVERLESS_API OpenSearchServerlessClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public OpenSearchServerlessPaginationBase { + public OpenSearchServerlessPaginationBase, + public OpenSearchServerlessWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-organizations/include/aws/organizations/OrganizationsClient.h b/generated/src/aws-cpp-sdk-organizations/include/aws/organizations/OrganizationsClient.h index 94abbab83bf..19a82485851 100644 --- a/generated/src/aws-cpp-sdk-organizations/include/aws/organizations/OrganizationsClient.h +++ b/generated/src/aws-cpp-sdk-organizations/include/aws/organizations/OrganizationsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -62,7 +63,8 @@ namespace Organizations { */ class AWS_ORGANIZATIONS_API OrganizationsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public OrganizationsPaginationBase { + public OrganizationsPaginationBase, + public OrganizationsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-osis/include/aws/osis/OSISClient.h b/generated/src/aws-cpp-sdk-osis/include/aws/osis/OSISClient.h index 7e6f8d14d69..1a3231cf006 100644 --- a/generated/src/aws-cpp-sdk-osis/include/aws/osis/OSISClient.h +++ b/generated/src/aws-cpp-sdk-osis/include/aws/osis/OSISClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace OSIS { */ class AWS_OSIS_API OSISClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public OSISPaginationBase { + public OSISPaginationBase, + public OSISWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-outposts/include/aws/outposts/OutpostsClient.h b/generated/src/aws-cpp-sdk-outposts/include/aws/outposts/OutpostsClient.h index e9842b6b0f8..c316e14ea76 100644 --- a/generated/src/aws-cpp-sdk-outposts/include/aws/outposts/OutpostsClient.h +++ b/generated/src/aws-cpp-sdk-outposts/include/aws/outposts/OutpostsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace Outposts { */ class AWS_OUTPOSTS_API OutpostsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public OutpostsPaginationBase { + public OutpostsPaginationBase, + public OutpostsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-panorama/include/aws/panorama/PanoramaClient.h b/generated/src/aws-cpp-sdk-panorama/include/aws/panorama/PanoramaClient.h index 5920936085a..cc2d043cccb 100644 --- a/generated/src/aws-cpp-sdk-panorama/include/aws/panorama/PanoramaClient.h +++ b/generated/src/aws-cpp-sdk-panorama/include/aws/panorama/PanoramaClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace Panorama { */ class AWS_PANORAMA_API PanoramaClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PanoramaPaginationBase { + public PanoramaPaginationBase, + public PanoramaWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-partnercentral-account/include/aws/partnercentral-account/PartnerCentralAccountClient.h b/generated/src/aws-cpp-sdk-partnercentral-account/include/aws/partnercentral-account/PartnerCentralAccountClient.h index d74b7a4bc42..90d533dd790 100644 --- a/generated/src/aws-cpp-sdk-partnercentral-account/include/aws/partnercentral-account/PartnerCentralAccountClient.h +++ b/generated/src/aws-cpp-sdk-partnercentral-account/include/aws/partnercentral-account/PartnerCentralAccountClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace PartnerCentralAccount { class AWS_PARTNERCENTRALACCOUNT_API PartnerCentralAccountClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PartnerCentralAccountPaginationBase { + public PartnerCentralAccountPaginationBase, + public PartnerCentralAccountWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-partnercentral-benefits/include/aws/partnercentral-benefits/PartnerCentralBenefitsClient.h b/generated/src/aws-cpp-sdk-partnercentral-benefits/include/aws/partnercentral-benefits/PartnerCentralBenefitsClient.h index f75335bcc02..ac91dc5cd8f 100644 --- a/generated/src/aws-cpp-sdk-partnercentral-benefits/include/aws/partnercentral-benefits/PartnerCentralBenefitsClient.h +++ b/generated/src/aws-cpp-sdk-partnercentral-benefits/include/aws/partnercentral-benefits/PartnerCentralBenefitsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace PartnerCentralBenefits { class AWS_PARTNERCENTRALBENEFITS_API PartnerCentralBenefitsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PartnerCentralBenefitsPaginationBase { + public PartnerCentralBenefitsPaginationBase, + public PartnerCentralBenefitsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-partnercentral-channel/include/aws/partnercentral-channel/PartnerCentralChannelClient.h b/generated/src/aws-cpp-sdk-partnercentral-channel/include/aws/partnercentral-channel/PartnerCentralChannelClient.h index 32325f1eb2f..e65fb38799f 100644 --- a/generated/src/aws-cpp-sdk-partnercentral-channel/include/aws/partnercentral-channel/PartnerCentralChannelClient.h +++ b/generated/src/aws-cpp-sdk-partnercentral-channel/include/aws/partnercentral-channel/PartnerCentralChannelClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace PartnerCentralChannel { class AWS_PARTNERCENTRALCHANNEL_API PartnerCentralChannelClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PartnerCentralChannelPaginationBase { + public PartnerCentralChannelPaginationBase, + public PartnerCentralChannelWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-partnercentral-selling/include/aws/partnercentral-selling/PartnerCentralSellingClient.h b/generated/src/aws-cpp-sdk-partnercentral-selling/include/aws/partnercentral-selling/PartnerCentralSellingClient.h index a1341b228a2..cba5a6c82d9 100644 --- a/generated/src/aws-cpp-sdk-partnercentral-selling/include/aws/partnercentral-selling/PartnerCentralSellingClient.h +++ b/generated/src/aws-cpp-sdk-partnercentral-selling/include/aws/partnercentral-selling/PartnerCentralSellingClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -53,7 +54,8 @@ namespace PartnerCentralSelling { class AWS_PARTNERCENTRALSELLING_API PartnerCentralSellingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PartnerCentralSellingPaginationBase { + public PartnerCentralSellingPaginationBase, + public PartnerCentralSellingWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-payment-cryptography-data/include/aws/payment-cryptography-data/PaymentCryptographyDataClient.h b/generated/src/aws-cpp-sdk-payment-cryptography-data/include/aws/payment-cryptography-data/PaymentCryptographyDataClient.h index 25d46adcedb..b31fa49a137 100644 --- a/generated/src/aws-cpp-sdk-payment-cryptography-data/include/aws/payment-cryptography-data/PaymentCryptographyDataClient.h +++ b/generated/src/aws-cpp-sdk-payment-cryptography-data/include/aws/payment-cryptography-data/PaymentCryptographyDataClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -31,7 +32,8 @@ namespace PaymentCryptographyData { class AWS_PAYMENTCRYPTOGRAPHYDATA_API PaymentCryptographyDataClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PaymentCryptographyDataPaginationBase { + public PaymentCryptographyDataPaginationBase, + public PaymentCryptographyDataWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/PaymentCryptographyClient.h b/generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/PaymentCryptographyClient.h index af46c4fb01c..da584f96107 100644 --- a/generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/PaymentCryptographyClient.h +++ b/generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/PaymentCryptographyClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -41,7 +42,8 @@ namespace PaymentCryptography { */ class AWS_PAYMENTCRYPTOGRAPHY_API PaymentCryptographyClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PaymentCryptographyPaginationBase { + public PaymentCryptographyPaginationBase, + public PaymentCryptographyWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-pca-connector-ad/include/aws/pca-connector-ad/PcaConnectorAdClient.h b/generated/src/aws-cpp-sdk-pca-connector-ad/include/aws/pca-connector-ad/PcaConnectorAdClient.h index 387b2e2c1c6..a020078f591 100644 --- a/generated/src/aws-cpp-sdk-pca-connector-ad/include/aws/pca-connector-ad/PcaConnectorAdClient.h +++ b/generated/src/aws-cpp-sdk-pca-connector-ad/include/aws/pca-connector-ad/PcaConnectorAdClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace PcaConnectorAd { */ class AWS_PCACONNECTORAD_API PcaConnectorAdClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PcaConnectorAdPaginationBase { + public PcaConnectorAdPaginationBase, + public PcaConnectorAdWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-pca-connector-scep/include/aws/pca-connector-scep/PcaConnectorScepClient.h b/generated/src/aws-cpp-sdk-pca-connector-scep/include/aws/pca-connector-scep/PcaConnectorScepClient.h index 38a6962e8bb..4f747bba4b1 100644 --- a/generated/src/aws-cpp-sdk-pca-connector-scep/include/aws/pca-connector-scep/PcaConnectorScepClient.h +++ b/generated/src/aws-cpp-sdk-pca-connector-scep/include/aws/pca-connector-scep/PcaConnectorScepClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace PcaConnectorScep { */ class AWS_PCACONNECTORSCEP_API PcaConnectorScepClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PcaConnectorScepPaginationBase { + public PcaConnectorScepPaginationBase, + public PcaConnectorScepWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-pcs/include/aws/pcs/PCSClient.h b/generated/src/aws-cpp-sdk-pcs/include/aws/pcs/PCSClient.h index fc907a3d8f7..8e0f51fc4af 100644 --- a/generated/src/aws-cpp-sdk-pcs/include/aws/pcs/PCSClient.h +++ b/generated/src/aws-cpp-sdk-pcs/include/aws/pcs/PCSClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -39,7 +40,8 @@ namespace PCS { */ class AWS_PCS_API PCSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PCSPaginationBase { + public PCSPaginationBase, + public PCSWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-personalize-events/include/aws/personalize-events/PersonalizeEventsClient.h b/generated/src/aws-cpp-sdk-personalize-events/include/aws/personalize-events/PersonalizeEventsClient.h index 056ece3e236..44a3f4ee4d3 100644 --- a/generated/src/aws-cpp-sdk-personalize-events/include/aws/personalize-events/PersonalizeEventsClient.h +++ b/generated/src/aws-cpp-sdk-personalize-events/include/aws/personalize-events/PersonalizeEventsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace PersonalizeEvents { */ class AWS_PERSONALIZEEVENTS_API PersonalizeEventsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PersonalizeEventsPaginationBase { + public PersonalizeEventsPaginationBase, + public PersonalizeEventsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-personalize-runtime/include/aws/personalize-runtime/PersonalizeRuntimeClient.h b/generated/src/aws-cpp-sdk-personalize-runtime/include/aws/personalize-runtime/PersonalizeRuntimeClient.h index 7c65113d41b..6e72fb8e0f4 100644 --- a/generated/src/aws-cpp-sdk-personalize-runtime/include/aws/personalize-runtime/PersonalizeRuntimeClient.h +++ b/generated/src/aws-cpp-sdk-personalize-runtime/include/aws/personalize-runtime/PersonalizeRuntimeClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace PersonalizeRuntime { */ class AWS_PERSONALIZERUNTIME_API PersonalizeRuntimeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PersonalizeRuntimePaginationBase { + public PersonalizeRuntimePaginationBase, + public PersonalizeRuntimeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-personalize/include/aws/personalize/PersonalizeClient.h b/generated/src/aws-cpp-sdk-personalize/include/aws/personalize/PersonalizeClient.h index 386dfd9b40b..8695afc7820 100644 --- a/generated/src/aws-cpp-sdk-personalize/include/aws/personalize/PersonalizeClient.h +++ b/generated/src/aws-cpp-sdk-personalize/include/aws/personalize/PersonalizeClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace Personalize { */ class AWS_PERSONALIZE_API PersonalizeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PersonalizePaginationBase { + public PersonalizePaginationBase, + public PersonalizeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-pi/include/aws/pi/PIClient.h b/generated/src/aws-cpp-sdk-pi/include/aws/pi/PIClient.h index 0e7a010f007..7b76989edf3 100644 --- a/generated/src/aws-cpp-sdk-pi/include/aws/pi/PIClient.h +++ b/generated/src/aws-cpp-sdk-pi/include/aws/pi/PIClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -41,7 +42,8 @@ namespace PI { */ class AWS_PI_API PIClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PIPaginationBase { + public PIPaginationBase, + public PIWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-pinpoint-email/include/aws/pinpoint-email/PinpointEmailClient.h b/generated/src/aws-cpp-sdk-pinpoint-email/include/aws/pinpoint-email/PinpointEmailClient.h index 1173dae8eef..d49b5712f82 100644 --- a/generated/src/aws-cpp-sdk-pinpoint-email/include/aws/pinpoint-email/PinpointEmailClient.h +++ b/generated/src/aws-cpp-sdk-pinpoint-email/include/aws/pinpoint-email/PinpointEmailClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -52,7 +53,8 @@ namespace PinpointEmail { */ class AWS_PINPOINTEMAIL_API PinpointEmailClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PinpointEmailPaginationBase { + public PinpointEmailPaginationBase, + public PinpointEmailWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-pinpoint-sms-voice-v2/include/aws/pinpoint-sms-voice-v2/PinpointSMSVoiceV2Client.h b/generated/src/aws-cpp-sdk-pinpoint-sms-voice-v2/include/aws/pinpoint-sms-voice-v2/PinpointSMSVoiceV2Client.h index 1ef907508d5..67d12ab9623 100644 --- a/generated/src/aws-cpp-sdk-pinpoint-sms-voice-v2/include/aws/pinpoint-sms-voice-v2/PinpointSMSVoiceV2Client.h +++ b/generated/src/aws-cpp-sdk-pinpoint-sms-voice-v2/include/aws/pinpoint-sms-voice-v2/PinpointSMSVoiceV2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -55,7 +56,8 @@ namespace PinpointSMSVoiceV2 { */ class AWS_PINPOINTSMSVOICEV2_API PinpointSMSVoiceV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PinpointSMSVoiceV2PaginationBase { + public PinpointSMSVoiceV2PaginationBase, + public PinpointSMSVoiceV2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-pinpoint/include/aws/pinpoint/PinpointClient.h b/generated/src/aws-cpp-sdk-pinpoint/include/aws/pinpoint/PinpointClient.h index 65a185c092f..e5a9d147db7 100644 --- a/generated/src/aws-cpp-sdk-pinpoint/include/aws/pinpoint/PinpointClient.h +++ b/generated/src/aws-cpp-sdk-pinpoint/include/aws/pinpoint/PinpointClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace Pinpoint { */ class AWS_PINPOINT_API PinpointClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PinpointPaginationBase { + public PinpointPaginationBase, + public PinpointWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-pipes/include/aws/pipes/PipesClient.h b/generated/src/aws-cpp-sdk-pipes/include/aws/pipes/PipesClient.h index 9ff8594f357..4451a7efd31 100644 --- a/generated/src/aws-cpp-sdk-pipes/include/aws/pipes/PipesClient.h +++ b/generated/src/aws-cpp-sdk-pipes/include/aws/pipes/PipesClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace Pipes { */ class AWS_PIPES_API PipesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PipesPaginationBase { + public PipesPaginationBase, + public PipesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-polly/include/aws/polly/PollyClient.h b/generated/src/aws-cpp-sdk-polly/include/aws/polly/PollyClient.h index d43e2615fea..111dcd654e4 100644 --- a/generated/src/aws-cpp-sdk-polly/include/aws/polly/PollyClient.h +++ b/generated/src/aws-cpp-sdk-polly/include/aws/polly/PollyClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace Polly { */ class AWS_POLLY_API PollyClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PollyPaginationBase { + public PollyPaginationBase, + public PollyWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-pricing/include/aws/pricing/PricingClient.h b/generated/src/aws-cpp-sdk-pricing/include/aws/pricing/PricingClient.h index 9760f968b99..363e8ac77af 100644 --- a/generated/src/aws-cpp-sdk-pricing/include/aws/pricing/PricingClient.h +++ b/generated/src/aws-cpp-sdk-pricing/include/aws/pricing/PricingClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -38,7 +39,8 @@ namespace Pricing { */ class AWS_PRICING_API PricingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PricingPaginationBase { + public PricingPaginationBase, + public PricingWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonClient.h b/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonClient.h index a8c5f897450..02496e35df5 100644 --- a/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonClient.h +++ b/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -104,7 +105,8 @@ namespace Proton { */ class AWS_PROTON_API ProtonClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ProtonPaginationBase { + public ProtonPaginationBase, + public ProtonWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h b/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h new file mode 100644 index 00000000000..aeafcfe5a85 --- /dev/null +++ b/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h @@ -0,0 +1,279 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Proton { + +template +class ProtonWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilComponentDeployed(const Model::GetComponentRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), + [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetComponent().GetDeploymentStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetComponent().GetDeploymentStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetComponentRequest& req) { return static_cast(this)->GetComponent(req); }; + Aws::Utils::Waiter waiter(5, 999, acceptors, operation, + "WaitUntilComponentDeployed"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilComponentDeleted(const Model::GetComponentRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetComponent().GetDeploymentStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetComponentRequest& req) { return static_cast(this)->GetComponent(req); }; + Aws::Utils::Waiter waiter(5, 999, acceptors, operation, + "WaitUntilComponentDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilEnvironmentDeployed(const Model::GetEnvironmentRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), + [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetEnvironment().GetDeploymentStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetEnvironment().GetDeploymentStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetEnvironmentRequest& req) { return static_cast(this)->GetEnvironment(req); }; + Aws::Utils::Waiter waiter(5, 999, acceptors, operation, + "WaitUntilEnvironmentDeployed"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilEnvironmentTemplateVersionRegistered( + const Model::GetEnvironmentTemplateVersionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DRAFT"), + [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("PUBLISHED"), + [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REGISTRATION_FAILED"), + [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetEnvironmentTemplateVersionRequest& req) { + return static_cast(this)->GetEnvironmentTemplateVersion(req); + }; + Aws::Utils::Waiter waiter( + 2, 150, acceptors, operation, "WaitUntilEnvironmentTemplateVersionRegistered"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilServiceCreated(const Model::GetServiceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED_CLEANUP_COMPLETE"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED_CLEANUP_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetServiceRequest& req) { return static_cast(this)->GetService(req); }; + Aws::Utils::Waiter waiter(5, 999, acceptors, operation, "WaitUntilServiceCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilServiceUpdated(const Model::GetServiceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED_CLEANUP_COMPLETE"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED_CLEANUP_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_COMPLETE_CLEANUP_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetServiceRequest& req) { return static_cast(this)->GetService(req); }; + Aws::Utils::Waiter waiter(5, 999, acceptors, operation, "WaitUntilServiceUpdated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilServiceDeleted(const Model::GetServiceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetServiceRequest& req) { return static_cast(this)->GetService(req); }; + Aws::Utils::Waiter waiter(5, 999, acceptors, operation, "WaitUntilServiceDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilServicePipelineDeployed(const Model::GetServiceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetPipeline().GetDeploymentStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetPipeline().GetDeploymentStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetServiceRequest& req) { return static_cast(this)->GetService(req); }; + Aws::Utils::Waiter waiter(10, 360, acceptors, operation, + "WaitUntilServicePipelineDeployed"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilServiceInstanceDeployed( + const Model::GetServiceInstanceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), + [](const Model::GetServiceInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetServiceInstance().GetDeploymentStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetServiceInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetServiceInstance().GetDeploymentStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetServiceInstanceRequest& req) { + return static_cast(this)->GetServiceInstance(req); + }; + Aws::Utils::Waiter waiter(5, 999, acceptors, operation, + "WaitUntilServiceInstanceDeployed"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilServiceTemplateVersionRegistered( + const Model::GetServiceTemplateVersionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DRAFT"), + [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetServiceTemplateVersion().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("PUBLISHED"), + [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetServiceTemplateVersion().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REGISTRATION_FAILED"), + [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetServiceTemplateVersion().GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetServiceTemplateVersionRequest& req) { + return static_cast(this)->GetServiceTemplateVersion(req); + }; + Aws::Utils::Waiter waiter( + 2, 150, acceptors, operation, "WaitUntilServiceTemplateVersionRegistered"); + return waiter.Wait(request); + } +}; +} // namespace Proton +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-qapps/include/aws/qapps/QAppsClient.h b/generated/src/aws-cpp-sdk-qapps/include/aws/qapps/QAppsClient.h index dad09230c00..ef51fa502ab 100644 --- a/generated/src/aws-cpp-sdk-qapps/include/aws/qapps/QAppsClient.h +++ b/generated/src/aws-cpp-sdk-qapps/include/aws/qapps/QAppsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -34,7 +35,8 @@ namespace QApps { */ class AWS_QAPPS_API QAppsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public QAppsPaginationBase { + public QAppsPaginationBase, + public QAppsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-qbusiness/include/aws/qbusiness/QBusinessClient.h b/generated/src/aws-cpp-sdk-qbusiness/include/aws/qbusiness/QBusinessClient.h index a5f05b341fc..eb09cc6ac3b 100644 --- a/generated/src/aws-cpp-sdk-qbusiness/include/aws/qbusiness/QBusinessClient.h +++ b/generated/src/aws-cpp-sdk-qbusiness/include/aws/qbusiness/QBusinessClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -42,7 +43,8 @@ namespace QBusiness { */ class AWS_QBUSINESS_API QBusinessClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public QBusinessPaginationBase { + public QBusinessPaginationBase, + public QBusinessWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-qconnect/include/aws/qconnect/QConnectClient.h b/generated/src/aws-cpp-sdk-qconnect/include/aws/qconnect/QConnectClient.h index 97a1bbff822..d9ba59b5487 100644 --- a/generated/src/aws-cpp-sdk-qconnect/include/aws/qconnect/QConnectClient.h +++ b/generated/src/aws-cpp-sdk-qconnect/include/aws/qconnect/QConnectClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -43,7 +44,8 @@ namespace QConnect { */ class AWS_QCONNECT_API QConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public QConnectPaginationBase { + public QConnectPaginationBase, + public QConnectWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-quicksight/include/aws/quicksight/QuickSightClient.h b/generated/src/aws-cpp-sdk-quicksight/include/aws/quicksight/QuickSightClient.h index 38c38fd7bbf..25482a80b6d 100644 --- a/generated/src/aws-cpp-sdk-quicksight/include/aws/quicksight/QuickSightClient.h +++ b/generated/src/aws-cpp-sdk-quicksight/include/aws/quicksight/QuickSightClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace QuickSight { */ class AWS_QUICKSIGHT_API QuickSightClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public QuickSightPaginationBase { + public QuickSightPaginationBase, + public QuickSightWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ram/include/aws/ram/RAMClient.h b/generated/src/aws-cpp-sdk-ram/include/aws/ram/RAMClient.h index aec7119b05f..79631a5f2c1 100644 --- a/generated/src/aws-cpp-sdk-ram/include/aws/ram/RAMClient.h +++ b/generated/src/aws-cpp-sdk-ram/include/aws/ram/RAMClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace RAM { */ class AWS_RAM_API RAMClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public RAMPaginationBase { + public RAMPaginationBase, + public RAMWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-rbin/include/aws/rbin/RecycleBinClient.h b/generated/src/aws-cpp-sdk-rbin/include/aws/rbin/RecycleBinClient.h index ee6b969e98c..55d14d412c6 100644 --- a/generated/src/aws-cpp-sdk-rbin/include/aws/rbin/RecycleBinClient.h +++ b/generated/src/aws-cpp-sdk-rbin/include/aws/rbin/RecycleBinClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -33,7 +34,8 @@ namespace RecycleBin { */ class AWS_RECYCLEBIN_API RecycleBinClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public RecycleBinPaginationBase { + public RecycleBinPaginationBase, + public RecycleBinWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-rds-data/include/aws/rds-data/RDSDataServiceClient.h b/generated/src/aws-cpp-sdk-rds-data/include/aws/rds-data/RDSDataServiceClient.h index ce88260811e..a976aef0e56 100644 --- a/generated/src/aws-cpp-sdk-rds-data/include/aws/rds-data/RDSDataServiceClient.h +++ b/generated/src/aws-cpp-sdk-rds-data/include/aws/rds-data/RDSDataServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -27,7 +28,8 @@ namespace RDSDataService { */ class AWS_RDSDATASERVICE_API RDSDataServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public RDSDataServicePaginationBase { + public RDSDataServicePaginationBase, + public RDSDataServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h b/generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h new file mode 100644 index 00000000000..bf86d384b87 --- /dev/null +++ b/generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h @@ -0,0 +1,534 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace RDS { + +template +class RDSWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilDBClusterAvailable(const Model::DescribeDBClustersRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBClustersRequest& req) { + return static_cast(this)->DescribeDBClusters(req); + }; + Aws::Utils::Waiter waiter(30, 60, acceptors, operation, + "WaitUntilDBClusterAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilDBClusterDeleted(const Model::DescribeDBClustersRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetDBClusters().size() == 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBClusterNotFoundFault")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBClustersRequest& req) { + return static_cast(this)->DescribeDBClusters(req); + }; + Aws::Utils::Waiter waiter(30, 60, acceptors, operation, + "WaitUntilDBClusterDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilDBClusterSnapshotAvailable( + const Model::DescribeDBClusterSnapshotsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBClusterSnapshotsRequest& req) { + return static_cast(this)->DescribeDBClusterSnapshots(req); + }; + Aws::Utils::Waiter waiter( + 30, 60, acceptors, operation, "WaitUntilDBClusterSnapshotAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilDBClusterSnapshotDeleted( + const Model::DescribeDBClusterSnapshotsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetDBClusterSnapshots().size() == 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBClusterSnapshotNotFoundFault")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBClusterSnapshotsRequest& req) { + return static_cast(this)->DescribeDBClusterSnapshots(req); + }; + Aws::Utils::Waiter waiter( + 30, 60, acceptors, operation, "WaitUntilDBClusterSnapshotDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilDBInstanceAvailable( + const Model::DescribeDBInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBInstancesRequest& req) { + return static_cast(this)->DescribeDBInstances(req); + }; + Aws::Utils::Waiter waiter(30, 60, acceptors, operation, + "WaitUntilDBInstanceAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilDBInstanceDeleted( + const Model::DescribeDBInstancesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetDBInstances().size() == 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBInstanceNotFound")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBInstancesRequest& req) { + return static_cast(this)->DescribeDBInstances(req); + }; + Aws::Utils::Waiter waiter(30, 60, acceptors, operation, + "WaitUntilDBInstanceDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilDBSnapshotAvailable( + const Model::DescribeDBSnapshotsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBSnapshotsRequest& req) { + return static_cast(this)->DescribeDBSnapshots(req); + }; + Aws::Utils::Waiter waiter(30, 60, acceptors, operation, + "WaitUntilDBSnapshotAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilDBSnapshotDeleted( + const Model::DescribeDBSnapshotsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetDBSnapshots().size() == 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBSnapshotNotFound")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeDBSnapshotsRequest& req) { + return static_cast(this)->DescribeDBSnapshots(req); + }; + Aws::Utils::Waiter waiter(30, 60, acceptors, operation, + "WaitUntilDBSnapshotDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTenantDatabaseAvailable( + const Model::DescribeTenantDatabasesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), + [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), + [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), + [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), + [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), + [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), + [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeTenantDatabasesRequest& req) { + return static_cast(this)->DescribeTenantDatabases(req); + }; + Aws::Utils::Waiter waiter( + 30, 60, acceptors, operation, "WaitUntilTenantDatabaseAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTenantDatabaseDeleted( + const Model::DescribeTenantDatabasesRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, + [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetTenantDatabases().size() == 0) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBInstanceNotFoundFault")}); + + auto operation = [this](const Model::DescribeTenantDatabasesRequest& req) { + return static_cast(this)->DescribeTenantDatabases(req); + }; + Aws::Utils::Waiter waiter( + 30, 60, acceptors, operation, "WaitUntilTenantDatabaseDeleted"); + return waiter.Wait(request); + } +}; +} // namespace RDS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-redshift-data/include/aws/redshift-data/RedshiftDataAPIServiceClient.h b/generated/src/aws-cpp-sdk-redshift-data/include/aws/redshift-data/RedshiftDataAPIServiceClient.h index 326e643fe5d..3749910d47f 100644 --- a/generated/src/aws-cpp-sdk-redshift-data/include/aws/redshift-data/RedshiftDataAPIServiceClient.h +++ b/generated/src/aws-cpp-sdk-redshift-data/include/aws/redshift-data/RedshiftDataAPIServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace RedshiftDataAPIService { class AWS_REDSHIFTDATAAPISERVICE_API RedshiftDataAPIServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public RedshiftDataAPIServicePaginationBase { + public RedshiftDataAPIServicePaginationBase, + public RedshiftDataAPIServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-redshift-serverless/include/aws/redshift-serverless/RedshiftServerlessClient.h b/generated/src/aws-cpp-sdk-redshift-serverless/include/aws/redshift-serverless/RedshiftServerlessClient.h index 28a5e2cfae5..1cae00699ba 100644 --- a/generated/src/aws-cpp-sdk-redshift-serverless/include/aws/redshift-serverless/RedshiftServerlessClient.h +++ b/generated/src/aws-cpp-sdk-redshift-serverless/include/aws/redshift-serverless/RedshiftServerlessClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace RedshiftServerless { */ class AWS_REDSHIFTSERVERLESS_API RedshiftServerlessClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public RedshiftServerlessPaginationBase { + public RedshiftServerlessPaginationBase, + public RedshiftServerlessWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftClient.h b/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftClient.h index d0b8beb84a3..3e7396db2bc 100644 --- a/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftClient.h +++ b/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -41,7 +42,8 @@ namespace Redshift { */ class AWS_REDSHIFT_API RedshiftClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public RedshiftPaginationBase { + public RedshiftPaginationBase, + public RedshiftWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h b/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h new file mode 100644 index 00000000000..e101cf93d59 --- /dev/null +++ b/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h @@ -0,0 +1,133 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Redshift { + +template +class RedshiftWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilClusterAvailable(const Model::DescribeClustersRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { + return item.GetClusterStatus() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { + return item.GetClusterStatus() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ClusterNotFound")}); + + auto operation = [this](const Model::DescribeClustersRequest& req) { return static_cast(this)->DescribeClusters(req); }; + Aws::Utils::Waiter waiter(60, 2, acceptors, operation, + "WaitUntilClusterAvailable"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClustersRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ClusterNotFound")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { + return item.GetClusterStatus() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { + return item.GetClusterStatus() == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeClustersRequest& req) { return static_cast(this)->DescribeClusters(req); }; + Aws::Utils::Waiter waiter(60, 2, acceptors, operation, + "WaitUntilClusterDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilClusterRestored(const Model::DescribeClustersRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { + return item.GetRestoreStatus().GetStatus() == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { + return item.GetClusterStatus() == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeClustersRequest& req) { return static_cast(this)->DescribeClusters(req); }; + Aws::Utils::Waiter waiter(60, 2, acceptors, operation, + "WaitUntilClusterRestored"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSnapshotAvailable( + const Model::DescribeClusterSnapshotsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), + [](const Model::DescribeClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), + [&](const Model::Snapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), + [](const Model::DescribeClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), + [&](const Model::Snapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), + [](const Model::DescribeClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), + [&](const Model::Snapshot& item) { return item.GetStatus() == expected.get(); }); + }}); + + auto operation = [this](const Model::DescribeClusterSnapshotsRequest& req) { + return static_cast(this)->DescribeClusterSnapshots(req); + }; + Aws::Utils::Waiter waiter(15, 8, acceptors, operation, + "WaitUntilSnapshotAvailable"); + return waiter.Wait(request); + } +}; +} // namespace Redshift +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionClient.h b/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionClient.h index 68fc27b62de..2e022c9aa72 100644 --- a/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionClient.h +++ b/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -172,7 +173,8 @@ namespace Rekognition { */ class AWS_REKOGNITION_API RekognitionClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public RekognitionPaginationBase { + public RekognitionPaginationBase, + public RekognitionWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h b/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h new file mode 100644 index 00000000000..cfc8fa0532b --- /dev/null +++ b/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h @@ -0,0 +1,86 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Rekognition { + +template +class RekognitionWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilProjectVersionRunning( + const Model::DescribeProjectVersionsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), + [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), + [&](const Model::ProjectVersionDescription& item) { + return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus( + item.GetStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), + [&](const Model::ProjectVersionDescription& item) { + return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus( + item.GetStatus()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeProjectVersionsRequest& req) { + return static_cast(this)->DescribeProjectVersions(req); + }; + Aws::Utils::Waiter waiter( + 30, 4, acceptors, operation, "WaitUntilProjectVersionRunning"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilProjectVersionTrainingCompleted( + const Model::DescribeProjectVersionsRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("TRAINING_COMPLETED"), + [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), + [&](const Model::ProjectVersionDescription& item) { + return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus( + item.GetStatus()) == expected.get(); + }); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TRAINING_FAILED"), + [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), + [&](const Model::ProjectVersionDescription& item) { + return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus( + item.GetStatus()) == expected.get(); + }); + }}); + + auto operation = [this](const Model::DescribeProjectVersionsRequest& req) { + return static_cast(this)->DescribeProjectVersions(req); + }; + Aws::Utils::Waiter waiter( + 120, 1, acceptors, operation, "WaitUntilProjectVersionTrainingCompleted"); + return waiter.Wait(request); + } +}; +} // namespace Rekognition +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceClient.h b/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceClient.h index b5ef5ffe78f..8002a3c0d4e 100644 --- a/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceClient.h +++ b/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -28,7 +29,8 @@ namespace repostspace { */ class AWS_REPOSTSPACE_API RepostspaceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public RepostspacePaginationBase { + public RepostspacePaginationBase, + public RepostspaceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h b/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h new file mode 100644 index 00000000000..462ae9070bd --- /dev/null +++ b/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h @@ -0,0 +1,136 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace repostspace { + +template +class RepostspaceWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilChannelCreated(const Model::GetChannelRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATED"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetChannelRequest& req) { return static_cast(this)->GetChannel(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilChannelCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilChannelDeleted(const Model::GetChannelRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetChannelRequest& req) { return static_cast(this)->GetChannel(req); }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilChannelDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSpaceCreated(const Model::GetSpaceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATED"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetSpaceRequest& req) { return static_cast(this)->GetSpace(req); }; + Aws::Utils::Waiter waiter(300, 24, acceptors, operation, "WaitUntilSpaceCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilSpaceDeleted(const Model::GetSpaceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetSpaceRequest& req) { return static_cast(this)->GetSpace(req); }; + Aws::Utils::Waiter waiter(300, 24, acceptors, operation, "WaitUntilSpaceDeleted"); + return waiter.Wait(request); + } +}; +} // namespace repostspace +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-resiliencehub/include/aws/resiliencehub/ResilienceHubClient.h b/generated/src/aws-cpp-sdk-resiliencehub/include/aws/resiliencehub/ResilienceHubClient.h index a9dda3491a6..4bfcc4cb098 100644 --- a/generated/src/aws-cpp-sdk-resiliencehub/include/aws/resiliencehub/ResilienceHubClient.h +++ b/generated/src/aws-cpp-sdk-resiliencehub/include/aws/resiliencehub/ResilienceHubClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace ResilienceHub { */ class AWS_RESILIENCEHUB_API ResilienceHubClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ResilienceHubPaginationBase { + public ResilienceHubPaginationBase, + public ResilienceHubWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-resource-explorer-2/include/aws/resource-explorer-2/ResourceExplorer2Client.h b/generated/src/aws-cpp-sdk-resource-explorer-2/include/aws/resource-explorer-2/ResourceExplorer2Client.h index 7ca1a0933b8..17e2387ee87 100644 --- a/generated/src/aws-cpp-sdk-resource-explorer-2/include/aws/resource-explorer-2/ResourceExplorer2Client.h +++ b/generated/src/aws-cpp-sdk-resource-explorer-2/include/aws/resource-explorer-2/ResourceExplorer2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -47,7 +48,8 @@ namespace ResourceExplorer2 { */ class AWS_RESOURCEEXPLORER2_API ResourceExplorer2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ResourceExplorer2PaginationBase { + public ResourceExplorer2PaginationBase, + public ResourceExplorer2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-resource-groups/include/aws/resource-groups/ResourceGroupsClient.h b/generated/src/aws-cpp-sdk-resource-groups/include/aws/resource-groups/ResourceGroupsClient.h index c78056e2e94..c63bd484e46 100644 --- a/generated/src/aws-cpp-sdk-resource-groups/include/aws/resource-groups/ResourceGroupsClient.h +++ b/generated/src/aws-cpp-sdk-resource-groups/include/aws/resource-groups/ResourceGroupsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -43,7 +44,8 @@ namespace ResourceGroups { */ class AWS_RESOURCEGROUPS_API ResourceGroupsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ResourceGroupsPaginationBase { + public ResourceGroupsPaginationBase, + public ResourceGroupsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-resourcegroupstaggingapi/include/aws/resourcegroupstaggingapi/ResourceGroupsTaggingAPIClient.h b/generated/src/aws-cpp-sdk-resourcegroupstaggingapi/include/aws/resourcegroupstaggingapi/ResourceGroupsTaggingAPIClient.h index 50c7c4fa996..7e3c2d8ede6 100644 --- a/generated/src/aws-cpp-sdk-resourcegroupstaggingapi/include/aws/resourcegroupstaggingapi/ResourceGroupsTaggingAPIClient.h +++ b/generated/src/aws-cpp-sdk-resourcegroupstaggingapi/include/aws/resourcegroupstaggingapi/ResourceGroupsTaggingAPIClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace ResourceGroupsTaggingAPI { class AWS_RESOURCEGROUPSTAGGINGAPI_API ResourceGroupsTaggingAPIClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ResourceGroupsTaggingAPIPaginationBase { + public ResourceGroupsTaggingAPIPaginationBase, + public ResourceGroupsTaggingAPIWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-rolesanywhere/include/aws/rolesanywhere/RolesAnywhereClient.h b/generated/src/aws-cpp-sdk-rolesanywhere/include/aws/rolesanywhere/RolesAnywhereClient.h index f4245b6a048..8b528e275fd 100644 --- a/generated/src/aws-cpp-sdk-rolesanywhere/include/aws/rolesanywhere/RolesAnywhereClient.h +++ b/generated/src/aws-cpp-sdk-rolesanywhere/include/aws/rolesanywhere/RolesAnywhereClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -34,7 +35,8 @@ namespace RolesAnywhere { */ class AWS_ROLESANYWHERE_API RolesAnywhereClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public RolesAnywherePaginationBase { + public RolesAnywherePaginationBase, + public RolesAnywhereWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-route53-recovery-cluster/include/aws/route53-recovery-cluster/Route53RecoveryClusterClient.h b/generated/src/aws-cpp-sdk-route53-recovery-cluster/include/aws/route53-recovery-cluster/Route53RecoveryClusterClient.h index f5ce0c435fe..fcdaa015ae5 100644 --- a/generated/src/aws-cpp-sdk-route53-recovery-cluster/include/aws/route53-recovery-cluster/Route53RecoveryClusterClient.h +++ b/generated/src/aws-cpp-sdk-route53-recovery-cluster/include/aws/route53-recovery-cluster/Route53RecoveryClusterClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -62,7 +63,8 @@ namespace Route53RecoveryCluster { class AWS_ROUTE53RECOVERYCLUSTER_API Route53RecoveryClusterClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Route53RecoveryClusterPaginationBase { + public Route53RecoveryClusterPaginationBase, + public Route53RecoveryClusterWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigClient.h b/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigClient.h index 0e586b735f2..6225301f26a 100644 --- a/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigClient.h +++ b/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace Route53RecoveryControlConfig { class AWS_ROUTE53RECOVERYCONTROLCONFIG_API Route53RecoveryControlConfigClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Route53RecoveryControlConfigPaginationBase { + public Route53RecoveryControlConfigPaginationBase, + public Route53RecoveryControlConfigWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h b/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h new file mode 100644 index 00000000000..e971eb189a5 --- /dev/null +++ b/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h @@ -0,0 +1,161 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Route53RecoveryControlConfig { + +template +class Route53RecoveryControlConfigWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilClusterCreated(const Model::DescribeClusterRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYED"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetCluster().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetCluster().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + + auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilClusterCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClusterRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING_DELETION"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetCluster().GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + + auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilClusterDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilControlPanelCreated( + const Model::DescribeControlPanelRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYED"), + [](const Model::DescribeControlPanelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetControlPanel().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), + [](const Model::DescribeControlPanelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetControlPanel().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + + auto operation = [this](const Model::DescribeControlPanelRequest& req) { + return static_cast(this)->DescribeControlPanel(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilControlPanelCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilControlPanelDeleted( + const Model::DescribeControlPanelRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING_DELETION"), + [](const Model::DescribeControlPanelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetControlPanel().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + + auto operation = [this](const Model::DescribeControlPanelRequest& req) { + return static_cast(this)->DescribeControlPanel(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilControlPanelDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilRoutingControlCreated( + const Model::DescribeRoutingControlRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYED"), + [](const Model::DescribeRoutingControlOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetRoutingControl().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), + [](const Model::DescribeRoutingControlOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetRoutingControl().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + + auto operation = [this](const Model::DescribeRoutingControlRequest& req) { + return static_cast(this)->DescribeRoutingControl(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilRoutingControlCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilRoutingControlDeleted( + const Model::DescribeRoutingControlRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING_DELETION"), + [](const Model::DescribeRoutingControlOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetRoutingControl().GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + + auto operation = [this](const Model::DescribeRoutingControlRequest& req) { + return static_cast(this)->DescribeRoutingControl(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilRoutingControlDeleted"); + return waiter.Wait(request); + } +}; +} // namespace Route53RecoveryControlConfig +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-route53-recovery-readiness/include/aws/route53-recovery-readiness/Route53RecoveryReadinessClient.h b/generated/src/aws-cpp-sdk-route53-recovery-readiness/include/aws/route53-recovery-readiness/Route53RecoveryReadinessClient.h index 11a9989d973..61ecad10d01 100644 --- a/generated/src/aws-cpp-sdk-route53-recovery-readiness/include/aws/route53-recovery-readiness/Route53RecoveryReadinessClient.h +++ b/generated/src/aws-cpp-sdk-route53-recovery-readiness/include/aws/route53-recovery-readiness/Route53RecoveryReadinessClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace Route53RecoveryReadiness { class AWS_ROUTE53RECOVERYREADINESS_API Route53RecoveryReadinessClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Route53RecoveryReadinessPaginationBase { + public Route53RecoveryReadinessPaginationBase, + public Route53RecoveryReadinessWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Client.h b/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Client.h index b5b740bd193..6544c0775ff 100644 --- a/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Client.h +++ b/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Client.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace Route53 { */ class AWS_ROUTE53_API Route53Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Route53PaginationBase { + public Route53PaginationBase, + public Route53Waiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h b/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h new file mode 100644 index 00000000000..c10191addea --- /dev/null +++ b/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h @@ -0,0 +1,38 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Route53 { + +template +class Route53Waiter { + public: + Aws::Utils::WaiterOutcome WaitUntilResourceRecordSetsChanged(const Model::GetChangeRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("INSYNC"), + [](const Model::GetChangeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChangeStatusMapper::GetNameForChangeStatus(result.GetChangeInfo().GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetChangeRequest& req) { return static_cast(this)->GetChange(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilResourceRecordSetsChanged"); + return waiter.Wait(request); + } +}; +} // namespace Route53 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-route53domains/include/aws/route53domains/Route53DomainsClient.h b/generated/src/aws-cpp-sdk-route53domains/include/aws/route53domains/Route53DomainsClient.h index 2341c802b43..0f7b329c521 100644 --- a/generated/src/aws-cpp-sdk-route53domains/include/aws/route53domains/Route53DomainsClient.h +++ b/generated/src/aws-cpp-sdk-route53domains/include/aws/route53domains/Route53DomainsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace Route53Domains { */ class AWS_ROUTE53DOMAINS_API Route53DomainsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Route53DomainsPaginationBase { + public Route53DomainsPaginationBase, + public Route53DomainsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-route53globalresolver/include/aws/route53globalresolver/Route53GlobalResolverClient.h b/generated/src/aws-cpp-sdk-route53globalresolver/include/aws/route53globalresolver/Route53GlobalResolverClient.h index dcfd1849907..7226736cbf4 100644 --- a/generated/src/aws-cpp-sdk-route53globalresolver/include/aws/route53globalresolver/Route53GlobalResolverClient.h +++ b/generated/src/aws-cpp-sdk-route53globalresolver/include/aws/route53globalresolver/Route53GlobalResolverClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace Route53GlobalResolver { class AWS_ROUTE53GLOBALRESOLVER_API Route53GlobalResolverClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Route53GlobalResolverPaginationBase { + public Route53GlobalResolverPaginationBase, + public Route53GlobalResolverWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-route53profiles/include/aws/route53profiles/Route53ProfilesClient.h b/generated/src/aws-cpp-sdk-route53profiles/include/aws/route53profiles/Route53ProfilesClient.h index 6da6bcfe7b0..1e0dfcfc4e9 100644 --- a/generated/src/aws-cpp-sdk-route53profiles/include/aws/route53profiles/Route53ProfilesClient.h +++ b/generated/src/aws-cpp-sdk-route53profiles/include/aws/route53profiles/Route53ProfilesClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace Route53Profiles { */ class AWS_ROUTE53PROFILES_API Route53ProfilesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Route53ProfilesPaginationBase { + public Route53ProfilesPaginationBase, + public Route53ProfilesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverClient.h b/generated/src/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverClient.h index 5275aae42a7..e00750717cb 100644 --- a/generated/src/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverClient.h +++ b/generated/src/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -47,7 +48,8 @@ namespace Route53Resolver { */ class AWS_ROUTE53RESOLVER_API Route53ResolverClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public Route53ResolverPaginationBase { + public Route53ResolverPaginationBase, + public Route53ResolverWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricClient.h b/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricClient.h index e51aa99ce9f..43d607c67a7 100644 --- a/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricClient.h +++ b/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace RTBFabric { */ class AWS_RTBFABRIC_API RTBFabricClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public RTBFabricPaginationBase { + public RTBFabricPaginationBase, + public RTBFabricWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h b/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h new file mode 100644 index 00000000000..4764a573396 --- /dev/null +++ b/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h @@ -0,0 +1,305 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace RTBFabric { + +template +class RTBFabricWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilInboundExternalLinkActive( + const Model::GetInboundExternalLinkRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REJECTED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ISOLATED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetInboundExternalLinkRequest& req) { + return static_cast(this)->GetInboundExternalLink(req); + }; + Aws::Utils::Waiter waiter( + 30, 4, acceptors, operation, "WaitUntilInboundExternalLinkActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilLinkAccepted(const Model::GetLinkRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACCEPTED"), + [](const Model::GetLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REJECTED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetLinkRequest& req) { return static_cast(this)->GetLink(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, "WaitUntilLinkAccepted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilLinkActive(const Model::GetLinkRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REJECTED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetLinkRequest& req) { return static_cast(this)->GetLink(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, "WaitUntilLinkActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilOutboundExternalLinkActive( + const Model::GetOutboundExternalLinkRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REJECTED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ISOLATED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetOutboundExternalLinkRequest& req) { + return static_cast(this)->GetOutboundExternalLink(req); + }; + Aws::Utils::Waiter waiter( + 30, 4, acceptors, operation, "WaitUntilOutboundExternalLinkActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilRequesterGatewayActive( + const Model::GetRequesterGatewayRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetRequesterGatewayRequest& req) { + return static_cast(this)->GetRequesterGateway(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilRequesterGatewayActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilRequesterGatewayDeleted( + const Model::GetRequesterGatewayRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetRequesterGatewayRequest& req) { + return static_cast(this)->GetRequesterGateway(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilRequesterGatewayDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilResponderGatewayActive( + const Model::GetResponderGatewayRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetResponderGatewayRequest& req) { + return static_cast(this)->GetResponderGateway(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilResponderGatewayActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilResponderGatewayDeleted( + const Model::GetResponderGatewayRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetResponderGatewayRequest& req) { + return static_cast(this)->GetResponderGateway(req); + }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, + "WaitUntilResponderGatewayDeleted"); + return waiter.Wait(request); + } +}; +} // namespace RTBFabric +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-rum/include/aws/rum/CloudWatchRUMClient.h b/generated/src/aws-cpp-sdk-rum/include/aws/rum/CloudWatchRUMClient.h index 82536fac8d0..d03710231df 100644 --- a/generated/src/aws-cpp-sdk-rum/include/aws/rum/CloudWatchRUMClient.h +++ b/generated/src/aws-cpp-sdk-rum/include/aws/rum/CloudWatchRUMClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace CloudWatchRUM { */ class AWS_CLOUDWATCHRUM_API CloudWatchRUMClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public CloudWatchRUMPaginationBase { + public CloudWatchRUMPaginationBase, + public CloudWatchRUMWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtClient.h b/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtClient.h index 257c302b8c8..9909acb7731 100644 --- a/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtClient.h +++ b/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtClient.h @@ -19,6 +19,7 @@ #include #include #include +#include #include #include #include @@ -51,7 +52,8 @@ class S3ExpressIdentityProvider; */ class AWS_S3CRT_API S3CrtClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public S3CrtPaginationBase { + public S3CrtPaginationBase, + public S3CrtWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h b/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h new file mode 100644 index 00000000000..722b0ee1bd7 --- /dev/null +++ b/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h @@ -0,0 +1,61 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace S3Crt { + +template +class S3CrtWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilBucketExists(const Model::HeadBucketRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::STATUS, 404}); + + auto operation = [this](const Model::HeadBucketRequest& req) { return static_cast(this)->HeadBucket(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilBucketExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilBucketNotExists(const Model::HeadBucketRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::STATUS, 404}); + + auto operation = [this](const Model::HeadBucketRequest& req) { return static_cast(this)->HeadBucket(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilBucketNotExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilObjectExists(const Model::HeadObjectRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::STATUS, 404}); + + auto operation = [this](const Model::HeadObjectRequest& req) { return static_cast(this)->HeadObject(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilObjectExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilObjectNotExists(const Model::HeadObjectRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::STATUS, 404}); + + auto operation = [this](const Model::HeadObjectRequest& req) { return static_cast(this)->HeadObject(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilObjectNotExists"); + return waiter.Wait(request); + } +}; +} // namespace S3Crt +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Client.h b/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Client.h index ae47f18b9e5..db096fc0341 100644 --- a/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Client.h +++ b/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Client.h @@ -12,6 +12,7 @@ #include #include #include +#include #include // TODO: temporary fix for naming conflicts on Windows. @@ -39,7 +40,8 @@ static const unsigned MAX_EXPIRATION_SECONDS = 7 * 24 * 60 * 60; */ class AWS_S3_API S3Client : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public S3PaginationBase { + public S3PaginationBase, + public S3Waiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h b/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h new file mode 100644 index 00000000000..2c3bb8afcdf --- /dev/null +++ b/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h @@ -0,0 +1,61 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace S3 { + +template +class S3Waiter { + public: + Aws::Utils::WaiterOutcome WaitUntilBucketExists(const Model::HeadBucketRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::STATUS, 404}); + + auto operation = [this](const Model::HeadBucketRequest& req) { return static_cast(this)->HeadBucket(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilBucketExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilBucketNotExists(const Model::HeadBucketRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::STATUS, 404}); + + auto operation = [this](const Model::HeadBucketRequest& req) { return static_cast(this)->HeadBucket(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilBucketNotExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilObjectExists(const Model::HeadObjectRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::STATUS, 404}); + + auto operation = [this](const Model::HeadObjectRequest& req) { return static_cast(this)->HeadObject(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilObjectExists"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilObjectNotExists(const Model::HeadObjectRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::STATUS, 404}); + + auto operation = [this](const Model::HeadObjectRequest& req) { return static_cast(this)->HeadObject(req); }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilObjectNotExists"); + return waiter.Wait(request); + } +}; +} // namespace S3 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-s3outposts/include/aws/s3outposts/S3OutpostsClient.h b/generated/src/aws-cpp-sdk-s3outposts/include/aws/s3outposts/S3OutpostsClient.h index 596b7d3db0d..d286cc0ad13 100644 --- a/generated/src/aws-cpp-sdk-s3outposts/include/aws/s3outposts/S3OutpostsClient.h +++ b/generated/src/aws-cpp-sdk-s3outposts/include/aws/s3outposts/S3OutpostsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace S3Outposts { */ class AWS_S3OUTPOSTS_API S3OutpostsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public S3OutpostsPaginationBase { + public S3OutpostsPaginationBase, + public S3OutpostsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-s3tables/include/aws/s3tables/S3TablesClient.h b/generated/src/aws-cpp-sdk-s3tables/include/aws/s3tables/S3TablesClient.h index 55245ee41d8..99fda0f8864 100644 --- a/generated/src/aws-cpp-sdk-s3tables/include/aws/s3tables/S3TablesClient.h +++ b/generated/src/aws-cpp-sdk-s3tables/include/aws/s3tables/S3TablesClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -34,7 +35,8 @@ namespace S3Tables { */ class AWS_S3TABLES_API S3TablesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public S3TablesPaginationBase { + public S3TablesPaginationBase, + public S3TablesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-s3vectors/include/aws/s3vectors/S3VectorsClient.h b/generated/src/aws-cpp-sdk-s3vectors/include/aws/s3vectors/S3VectorsClient.h index 78b866013d8..40809c22efa 100644 --- a/generated/src/aws-cpp-sdk-s3vectors/include/aws/s3vectors/S3VectorsClient.h +++ b/generated/src/aws-cpp-sdk-s3vectors/include/aws/s3vectors/S3VectorsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace S3Vectors { */ class AWS_S3VECTORS_API S3VectorsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public S3VectorsPaginationBase { + public S3VectorsPaginationBase, + public S3VectorsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sagemaker-a2i-runtime/include/aws/sagemaker-a2i-runtime/AugmentedAIRuntimeClient.h b/generated/src/aws-cpp-sdk-sagemaker-a2i-runtime/include/aws/sagemaker-a2i-runtime/AugmentedAIRuntimeClient.h index cc528d6ce49..bdfff96a703 100644 --- a/generated/src/aws-cpp-sdk-sagemaker-a2i-runtime/include/aws/sagemaker-a2i-runtime/AugmentedAIRuntimeClient.h +++ b/generated/src/aws-cpp-sdk-sagemaker-a2i-runtime/include/aws/sagemaker-a2i-runtime/AugmentedAIRuntimeClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -47,7 +48,8 @@ namespace AugmentedAIRuntime { */ class AWS_AUGMENTEDAIRUNTIME_API AugmentedAIRuntimeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AugmentedAIRuntimePaginationBase { + public AugmentedAIRuntimePaginationBase, + public AugmentedAIRuntimeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sagemaker-edge/include/aws/sagemaker-edge/SagemakerEdgeManagerClient.h b/generated/src/aws-cpp-sdk-sagemaker-edge/include/aws/sagemaker-edge/SagemakerEdgeManagerClient.h index 7d7de0d677d..acdac5a96e7 100644 --- a/generated/src/aws-cpp-sdk-sagemaker-edge/include/aws/sagemaker-edge/SagemakerEdgeManagerClient.h +++ b/generated/src/aws-cpp-sdk-sagemaker-edge/include/aws/sagemaker-edge/SagemakerEdgeManagerClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace SagemakerEdgeManager { class AWS_SAGEMAKEREDGEMANAGER_API SagemakerEdgeManagerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SagemakerEdgeManagerPaginationBase { + public SagemakerEdgeManagerPaginationBase, + public SagemakerEdgeManagerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sagemaker-featurestore-runtime/include/aws/sagemaker-featurestore-runtime/SageMakerFeatureStoreRuntimeClient.h b/generated/src/aws-cpp-sdk-sagemaker-featurestore-runtime/include/aws/sagemaker-featurestore-runtime/SageMakerFeatureStoreRuntimeClient.h index 77675e5dbad..356138c74b1 100644 --- a/generated/src/aws-cpp-sdk-sagemaker-featurestore-runtime/include/aws/sagemaker-featurestore-runtime/SageMakerFeatureStoreRuntimeClient.h +++ b/generated/src/aws-cpp-sdk-sagemaker-featurestore-runtime/include/aws/sagemaker-featurestore-runtime/SageMakerFeatureStoreRuntimeClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -32,7 +33,8 @@ namespace SageMakerFeatureStoreRuntime { class AWS_SAGEMAKERFEATURESTORERUNTIME_API SageMakerFeatureStoreRuntimeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SageMakerFeatureStoreRuntimePaginationBase { + public SageMakerFeatureStoreRuntimePaginationBase, + public SageMakerFeatureStoreRuntimeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sagemaker-geospatial/include/aws/sagemaker-geospatial/SageMakerGeospatialClient.h b/generated/src/aws-cpp-sdk-sagemaker-geospatial/include/aws/sagemaker-geospatial/SageMakerGeospatialClient.h index a501be9d15b..f097863253f 100644 --- a/generated/src/aws-cpp-sdk-sagemaker-geospatial/include/aws/sagemaker-geospatial/SageMakerGeospatialClient.h +++ b/generated/src/aws-cpp-sdk-sagemaker-geospatial/include/aws/sagemaker-geospatial/SageMakerGeospatialClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace SageMakerGeospatial { */ class AWS_SAGEMAKERGEOSPATIAL_API SageMakerGeospatialClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SageMakerGeospatialPaginationBase { + public SageMakerGeospatialPaginationBase, + public SageMakerGeospatialWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sagemaker-metrics/include/aws/sagemaker-metrics/SageMakerMetricsClient.h b/generated/src/aws-cpp-sdk-sagemaker-metrics/include/aws/sagemaker-metrics/SageMakerMetricsClient.h index 3a96e81b043..e189871a83b 100644 --- a/generated/src/aws-cpp-sdk-sagemaker-metrics/include/aws/sagemaker-metrics/SageMakerMetricsClient.h +++ b/generated/src/aws-cpp-sdk-sagemaker-metrics/include/aws/sagemaker-metrics/SageMakerMetricsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -23,7 +24,8 @@ namespace SageMakerMetrics { */ class AWS_SAGEMAKERMETRICS_API SageMakerMetricsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SageMakerMetricsPaginationBase { + public SageMakerMetricsPaginationBase, + public SageMakerMetricsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sagemaker-runtime-http2/include/aws/sagemaker-runtime-http2/SageMakerRuntimeHTTP2Client.h b/generated/src/aws-cpp-sdk-sagemaker-runtime-http2/include/aws/sagemaker-runtime-http2/SageMakerRuntimeHTTP2Client.h index ed4a265157a..b055bdc3134 100644 --- a/generated/src/aws-cpp-sdk-sagemaker-runtime-http2/include/aws/sagemaker-runtime-http2/SageMakerRuntimeHTTP2Client.h +++ b/generated/src/aws-cpp-sdk-sagemaker-runtime-http2/include/aws/sagemaker-runtime-http2/SageMakerRuntimeHTTP2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace SageMakerRuntimeHTTP2 { class AWS_SAGEMAKERRUNTIMEHTTP2_API SageMakerRuntimeHTTP2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SageMakerRuntimeHTTP2PaginationBase { + public SageMakerRuntimeHTTP2PaginationBase, + public SageMakerRuntimeHTTP2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sagemaker-runtime/include/aws/sagemaker-runtime/SageMakerRuntimeClient.h b/generated/src/aws-cpp-sdk-sagemaker-runtime/include/aws/sagemaker-runtime/SageMakerRuntimeClient.h index 023e392aaed..56cfe094ce8 100644 --- a/generated/src/aws-cpp-sdk-sagemaker-runtime/include/aws/sagemaker-runtime/SageMakerRuntimeClient.h +++ b/generated/src/aws-cpp-sdk-sagemaker-runtime/include/aws/sagemaker-runtime/SageMakerRuntimeClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace SageMakerRuntime { */ class AWS_SAGEMAKERRUNTIME_API SageMakerRuntimeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SageMakerRuntimePaginationBase { + public SageMakerRuntimePaginationBase, + public SageMakerRuntimeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerClient.h b/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerClient.h index 9abec7f6a19..73482bc5997 100644 --- a/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerClient.h +++ b/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace SageMaker { */ class AWS_SAGEMAKER_API SageMakerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SageMakerPaginationBase { + public SageMakerPaginationBase, + public SageMakerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h b/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h new file mode 100644 index 00000000000..a22eff5855f --- /dev/null +++ b/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h @@ -0,0 +1,364 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace SageMaker { + +template +class SageMakerWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilEndpointDeleted(const Model::DescribeEndpointRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EndpointStatusMapper::GetNameForEndpointStatus(result.GetEndpointStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeEndpointRequest& req) { return static_cast(this)->DescribeEndpoint(req); }; + Aws::Utils::Waiter waiter(30, 60, acceptors, operation, + "WaitUntilEndpointDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilEndpointInService(const Model::DescribeEndpointRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("InService"), + [](const Model::DescribeEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EndpointStatusMapper::GetNameForEndpointStatus(result.GetEndpointStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EndpointStatusMapper::GetNameForEndpointStatus(result.GetEndpointStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + + auto operation = [this](const Model::DescribeEndpointRequest& req) { return static_cast(this)->DescribeEndpoint(req); }; + Aws::Utils::Waiter waiter(30, 120, acceptors, operation, + "WaitUntilEndpointInService"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilImageCreated(const Model::DescribeImageRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATED"), + [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + + auto operation = [this](const Model::DescribeImageRequest& req) { return static_cast(this)->DescribeImage(req); }; + Aws::Utils::Waiter waiter(60, 60, acceptors, operation, + "WaitUntilImageCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilImageDeleted(const Model::DescribeImageRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + + auto operation = [this](const Model::DescribeImageRequest& req) { return static_cast(this)->DescribeImage(req); }; + Aws::Utils::Waiter waiter(60, 60, acceptors, operation, + "WaitUntilImageDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilImageUpdated(const Model::DescribeImageRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATED"), + [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), + [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + + auto operation = [this](const Model::DescribeImageRequest& req) { return static_cast(this)->DescribeImage(req); }; + Aws::Utils::Waiter waiter(60, 60, acceptors, operation, + "WaitUntilImageUpdated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilImageVersionCreated( + const Model::DescribeImageVersionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATED"), + [](const Model::DescribeImageVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageVersionStatusMapper::GetNameForImageVersionStatus(result.GetImageVersionStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeImageVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageVersionStatusMapper::GetNameForImageVersionStatus(result.GetImageVersionStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + + auto operation = [this](const Model::DescribeImageVersionRequest& req) { + return static_cast(this)->DescribeImageVersion(req); + }; + Aws::Utils::Waiter waiter(60, 60, acceptors, operation, + "WaitUntilImageVersionCreated"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilImageVersionDeleted( + const Model::DescribeImageVersionRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), + [](const Model::DescribeImageVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageVersionStatusMapper::GetNameForImageVersionStatus(result.GetImageVersionStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + + auto operation = [this](const Model::DescribeImageVersionRequest& req) { + return static_cast(this)->DescribeImageVersion(req); + }; + Aws::Utils::Waiter waiter(60, 60, acceptors, operation, + "WaitUntilImageVersionDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilNotebookInstanceDeleted( + const Model::DescribeNotebookInstanceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus( + result.GetNotebookInstanceStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeNotebookInstanceRequest& req) { + return static_cast(this)->DescribeNotebookInstance(req); + }; + Aws::Utils::Waiter waiter( + 30, 60, acceptors, operation, "WaitUntilNotebookInstanceDeleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilNotebookInstanceInService( + const Model::DescribeNotebookInstanceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("InService"), + [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus( + result.GetNotebookInstanceStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus( + result.GetNotebookInstanceStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeNotebookInstanceRequest& req) { + return static_cast(this)->DescribeNotebookInstance(req); + }; + Aws::Utils::Waiter waiter( + 30, 60, acceptors, operation, "WaitUntilNotebookInstanceInService"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilNotebookInstanceStopped( + const Model::DescribeNotebookInstanceRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Stopped"), + [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus( + result.GetNotebookInstanceStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus( + result.GetNotebookInstanceStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::DescribeNotebookInstanceRequest& req) { + return static_cast(this)->DescribeNotebookInstance(req); + }; + Aws::Utils::Waiter waiter( + 30, 60, acceptors, operation, "WaitUntilNotebookInstanceStopped"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilProcessingJobCompletedOrStopped( + const Model::DescribeProcessingJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), + [](const Model::DescribeProcessingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ProcessingJobStatusMapper::GetNameForProcessingJobStatus(result.GetProcessingJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Stopped"), + [](const Model::DescribeProcessingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ProcessingJobStatusMapper::GetNameForProcessingJobStatus(result.GetProcessingJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeProcessingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ProcessingJobStatusMapper::GetNameForProcessingJobStatus(result.GetProcessingJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + + auto operation = [this](const Model::DescribeProcessingJobRequest& req) { + return static_cast(this)->DescribeProcessingJob(req); + }; + Aws::Utils::Waiter waiter( + 60, 60, acceptors, operation, "WaitUntilProcessingJobCompletedOrStopped"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTrainingJobCompletedOrStopped( + const Model::DescribeTrainingJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), + [](const Model::DescribeTrainingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TrainingJobStatusMapper::GetNameForTrainingJobStatus(result.GetTrainingJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Stopped"), + [](const Model::DescribeTrainingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TrainingJobStatusMapper::GetNameForTrainingJobStatus(result.GetTrainingJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeTrainingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TrainingJobStatusMapper::GetNameForTrainingJobStatus(result.GetTrainingJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + + auto operation = [this](const Model::DescribeTrainingJobRequest& req) { + return static_cast(this)->DescribeTrainingJob(req); + }; + Aws::Utils::Waiter waiter( + 120, 180, acceptors, operation, "WaitUntilTrainingJobCompletedOrStopped"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTransformJobCompletedOrStopped( + const Model::DescribeTransformJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), + [](const Model::DescribeTransformJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TransformJobStatusMapper::GetNameForTransformJobStatus(result.GetTransformJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Stopped"), + [](const Model::DescribeTransformJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TransformJobStatusMapper::GetNameForTransformJobStatus(result.GetTransformJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeTransformJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TransformJobStatusMapper::GetNameForTransformJobStatus(result.GetTransformJobStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + + auto operation = [this](const Model::DescribeTransformJobRequest& req) { + return static_cast(this)->DescribeTransformJob(req); + }; + Aws::Utils::Waiter waiter( + 60, 60, acceptors, operation, "WaitUntilTransformJobCompletedOrStopped"); + return waiter.Wait(request); + } +}; +} // namespace SageMaker +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-savingsplans/include/aws/savingsplans/SavingsPlansClient.h b/generated/src/aws-cpp-sdk-savingsplans/include/aws/savingsplans/SavingsPlansClient.h index c2bfa32b461..e673ea6811f 100644 --- a/generated/src/aws-cpp-sdk-savingsplans/include/aws/savingsplans/SavingsPlansClient.h +++ b/generated/src/aws-cpp-sdk-savingsplans/include/aws/savingsplans/SavingsPlansClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace SavingsPlans { */ class AWS_SAVINGSPLANS_API SavingsPlansClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SavingsPlansPaginationBase { + public SavingsPlansPaginationBase, + public SavingsPlansWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-scheduler/include/aws/scheduler/SchedulerClient.h b/generated/src/aws-cpp-sdk-scheduler/include/aws/scheduler/SchedulerClient.h index 46256a1cc2b..73fd8f336b3 100644 --- a/generated/src/aws-cpp-sdk-scheduler/include/aws/scheduler/SchedulerClient.h +++ b/generated/src/aws-cpp-sdk-scheduler/include/aws/scheduler/SchedulerClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace Scheduler { */ class AWS_SCHEDULER_API SchedulerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SchedulerPaginationBase { + public SchedulerPaginationBase, + public SchedulerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasClient.h b/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasClient.h index ff0a3832524..fd075534fbb 100644 --- a/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasClient.h +++ b/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace Schemas { */ class AWS_SCHEMAS_API SchemasClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SchemasPaginationBase { + public SchemasPaginationBase, + public SchemasWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h b/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h new file mode 100644 index 00000000000..f5c1a67fa58 --- /dev/null +++ b/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h @@ -0,0 +1,56 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace Schemas { + +template +class SchemasWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilCodeBindingExists( + const Model::DescribeCodeBindingRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), + [](const Model::DescribeCodeBindingOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CodeGenerationStatusMapper::GetNameForCodeGenerationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_IN_PROGRESS"), + [](const Model::DescribeCodeBindingOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CodeGenerationStatusMapper::GetNameForCodeGenerationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), + [](const Model::DescribeCodeBindingOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CodeGenerationStatusMapper::GetNameForCodeGenerationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("NotFoundException")}); + + auto operation = [this](const Model::DescribeCodeBindingRequest& req) { + return static_cast(this)->DescribeCodeBinding(req); + }; + Aws::Utils::Waiter waiter(2, 60, acceptors, operation, + "WaitUntilCodeBindingExists"); + return waiter.Wait(request); + } +}; +} // namespace Schemas +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sdb/include/aws/sdb/SimpleDBClient.h b/generated/src/aws-cpp-sdk-sdb/include/aws/sdb/SimpleDBClient.h index c02cf838baa..7d80be43f23 100644 --- a/generated/src/aws-cpp-sdk-sdb/include/aws/sdb/SimpleDBClient.h +++ b/generated/src/aws-cpp-sdk-sdb/include/aws/sdb/SimpleDBClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -33,7 +34,8 @@ namespace SimpleDB { */ class AWS_SIMPLEDB_API SimpleDBClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SimpleDBPaginationBase { + public SimpleDBPaginationBase, + public SimpleDBWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-secretsmanager/include/aws/secretsmanager/SecretsManagerClient.h b/generated/src/aws-cpp-sdk-secretsmanager/include/aws/secretsmanager/SecretsManagerClient.h index 6181eda0fc7..e62ce8bf6a6 100644 --- a/generated/src/aws-cpp-sdk-secretsmanager/include/aws/secretsmanager/SecretsManagerClient.h +++ b/generated/src/aws-cpp-sdk-secretsmanager/include/aws/secretsmanager/SecretsManagerClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -50,7 +51,8 @@ namespace SecretsManager { */ class AWS_SECRETSMANAGER_API SecretsManagerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SecretsManagerPaginationBase { + public SecretsManagerPaginationBase, + public SecretsManagerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-security-ir/include/aws/security-ir/SecurityIRClient.h b/generated/src/aws-cpp-sdk-security-ir/include/aws/security-ir/SecurityIRClient.h index 7e8007cb466..55b2ae40499 100644 --- a/generated/src/aws-cpp-sdk-security-ir/include/aws/security-ir/SecurityIRClient.h +++ b/generated/src/aws-cpp-sdk-security-ir/include/aws/security-ir/SecurityIRClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace SecurityIR { */ class AWS_SECURITYIR_API SecurityIRClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SecurityIRPaginationBase { + public SecurityIRPaginationBase, + public SecurityIRWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-securityhub/include/aws/securityhub/SecurityHubClient.h b/generated/src/aws-cpp-sdk-securityhub/include/aws/securityhub/SecurityHubClient.h index 9e8fde443f5..499a170323f 100644 --- a/generated/src/aws-cpp-sdk-securityhub/include/aws/securityhub/SecurityHubClient.h +++ b/generated/src/aws-cpp-sdk-securityhub/include/aws/securityhub/SecurityHubClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -87,7 +88,8 @@ namespace SecurityHub { */ class AWS_SECURITYHUB_API SecurityHubClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SecurityHubPaginationBase { + public SecurityHubPaginationBase, + public SecurityHubWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-securitylake/include/aws/securitylake/SecurityLakeClient.h b/generated/src/aws-cpp-sdk-securitylake/include/aws/securitylake/SecurityLakeClient.h index 68f4e374c0a..0771ce7fd51 100644 --- a/generated/src/aws-cpp-sdk-securitylake/include/aws/securitylake/SecurityLakeClient.h +++ b/generated/src/aws-cpp-sdk-securitylake/include/aws/securitylake/SecurityLakeClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -50,7 +51,8 @@ namespace SecurityLake { */ class AWS_SECURITYLAKE_API SecurityLakeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SecurityLakePaginationBase { + public SecurityLakePaginationBase, + public SecurityLakeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-serverlessrepo/include/aws/serverlessrepo/ServerlessApplicationRepositoryClient.h b/generated/src/aws-cpp-sdk-serverlessrepo/include/aws/serverlessrepo/ServerlessApplicationRepositoryClient.h index 534f51cacd0..f41415b4b3b 100644 --- a/generated/src/aws-cpp-sdk-serverlessrepo/include/aws/serverlessrepo/ServerlessApplicationRepositoryClient.h +++ b/generated/src/aws-cpp-sdk-serverlessrepo/include/aws/serverlessrepo/ServerlessApplicationRepositoryClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -64,7 +65,8 @@ developers, and publish new versions of applications.

class AWS_SERVERLESSAPPLICATIONREPOSITORY_API ServerlessApplicationRepositoryClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ServerlessApplicationRepositoryPaginationBase { + public ServerlessApplicationRepositoryPaginationBase, + public ServerlessApplicationRepositoryWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-service-quotas/include/aws/service-quotas/ServiceQuotasClient.h b/generated/src/aws-cpp-sdk-service-quotas/include/aws/service-quotas/ServiceQuotasClient.h index e4360de96a9..5482adc8d40 100644 --- a/generated/src/aws-cpp-sdk-service-quotas/include/aws/service-quotas/ServiceQuotasClient.h +++ b/generated/src/aws-cpp-sdk-service-quotas/include/aws/service-quotas/ServiceQuotasClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace ServiceQuotas { */ class AWS_SERVICEQUOTAS_API ServiceQuotasClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ServiceQuotasPaginationBase { + public ServiceQuotasPaginationBase, + public ServiceQuotasWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-servicecatalog-appregistry/include/aws/servicecatalog-appregistry/AppRegistryClient.h b/generated/src/aws-cpp-sdk-servicecatalog-appregistry/include/aws/servicecatalog-appregistry/AppRegistryClient.h index 0c0d4b216a2..df5c834e159 100644 --- a/generated/src/aws-cpp-sdk-servicecatalog-appregistry/include/aws/servicecatalog-appregistry/AppRegistryClient.h +++ b/generated/src/aws-cpp-sdk-servicecatalog-appregistry/include/aws/servicecatalog-appregistry/AppRegistryClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace AppRegistry { */ class AWS_APPREGISTRY_API AppRegistryClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public AppRegistryPaginationBase { + public AppRegistryPaginationBase, + public AppRegistryWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-servicecatalog/include/aws/servicecatalog/ServiceCatalogClient.h b/generated/src/aws-cpp-sdk-servicecatalog/include/aws/servicecatalog/ServiceCatalogClient.h index 4c79b152c96..412a5bb21b0 100644 --- a/generated/src/aws-cpp-sdk-servicecatalog/include/aws/servicecatalog/ServiceCatalogClient.h +++ b/generated/src/aws-cpp-sdk-servicecatalog/include/aws/servicecatalog/ServiceCatalogClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace ServiceCatalog { */ class AWS_SERVICECATALOG_API ServiceCatalogClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ServiceCatalogPaginationBase { + public ServiceCatalogPaginationBase, + public ServiceCatalogWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-servicediscovery/include/aws/servicediscovery/ServiceDiscoveryClient.h b/generated/src/aws-cpp-sdk-servicediscovery/include/aws/servicediscovery/ServiceDiscoveryClient.h index 258eff0d4a4..4b4340c830e 100644 --- a/generated/src/aws-cpp-sdk-servicediscovery/include/aws/servicediscovery/ServiceDiscoveryClient.h +++ b/generated/src/aws-cpp-sdk-servicediscovery/include/aws/servicediscovery/ServiceDiscoveryClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace ServiceDiscovery { */ class AWS_SERVICEDISCOVERY_API ServiceDiscoveryClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ServiceDiscoveryPaginationBase { + public ServiceDiscoveryPaginationBase, + public ServiceDiscoveryWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sesv2/include/aws/sesv2/SESV2Client.h b/generated/src/aws-cpp-sdk-sesv2/include/aws/sesv2/SESV2Client.h index 06528f620f9..aa4cc54e9bd 100644 --- a/generated/src/aws-cpp-sdk-sesv2/include/aws/sesv2/SESV2Client.h +++ b/generated/src/aws-cpp-sdk-sesv2/include/aws/sesv2/SESV2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace SESV2 { */ class AWS_SESV2_API SESV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SESV2PaginationBase { + public SESV2PaginationBase, + public SESV2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-shield/include/aws/shield/ShieldClient.h b/generated/src/aws-cpp-sdk-shield/include/aws/shield/ShieldClient.h index c7c48b509c3..e4a9d4c7943 100644 --- a/generated/src/aws-cpp-sdk-shield/include/aws/shield/ShieldClient.h +++ b/generated/src/aws-cpp-sdk-shield/include/aws/shield/ShieldClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace Shield { */ class AWS_SHIELD_API ShieldClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ShieldPaginationBase { + public ShieldPaginationBase, + public ShieldWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-signer-data/include/aws/signer-data/SignerDataClient.h b/generated/src/aws-cpp-sdk-signer-data/include/aws/signer-data/SignerDataClient.h index a60f24a3bbf..27d7143fcb1 100644 --- a/generated/src/aws-cpp-sdk-signer-data/include/aws/signer-data/SignerDataClient.h +++ b/generated/src/aws-cpp-sdk-signer-data/include/aws/signer-data/SignerDataClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace SignerData { */ class AWS_SIGNERDATA_API SignerDataClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SignerDataPaginationBase { + public SignerDataPaginationBase, + public SignerDataWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerClient.h b/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerClient.h index 7275ecdf950..d795a5a905b 100644 --- a/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerClient.h +++ b/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -45,7 +46,8 @@ namespace signer { */ class AWS_SIGNER_API SignerClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SignerPaginationBase { + public SignerPaginationBase, + public SignerWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h b/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h new file mode 100644 index 00000000000..250a82d68dd --- /dev/null +++ b/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h @@ -0,0 +1,47 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace signer { + +template +class SignerWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilSuccessfulSigningJob( + const Model::DescribeSigningJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Succeeded"), + [](const Model::DescribeSigningJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SigningStatusMapper::GetNameForSigningStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::DescribeSigningJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SigningStatusMapper::GetNameForSigningStatus(result.GetStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + + auto operation = [this](const Model::DescribeSigningJobRequest& req) { + return static_cast(this)->DescribeSigningJob(req); + }; + Aws::Utils::Waiter waiter(20, 6, acceptors, operation, + "WaitUntilSuccessfulSigningJob"); + return waiter.Wait(request); + } +}; +} // namespace signer +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-signin/include/aws/signin/SigninClient.h b/generated/src/aws-cpp-sdk-signin/include/aws/signin/SigninClient.h index 41b97486c87..54c8082eea0 100644 --- a/generated/src/aws-cpp-sdk-signin/include/aws/signin/SigninClient.h +++ b/generated/src/aws-cpp-sdk-signin/include/aws/signin/SigninClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace Signin { */ class AWS_SIGNIN_API SigninClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SigninPaginationBase { + public SigninPaginationBase, + public SigninWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Client.h b/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Client.h index ce4318e4b42..cc7949aafdb 100644 --- a/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Client.h +++ b/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace SimpleDBv2 { */ class AWS_SIMPLEDBV2_API SimpleDBv2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SimpleDBv2PaginationBase { + public SimpleDBv2PaginationBase, + public SimpleDBv2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h b/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h new file mode 100644 index 00000000000..6207cee11e9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h @@ -0,0 +1,44 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace SimpleDBv2 { + +template +class SimpleDBv2Waiter { + public: + Aws::Utils::WaiterOutcome WaitUntilExportSucceeded(const Model::GetExportRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), + [](const Model::GetExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetExportRequest& req) { return static_cast(this)->GetExport(req); }; + Aws::Utils::Waiter waiter(30, 4, acceptors, operation, "WaitUntilExportSucceeded"); + return waiter.Wait(request); + } +}; +} // namespace SimpleDBv2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-simspaceweaver/include/aws/simspaceweaver/SimSpaceWeaverClient.h b/generated/src/aws-cpp-sdk-simspaceweaver/include/aws/simspaceweaver/SimSpaceWeaverClient.h index d119769e975..b617df518d7 100644 --- a/generated/src/aws-cpp-sdk-simspaceweaver/include/aws/simspaceweaver/SimSpaceWeaverClient.h +++ b/generated/src/aws-cpp-sdk-simspaceweaver/include/aws/simspaceweaver/SimSpaceWeaverClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -30,7 +31,8 @@ namespace SimSpaceWeaver { */ class AWS_SIMSPACEWEAVER_API SimSpaceWeaverClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SimSpaceWeaverPaginationBase { + public SimSpaceWeaverPaginationBase, + public SimSpaceWeaverWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sms-voice/include/aws/sms-voice/PinpointSMSVoiceClient.h b/generated/src/aws-cpp-sdk-sms-voice/include/aws/sms-voice/PinpointSMSVoiceClient.h index fc5980a3833..9fed004b14d 100644 --- a/generated/src/aws-cpp-sdk-sms-voice/include/aws/sms-voice/PinpointSMSVoiceClient.h +++ b/generated/src/aws-cpp-sdk-sms-voice/include/aws/sms-voice/PinpointSMSVoiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace PinpointSMSVoice { */ class AWS_PINPOINTSMSVOICE_API PinpointSMSVoiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public PinpointSMSVoicePaginationBase { + public PinpointSMSVoicePaginationBase, + public PinpointSMSVoiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-snow-device-management/include/aws/snow-device-management/SnowDeviceManagementClient.h b/generated/src/aws-cpp-sdk-snow-device-management/include/aws/snow-device-management/SnowDeviceManagementClient.h index b97106eb945..92de4a38f30 100644 --- a/generated/src/aws-cpp-sdk-snow-device-management/include/aws/snow-device-management/SnowDeviceManagementClient.h +++ b/generated/src/aws-cpp-sdk-snow-device-management/include/aws/snow-device-management/SnowDeviceManagementClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace SnowDeviceManagement { class AWS_SNOWDEVICEMANAGEMENT_API SnowDeviceManagementClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SnowDeviceManagementPaginationBase { + public SnowDeviceManagementPaginationBase, + public SnowDeviceManagementWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-snowball/include/aws/snowball/SnowballClient.h b/generated/src/aws-cpp-sdk-snowball/include/aws/snowball/SnowballClient.h index 6d621a12b77..d4ca42a7aa8 100644 --- a/generated/src/aws-cpp-sdk-snowball/include/aws/snowball/SnowballClient.h +++ b/generated/src/aws-cpp-sdk-snowball/include/aws/snowball/SnowballClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -29,7 +30,8 @@ namespace Snowball { */ class AWS_SNOWBALL_API SnowballClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SnowballPaginationBase { + public SnowballPaginationBase, + public SnowballWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sns/include/aws/sns/SNSClient.h b/generated/src/aws-cpp-sdk-sns/include/aws/sns/SNSClient.h index fee1e50f51d..6bb3f68624e 100644 --- a/generated/src/aws-cpp-sdk-sns/include/aws/sns/SNSClient.h +++ b/generated/src/aws-cpp-sdk-sns/include/aws/sns/SNSClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -37,7 +38,8 @@ namespace SNS { */ class AWS_SNS_API SNSClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SNSPaginationBase { + public SNSPaginationBase, + public SNSWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-socialmessaging/include/aws/socialmessaging/SocialMessagingClient.h b/generated/src/aws-cpp-sdk-socialmessaging/include/aws/socialmessaging/SocialMessagingClient.h index 98e88c3d3ac..f43e5963e8f 100644 --- a/generated/src/aws-cpp-sdk-socialmessaging/include/aws/socialmessaging/SocialMessagingClient.h +++ b/generated/src/aws-cpp-sdk-socialmessaging/include/aws/socialmessaging/SocialMessagingClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -57,7 +58,8 @@ namespace SocialMessaging { */ class AWS_SOCIALMESSAGING_API SocialMessagingClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SocialMessagingPaginationBase { + public SocialMessagingPaginationBase, + public SocialMessagingWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sqs/include/aws/sqs/SQSClient.h b/generated/src/aws-cpp-sdk-sqs/include/aws/sqs/SQSClient.h index b3a509e5504..5539af093b5 100644 --- a/generated/src/aws-cpp-sdk-sqs/include/aws/sqs/SQSClient.h +++ b/generated/src/aws-cpp-sdk-sqs/include/aws/sqs/SQSClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -43,7 +44,8 @@ namespace SQS { */ class AWS_SQS_API SQSClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SQSPaginationBase { + public SQSPaginationBase, + public SQSWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ssm-contacts/include/aws/ssm-contacts/SSMContactsClient.h b/generated/src/aws-cpp-sdk-ssm-contacts/include/aws/ssm-contacts/SSMContactsClient.h index ea3749c7703..96a92ee8c86 100644 --- a/generated/src/aws-cpp-sdk-ssm-contacts/include/aws/ssm-contacts/SSMContactsClient.h +++ b/generated/src/aws-cpp-sdk-ssm-contacts/include/aws/ssm-contacts/SSMContactsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -27,7 +28,8 @@ namespace SSMContacts { */ class AWS_SSMCONTACTS_API SSMContactsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SSMContactsPaginationBase { + public SSMContactsPaginationBase, + public SSMContactsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ssm-guiconnect/include/aws/ssm-guiconnect/SSMGuiConnectClient.h b/generated/src/aws-cpp-sdk-ssm-guiconnect/include/aws/ssm-guiconnect/SSMGuiConnectClient.h index 4a3e5e47f43..8cd5ad49881 100644 --- a/generated/src/aws-cpp-sdk-ssm-guiconnect/include/aws/ssm-guiconnect/SSMGuiConnectClient.h +++ b/generated/src/aws-cpp-sdk-ssm-guiconnect/include/aws/ssm-guiconnect/SSMGuiConnectClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -36,7 +37,8 @@ namespace SSMGuiConnect { */ class AWS_SSMGUICONNECT_API SSMGuiConnectClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SSMGuiConnectPaginationBase { + public SSMGuiConnectPaginationBase, + public SSMGuiConnectWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsClient.h b/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsClient.h index 6648a784991..1901ab12275 100644 --- a/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsClient.h +++ b/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -27,7 +28,8 @@ namespace SSMIncidents { */ class AWS_SSMINCIDENTS_API SSMIncidentsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SSMIncidentsPaginationBase { + public SSMIncidentsPaginationBase, + public SSMIncidentsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h b/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h new file mode 100644 index 00000000000..57f3705fe19 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h @@ -0,0 +1,82 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include + +#include + +namespace Aws { +namespace SSMIncidents { + +template +class SSMIncidentsWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilWaitForReplicationSetActive( + const Model::GetReplicationSetRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetReplicationSetRequest& req) { + return static_cast(this)->GetReplicationSet(req); + }; + Aws::Utils::Waiter waiter(30, 1, acceptors, operation, + "WaitUntilWaitForReplicationSetActive"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilWaitForReplicationSetDeleted( + const Model::GetReplicationSetRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + }}); + + auto operation = [this](const Model::GetReplicationSetRequest& req) { + return static_cast(this)->GetReplicationSet(req); + }; + Aws::Utils::Waiter waiter(30, 1, acceptors, operation, + "WaitUntilWaitForReplicationSetDeleted"); + return waiter.Wait(request); + } +}; +} // namespace SSMIncidents +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ssm-quicksetup/include/aws/ssm-quicksetup/SSMQuickSetupClient.h b/generated/src/aws-cpp-sdk-ssm-quicksetup/include/aws/ssm-quicksetup/SSMQuickSetupClient.h index b1b38225b9a..9de97e7fc9a 100644 --- a/generated/src/aws-cpp-sdk-ssm-quicksetup/include/aws/ssm-quicksetup/SSMQuickSetupClient.h +++ b/generated/src/aws-cpp-sdk-ssm-quicksetup/include/aws/ssm-quicksetup/SSMQuickSetupClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace SSMQuickSetup { */ class AWS_SSMQUICKSETUP_API SSMQuickSetupClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SSMQuickSetupPaginationBase { + public SSMQuickSetupPaginationBase, + public SSMQuickSetupWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ssm-sap/include/aws/ssm-sap/SsmSapClient.h b/generated/src/aws-cpp-sdk-ssm-sap/include/aws/ssm-sap/SsmSapClient.h index 91c3e2d9669..e0d4644bbd0 100644 --- a/generated/src/aws-cpp-sdk-ssm-sap/include/aws/ssm-sap/SsmSapClient.h +++ b/generated/src/aws-cpp-sdk-ssm-sap/include/aws/ssm-sap/SsmSapClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace SsmSap { */ class AWS_SSMSAP_API SsmSapClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SsmSapPaginationBase { + public SsmSapPaginationBase, + public SsmSapWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMClient.h b/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMClient.h index 78bbb155b31..53df188f92f 100644 --- a/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMClient.h +++ b/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -44,7 +45,8 @@ namespace SSM { */ class AWS_SSM_API SSMClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SSMPaginationBase { + public SSMPaginationBase, + public SSMWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h b/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h new file mode 100644 index 00000000000..2f4d6f09610 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h @@ -0,0 +1,91 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace SSM { + +template +class SSMWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilCommandExecuted( + const Model::GetCommandInvocationRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Pending"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("InProgress"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Delayed"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Success"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Cancelled"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TimedOut"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Cancelling"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvocationDoesNotExist")}); + + auto operation = [this](const Model::GetCommandInvocationRequest& req) { + return static_cast(this)->GetCommandInvocation(req); + }; + Aws::Utils::Waiter waiter(5, 24, acceptors, operation, + "WaitUntilCommandExecuted"); + return waiter.Wait(request); + } +}; +} // namespace SSM +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sso-admin/include/aws/sso-admin/SSOAdminClient.h b/generated/src/aws-cpp-sdk-sso-admin/include/aws/sso-admin/SSOAdminClient.h index 196f874f60b..4a7ef800b77 100644 --- a/generated/src/aws-cpp-sdk-sso-admin/include/aws/sso-admin/SSOAdminClient.h +++ b/generated/src/aws-cpp-sdk-sso-admin/include/aws/sso-admin/SSOAdminClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -43,7 +44,8 @@ namespace SSOAdmin { */ class AWS_SSOADMIN_API SSOAdminClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SSOAdminPaginationBase { + public SSOAdminPaginationBase, + public SSOAdminWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sso-oidc/include/aws/sso-oidc/SSOOIDCClient.h b/generated/src/aws-cpp-sdk-sso-oidc/include/aws/sso-oidc/SSOOIDCClient.h index 704608752a6..465b014e919 100644 --- a/generated/src/aws-cpp-sdk-sso-oidc/include/aws/sso-oidc/SSOOIDCClient.h +++ b/generated/src/aws-cpp-sdk-sso-oidc/include/aws/sso-oidc/SSOOIDCClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -51,7 +52,8 @@ namespace SSOOIDC { */ class AWS_SSOOIDC_API SSOOIDCClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SSOOIDCPaginationBase { + public SSOOIDCPaginationBase, + public SSOOIDCWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sso/include/aws/sso/SSOClient.h b/generated/src/aws-cpp-sdk-sso/include/aws/sso/SSOClient.h index 798798be820..1d8762b4c61 100644 --- a/generated/src/aws-cpp-sdk-sso/include/aws/sso/SSOClient.h +++ b/generated/src/aws-cpp-sdk-sso/include/aws/sso/SSOClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -35,7 +36,8 @@ namespace SSO { */ class AWS_SSO_API SSOClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SSOPaginationBase { + public SSOPaginationBase, + public SSOWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-states/include/aws/states/SFNClient.h b/generated/src/aws-cpp-sdk-states/include/aws/states/SFNClient.h index e1c719c0b95..dfd5d1261d4 100644 --- a/generated/src/aws-cpp-sdk-states/include/aws/states/SFNClient.h +++ b/generated/src/aws-cpp-sdk-states/include/aws/states/SFNClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -34,7 +35,8 @@ namespace SFN { */ class AWS_SFN_API SFNClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SFNPaginationBase { + public SFNPaginationBase, + public SFNWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-storagegateway/include/aws/storagegateway/StorageGatewayClient.h b/generated/src/aws-cpp-sdk-storagegateway/include/aws/storagegateway/StorageGatewayClient.h index e973e7e8554..2a97e05047b 100644 --- a/generated/src/aws-cpp-sdk-storagegateway/include/aws/storagegateway/StorageGatewayClient.h +++ b/generated/src/aws-cpp-sdk-storagegateway/include/aws/storagegateway/StorageGatewayClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -66,7 +67,8 @@ namespace StorageGateway { */ class AWS_STORAGEGATEWAY_API StorageGatewayClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public StorageGatewayPaginationBase { + public StorageGatewayPaginationBase, + public StorageGatewayWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-sts/include/aws/sts/STSClient.h b/generated/src/aws-cpp-sdk-sts/include/aws/sts/STSClient.h index 1bc11bf3a1a..560cf11bac5 100644 --- a/generated/src/aws-cpp-sdk-sts/include/aws/sts/STSClient.h +++ b/generated/src/aws-cpp-sdk-sts/include/aws/sts/STSClient.h @@ -11,6 +11,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace STS { */ class AWS_STS_API STSClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public STSPaginationBase { + public STSPaginationBase, + public STSWaiter { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-supplychain/include/aws/supplychain/SupplyChainClient.h b/generated/src/aws-cpp-sdk-supplychain/include/aws/supplychain/SupplyChainClient.h index f407904fe95..d84ef747486 100644 --- a/generated/src/aws-cpp-sdk-supplychain/include/aws/supplychain/SupplyChainClient.h +++ b/generated/src/aws-cpp-sdk-supplychain/include/aws/supplychain/SupplyChainClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -27,7 +28,8 @@ namespace SupplyChain { */ class AWS_SUPPLYCHAIN_API SupplyChainClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SupplyChainPaginationBase { + public SupplyChainPaginationBase, + public SupplyChainWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-support-app/include/aws/support-app/SupportAppClient.h b/generated/src/aws-cpp-sdk-support-app/include/aws/support-app/SupportAppClient.h index 812e075c0ec..207621dab75 100644 --- a/generated/src/aws-cpp-sdk-support-app/include/aws/support-app/SupportAppClient.h +++ b/generated/src/aws-cpp-sdk-support-app/include/aws/support-app/SupportAppClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -48,7 +49,8 @@ namespace SupportApp { */ class AWS_SUPPORTAPP_API SupportAppClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SupportAppPaginationBase { + public SupportAppPaginationBase, + public SupportAppWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-support/include/aws/support/SupportClient.h b/generated/src/aws-cpp-sdk-support/include/aws/support/SupportClient.h index ee215fa9fa4..bd853094697 100644 --- a/generated/src/aws-cpp-sdk-support/include/aws/support/SupportClient.h +++ b/generated/src/aws-cpp-sdk-support/include/aws/support/SupportClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -57,7 +58,8 @@ namespace Support { */ class AWS_SUPPORT_API SupportClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SupportPaginationBase { + public SupportPaginationBase, + public SupportWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-swf/include/aws/swf/SWFClient.h b/generated/src/aws-cpp-sdk-swf/include/aws/swf/SWFClient.h index 81d252455cb..537f2b1f67b 100644 --- a/generated/src/aws-cpp-sdk-swf/include/aws/swf/SWFClient.h +++ b/generated/src/aws-cpp-sdk-swf/include/aws/swf/SWFClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -31,7 +32,8 @@ namespace SWF { */ class AWS_SWF_API SWFClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SWFPaginationBase { + public SWFPaginationBase, + public SWFWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-synthetics/include/aws/synthetics/SyntheticsClient.h b/generated/src/aws-cpp-sdk-synthetics/include/aws/synthetics/SyntheticsClient.h index fe78383f51c..8ea85c4a8a4 100644 --- a/generated/src/aws-cpp-sdk-synthetics/include/aws/synthetics/SyntheticsClient.h +++ b/generated/src/aws-cpp-sdk-synthetics/include/aws/synthetics/SyntheticsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -33,7 +34,8 @@ namespace Synthetics { */ class AWS_SYNTHETICS_API SyntheticsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public SyntheticsPaginationBase { + public SyntheticsPaginationBase, + public SyntheticsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-taxsettings/include/aws/taxsettings/TaxSettingsClient.h b/generated/src/aws-cpp-sdk-taxsettings/include/aws/taxsettings/TaxSettingsClient.h index a3a8c742cfa..6a4abcbc468 100644 --- a/generated/src/aws-cpp-sdk-taxsettings/include/aws/taxsettings/TaxSettingsClient.h +++ b/generated/src/aws-cpp-sdk-taxsettings/include/aws/taxsettings/TaxSettingsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace TaxSettings { */ class AWS_TAXSETTINGS_API TaxSettingsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public TaxSettingsPaginationBase { + public TaxSettingsPaginationBase, + public TaxSettingsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-textract/include/aws/textract/TextractClient.h b/generated/src/aws-cpp-sdk-textract/include/aws/textract/TextractClient.h index e3b4b6dddd2..6b71952bbcb 100644 --- a/generated/src/aws-cpp-sdk-textract/include/aws/textract/TextractClient.h +++ b/generated/src/aws-cpp-sdk-textract/include/aws/textract/TextractClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace Textract { */ class AWS_TEXTRACT_API TextractClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public TextractPaginationBase { + public TextractPaginationBase, + public TextractWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-timestream-influxdb/include/aws/timestream-influxdb/TimestreamInfluxDBClient.h b/generated/src/aws-cpp-sdk-timestream-influxdb/include/aws/timestream-influxdb/TimestreamInfluxDBClient.h index cfadaceda8e..2f00094c957 100644 --- a/generated/src/aws-cpp-sdk-timestream-influxdb/include/aws/timestream-influxdb/TimestreamInfluxDBClient.h +++ b/generated/src/aws-cpp-sdk-timestream-influxdb/include/aws/timestream-influxdb/TimestreamInfluxDBClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace TimestreamInfluxDB { */ class AWS_TIMESTREAMINFLUXDB_API TimestreamInfluxDBClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public TimestreamInfluxDBPaginationBase { + public TimestreamInfluxDBPaginationBase, + public TimestreamInfluxDBWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-timestream-query/include/aws/timestream-query/TimestreamQueryClient.h b/generated/src/aws-cpp-sdk-timestream-query/include/aws/timestream-query/TimestreamQueryClient.h index 5a5ff4087ad..868dad3ff34 100644 --- a/generated/src/aws-cpp-sdk-timestream-query/include/aws/timestream-query/TimestreamQueryClient.h +++ b/generated/src/aws-cpp-sdk-timestream-query/include/aws/timestream-query/TimestreamQueryClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace TimestreamQuery { */ class AWS_TIMESTREAMQUERY_API TimestreamQueryClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public TimestreamQueryPaginationBase { + public TimestreamQueryPaginationBase, + public TimestreamQueryWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-timestream-write/include/aws/timestream-write/TimestreamWriteClient.h b/generated/src/aws-cpp-sdk-timestream-write/include/aws/timestream-write/TimestreamWriteClient.h index c843a838be5..4553bf793f0 100644 --- a/generated/src/aws-cpp-sdk-timestream-write/include/aws/timestream-write/TimestreamWriteClient.h +++ b/generated/src/aws-cpp-sdk-timestream-write/include/aws/timestream-write/TimestreamWriteClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -32,7 +33,8 @@ namespace TimestreamWrite { */ class AWS_TIMESTREAMWRITE_API TimestreamWriteClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public TimestreamWritePaginationBase { + public TimestreamWritePaginationBase, + public TimestreamWriteWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-tnb/include/aws/tnb/TnbClient.h b/generated/src/aws-cpp-sdk-tnb/include/aws/tnb/TnbClient.h index a5b69bab5b7..e95fc92137f 100644 --- a/generated/src/aws-cpp-sdk-tnb/include/aws/tnb/TnbClient.h +++ b/generated/src/aws-cpp-sdk-tnb/include/aws/tnb/TnbClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -22,7 +23,8 @@ namespace tnb { */ class AWS_TNB_API TnbClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public TnbPaginationBase { + public TnbPaginationBase, + public TnbWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceClient.h b/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceClient.h index b83f24faa66..7ee68abb352 100644 --- a/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceClient.h +++ b/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -28,7 +29,8 @@ namespace TranscribeService { */ class AWS_TRANSCRIBESERVICE_API TranscribeServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public TranscribeServicePaginationBase { + public TranscribeServicePaginationBase, + public TranscribeServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h b/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h new file mode 100644 index 00000000000..3025c06badf --- /dev/null +++ b/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h @@ -0,0 +1,217 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace Aws { +namespace TranscribeService { + +template +class TranscribeServiceWaiter { + public: + Aws::Utils::WaiterOutcome WaitUntilLanguageModelCompleted( + const Model::DescribeLanguageModelRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::DescribeLanguageModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ModelStatusMapper::GetNameForModelStatus(result.GetLanguageModel().GetModelStatus()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::DescribeLanguageModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ModelStatusMapper::GetNameForModelStatus(result.GetLanguageModel().GetModelStatus()) == + expected.get(); + }}); + + auto operation = [this](const Model::DescribeLanguageModelRequest& req) { + return static_cast(this)->DescribeLanguageModel(req); + }; + Aws::Utils::Waiter waiter(120, 1, acceptors, operation, + "WaitUntilLanguageModelCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilCallAnalyticsJobCompleted( + const Model::GetCallAnalyticsJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetCallAnalyticsJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CallAnalyticsJobStatusMapper::GetNameForCallAnalyticsJobStatus( + result.GetCallAnalyticsJob().GetCallAnalyticsJobStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetCallAnalyticsJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CallAnalyticsJobStatusMapper::GetNameForCallAnalyticsJobStatus( + result.GetCallAnalyticsJob().GetCallAnalyticsJobStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetCallAnalyticsJobRequest& req) { + return static_cast(this)->GetCallAnalyticsJob(req); + }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilCallAnalyticsJobCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilMedicalScribeJobCompleted( + const Model::GetMedicalScribeJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetMedicalScribeJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MedicalScribeJobStatusMapper::GetNameForMedicalScribeJobStatus( + result.GetMedicalScribeJob().GetMedicalScribeJobStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetMedicalScribeJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MedicalScribeJobStatusMapper::GetNameForMedicalScribeJobStatus( + result.GetMedicalScribeJob().GetMedicalScribeJobStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetMedicalScribeJobRequest& req) { + return static_cast(this)->GetMedicalScribeJob(req); + }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilMedicalScribeJobCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilMedicalTranscriptionJobCompleted( + const Model::GetMedicalTranscriptionJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetMedicalTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( + result.GetMedicalTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetMedicalTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( + result.GetMedicalTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetMedicalTranscriptionJobRequest& req) { + return static_cast(this)->GetMedicalTranscriptionJob(req); + }; + Aws::Utils::Waiter waiter( + 10, 12, acceptors, operation, "WaitUntilMedicalTranscriptionJobCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilMedicalVocabularyReady( + const Model::GetMedicalVocabularyRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("READY"), + [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetMedicalVocabularyRequest& req) { + return static_cast(this)->GetMedicalVocabulary(req); + }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilMedicalVocabularyReady"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilTranscriptionJobCompleted( + const Model::GetTranscriptionJobRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), + [](const Model::GetTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( + result.GetTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( + result.GetTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); + }}); + + auto operation = [this](const Model::GetTranscriptionJobRequest& req) { + return static_cast(this)->GetTranscriptionJob(req); + }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilTranscriptionJobCompleted"); + return waiter.Wait(request); + } + + Aws::Utils::WaiterOutcome WaitUntilVocabularyReady(const Model::GetVocabularyRequest& request) { + std::vector> acceptors; + acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("READY"), + [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == + expected.get(); + }}); + acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), + [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == + expected.get(); + }}); + + auto operation = [this](const Model::GetVocabularyRequest& req) { return static_cast(this)->GetVocabulary(req); }; + Aws::Utils::Waiter waiter(10, 12, acceptors, operation, + "WaitUntilVocabularyReady"); + return waiter.Wait(request); + } +}; +} // namespace TranscribeService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-transcribestreaming/include/aws/transcribestreaming/TranscribeStreamingServiceClient.h b/generated/src/aws-cpp-sdk-transcribestreaming/include/aws/transcribestreaming/TranscribeStreamingServiceClient.h index 5f3a251b71c..d285a40d088 100644 --- a/generated/src/aws-cpp-sdk-transcribestreaming/include/aws/transcribestreaming/TranscribeStreamingServiceClient.h +++ b/generated/src/aws-cpp-sdk-transcribestreaming/include/aws/transcribestreaming/TranscribeStreamingServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -33,7 +34,8 @@ namespace TranscribeStreamingService { class AWS_TRANSCRIBESTREAMINGSERVICE_API TranscribeStreamingServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public TranscribeStreamingServicePaginationBase { + public TranscribeStreamingServicePaginationBase, + public TranscribeStreamingServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-translate/include/aws/translate/TranslateClient.h b/generated/src/aws-cpp-sdk-translate/include/aws/translate/TranslateClient.h index b8824ea1a0d..65b3c26c8c9 100644 --- a/generated/src/aws-cpp-sdk-translate/include/aws/translate/TranslateClient.h +++ b/generated/src/aws-cpp-sdk-translate/include/aws/translate/TranslateClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace Translate { */ class AWS_TRANSLATE_API TranslateClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public TranslatePaginationBase { + public TranslatePaginationBase, + public TranslateWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-trustedadvisor/include/aws/trustedadvisor/TrustedAdvisorClient.h b/generated/src/aws-cpp-sdk-trustedadvisor/include/aws/trustedadvisor/TrustedAdvisorClient.h index 381a085222f..28b2a026452 100644 --- a/generated/src/aws-cpp-sdk-trustedadvisor/include/aws/trustedadvisor/TrustedAdvisorClient.h +++ b/generated/src/aws-cpp-sdk-trustedadvisor/include/aws/trustedadvisor/TrustedAdvisorClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -19,7 +20,8 @@ namespace TrustedAdvisor { */ class AWS_TRUSTEDADVISOR_API TrustedAdvisorClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public TrustedAdvisorPaginationBase { + public TrustedAdvisorPaginationBase, + public TrustedAdvisorWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-verifiedpermissions/include/aws/verifiedpermissions/VerifiedPermissionsClient.h b/generated/src/aws-cpp-sdk-verifiedpermissions/include/aws/verifiedpermissions/VerifiedPermissionsClient.h index b4b65a3429e..16d88888c16 100644 --- a/generated/src/aws-cpp-sdk-verifiedpermissions/include/aws/verifiedpermissions/VerifiedPermissionsClient.h +++ b/generated/src/aws-cpp-sdk-verifiedpermissions/include/aws/verifiedpermissions/VerifiedPermissionsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -66,7 +67,8 @@ namespace VerifiedPermissions { */ class AWS_VERIFIEDPERMISSIONS_API VerifiedPermissionsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public VerifiedPermissionsPaginationBase { + public VerifiedPermissionsPaginationBase, + public VerifiedPermissionsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-voice-id/include/aws/voice-id/VoiceIDClient.h b/generated/src/aws-cpp-sdk-voice-id/include/aws/voice-id/VoiceIDClient.h index 9c92a07f63a..9b01d3c5b2d 100644 --- a/generated/src/aws-cpp-sdk-voice-id/include/aws/voice-id/VoiceIDClient.h +++ b/generated/src/aws-cpp-sdk-voice-id/include/aws/voice-id/VoiceIDClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace VoiceID { */ class AWS_VOICEID_API VoiceIDClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public VoiceIDPaginationBase { + public VoiceIDPaginationBase, + public VoiceIDWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-vpc-lattice/include/aws/vpc-lattice/VPCLatticeClient.h b/generated/src/aws-cpp-sdk-vpc-lattice/include/aws/vpc-lattice/VPCLatticeClient.h index db5e9aa0894..ca3669f7cc3 100644 --- a/generated/src/aws-cpp-sdk-vpc-lattice/include/aws/vpc-lattice/VPCLatticeClient.h +++ b/generated/src/aws-cpp-sdk-vpc-lattice/include/aws/vpc-lattice/VPCLatticeClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -25,7 +26,8 @@ namespace VPCLattice { */ class AWS_VPCLATTICE_API VPCLatticeClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public VPCLatticePaginationBase { + public VPCLatticePaginationBase, + public VPCLatticeWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-waf-regional/include/aws/waf-regional/WAFRegionalClient.h b/generated/src/aws-cpp-sdk-waf-regional/include/aws/waf-regional/WAFRegionalClient.h index 01f381bf861..58b1070e35a 100644 --- a/generated/src/aws-cpp-sdk-waf-regional/include/aws/waf-regional/WAFRegionalClient.h +++ b/generated/src/aws-cpp-sdk-waf-regional/include/aws/waf-regional/WAFRegionalClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -39,7 +40,8 @@ namespace WAFRegional { */ class AWS_WAFREGIONAL_API WAFRegionalClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WAFRegionalPaginationBase { + public WAFRegionalPaginationBase, + public WAFRegionalWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-waf/include/aws/waf/WAFClient.h b/generated/src/aws-cpp-sdk-waf/include/aws/waf/WAFClient.h index ca53389dd68..c97438ecc50 100644 --- a/generated/src/aws-cpp-sdk-waf/include/aws/waf/WAFClient.h +++ b/generated/src/aws-cpp-sdk-waf/include/aws/waf/WAFClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -35,7 +36,8 @@ namespace WAF { */ class AWS_WAF_API WAFClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WAFPaginationBase { + public WAFPaginationBase, + public WAFWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-wafv2/include/aws/wafv2/WAFV2Client.h b/generated/src/aws-cpp-sdk-wafv2/include/aws/wafv2/WAFV2Client.h index e4736fa1efc..55e89e3e33b 100644 --- a/generated/src/aws-cpp-sdk-wafv2/include/aws/wafv2/WAFV2Client.h +++ b/generated/src/aws-cpp-sdk-wafv2/include/aws/wafv2/WAFV2Client.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -56,7 +57,8 @@ namespace WAFV2 { */ class AWS_WAFV2_API WAFV2Client : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WAFV2PaginationBase { + public WAFV2PaginationBase, + public WAFV2Waiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-wellarchitected/include/aws/wellarchitected/WellArchitectedClient.h b/generated/src/aws-cpp-sdk-wellarchitected/include/aws/wellarchitected/WellArchitectedClient.h index 97fb0a29115..78f79cb9dcb 100644 --- a/generated/src/aws-cpp-sdk-wellarchitected/include/aws/wellarchitected/WellArchitectedClient.h +++ b/generated/src/aws-cpp-sdk-wellarchitected/include/aws/wellarchitected/WellArchitectedClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace WellArchitected { */ class AWS_WELLARCHITECTED_API WellArchitectedClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WellArchitectedPaginationBase { + public WellArchitectedPaginationBase, + public WellArchitectedWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-wickr/include/aws/wickr/WickrClient.h b/generated/src/aws-cpp-sdk-wickr/include/aws/wickr/WickrClient.h index 2553e8773fc..91b9e60473b 100644 --- a/generated/src/aws-cpp-sdk-wickr/include/aws/wickr/WickrClient.h +++ b/generated/src/aws-cpp-sdk-wickr/include/aws/wickr/WickrClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -60,7 +61,8 @@ namespace Wickr { */ class AWS_WICKR_API WickrClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WickrPaginationBase { + public WickrPaginationBase, + public WickrWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-wisdom/include/aws/wisdom/ConnectWisdomServiceClient.h b/generated/src/aws-cpp-sdk-wisdom/include/aws/wisdom/ConnectWisdomServiceClient.h index f73f8b1345c..da8a5767942 100644 --- a/generated/src/aws-cpp-sdk-wisdom/include/aws/wisdom/ConnectWisdomServiceClient.h +++ b/generated/src/aws-cpp-sdk-wisdom/include/aws/wisdom/ConnectWisdomServiceClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -24,7 +25,8 @@ namespace ConnectWisdomService { class AWS_CONNECTWISDOMSERVICE_API ConnectWisdomServiceClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public ConnectWisdomServicePaginationBase { + public ConnectWisdomServicePaginationBase, + public ConnectWisdomServiceWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-workdocs/include/aws/workdocs/WorkDocsClient.h b/generated/src/aws-cpp-sdk-workdocs/include/aws/workdocs/WorkDocsClient.h index bf29a0c7482..28a79881b86 100644 --- a/generated/src/aws-cpp-sdk-workdocs/include/aws/workdocs/WorkDocsClient.h +++ b/generated/src/aws-cpp-sdk-workdocs/include/aws/workdocs/WorkDocsClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -50,7 +51,8 @@ namespace WorkDocs { */ class AWS_WORKDOCS_API WorkDocsClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WorkDocsPaginationBase { + public WorkDocsPaginationBase, + public WorkDocsWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-workmail/include/aws/workmail/WorkMailClient.h b/generated/src/aws-cpp-sdk-workmail/include/aws/workmail/WorkMailClient.h index 1eeadcab59a..15baa7e5031 100644 --- a/generated/src/aws-cpp-sdk-workmail/include/aws/workmail/WorkMailClient.h +++ b/generated/src/aws-cpp-sdk-workmail/include/aws/workmail/WorkMailClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -37,7 +38,8 @@ namespace WorkMail { */ class AWS_WORKMAIL_API WorkMailClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WorkMailPaginationBase { + public WorkMailPaginationBase, + public WorkMailWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-workmailmessageflow/include/aws/workmailmessageflow/WorkMailMessageFlowClient.h b/generated/src/aws-cpp-sdk-workmailmessageflow/include/aws/workmailmessageflow/WorkMailMessageFlowClient.h index f64234be8e0..a00eba4be42 100644 --- a/generated/src/aws-cpp-sdk-workmailmessageflow/include/aws/workmailmessageflow/WorkMailMessageFlowClient.h +++ b/generated/src/aws-cpp-sdk-workmailmessageflow/include/aws/workmailmessageflow/WorkMailMessageFlowClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace WorkMailMessageFlow { */ class AWS_WORKMAILMESSAGEFLOW_API WorkMailMessageFlowClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WorkMailMessageFlowPaginationBase { + public WorkMailMessageFlowPaginationBase, + public WorkMailMessageFlowWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-workspaces-instances/include/aws/workspaces-instances/WorkspacesInstancesClient.h b/generated/src/aws-cpp-sdk-workspaces-instances/include/aws/workspaces-instances/WorkspacesInstancesClient.h index db69ca9003a..8eb1d5c55c2 100644 --- a/generated/src/aws-cpp-sdk-workspaces-instances/include/aws/workspaces-instances/WorkspacesInstancesClient.h +++ b/generated/src/aws-cpp-sdk-workspaces-instances/include/aws/workspaces-instances/WorkspacesInstancesClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -21,7 +22,8 @@ namespace WorkspacesInstances { */ class AWS_WORKSPACESINSTANCES_API WorkspacesInstancesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WorkspacesInstancesPaginationBase { + public WorkspacesInstancesPaginationBase, + public WorkspacesInstancesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-workspaces-thin-client/include/aws/workspaces-thin-client/WorkSpacesThinClientClient.h b/generated/src/aws-cpp-sdk-workspaces-thin-client/include/aws/workspaces-thin-client/WorkSpacesThinClientClient.h index 24ce6048929..3e71551aabd 100644 --- a/generated/src/aws-cpp-sdk-workspaces-thin-client/include/aws/workspaces-thin-client/WorkSpacesThinClientClient.h +++ b/generated/src/aws-cpp-sdk-workspaces-thin-client/include/aws/workspaces-thin-client/WorkSpacesThinClientClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -36,7 +37,8 @@ namespace WorkSpacesThinClient { class AWS_WORKSPACESTHINCLIENT_API WorkSpacesThinClientClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WorkSpacesThinClientPaginationBase { + public WorkSpacesThinClientPaginationBase, + public WorkSpacesThinClientWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-workspaces-web/include/aws/workspaces-web/WorkSpacesWebClient.h b/generated/src/aws-cpp-sdk-workspaces-web/include/aws/workspaces-web/WorkSpacesWebClient.h index e65692ceca9..cb51b03ba1b 100644 --- a/generated/src/aws-cpp-sdk-workspaces-web/include/aws/workspaces-web/WorkSpacesWebClient.h +++ b/generated/src/aws-cpp-sdk-workspaces-web/include/aws/workspaces-web/WorkSpacesWebClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -26,7 +27,8 @@ namespace WorkSpacesWeb { */ class AWS_WORKSPACESWEB_API WorkSpacesWebClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WorkSpacesWebPaginationBase { + public WorkSpacesWebPaginationBase, + public WorkSpacesWebWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-workspaces/include/aws/workspaces/WorkSpacesClient.h b/generated/src/aws-cpp-sdk-workspaces/include/aws/workspaces/WorkSpacesClient.h index 11ace168534..292eaf8b71c 100644 --- a/generated/src/aws-cpp-sdk-workspaces/include/aws/workspaces/WorkSpacesClient.h +++ b/generated/src/aws-cpp-sdk-workspaces/include/aws/workspaces/WorkSpacesClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -41,7 +42,8 @@ namespace WorkSpaces { */ class AWS_WORKSPACES_API WorkSpacesClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public WorkSpacesPaginationBase { + public WorkSpacesPaginationBase, + public WorkSpacesWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); diff --git a/generated/src/aws-cpp-sdk-xray/include/aws/xray/XRayClient.h b/generated/src/aws-cpp-sdk-xray/include/aws/xray/XRayClient.h index ffb94230c3c..04c52fec4ad 100644 --- a/generated/src/aws-cpp-sdk-xray/include/aws/xray/XRayClient.h +++ b/generated/src/aws-cpp-sdk-xray/include/aws/xray/XRayClient.h @@ -10,6 +10,7 @@ #include #include #include +#include #include namespace Aws { @@ -20,7 +21,8 @@ namespace XRay { */ class AWS_XRAY_API XRayClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods, - public XRayPaginationBase { + public XRayPaginationBase, + public XRayWaiter { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* GetServiceName(); From 473e1e50d04bc3b56519eaf1bec3e57388550948 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Tue, 17 Mar 2026 13:47:31 -0400 Subject: [PATCH 08/21] Add namespace mapping to WaiterCodeGenPlugin --- .../generators/waiters/WaiterCodegenPlugin.java | 2 +- .../generators/waiters/WaiterHeaderGenerator.java | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java index 653aec07b8f..e829e2fa611 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java @@ -47,7 +47,7 @@ public void execute(PluginContext context) { String serviceName = ServiceNameUtil.getServiceNameUpperCamel(featureParser.getService()); featureParser.generateClientHeader( serviceName + "Waiter.h", - writer -> new WaiterHeaderGenerator(featureParser.getService(), featureParser.getOperations(), featureParser.getServiceMap(), model).render(writer) + writer -> new WaiterHeaderGenerator(featureParser.getService(), featureParser.getOperations(), featureParser.getServiceMap(), model, featureParser.getNamespaceMap()).render(writer) ); }); } diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java index f29278160c2..9d96bd8f7e8 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java @@ -28,8 +28,8 @@ public class WaiterHeaderGenerator extends BaseHeaderGenerator generatedCode = new HashMap<>(); public WaiterHeaderGenerator(ServiceShape service, List waiterOps, - Map serviceMap, Model model) { - super(service, waiterOps, serviceMap); + Map serviceMap, Model model, Map namespaceMap) { + super(service, waiterOps, serviceMap, namespaceMap); this.model = model; } From b550a2e09fa8fd646c33c9452d9ffe1141aae843 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Tue, 17 Mar 2026 16:35:44 -0400 Subject: [PATCH 09/21] generate Waiter.h for clients that don't have waiters modeled --- .../waiters/WaiterCodegenPlugin.java | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java index e829e2fa611..371c1e60175 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterCodegenPlugin.java @@ -41,16 +41,15 @@ public void execute(PluginContext context) { }) .collect(Collectors.toList()); - if (!waiterOps.isEmpty()) { - FeatureParser parser = new FeatureParser<>(context, processedService, waiterOps, "Waiter"); - parser.run(featureParser -> { - String serviceName = ServiceNameUtil.getServiceNameUpperCamel(featureParser.getService()); - featureParser.generateClientHeader( - serviceName + "Waiter.h", - writer -> new WaiterHeaderGenerator(featureParser.getService(), featureParser.getOperations(), featureParser.getServiceMap(), model, featureParser.getNamespaceMap()).render(writer) - ); - }); - } + // Always generate ServiceWaiter.h, even if empty (matches pagination pattern) + FeatureParser parser = new FeatureParser<>(context, processedService, waiterOps, "Waiter"); + parser.run(featureParser -> { + String serviceName = ServiceNameUtil.getServiceNameUpperCamel(featureParser.getService()); + featureParser.generateClientHeader( + serviceName + "Waiter.h", + writer -> new WaiterHeaderGenerator(featureParser.getService(), featureParser.getOperations(), featureParser.getServiceMap(), model, featureParser.getNamespaceMap()).render(writer) + ); + }); } } } From d78cc487f3a095392f5cd604ff7b907954afbad6 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Tue, 17 Mar 2026 17:31:34 -0400 Subject: [PATCH 10/21] Seperate different acceptors into seperate structs/classes --- .../include/aws/core/utils/Waiter.h | 156 +++++++++--------- 1 file changed, 74 insertions(+), 82 deletions(-) diff --git a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h index c1981b1ad30..b081fb3c029 100644 --- a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h +++ b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h @@ -10,6 +10,7 @@ #include #include +#include #include #include #include @@ -18,7 +19,6 @@ namespace Aws { namespace Utils { enum class WaiterState { SUCCESS, RETRY, FAILURE }; -enum class MatcherType { STATUS, ERROR, PATH, PATH_ALL, PATH_ANY }; enum class WaiterErrors { MAX_ATTEMPTS, INVALID_ACTION }; using ExpectedValue = Crt::Variant; @@ -30,46 +30,85 @@ using WaiterOutcome = Outcome; template struct Acceptor { WaiterState state; - MatcherType matcher; - ExpectedValue expected; - std::function pathMatcher; - - Acceptor(WaiterState s, MatcherType m, ExpectedValue e, std::function pm = [](const OutcomeT&, const ExpectedValue&) { return false; }) - : state(s), matcher(m), expected(std::move(e)), pathMatcher(std::move(pm)) {} + explicit Acceptor(WaiterState s) : state(s) {} + virtual ~Acceptor() = default; + virtual bool Matches(const OutcomeT& outcome) const = 0; }; template -using PathMatcher = std::function; +struct StatusAcceptor : Acceptor { + int expectedStatus; + StatusAcceptor(WaiterState s, int status) : Acceptor(s), expectedStatus(status) {} + bool Matches(const OutcomeT& outcome) const override { + return GetStatusCode(outcome) == expectedStatus; + } -template -class Waiter { - bool Matches(const Acceptor& acceptor, const OutcomeT& outcome) { - switch (acceptor.matcher) { - case MatcherType::STATUS: { - int status = GetStatusCode(outcome); - return status == acceptor.expected.template get(); - } - case MatcherType::ERROR: { - if (acceptor.expected.template holds_alternative()) { - bool expectError = acceptor.expected.template get(); - return outcome.IsSuccess() != expectError; - } - if (!outcome.IsSuccess()) { - auto errorCode = outcome.GetError().GetExceptionName(); - return errorCode == acceptor.expected.template get(); - } - return false; - } - case MatcherType::PATH: - case MatcherType::PATH_ALL: - case MatcherType::PATH_ANY: - return acceptor.pathMatcher ? acceptor.pathMatcher(outcome, acceptor.expected) : false; + private: + template + struct HasGetHttpResponseCode { + template static auto test(int) -> decltype(std::declval().GetHttpResponseCode(), std::true_type()); + template static std::false_type test(...); + static constexpr bool value = decltype(test(0))::value; + }; + template + struct HasGetResponseCode { + template static auto test(int) -> decltype(std::declval().GetResponseCode(), std::true_type()); + template static std::false_type test(...); + static constexpr bool value = decltype(test(0))::value; + }; + template + static int GetStatusCodeFromResult(const T& result) { + static_assert(HasGetHttpResponseCode::value, "Result type must have GetHttpResponseCode() method"); + return static_cast(result.GetHttpResponseCode()); + } + template + static int GetStatusCodeFromError(const T& error) { + static_assert(HasGetResponseCode::value, "Error type must have GetResponseCode() method"); + return static_cast(error.GetResponseCode()); + } + static int GetStatusCode(const OutcomeT& outcome) { + return outcome.IsSuccess() + ? GetStatusCodeFromResult(outcome.GetResult()) + : GetStatusCodeFromError(outcome.GetError()); + } +}; + +template +struct ErrorAcceptor : Acceptor { + ExpectedValue expected; + ErrorAcceptor(WaiterState s, ExpectedValue e) : Acceptor(s), expected(std::move(e)) {} + bool Matches(const OutcomeT& outcome) const override { + if (this->expected.holds_alternative()) { + return outcome.IsSuccess() != this->expected.get(); + } + if (!outcome.IsSuccess()) { + return outcome.GetError().GetExceptionName() == this->expected.get(); } return false; } +}; + +template +using PathMatcherFn = std::function; + +template +struct PathAcceptor : Acceptor { + ExpectedValue expected; + PathMatcherFn pathMatcher; + PathAcceptor(WaiterState s, ExpectedValue e, PathMatcherFn pm) + : Acceptor(s), expected(std::move(e)), pathMatcher(std::move(pm)) {} + bool Matches(const OutcomeT& outcome) const override { + return pathMatcher ? pathMatcher(outcome, expected) : false; + } +}; + +template +class Waiter { public: - Waiter(int delay, int maxAttempts, std::vector> acceptors, std::function op, + using AcceptorPtr = Aws::UniquePtr>; + + Waiter(int delay, int maxAttempts, std::vector acceptors, std::function op, const Aws::String& waiterName = "Waiter") : m_delay(delay), m_maxAttempts(maxAttempts), @@ -82,9 +121,9 @@ class Waiter { auto outcome = m_operation(request); auto matched = std::find_if(m_acceptors.begin(), m_acceptors.end(), - [this, &outcome](const Acceptor& acceptor) -> bool { return Matches(acceptor, outcome); }); + [&outcome](const AcceptorPtr& acceptor) -> bool { return acceptor->Matches(outcome); }); if (matched != m_acceptors.end()) { - switch (matched->state) { + switch (matched->get()->state) { case WaiterState::SUCCESS: return WaiterOutcome(outcome); case WaiterState::FAILURE: @@ -106,56 +145,9 @@ class Waiter { private: int m_delay; int m_maxAttempts; - std::vector> m_acceptors; + std::vector m_acceptors; std::function m_operation; Aws::String m_name; - /** - * Returns the HTTP status code from the result or error. - * Result objects use GetHttpResponseCode(), errors use GetResponseCode(). - */ - inline int GetStatusCode(OutcomeT outcome) const { - return outcome.IsSuccess() - ? GetStatusCodeFromResult(outcome.GetResult()) - : GetStatusCodeFromError(outcome.GetError()); - } - - template - struct has_get_http_response_code - { - template - static auto test(int) -> decltype(std::declval().GetHttpResponseCode(), std::true_type()); - - template - static std::false_type test(...); - - static constexpr bool value = decltype(test(0))::value; - }; - - template - struct has_get_response_code - { - template - static auto test(int) -> decltype(std::declval().GetResponseCode(), std::true_type()); - - template - static std::false_type test(...); - - static constexpr bool value = decltype(test(0))::value; - }; - - template - static int GetStatusCodeFromResult(const T& result) - { - static_assert(has_get_http_response_code::value, "Result type must have GetHttpResponseCode() method"); - return static_cast(result.GetHttpResponseCode()); - } - - template - static int GetStatusCodeFromError(const T& error) - { - static_assert(has_get_response_code::value, "Error type must have GetResponseCode() method"); - return static_cast(error.GetResponseCode()); - } }; } // namespace Utils From 37964bf3e95b4b1c700f28260208f232aa87bfa4 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Wed, 18 Mar 2026 11:29:16 -0400 Subject: [PATCH 11/21] Update codegen to use new Acceptor structs --- .../waiters/WaiterHeaderGenerator.java | 66 +++++++++---------- 1 file changed, 30 insertions(+), 36 deletions(-) diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java index 9d96bd8f7e8..a24333d0f3e 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java @@ -14,7 +14,6 @@ import software.amazon.smithy.waiters.AcceptorState; import software.amazon.smithy.waiters.Matcher; import software.amazon.smithy.waiters.PathMatcher; -import software.amazon.smithy.waiters.PathComparator; import java.util.HashMap; import java.util.HashSet; import java.util.List; @@ -48,6 +47,7 @@ protected void writeSpecificIncludes(CppWriter writer, String serviceName, Strin String classPrefix = ServiceNameUtil.getServiceNameUpperCamel(service); writer.writeInclude("aws/" + smithyServiceName + "/" + classPrefix + "Client.h"); writer.writeInclude("aws/core/utils/Waiter.h"); + writer.writeInclude("aws/core/utils/memory/AWSMemory.h"); writer.writeInclude("algorithm"); for (WaiterOperationData data : operations) { @@ -115,91 +115,85 @@ private void writeWaiterMethod(CppWriter writer, WaiterOperationData data) { String opName = data.getOperation().getId().getName(); String methodName = ShapeUtil.getOperationMethodName(opName, smithyServiceName); String waiterFuncName = "WaitUntil" + ServiceNameUtil.capitalize(data.getWaiterName()); + String waiterTag = ServiceNameUtil.capitalize(data.getWaiterName()) + "Waiter"; String outcomeType = "Model::" + methodName + "Outcome"; + String requestType = "Model::" + methodName + "Request"; writer.write(""); writer.openBlock("Aws::Utils::WaiterOutcome<" + outcomeType + "> " + waiterFuncName + "(const Model::" + methodName + "Request& request) {", "}", () -> { - writer.write("std::vector> acceptors;"); + writer.write("using OutcomeT = $L;", outcomeType); + writer.write("using RequestT = $L;", requestType); + writer.write("std::vector>> acceptors;"); for (Acceptor acceptor : data.getWaiter().getAcceptors()) { - writeAcceptor(writer, acceptor, outcomeType, data); + writeAcceptor(writer, acceptor, waiterTag, data); } int delay = data.getWaiter().getMinDelay(); int maxAttempts = data.getWaiter().getMaxDelay() / delay; writer.write(""); - writer.write("auto operation = [this](const Model::$LRequest& req) { return static_cast(this)->$L(req); };", - methodName, methodName); - writer.write("Aws::Utils::Waiter waiter(", methodName, outcomeType); - writer.write(" $L, $L, acceptors, operation, \"$L\");", delay, maxAttempts, waiterFuncName); + writer.write("auto operation = [this](const RequestT& req) { return static_cast(this)->$L(req); };", + methodName); + writer.write("Aws::Utils::Waiter waiter("); + writer.write(" $L, $L, std::move(acceptors), operation, \"$L\");", + delay, maxAttempts, waiterFuncName); writer.write("return waiter.Wait(request);"); }); } - private void writeAcceptor(CppWriter writer, Acceptor acceptor, String outcomeType, + private void writeAcceptor(CppWriter writer, Acceptor acceptor, String waiterTag, WaiterOperationData data) { String state = waiterStateToEnum(acceptor.getState()); Matcher matcher = acceptor.getMatcher(); if (matcher instanceof Matcher.SuccessMember) { boolean expectSuccess = ((Matcher.SuccessMember) matcher).getValue(); - writer.write("acceptors.push_back({"); - writer.write(" $L,", state); - writer.write(" Aws::Utils::MatcherType::ERROR,"); - writer.write(" $L", expectSuccess ? "false" : "true"); - writer.write("});"); + writer.write("acceptors.emplace_back(Aws::MakeUnique>(\"$L\", $L, $L));", + waiterTag, state, expectSuccess ? "false" : "true"); } else if (matcher instanceof Matcher.ErrorTypeMember) { String errorType = ((Matcher.ErrorTypeMember) matcher).getValue(); - if(!C2J_LOST_ERRORS.containsKey(errorType)) { - writer.write("acceptors.push_back({"); - writer.write(" $L,", state); - writer.write(" Aws::Utils::MatcherType::ERROR,"); - writer.write(" Aws::String(\"$L\")", errorType); - writer.write("});"); + if (!C2J_LOST_ERRORS.containsKey(errorType)) { + writer.write("acceptors.emplace_back(Aws::MakeUnique>(\"$L\", $L, Aws::String(\"$L\")));", + waiterTag, state, errorType); } else { int statusCode = C2J_LOST_ERRORS.get(errorType); - writer.write("acceptors.push_back({"); - writer.write(" $L,", state); - writer.write(" Aws::Utils::MatcherType::STATUS,"); - writer.write(" $L", statusCode); - writer.write("});"); + writer.write("acceptors.emplace_back(Aws::MakeUnique>(\"$L\", $L, $L));", + waiterTag, state, statusCode); } } else if (matcher instanceof Matcher.OutputMember) { writePathAcceptor(writer, ((Matcher.OutputMember) matcher).getValue(), - state, outcomeType, data); + state, waiterTag, data); } else if (matcher instanceof Matcher.InputOutputMember) { writePathAcceptor(writer, ((Matcher.InputOutputMember) matcher).getValue(), - state, outcomeType, data); + state, waiterTag, data); } else { throw new UnsupportedOperationException("Unsupported matcher type: " + matcher.getClass().getSimpleName()); } } private void writePathAcceptor(CppWriter writer, PathMatcher pathMatcher, - String state, String outcomeType, WaiterOperationData data) { + String state, String waiterTag, WaiterOperationData data) { String expected = pathMatcher.getExpected(); - PathComparator comparator = pathMatcher.getComparator(); - - writer.write("acceptors.push_back({"); - writer.write(" $L,", state); - writer.write(" Aws::Utils::MatcherType::PATH,"); + String expectedExpr; if ("true".equals(expected) || "false".equals(expected)) { - writer.write(" $L,", expected); + expectedExpr = expected; } else { try { Integer.parseInt(expected); - writer.write(" $L,", expected); + expectedExpr = expected; } catch (NumberFormatException e) { - writer.write(" Aws::String(\"$L\"),", expected); + expectedExpr = "Aws::String(\"" + expected + "\")"; } } + writer.write("acceptors.emplace_back(Aws::MakeUnique>(\"$L\", $L, $L,", + waiterTag, state, expectedExpr); writer.write(generatedCode.get(pathMatcher).getCode()); - writer.write("});"); + writer.write("));"); } private static String waiterStateToEnum(AcceptorState state) { From ac024392bd8df04aa8425aa88a9491700a55159c Mon Sep 17 00:00:00 2001 From: sbaluja Date: Wed, 18 Mar 2026 11:33:34 -0400 Subject: [PATCH 12/21] Return Optional in private methods of CollectionElementTypeResolver --- .../CollectionElementTypeResolver.java | 71 +++++++++---------- 1 file changed, 32 insertions(+), 39 deletions(-) diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java index 8916928c4ad..d2bce09f20b 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java @@ -13,6 +13,8 @@ import software.amazon.smithy.model.shapes.OperationShape; import software.amazon.smithy.model.shapes.Shape; +import java.util.Optional; + /** * Resolves the C++ element type for a collection referenced by a JMESPath expression. * Returns "auto" when the model is unavailable or the type cannot be determined. @@ -38,85 +40,76 @@ public static String resolve(JmespathExpression expr, Model model, OperationShap public static String resolveFromShape(JmespathExpression expr, Shape current, Model model, String smithyServiceName) { if (model == null || current == null) return "auto"; - Shape element = findFirstListElement(expr, current, model); - if (element == null || !element.isStructureShape()) return "auto"; - String shapeName = element.getId().getName(); - // EC2 renames *Result shapes to *Response - if ("ec2".equals(smithyServiceName) && shapeName.endsWith("Result")) { - shapeName = shapeName.substring(0, shapeName.length() - 6) + "Response"; - } - return "Model::" + shapeName; + return findFirstListElement(expr, current, model) + .filter(Shape::isStructureShape) + .map(element -> { + String shapeName = element.getId().getName(); + if ("ec2".equals(smithyServiceName) && shapeName.endsWith("Result")) { + shapeName = shapeName.substring(0, shapeName.length() - 6) + "Response"; + } + return "Model::" + shapeName; + }) + .orElse("auto"); } /** * Finds the element shape of the first list encountered when walking the projection's * collection path (the left side of the projection). */ - private static Shape findFirstListElement(JmespathExpression expr, Shape current, Model model) { - if (current == null) return null; - + private static Optional findFirstListElement(JmespathExpression expr, Shape current, Model model) { if (expr instanceof ProjectionExpression) { return findFirstListInPath(((ProjectionExpression) expr).getLeft(), current, model); } else if (expr instanceof FlattenExpression) { return findFirstListElement(((FlattenExpression) expr).getExpression(), current, model); } else if (expr instanceof Subexpression) { Subexpression sub = (Subexpression) expr; - Shape afterLeft = walkFields(sub.getLeft(), current, model); - return afterLeft != null ? findFirstListElement(sub.getRight(), afterLeft, model) : null; + return walkFields(sub.getLeft(), current, model) + .flatMap(afterLeft -> findFirstListElement(sub.getRight(), afterLeft, model)); } - return null; + return Optional.empty(); } /** * Walks the left side of a projection to find the first list shape and return its element. * Stops at the first list encountered (the collection being iterated). */ - private static Shape findFirstListInPath(JmespathExpression expr, Shape current, Model model) { - if (current == null) return null; - + private static Optional findFirstListInPath(JmespathExpression expr, Shape current, Model model) { if (expr instanceof FieldExpression) { - Shape target = resolveMemberTarget(current, ((FieldExpression) expr).getName(), model); - if (target != null && target.isListShape()) { - return model.expectShape(target.asListShape().get().getMember().getTarget()); - } - return null; + return resolveMemberTarget(current, ((FieldExpression) expr).getName(), model) + .filter(Shape::isListShape) + .map(target -> model.expectShape(target.asListShape().get().getMember().getTarget())); } else if (expr instanceof Subexpression) { - // Walk fields until we hit a list Subexpression sub = (Subexpression) expr; - Shape afterLeft = walkFields(sub.getLeft(), current, model); - if (afterLeft != null && afterLeft.isListShape()) { - return model.expectShape(afterLeft.asListShape().get().getMember().getTarget()); + Optional afterLeft = walkFields(sub.getLeft(), current, model); + if (afterLeft.filter(Shape::isListShape).isPresent()) { + return afterLeft.map(s -> model.expectShape(s.asListShape().get().getMember().getTarget())); } - return findFirstListInPath(sub.getRight(), afterLeft, model); + return afterLeft.flatMap(s -> findFirstListInPath(sub.getRight(), s, model)); } else if (expr instanceof FlattenExpression) { return findFirstListInPath(((FlattenExpression) expr).getExpression(), current, model); } else if (expr instanceof ProjectionExpression) { - // Nested projection in the left side — find the first list return findFirstListInPath(((ProjectionExpression) expr).getLeft(), current, model); } - return null; + return Optional.empty(); } /** * Walks field/subexpression nodes to resolve the shape, without unwrapping lists. */ - private static Shape walkFields(JmespathExpression expr, Shape current, Model model) { - if (current == null) return null; - + private static Optional walkFields(JmespathExpression expr, Shape current, Model model) { if (expr instanceof FieldExpression) { return resolveMemberTarget(current, ((FieldExpression) expr).getName(), model); } else if (expr instanceof Subexpression) { - Shape left = walkFields(((Subexpression) expr).getLeft(), current, model); - return walkFields(((Subexpression) expr).getRight(), left, model); + return walkFields(((Subexpression) expr).getLeft(), current, model) + .flatMap(left -> walkFields(((Subexpression) expr).getRight(), left, model)); } - return current; + return Optional.of(current); } - private static Shape resolveMemberTarget(Shape structShape, String memberName, Model model) { - if (!structShape.isStructureShape()) return null; + private static Optional resolveMemberTarget(Shape structShape, String memberName, Model model) { + if (!structShape.isStructureShape()) return Optional.empty(); return structShape.asStructureShape().get() .getMember(memberName) - .flatMap(member -> model.getShape(member.getTarget())) - .orElse(null); + .flatMap(member -> model.getShape(member.getTarget())); } } From 3bed50621c4cfa92e1d37b51506063e5eb98a200 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Wed, 18 Mar 2026 12:56:11 -0400 Subject: [PATCH 13/21] Add userAgent metrics for waiters --- src/aws-cpp-sdk-core/include/aws/core/client/UserAgent.h | 3 ++- src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h | 1 + src/aws-cpp-sdk-core/source/client/UserAgent.cpp | 1 + 3 files changed, 4 insertions(+), 1 deletion(-) diff --git a/src/aws-cpp-sdk-core/include/aws/core/client/UserAgent.h b/src/aws-cpp-sdk-core/include/aws/core/client/UserAgent.h index fa0e50ce065..541186b2050 100644 --- a/src/aws-cpp-sdk-core/include/aws/core/client/UserAgent.h +++ b/src/aws-cpp-sdk-core/include/aws/core/client/UserAgent.h @@ -49,7 +49,8 @@ enum class UserAgentFeature { FLEXIBLE_CHECKSUMS_REQ_XXHASH64, FLEXIBLE_CHECKSUMS_REQ_XXHASH3, FLEXIBLE_CHECKSUMS_REQ_XXHASH128, - PAGINATOR + PAGINATOR, + WAITER }; class AWS_CORE_API UserAgent { diff --git a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h index b081fb3c029..7c7a2f4b129 100644 --- a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h +++ b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h @@ -117,6 +117,7 @@ class Waiter { m_name(waiterName) {} WaiterOutcome Wait(const RequestT& request) { + request.AddUserAgentFeature(Aws::Client::UserAgentFeature::WAITER); for (int attempt = 0; attempt < m_maxAttempts; ++attempt) { auto outcome = m_operation(request); diff --git a/src/aws-cpp-sdk-core/source/client/UserAgent.cpp b/src/aws-cpp-sdk-core/source/client/UserAgent.cpp index f0fb6678951..098688119cb 100644 --- a/src/aws-cpp-sdk-core/source/client/UserAgent.cpp +++ b/src/aws-cpp-sdk-core/source/client/UserAgent.cpp @@ -60,6 +60,7 @@ const std::pair BUSINESS_METRIC_MAPPING[] = { {UserAgentFeature::FLEXIBLE_CHECKSUMS_REQ_XXHASH3, "AF"}, {UserAgentFeature::FLEXIBLE_CHECKSUMS_REQ_XXHASH128, "AH"}, {UserAgentFeature::PAGINATOR, "C"}, + {UserAgentFeature::WAITER, "B"}, }; const std::pair RETRY_FEATURE_MAPPING[] = { From 7211b70767482d9622f09e089fa569af699f7abe Mon Sep 17 00:00:00 2001 From: sbaluja Date: Wed, 18 Mar 2026 12:56:32 -0400 Subject: [PATCH 14/21] Updated waiters --- .../aws/AWSMigrationHub/MigrationHubWaiter.h | 21 + .../aws/accessanalyzer/AccessAnalyzerWaiter.h | 21 + .../include/aws/account/AccountWaiter.h | 21 + .../include/aws/acm-pca/ACMPCAWaiter.h | 79 +- .../include/aws/acm/ACMWaiter.h | 68 +- .../include/aws/aiops/AIOpsWaiter.h | 21 + .../include/aws/amp/PrometheusServiceWaiter.h | 223 +- .../include/aws/amplify/AmplifyWaiter.h | 21 + .../aws/amplifybackend/AmplifyBackendWaiter.h | 21 + .../amplifyuibuilder/AmplifyUIBuilderWaiter.h | 21 + .../include/aws/apigateway/APIGatewayWaiter.h | 21 + .../ApiGatewayManagementApiWaiter.h | 21 + .../aws/apigatewayv2/ApiGatewayV2Waiter.h | 21 + .../include/aws/appconfig/AppConfigWaiter.h | 100 +- .../aws/appconfigdata/AppConfigDataWaiter.h | 21 + .../include/aws/appfabric/AppFabricWaiter.h | 21 + .../include/aws/appflow/AppflowWaiter.h | 21 + .../AppIntegrationsServiceWaiter.h | 21 + .../ApplicationAutoScalingWaiter.h | 21 + .../ApplicationInsightsWaiter.h | 21 + .../ApplicationSignalsWaiter.h | 21 + .../ApplicationCostProfilerWaiter.h | 21 + .../include/aws/appmesh/AppMeshWaiter.h | 21 + .../include/aws/apprunner/AppRunnerWaiter.h | 21 + .../include/aws/appstream/AppStreamWaiter.h | 121 +- .../include/aws/appsync/AppSyncWaiter.h | 21 + .../arc-region-switch/ARCRegionswitchWaiter.h | 133 +- .../aws/arc-zonal-shift/ARCZonalShiftWaiter.h | 21 + .../include/aws/artifact/ArtifactWaiter.h | 21 + .../include/aws/athena/AthenaWaiter.h | 21 + .../aws/auditmanager/AuditManagerWaiter.h | 21 + .../AutoScalingPlansWaiter.h | 21 + .../aws/autoscaling/AutoScalingWaiter.h | 134 +- .../include/aws/awstransfer/TransferWaiter.h | 71 +- .../include/aws/b2bi/B2BIWaiter.h | 40 +- .../aws/backup-gateway/BackupGatewayWaiter.h | 21 + .../include/aws/backup/BackupWaiter.h | 21 + .../aws/backupsearch/BackupSearchWaiter.h | 21 + .../include/aws/batch/BatchWaiter.h | 21 + .../aws/bcm-dashboards/BCMDashboardsWaiter.h | 21 + .../bcm-data-exports/BCMDataExportsWaiter.h | 21 + .../BCMPricingCalculatorWaiter.h | 21 + .../BCMRecommendedActionsWaiter.h | 21 + .../BedrockAgentRuntimeWaiter.h | 21 + .../aws/bedrock-agent/BedrockAgentWaiter.h | 21 + .../BedrockAgentCoreControlWaiter.h | 326 +-- .../BedrockAgentCoreWaiter.h | 21 + .../BedrockDataAutomationRuntimeWaiter.h | 21 + .../BedrockDataAutomationWaiter.h | 21 + .../bedrock-runtime/BedrockRuntimeWaiter.h | 21 + .../include/aws/bedrock/BedrockWaiter.h | 21 + .../include/aws/billing/BillingWaiter.h | 21 + .../billingconductor/BillingConductorWaiter.h | 21 + .../include/aws/braket/BraketWaiter.h | 21 + .../include/aws/budgets/BudgetsWaiter.h | 21 + .../include/aws/ce/CostExplorerWaiter.h | 21 + .../include/aws/chatbot/ChatbotWaiter.h | 21 + .../ChimeSDKIdentityWaiter.h | 21 + .../ChimeSDKMediaPipelinesWaiter.h | 21 + .../ChimeSDKMeetingsWaiter.h | 21 + .../ChimeSDKMessagingWaiter.h | 21 + .../aws/chime-sdk-voice/ChimeSDKVoiceWaiter.h | 21 + .../include/aws/chime/ChimeWaiter.h | 21 + .../include/aws/cleanrooms/CleanRoomsWaiter.h | 21 + .../aws/cleanroomsml/CleanRoomsMLWaiter.h | 21 + .../include/aws/cloud9/Cloud9Waiter.h | 21 + .../aws/cloudcontrol/CloudControlApiWaiter.h | 51 +- .../aws/clouddirectory/CloudDirectoryWaiter.h | 21 + .../aws/cloudformation/CloudFormationWaiter.h | 872 +++---- .../CloudFrontKeyValueStoreWaiter.h | 21 + .../include/aws/cloudfront/CloudFrontWaiter.h | 99 +- .../include/aws/cloudhsm/CloudHSMWaiter.h | 21 + .../include/aws/cloudhsmv2/CloudHSMV2Waiter.h | 21 + .../aws/cloudsearch/CloudSearchWaiter.h | 21 + .../CloudSearchDomainWaiter.h | 21 + .../cloudtrail-data/CloudTrailDataWaiter.h | 21 + .../include/aws/cloudtrail/CloudTrailWaiter.h | 21 + .../aws/codeartifact/CodeArtifactWaiter.h | 21 + .../include/aws/codebuild/CodeBuildWaiter.h | 21 + .../aws/codecatalyst/CodeCatalystWaiter.h | 21 + .../include/aws/codecommit/CodeCommitWaiter.h | 21 + .../codeconnections/CodeConnectionsWaiter.h | 21 + .../include/aws/codedeploy/CodeDeployWaiter.h | 55 +- .../CodeGuruReviewerWaiter.h | 110 +- .../CodeGuruSecurityWaiter.h | 21 + .../codeguruprofiler/CodeGuruProfilerWaiter.h | 21 + .../aws/codepipeline/CodePipelineWaiter.h | 21 + .../CodeStarconnectionsWaiter.h | 21 + .../CodeStarNotificationsWaiter.h | 21 + .../cognito-identity/CognitoIdentityWaiter.h | 21 + .../CognitoIdentityProviderWaiter.h | 21 + .../aws/cognito-sync/CognitoSyncWaiter.h | 21 + .../include/aws/comprehend/ComprehendWaiter.h | 21 + .../ComprehendMedicalWaiter.h | 21 + .../ComputeOptimizerAutomationWaiter.h | 21 + .../ComputeOptimizerWaiter.h | 21 + .../include/aws/config/ConfigServiceWaiter.h | 21 + .../ConnectContactLensWaiter.h | 21 + .../include/aws/connect/ConnectWaiter.h | 21 + .../connectcampaigns/ConnectCampaignsWaiter.h | 21 + .../ConnectCampaignsV2Waiter.h | 21 + .../aws/connectcases/ConnectCasesWaiter.h | 21 + .../aws/connecthealth/ConnectHealthWaiter.h | 21 + .../ConnectParticipantWaiter.h | 21 + .../aws/controlcatalog/ControlCatalogWaiter.h | 21 + .../aws/controltower/ControlTowerWaiter.h | 21 + .../CostOptimizationHubWaiter.h | 21 + .../aws/cur/CostandUsageReportServiceWaiter.h | 21 + .../CustomerProfilesWaiter.h | 21 + .../include/aws/databrew/GlueDataBrewWaiter.h | 21 + .../aws/dataexchange/DataExchangeWaiter.h | 21 + .../aws/datapipeline/DataPipelineWaiter.h | 21 + .../include/aws/datasync/DataSyncWaiter.h | 21 + .../include/aws/datazone/DataZoneWaiter.h | 21 + .../include/aws/dax/DAXWaiter.h | 21 + .../include/aws/deadline/DeadlineWaiter.h | 486 ++-- .../include/aws/detective/DetectiveWaiter.h | 21 + .../include/aws/devicefarm/DeviceFarmWaiter.h | 21 + .../aws/devops-guru/DevOpsGuruWaiter.h | 21 + .../aws/directconnect/DirectConnectWaiter.h | 21 + .../DirectoryServiceDataWaiter.h | 21 + .../ApplicationDiscoveryServiceWaiter.h | 21 + .../include/aws/dlm/DLMWaiter.h | 21 + .../aws/dms/DatabaseMigrationServiceWaiter.h | 764 +++--- .../aws/docdb-elastic/DocDBElasticWaiter.h | 21 + .../include/aws/docdb/DocDBWaiter.h | 202 +- .../include/aws/drs/DrsWaiter.h | 21 + .../include/aws/ds/DirectoryServiceWaiter.h | 48 +- .../include/aws/dsql/DSQLWaiter.h | 33 +- .../include/aws/dynamodb/DynamoDBWaiter.h | 229 +- .../dynamodbstreams/DynamoDBStreamsWaiter.h | 21 + .../include/aws/ebs/EBSWaiter.h | 21 + .../EC2InstanceConnectWaiter.h | 21 + .../include/aws/ec2/EC2Waiter.h | 2119 +++++++++-------- .../include/aws/ecr-public/ECRPublicWaiter.h | 21 + .../include/aws/ecr/ECRWaiter.h | 81 +- .../include/aws/ecs/ECSWaiter.h | 189 +- .../include/aws/eks-auth/EKSAuthWaiter.h | 21 + .../include/aws/eks/EKSWaiter.h | 336 +-- .../aws/elasticache/ElastiCacheWaiter.h | 307 ++- .../elasticbeanstalk/ElasticBeanstalkWaiter.h | 154 +- .../include/aws/elasticfilesystem/EFSWaiter.h | 21 + .../ElasticLoadBalancingWaiter.h | 88 +- .../ElasticLoadBalancingv2Waiter.h | 176 +- .../include/aws/elasticmapreduce/EMRWaiter.h | 174 +- .../ElementalInferenceWaiter.h | 44 +- .../include/aws/email/SESWaiter.h | 34 +- .../aws/emr-containers/EMRContainersWaiter.h | 21 + .../aws/emr-serverless/EMRServerlessWaiter.h | 21 + .../entityresolution/EntityResolutionWaiter.h | 21 + .../aws/es/ElasticsearchServiceWaiter.h | 21 + .../aws/eventbridge/EventBridgeWaiter.h | 21 + .../aws/events/CloudWatchEventsWaiter.h | 21 + .../include/aws/evs/EVSWaiter.h | 21 + .../aws/finspace-data/FinSpaceDataWaiter.h | 21 + .../include/aws/finspace/FinspaceWaiter.h | 21 + .../include/aws/firehose/FirehoseWaiter.h | 21 + .../include/aws/fis/FISWaiter.h | 21 + .../include/aws/fms/FMSWaiter.h | 21 + .../aws/forecast/ForecastServiceWaiter.h | 21 + .../ForecastQueryServiceWaiter.h | 21 + .../aws/frauddetector/FraudDetectorWaiter.h | 21 + .../include/aws/freetier/FreeTierWaiter.h | 21 + .../include/aws/fsx/FSxWaiter.h | 21 + .../include/aws/gamelift/GameLiftWaiter.h | 21 + .../gameliftstreams/GameLiftStreamsWaiter.h | 164 +- .../include/aws/geo-maps/GeoMapsWaiter.h | 21 + .../include/aws/geo-places/GeoPlacesWaiter.h | 21 + .../include/aws/geo-routes/GeoRoutesWaiter.h | 21 + .../include/aws/glacier/GlacierWaiter.h | 31 +- .../GlobalAcceleratorWaiter.h | 21 + .../include/aws/glue/GlueWaiter.h | 21 + .../aws/grafana/ManagedGrafanaWaiter.h | 21 + .../include/aws/greengrass/GreengrassWaiter.h | 21 + .../aws/greengrassv2/GreengrassV2Waiter.h | 21 + .../aws/groundstation/GroundStationWaiter.h | 38 +- .../include/aws/guardduty/GuardDutyWaiter.h | 21 + .../include/aws/health/HealthWaiter.h | 21 + .../include/aws/healthlake/HealthLakeWaiter.h | 217 +- .../include/aws/iam/IAMWaiter.h | 60 +- .../aws/identitystore/IdentityStoreWaiter.h | 21 + .../aws/imagebuilder/ImagebuilderWaiter.h | 21 + .../aws/inspector-scan/InspectorscanWaiter.h | 21 + .../include/aws/inspector/InspectorWaiter.h | 21 + .../include/aws/inspector2/Inspector2Waiter.h | 21 + .../internetmonitor/InternetMonitorWaiter.h | 21 + .../include/aws/invoicing/InvoicingWaiter.h | 21 + .../include/aws/iot-data/IoTDataPlaneWaiter.h | 21 + .../iot-jobs-data/IoTJobsDataPlaneWaiter.h | 21 + .../IoTManagedIntegrationsWaiter.h | 21 + .../include/aws/iot/IoTWaiter.h | 21 + .../iotdeviceadvisor/IoTDeviceAdvisorWaiter.h | 21 + .../aws/iotevents-data/IoTEventsDataWaiter.h | 21 + .../include/aws/iotevents/IoTEventsWaiter.h | 21 + .../aws/iotfleetwise/IoTFleetWiseWaiter.h | 21 + .../IoTSecureTunnelingWaiter.h | 21 + .../aws/iotsitewise/IoTSiteWiseWaiter.h | 140 +- .../aws/iotthingsgraph/IoTThingsGraphWaiter.h | 21 + .../aws/iottwinmaker/IoTTwinMakerWaiter.h | 21 + .../aws/iotwireless/IoTWirelessWaiter.h | 21 + .../aws/ivs-realtime/IvsrealtimeWaiter.h | 21 + .../include/aws/ivs/IVSWaiter.h | 21 + .../include/aws/ivschat/IvschatWaiter.h | 21 + .../include/aws/kafka/KafkaWaiter.h | 21 + .../aws/kafkaconnect/KafkaConnectWaiter.h | 21 + .../aws/kendra-ranking/KendraRankingWaiter.h | 21 + .../include/aws/kendra/KendraWaiter.h | 21 + .../include/aws/keyspaces/KeyspacesWaiter.h | 21 + .../keyspacesstreams/KeyspacesStreamsWaiter.h | 21 + .../KinesisVideoArchivedMediaWaiter.h | 21 + .../KinesisVideoMediaWaiter.h | 21 + .../KinesisVideoSignalingChannelsWaiter.h | 21 + .../KinesisVideoWebRTCStorageWaiter.h | 21 + .../include/aws/kinesis/KinesisWaiter.h | 37 +- .../kinesisanalytics/KinesisAnalyticsWaiter.h | 21 + .../KinesisAnalyticsV2Waiter.h | 21 + .../aws/kinesisvideo/KinesisVideoWaiter.h | 21 + .../include/aws/kms/KMSWaiter.h | 21 + .../aws/lakeformation/LakeFormationWaiter.h | 21 + .../include/aws/lambda/LambdaWaiter.h | 270 ++- .../aws/launch-wizard/LaunchWizardWaiter.h | 21 + .../LexModelBuildingServiceWaiter.h | 21 + .../include/aws/lex/LexRuntimeServiceWaiter.h | 21 + .../aws/lexv2-models/LexModelsV2Waiter.h | 496 ++-- .../aws/lexv2-runtime/LexRuntimeV2Waiter.h | 21 + .../LicenseManagerLinuxSubscriptionsWaiter.h | 21 + .../LicenseManagerUserSubscriptionsWaiter.h | 21 + .../license-manager/LicenseManagerWaiter.h | 21 + .../include/aws/lightsail/LightsailWaiter.h | 21 + .../aws/location/LocationServiceWaiter.h | 21 + .../include/aws/logs/CloudWatchLogsWaiter.h | 21 + .../lookoutequipment/LookoutEquipmentWaiter.h | 21 + .../aws/m2/MainframeModernizationWaiter.h | 21 + .../machinelearning/MachineLearningWaiter.h | 179 +- .../include/aws/macie2/Macie2Waiter.h | 40 +- .../aws/mailmanager/MailManagerWaiter.h | 21 + .../ManagedBlockchainQueryWaiter.h | 21 + .../ManagedBlockchainWaiter.h | 21 + .../AgreementServiceWaiter.h | 21 + .../MarketplaceCatalogWaiter.h | 21 + .../MarketplaceDeploymentWaiter.h | 21 + .../MarketplaceEntitlementServiceWaiter.h | 21 + .../MarketplaceReportingWaiter.h | 21 + .../MarketplaceCommerceAnalyticsWaiter.h | 21 + .../aws/mediaconnect/MediaConnectWaiter.h | 662 ++--- .../aws/mediaconvert/MediaConvertWaiter.h | 21 + .../include/aws/medialive/MediaLiveWaiter.h | 1101 +++++---- .../mediapackage-vod/MediaPackageVodWaiter.h | 21 + .../aws/mediapackage/MediaPackageWaiter.h | 21 + .../aws/mediapackagev2/Mediapackagev2Waiter.h | 80 +- .../mediastore-data/MediaStoreDataWaiter.h | 21 + .../include/aws/mediastore/MediaStoreWaiter.h | 21 + .../aws/mediatailor/MediaTailorWaiter.h | 21 + .../medical-imaging/MedicalImagingWaiter.h | 21 + .../include/aws/memorydb/MemoryDBWaiter.h | 21 + .../MarketplaceMeteringWaiter.h | 21 + .../include/aws/mgn/MgnWaiter.h | 21 + .../MigrationHubRefactorSpacesWaiter.h | 21 + .../MigrationHubConfigWaiter.h | 21 + .../MigrationHubOrchestratorWaiter.h | 21 + ...igrationHubStrategyRecommendationsWaiter.h | 21 + .../include/aws/monitoring/CloudWatchWaiter.h | 60 +- .../include/aws/mpa/MPAWaiter.h | 21 + .../aws-cpp-sdk-mq/include/aws/mq/MQWaiter.h | 21 + .../include/aws/mturk-requester/MTurkWaiter.h | 21 + .../mwaa-serverless/MWAAServerlessWaiter.h | 21 + .../include/aws/mwaa/MWAAWaiter.h | 21 + .../aws/neptune-graph/NeptuneGraphWaiter.h | 492 ++-- .../include/aws/neptune/NeptuneWaiter.h | 202 +- .../aws/neptunedata/NeptunedataWaiter.h | 21 + .../network-firewall/NetworkFirewallWaiter.h | 21 + .../NetworkFlowMonitorWaiter.h | 21 + .../aws/networkmanager/NetworkManagerWaiter.h | 21 + .../aws/networkmonitor/NetworkMonitorWaiter.h | 21 + .../aws/notifications/NotificationsWaiter.h | 21 + .../NotificationsContactsWaiter.h | 21 + .../include/aws/nova-act/NovaActWaiter.h | 21 + .../include/aws/oam/OAMWaiter.h | 21 + .../ObservabilityAdminWaiter.h | 21 + .../include/aws/odb/OdbWaiter.h | 21 + .../include/aws/omics/OmicsWaiter.h | 1343 ++++++----- .../aws/opensearch/OpenSearchServiceWaiter.h | 21 + .../OpenSearchServerlessWaiter.h | 21 + .../aws/organizations/OrganizationsWaiter.h | 21 + .../include/aws/osis/OSISWaiter.h | 21 + .../include/aws/outposts/OutpostsWaiter.h | 21 + .../include/aws/panorama/PanoramaWaiter.h | 21 + .../PartnerCentralAccountWaiter.h | 21 + .../PartnerCentralBenefitsWaiter.h | 21 + .../PartnerCentralChannelWaiter.h | 21 + .../PartnerCentralSellingWaiter.h | 21 + .../PaymentCryptographyDataWaiter.h | 21 + .../PaymentCryptographyWaiter.h | 21 + .../pca-connector-ad/PcaConnectorAdWaiter.h | 21 + .../PcaConnectorScepWaiter.h | 21 + .../include/aws/pcs/PCSWaiter.h | 21 + .../PersonalizeEventsWaiter.h | 21 + .../PersonalizeRuntimeWaiter.h | 21 + .../aws/personalize/PersonalizeWaiter.h | 21 + .../aws-cpp-sdk-pi/include/aws/pi/PIWaiter.h | 21 + .../aws/pinpoint-email/PinpointEmailWaiter.h | 21 + .../PinpointSMSVoiceV2Waiter.h | 21 + .../include/aws/pinpoint/PinpointWaiter.h | 21 + .../include/aws/pipes/PipesWaiter.h | 21 + .../include/aws/polly/PollyWaiter.h | 21 + .../include/aws/pricing/PricingWaiter.h | 21 + .../include/aws/proton/ProtonWaiter.h | 425 ++-- .../include/aws/qapps/QAppsWaiter.h | 21 + .../include/aws/qbusiness/QBusinessWaiter.h | 21 + .../include/aws/qconnect/QConnectWaiter.h | 21 + .../include/aws/quicksight/QuickSightWaiter.h | 21 + .../include/aws/ram/RAMWaiter.h | 21 + .../include/aws/rbin/RecycleBinWaiter.h | 21 + .../aws/rds-data/RDSDataServiceWaiter.h | 21 + .../include/aws/rds/RDSWaiter.h | 895 +++---- .../RedshiftDataAPIServiceWaiter.h | 21 + .../RedshiftServerlessWaiter.h | 21 + .../include/aws/redshift/RedshiftWaiter.h | 187 +- .../aws/rekognition/RekognitionWaiter.h | 107 +- .../aws/repostspace/RepostspaceWaiter.h | 201 +- .../aws/resiliencehub/ResilienceHubWaiter.h | 21 + .../ResourceExplorer2Waiter.h | 21 + .../resource-groups/ResourceGroupsWaiter.h | 21 + .../ResourceGroupsTaggingAPIWaiter.h | 21 + .../aws/rolesanywhere/RolesAnywhereWaiter.h | 21 + .../Route53RecoveryClusterWaiter.h | 21 + .../Route53RecoveryControlConfigWaiter.h | 213 +- .../Route53RecoveryReadinessWaiter.h | 21 + .../include/aws/route53/Route53Waiter.h | 24 +- .../aws/route53domains/Route53DomainsWaiter.h | 21 + .../Route53GlobalResolverWaiter.h | 21 + .../route53profiles/Route53ProfilesWaiter.h | 21 + .../route53resolver/Route53ResolverWaiter.h | 21 + .../include/aws/rtbfabric/RTBFabricWaiter.h | 464 ++-- .../include/aws/rum/CloudWatchRUMWaiter.h | 21 + .../include/aws/s3-crt/S3CrtWaiter.h | 51 +- .../aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h | 51 +- .../include/aws/s3control/S3ControlWaiter.h | 21 + .../include/aws/s3outposts/S3OutpostsWaiter.h | 21 + .../include/aws/s3tables/S3TablesWaiter.h | 21 + .../include/aws/s3vectors/S3VectorsWaiter.h | 21 + .../AugmentedAIRuntimeWaiter.h | 21 + .../SagemakerEdgeManagerWaiter.h | 21 + .../SageMakerFeatureStoreRuntimeWaiter.h | 21 + .../SageMakerGeospatialWaiter.h | 21 + .../SageMakerMetricsWaiter.h | 21 + .../SageMakerRuntimeHTTP2Waiter.h | 21 + .../SageMakerRuntimeWaiter.h | 21 + .../include/aws/sagemaker/SageMakerWaiter.h | 532 +++-- .../aws/savingsplans/SavingsPlansWaiter.h | 21 + .../include/aws/scheduler/SchedulerWaiter.h | 21 + .../include/aws/schemas/SchemasWaiter.h | 57 +- .../aws/secretsmanager/SecretsManagerWaiter.h | 21 + .../aws/security-ir/SecurityIRWaiter.h | 21 + .../aws/securityhub/SecurityHubWaiter.h | 21 + .../aws/securitylake/SecurityLakeWaiter.h | 21 + .../ServerlessApplicationRepositoryWaiter.h | 21 + .../aws/service-quotas/ServiceQuotasWaiter.h | 21 + .../AppRegistryWaiter.h | 21 + .../aws/servicecatalog/ServiceCatalogWaiter.h | 21 + .../servicediscovery/ServiceDiscoveryWaiter.h | 21 + .../include/aws/sesv2/SESV2Waiter.h | 21 + .../include/aws/shield/ShieldWaiter.h | 21 + .../aws/signer-data/SignerDataWaiter.h | 21 + .../include/aws/signer/SignerWaiter.h | 41 +- .../include/aws/signin/SigninWaiter.h | 21 + .../include/aws/simpledbv2/SimpleDBv2Waiter.h | 37 +- .../aws/simspaceweaver/SimSpaceWeaverWaiter.h | 21 + .../aws/sms-voice/PinpointSMSVoiceWaiter.h | 21 + .../SnowDeviceManagementWaiter.h | 21 + .../include/aws/snowball/SnowballWaiter.h | 21 + .../include/aws/sns/SNSWaiter.h | 21 + .../socialmessaging/SocialMessagingWaiter.h | 21 + .../include/aws/sqs/SQSWaiter.h | 21 + .../aws/ssm-contacts/SSMContactsWaiter.h | 21 + .../aws/ssm-guiconnect/SSMGuiConnectWaiter.h | 21 + .../aws/ssm-incidents/SSMIncidentsWaiter.h | 104 +- .../aws/ssm-quicksetup/SSMQuickSetupWaiter.h | 21 + .../include/aws/ssm-sap/SsmSapWaiter.h | 21 + .../include/aws/ssm/SSMWaiter.h | 127 +- .../include/aws/sso-admin/SSOAdminWaiter.h | 21 + .../include/aws/sso-oidc/SSOOIDCWaiter.h | 21 + .../include/aws/sso/SSOWaiter.h | 21 + .../include/aws/states/SFNWaiter.h | 21 + .../aws/storagegateway/StorageGatewayWaiter.h | 21 + .../include/aws/sts/STSWaiter.h | 21 + .../aws/supplychain/SupplyChainWaiter.h | 21 + .../aws/support-app/SupportAppWaiter.h | 21 + .../include/aws/support/SupportWaiter.h | 21 + .../include/aws/swf/SWFWaiter.h | 21 + .../include/aws/synthetics/SyntheticsWaiter.h | 21 + .../aws/taxsettings/TaxSettingsWaiter.h | 21 + .../include/aws/textract/TextractWaiter.h | 21 + .../TimestreamInfluxDBWaiter.h | 21 + .../timestream-query/TimestreamQueryWaiter.h | 21 + .../timestream-write/TimestreamWriteWaiter.h | 21 + .../include/aws/tnb/TnbWaiter.h | 21 + .../aws/transcribe/TranscribeServiceWaiter.h | 294 +-- .../TranscribeStreamingServiceWaiter.h | 21 + .../include/aws/translate/TranslateWaiter.h | 21 + .../aws/trustedadvisor/TrustedAdvisorWaiter.h | 21 + .../VerifiedPermissionsWaiter.h | 21 + .../include/aws/voice-id/VoiceIDWaiter.h | 21 + .../aws/vpc-lattice/VPCLatticeWaiter.h | 21 + .../aws/waf-regional/WAFRegionalWaiter.h | 21 + .../include/aws/waf/WAFWaiter.h | 21 + .../include/aws/wafv2/WAFV2Waiter.h | 21 + .../wellarchitected/WellArchitectedWaiter.h | 21 + .../include/aws/wickr/WickrWaiter.h | 21 + .../aws/wisdom/ConnectWisdomServiceWaiter.h | 21 + .../include/aws/workdocs/WorkDocsWaiter.h | 21 + .../include/aws/workmail/WorkMailWaiter.h | 21 + .../WorkMailMessageFlowWaiter.h | 21 + .../WorkspacesInstancesWaiter.h | 21 + .../WorkSpacesThinClientWaiter.h | 21 + .../aws/workspaces-web/WorkSpacesWebWaiter.h | 21 + .../include/aws/workspaces/WorkSpacesWaiter.h | 21 + .../include/aws/xray/XRayWaiter.h | 21 + 418 files changed, 16422 insertions(+), 8317 deletions(-) create mode 100644 generated/src/aws-cpp-sdk-AWSMigrationHub/include/aws/AWSMigrationHub/MigrationHubWaiter.h create mode 100644 generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-account/include/aws/account/AccountWaiter.h create mode 100644 generated/src/aws-cpp-sdk-aiops/include/aws/aiops/AIOpsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-amplify/include/aws/amplify/AmplifyWaiter.h create mode 100644 generated/src/aws-cpp-sdk-amplifybackend/include/aws/amplifybackend/AmplifyBackendWaiter.h create mode 100644 generated/src/aws-cpp-sdk-amplifyuibuilder/include/aws/amplifyuibuilder/AmplifyUIBuilderWaiter.h create mode 100644 generated/src/aws-cpp-sdk-apigateway/include/aws/apigateway/APIGatewayWaiter.h create mode 100644 generated/src/aws-cpp-sdk-apigatewaymanagementapi/include/aws/apigatewaymanagementapi/ApiGatewayManagementApiWaiter.h create mode 100644 generated/src/aws-cpp-sdk-apigatewayv2/include/aws/apigatewayv2/ApiGatewayV2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-appconfigdata/include/aws/appconfigdata/AppConfigDataWaiter.h create mode 100644 generated/src/aws-cpp-sdk-appfabric/include/aws/appfabric/AppFabricWaiter.h create mode 100644 generated/src/aws-cpp-sdk-appflow/include/aws/appflow/AppflowWaiter.h create mode 100644 generated/src/aws-cpp-sdk-appintegrations/include/aws/appintegrations/AppIntegrationsServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-application-autoscaling/include/aws/application-autoscaling/ApplicationAutoScalingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-application-insights/include/aws/application-insights/ApplicationInsightsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-application-signals/include/aws/application-signals/ApplicationSignalsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-applicationcostprofiler/include/aws/applicationcostprofiler/ApplicationCostProfilerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-appmesh/include/aws/appmesh/AppMeshWaiter.h create mode 100644 generated/src/aws-cpp-sdk-apprunner/include/aws/apprunner/AppRunnerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-appsync/include/aws/appsync/AppSyncWaiter.h create mode 100644 generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/ARCZonalShiftWaiter.h create mode 100644 generated/src/aws-cpp-sdk-artifact/include/aws/artifact/ArtifactWaiter.h create mode 100644 generated/src/aws-cpp-sdk-athena/include/aws/athena/AthenaWaiter.h create mode 100644 generated/src/aws-cpp-sdk-auditmanager/include/aws/auditmanager/AuditManagerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-autoscaling-plans/include/aws/autoscaling-plans/AutoScalingPlansWaiter.h create mode 100644 generated/src/aws-cpp-sdk-backup-gateway/include/aws/backup-gateway/BackupGatewayWaiter.h create mode 100644 generated/src/aws-cpp-sdk-backup/include/aws/backup/BackupWaiter.h create mode 100644 generated/src/aws-cpp-sdk-backupsearch/include/aws/backupsearch/BackupSearchWaiter.h create mode 100644 generated/src/aws-cpp-sdk-batch/include/aws/batch/BatchWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bcm-dashboards/include/aws/bcm-dashboards/BCMDashboardsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bcm-data-exports/include/aws/bcm-data-exports/BCMDataExportsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bcm-pricing-calculator/include/aws/bcm-pricing-calculator/BCMPricingCalculatorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bcm-recommended-actions/include/aws/bcm-recommended-actions/BCMRecommendedActionsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bedrock-agent-runtime/include/aws/bedrock-agent-runtime/BedrockAgentRuntimeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bedrock-agent/include/aws/bedrock-agent/BedrockAgentWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bedrock-agentcore/include/aws/bedrock-agentcore/BedrockAgentCoreWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bedrock-data-automation-runtime/include/aws/bedrock-data-automation-runtime/BedrockDataAutomationRuntimeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/BedrockDataAutomationWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/BedrockRuntimeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-bedrock/include/aws/bedrock/BedrockWaiter.h create mode 100644 generated/src/aws-cpp-sdk-billing/include/aws/billing/BillingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-billingconductor/include/aws/billingconductor/BillingConductorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-braket/include/aws/braket/BraketWaiter.h create mode 100644 generated/src/aws-cpp-sdk-budgets/include/aws/budgets/BudgetsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ce/include/aws/ce/CostExplorerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-chatbot/include/aws/chatbot/ChatbotWaiter.h create mode 100644 generated/src/aws-cpp-sdk-chime-sdk-identity/include/aws/chime-sdk-identity/ChimeSDKIdentityWaiter.h create mode 100644 generated/src/aws-cpp-sdk-chime-sdk-media-pipelines/include/aws/chime-sdk-media-pipelines/ChimeSDKMediaPipelinesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-chime-sdk-meetings/include/aws/chime-sdk-meetings/ChimeSDKMeetingsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-chime-sdk-messaging/include/aws/chime-sdk-messaging/ChimeSDKMessagingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-chime-sdk-voice/include/aws/chime-sdk-voice/ChimeSDKVoiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-chime/include/aws/chime/ChimeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cleanrooms/include/aws/cleanrooms/CleanRoomsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cleanroomsml/include/aws/cleanroomsml/CleanRoomsMLWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cloud9/include/aws/cloud9/Cloud9Waiter.h create mode 100644 generated/src/aws-cpp-sdk-clouddirectory/include/aws/clouddirectory/CloudDirectoryWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cloudfront-keyvaluestore/include/aws/cloudfront-keyvaluestore/CloudFrontKeyValueStoreWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cloudhsm/include/aws/cloudhsm/CloudHSMWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cloudhsmv2/include/aws/cloudhsmv2/CloudHSMV2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-cloudsearch/include/aws/cloudsearch/CloudSearchWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cloudsearchdomain/include/aws/cloudsearchdomain/CloudSearchDomainWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cloudtrail-data/include/aws/cloudtrail-data/CloudTrailDataWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cloudtrail/include/aws/cloudtrail/CloudTrailWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codeartifact/include/aws/codeartifact/CodeArtifactWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/CodeBuildWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codecatalyst/include/aws/codecatalyst/CodeCatalystWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codecommit/include/aws/codecommit/CodeCommitWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codeconnections/include/aws/codeconnections/CodeConnectionsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codeguru-security/include/aws/codeguru-security/CodeGuruSecurityWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codeguruprofiler/include/aws/codeguruprofiler/CodeGuruProfilerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codepipeline/include/aws/codepipeline/CodePipelineWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codestar-connections/include/aws/codestar-connections/CodeStarconnectionsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cognito-identity/include/aws/cognito-identity/CognitoIdentityWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cognito-idp/include/aws/cognito-idp/CognitoIdentityProviderWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cognito-sync/include/aws/cognito-sync/CognitoSyncWaiter.h create mode 100644 generated/src/aws-cpp-sdk-comprehend/include/aws/comprehend/ComprehendWaiter.h create mode 100644 generated/src/aws-cpp-sdk-comprehendmedical/include/aws/comprehendmedical/ComprehendMedicalWaiter.h create mode 100644 generated/src/aws-cpp-sdk-compute-optimizer-automation/include/aws/compute-optimizer-automation/ComputeOptimizerAutomationWaiter.h create mode 100644 generated/src/aws-cpp-sdk-compute-optimizer/include/aws/compute-optimizer/ComputeOptimizerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-config/include/aws/config/ConfigServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-connect-contact-lens/include/aws/connect-contact-lens/ConnectContactLensWaiter.h create mode 100644 generated/src/aws-cpp-sdk-connect/include/aws/connect/ConnectWaiter.h create mode 100644 generated/src/aws-cpp-sdk-connectcampaigns/include/aws/connectcampaigns/ConnectCampaignsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-connectcampaignsv2/include/aws/connectcampaignsv2/ConnectCampaignsV2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-connectcases/include/aws/connectcases/ConnectCasesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-connecthealth/include/aws/connecthealth/ConnectHealthWaiter.h create mode 100644 generated/src/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantWaiter.h create mode 100644 generated/src/aws-cpp-sdk-controlcatalog/include/aws/controlcatalog/ControlCatalogWaiter.h create mode 100644 generated/src/aws-cpp-sdk-controltower/include/aws/controltower/ControlTowerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cost-optimization-hub/include/aws/cost-optimization-hub/CostOptimizationHubWaiter.h create mode 100644 generated/src/aws-cpp-sdk-cur/include/aws/cur/CostandUsageReportServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-customer-profiles/include/aws/customer-profiles/CustomerProfilesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-databrew/include/aws/databrew/GlueDataBrewWaiter.h create mode 100644 generated/src/aws-cpp-sdk-dataexchange/include/aws/dataexchange/DataExchangeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-datapipeline/include/aws/datapipeline/DataPipelineWaiter.h create mode 100644 generated/src/aws-cpp-sdk-datasync/include/aws/datasync/DataSyncWaiter.h create mode 100644 generated/src/aws-cpp-sdk-datazone/include/aws/datazone/DataZoneWaiter.h create mode 100644 generated/src/aws-cpp-sdk-dax/include/aws/dax/DAXWaiter.h create mode 100644 generated/src/aws-cpp-sdk-detective/include/aws/detective/DetectiveWaiter.h create mode 100644 generated/src/aws-cpp-sdk-devicefarm/include/aws/devicefarm/DeviceFarmWaiter.h create mode 100644 generated/src/aws-cpp-sdk-devops-guru/include/aws/devops-guru/DevOpsGuruWaiter.h create mode 100644 generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/DirectConnectWaiter.h create mode 100644 generated/src/aws-cpp-sdk-directory-service-data/include/aws/directory-service-data/DirectoryServiceDataWaiter.h create mode 100644 generated/src/aws-cpp-sdk-discovery/include/aws/discovery/ApplicationDiscoveryServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-dlm/include/aws/dlm/DLMWaiter.h create mode 100644 generated/src/aws-cpp-sdk-docdb-elastic/include/aws/docdb-elastic/DocDBElasticWaiter.h create mode 100644 generated/src/aws-cpp-sdk-drs/include/aws/drs/DrsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-dynamodbstreams/include/aws/dynamodbstreams/DynamoDBStreamsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ebs/include/aws/ebs/EBSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ec2-instance-connect/include/aws/ec2-instance-connect/EC2InstanceConnectWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ecr-public/include/aws/ecr-public/ECRPublicWaiter.h create mode 100644 generated/src/aws-cpp-sdk-eks-auth/include/aws/eks-auth/EKSAuthWaiter.h create mode 100644 generated/src/aws-cpp-sdk-elasticfilesystem/include/aws/elasticfilesystem/EFSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-emr-containers/include/aws/emr-containers/EMRContainersWaiter.h create mode 100644 generated/src/aws-cpp-sdk-emr-serverless/include/aws/emr-serverless/EMRServerlessWaiter.h create mode 100644 generated/src/aws-cpp-sdk-entityresolution/include/aws/entityresolution/EntityResolutionWaiter.h create mode 100644 generated/src/aws-cpp-sdk-es/include/aws/es/ElasticsearchServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-eventbridge/include/aws/eventbridge/EventBridgeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-events/include/aws/events/CloudWatchEventsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-evs/include/aws/evs/EVSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-finspace-data/include/aws/finspace-data/FinSpaceDataWaiter.h create mode 100644 generated/src/aws-cpp-sdk-finspace/include/aws/finspace/FinspaceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-firehose/include/aws/firehose/FirehoseWaiter.h create mode 100644 generated/src/aws-cpp-sdk-fis/include/aws/fis/FISWaiter.h create mode 100644 generated/src/aws-cpp-sdk-fms/include/aws/fms/FMSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-forecast/include/aws/forecast/ForecastServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-forecastquery/include/aws/forecastquery/ForecastQueryServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-frauddetector/include/aws/frauddetector/FraudDetectorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-freetier/include/aws/freetier/FreeTierWaiter.h create mode 100644 generated/src/aws-cpp-sdk-fsx/include/aws/fsx/FSxWaiter.h create mode 100644 generated/src/aws-cpp-sdk-gamelift/include/aws/gamelift/GameLiftWaiter.h create mode 100644 generated/src/aws-cpp-sdk-geo-maps/include/aws/geo-maps/GeoMapsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-geo-places/include/aws/geo-places/GeoPlacesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-geo-routes/include/aws/geo-routes/GeoRoutesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-globalaccelerator/include/aws/globalaccelerator/GlobalAcceleratorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-glue/include/aws/glue/GlueWaiter.h create mode 100644 generated/src/aws-cpp-sdk-grafana/include/aws/grafana/ManagedGrafanaWaiter.h create mode 100644 generated/src/aws-cpp-sdk-greengrass/include/aws/greengrass/GreengrassWaiter.h create mode 100644 generated/src/aws-cpp-sdk-greengrassv2/include/aws/greengrassv2/GreengrassV2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-guardduty/include/aws/guardduty/GuardDutyWaiter.h create mode 100644 generated/src/aws-cpp-sdk-health/include/aws/health/HealthWaiter.h create mode 100644 generated/src/aws-cpp-sdk-identitystore/include/aws/identitystore/IdentityStoreWaiter.h create mode 100644 generated/src/aws-cpp-sdk-imagebuilder/include/aws/imagebuilder/ImagebuilderWaiter.h create mode 100644 generated/src/aws-cpp-sdk-inspector-scan/include/aws/inspector-scan/InspectorscanWaiter.h create mode 100644 generated/src/aws-cpp-sdk-inspector/include/aws/inspector/InspectorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-inspector2/include/aws/inspector2/Inspector2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-internetmonitor/include/aws/internetmonitor/InternetMonitorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-invoicing/include/aws/invoicing/InvoicingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iot-data/include/aws/iot-data/IoTDataPlaneWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iot-jobs-data/include/aws/iot-jobs-data/IoTJobsDataPlaneWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iot-managed-integrations/include/aws/iot-managed-integrations/IoTManagedIntegrationsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iot/include/aws/iot/IoTWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iotdeviceadvisor/include/aws/iotdeviceadvisor/IoTDeviceAdvisorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iotevents-data/include/aws/iotevents-data/IoTEventsDataWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iotevents/include/aws/iotevents/IoTEventsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iotfleetwise/include/aws/iotfleetwise/IoTFleetWiseWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iotsecuretunneling/include/aws/iotsecuretunneling/IoTSecureTunnelingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iotthingsgraph/include/aws/iotthingsgraph/IoTThingsGraphWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iottwinmaker/include/aws/iottwinmaker/IoTTwinMakerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-iotwireless/include/aws/iotwireless/IoTWirelessWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ivs-realtime/include/aws/ivs-realtime/IvsrealtimeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ivs/include/aws/ivs/IVSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ivschat/include/aws/ivschat/IvschatWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kafka/include/aws/kafka/KafkaWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kafkaconnect/include/aws/kafkaconnect/KafkaConnectWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kendra-ranking/include/aws/kendra-ranking/KendraRankingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kendra/include/aws/kendra/KendraWaiter.h create mode 100644 generated/src/aws-cpp-sdk-keyspaces/include/aws/keyspaces/KeyspacesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-keyspacesstreams/include/aws/keyspacesstreams/KeyspacesStreamsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kinesis-video-archived-media/include/aws/kinesis-video-archived-media/KinesisVideoArchivedMediaWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kinesis-video-media/include/aws/kinesis-video-media/KinesisVideoMediaWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kinesis-video-signaling/include/aws/kinesis-video-signaling/KinesisVideoSignalingChannelsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kinesis-video-webrtc-storage/include/aws/kinesis-video-webrtc-storage/KinesisVideoWebRTCStorageWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kinesisanalytics/include/aws/kinesisanalytics/KinesisAnalyticsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kinesisanalyticsv2/include/aws/kinesisanalyticsv2/KinesisAnalyticsV2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideoWaiter.h create mode 100644 generated/src/aws-cpp-sdk-kms/include/aws/kms/KMSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-lakeformation/include/aws/lakeformation/LakeFormationWaiter.h create mode 100644 generated/src/aws-cpp-sdk-launch-wizard/include/aws/launch-wizard/LaunchWizardWaiter.h create mode 100644 generated/src/aws-cpp-sdk-lex-models/include/aws/lex-models/LexModelBuildingServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-lex/include/aws/lex/LexRuntimeServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-lexv2-runtime/include/aws/lexv2-runtime/LexRuntimeV2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-license-manager-linux-subscriptions/include/aws/license-manager-linux-subscriptions/LicenseManagerLinuxSubscriptionsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-license-manager-user-subscriptions/include/aws/license-manager-user-subscriptions/LicenseManagerUserSubscriptionsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-license-manager/include/aws/license-manager/LicenseManagerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-lightsail/include/aws/lightsail/LightsailWaiter.h create mode 100644 generated/src/aws-cpp-sdk-location/include/aws/location/LocationServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-logs/include/aws/logs/CloudWatchLogsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-lookoutequipment/include/aws/lookoutequipment/LookoutEquipmentWaiter.h create mode 100644 generated/src/aws-cpp-sdk-m2/include/aws/m2/MainframeModernizationWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mailmanager/include/aws/mailmanager/MailManagerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-managedblockchain-query/include/aws/managedblockchain-query/ManagedBlockchainQueryWaiter.h create mode 100644 generated/src/aws-cpp-sdk-managedblockchain/include/aws/managedblockchain/ManagedBlockchainWaiter.h create mode 100644 generated/src/aws-cpp-sdk-marketplace-agreement/include/aws/marketplace-agreement/AgreementServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-marketplace-catalog/include/aws/marketplace-catalog/MarketplaceCatalogWaiter.h create mode 100644 generated/src/aws-cpp-sdk-marketplace-deployment/include/aws/marketplace-deployment/MarketplaceDeploymentWaiter.h create mode 100644 generated/src/aws-cpp-sdk-marketplace-entitlement/include/aws/marketplace-entitlement/MarketplaceEntitlementServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-marketplace-reporting/include/aws/marketplace-reporting/MarketplaceReportingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-marketplacecommerceanalytics/include/aws/marketplacecommerceanalytics/MarketplaceCommerceAnalyticsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mediaconvert/include/aws/mediaconvert/MediaConvertWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mediapackage-vod/include/aws/mediapackage-vod/MediaPackageVodWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mediapackage/include/aws/mediapackage/MediaPackageWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mediastore-data/include/aws/mediastore-data/MediaStoreDataWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mediatailor/include/aws/mediatailor/MediaTailorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-medical-imaging/include/aws/medical-imaging/MedicalImagingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-memorydb/include/aws/memorydb/MemoryDBWaiter.h create mode 100644 generated/src/aws-cpp-sdk-meteringmarketplace/include/aws/meteringmarketplace/MarketplaceMeteringWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mgn/include/aws/mgn/MgnWaiter.h create mode 100644 generated/src/aws-cpp-sdk-migration-hub-refactor-spaces/include/aws/migration-hub-refactor-spaces/MigrationHubRefactorSpacesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-migrationhub-config/include/aws/migrationhub-config/MigrationHubConfigWaiter.h create mode 100644 generated/src/aws-cpp-sdk-migrationhuborchestrator/include/aws/migrationhuborchestrator/MigrationHubOrchestratorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-migrationhubstrategy/include/aws/migrationhubstrategy/MigrationHubStrategyRecommendationsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mpa/include/aws/mpa/MPAWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mq/include/aws/mq/MQWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mturk-requester/include/aws/mturk-requester/MTurkWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mwaa-serverless/include/aws/mwaa-serverless/MWAAServerlessWaiter.h create mode 100644 generated/src/aws-cpp-sdk-mwaa/include/aws/mwaa/MWAAWaiter.h create mode 100644 generated/src/aws-cpp-sdk-neptunedata/include/aws/neptunedata/NeptunedataWaiter.h create mode 100644 generated/src/aws-cpp-sdk-network-firewall/include/aws/network-firewall/NetworkFirewallWaiter.h create mode 100644 generated/src/aws-cpp-sdk-networkflowmonitor/include/aws/networkflowmonitor/NetworkFlowMonitorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-networkmanager/include/aws/networkmanager/NetworkManagerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-networkmonitor/include/aws/networkmonitor/NetworkMonitorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-notifications/include/aws/notifications/NotificationsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-notificationscontacts/include/aws/notificationscontacts/NotificationsContactsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-nova-act/include/aws/nova-act/NovaActWaiter.h create mode 100644 generated/src/aws-cpp-sdk-oam/include/aws/oam/OAMWaiter.h create mode 100644 generated/src/aws-cpp-sdk-observabilityadmin/include/aws/observabilityadmin/ObservabilityAdminWaiter.h create mode 100644 generated/src/aws-cpp-sdk-odb/include/aws/odb/OdbWaiter.h create mode 100644 generated/src/aws-cpp-sdk-opensearch/include/aws/opensearch/OpenSearchServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-opensearchserverless/include/aws/opensearchserverless/OpenSearchServerlessWaiter.h create mode 100644 generated/src/aws-cpp-sdk-organizations/include/aws/organizations/OrganizationsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-osis/include/aws/osis/OSISWaiter.h create mode 100644 generated/src/aws-cpp-sdk-outposts/include/aws/outposts/OutpostsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-panorama/include/aws/panorama/PanoramaWaiter.h create mode 100644 generated/src/aws-cpp-sdk-partnercentral-account/include/aws/partnercentral-account/PartnerCentralAccountWaiter.h create mode 100644 generated/src/aws-cpp-sdk-partnercentral-benefits/include/aws/partnercentral-benefits/PartnerCentralBenefitsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-partnercentral-channel/include/aws/partnercentral-channel/PartnerCentralChannelWaiter.h create mode 100644 generated/src/aws-cpp-sdk-partnercentral-selling/include/aws/partnercentral-selling/PartnerCentralSellingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-payment-cryptography-data/include/aws/payment-cryptography-data/PaymentCryptographyDataWaiter.h create mode 100644 generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/PaymentCryptographyWaiter.h create mode 100644 generated/src/aws-cpp-sdk-pca-connector-ad/include/aws/pca-connector-ad/PcaConnectorAdWaiter.h create mode 100644 generated/src/aws-cpp-sdk-pca-connector-scep/include/aws/pca-connector-scep/PcaConnectorScepWaiter.h create mode 100644 generated/src/aws-cpp-sdk-pcs/include/aws/pcs/PCSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-personalize-events/include/aws/personalize-events/PersonalizeEventsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-personalize-runtime/include/aws/personalize-runtime/PersonalizeRuntimeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-personalize/include/aws/personalize/PersonalizeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-pi/include/aws/pi/PIWaiter.h create mode 100644 generated/src/aws-cpp-sdk-pinpoint-email/include/aws/pinpoint-email/PinpointEmailWaiter.h create mode 100644 generated/src/aws-cpp-sdk-pinpoint-sms-voice-v2/include/aws/pinpoint-sms-voice-v2/PinpointSMSVoiceV2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-pinpoint/include/aws/pinpoint/PinpointWaiter.h create mode 100644 generated/src/aws-cpp-sdk-pipes/include/aws/pipes/PipesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-polly/include/aws/polly/PollyWaiter.h create mode 100644 generated/src/aws-cpp-sdk-pricing/include/aws/pricing/PricingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-qapps/include/aws/qapps/QAppsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-qbusiness/include/aws/qbusiness/QBusinessWaiter.h create mode 100644 generated/src/aws-cpp-sdk-qconnect/include/aws/qconnect/QConnectWaiter.h create mode 100644 generated/src/aws-cpp-sdk-quicksight/include/aws/quicksight/QuickSightWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ram/include/aws/ram/RAMWaiter.h create mode 100644 generated/src/aws-cpp-sdk-rbin/include/aws/rbin/RecycleBinWaiter.h create mode 100644 generated/src/aws-cpp-sdk-rds-data/include/aws/rds-data/RDSDataServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-redshift-data/include/aws/redshift-data/RedshiftDataAPIServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-redshift-serverless/include/aws/redshift-serverless/RedshiftServerlessWaiter.h create mode 100644 generated/src/aws-cpp-sdk-resiliencehub/include/aws/resiliencehub/ResilienceHubWaiter.h create mode 100644 generated/src/aws-cpp-sdk-resource-explorer-2/include/aws/resource-explorer-2/ResourceExplorer2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-resource-groups/include/aws/resource-groups/ResourceGroupsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-resourcegroupstaggingapi/include/aws/resourcegroupstaggingapi/ResourceGroupsTaggingAPIWaiter.h create mode 100644 generated/src/aws-cpp-sdk-rolesanywhere/include/aws/rolesanywhere/RolesAnywhereWaiter.h create mode 100644 generated/src/aws-cpp-sdk-route53-recovery-cluster/include/aws/route53-recovery-cluster/Route53RecoveryClusterWaiter.h create mode 100644 generated/src/aws-cpp-sdk-route53-recovery-readiness/include/aws/route53-recovery-readiness/Route53RecoveryReadinessWaiter.h create mode 100644 generated/src/aws-cpp-sdk-route53domains/include/aws/route53domains/Route53DomainsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-route53globalresolver/include/aws/route53globalresolver/Route53GlobalResolverWaiter.h create mode 100644 generated/src/aws-cpp-sdk-route53profiles/include/aws/route53profiles/Route53ProfilesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverWaiter.h create mode 100644 generated/src/aws-cpp-sdk-rum/include/aws/rum/CloudWatchRUMWaiter.h create mode 100644 generated/src/aws-cpp-sdk-s3control/include/aws/s3control/S3ControlWaiter.h create mode 100644 generated/src/aws-cpp-sdk-s3outposts/include/aws/s3outposts/S3OutpostsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-s3tables/include/aws/s3tables/S3TablesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-s3vectors/include/aws/s3vectors/S3VectorsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sagemaker-a2i-runtime/include/aws/sagemaker-a2i-runtime/AugmentedAIRuntimeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sagemaker-edge/include/aws/sagemaker-edge/SagemakerEdgeManagerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sagemaker-featurestore-runtime/include/aws/sagemaker-featurestore-runtime/SageMakerFeatureStoreRuntimeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sagemaker-geospatial/include/aws/sagemaker-geospatial/SageMakerGeospatialWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sagemaker-metrics/include/aws/sagemaker-metrics/SageMakerMetricsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sagemaker-runtime-http2/include/aws/sagemaker-runtime-http2/SageMakerRuntimeHTTP2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-sagemaker-runtime/include/aws/sagemaker-runtime/SageMakerRuntimeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-savingsplans/include/aws/savingsplans/SavingsPlansWaiter.h create mode 100644 generated/src/aws-cpp-sdk-scheduler/include/aws/scheduler/SchedulerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-secretsmanager/include/aws/secretsmanager/SecretsManagerWaiter.h create mode 100644 generated/src/aws-cpp-sdk-security-ir/include/aws/security-ir/SecurityIRWaiter.h create mode 100644 generated/src/aws-cpp-sdk-securityhub/include/aws/securityhub/SecurityHubWaiter.h create mode 100644 generated/src/aws-cpp-sdk-securitylake/include/aws/securitylake/SecurityLakeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-serverlessrepo/include/aws/serverlessrepo/ServerlessApplicationRepositoryWaiter.h create mode 100644 generated/src/aws-cpp-sdk-service-quotas/include/aws/service-quotas/ServiceQuotasWaiter.h create mode 100644 generated/src/aws-cpp-sdk-servicecatalog-appregistry/include/aws/servicecatalog-appregistry/AppRegistryWaiter.h create mode 100644 generated/src/aws-cpp-sdk-servicecatalog/include/aws/servicecatalog/ServiceCatalogWaiter.h create mode 100644 generated/src/aws-cpp-sdk-servicediscovery/include/aws/servicediscovery/ServiceDiscoveryWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sesv2/include/aws/sesv2/SESV2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-shield/include/aws/shield/ShieldWaiter.h create mode 100644 generated/src/aws-cpp-sdk-signer-data/include/aws/signer-data/SignerDataWaiter.h create mode 100644 generated/src/aws-cpp-sdk-signin/include/aws/signin/SigninWaiter.h create mode 100644 generated/src/aws-cpp-sdk-simspaceweaver/include/aws/simspaceweaver/SimSpaceWeaverWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sms-voice/include/aws/sms-voice/PinpointSMSVoiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-snow-device-management/include/aws/snow-device-management/SnowDeviceManagementWaiter.h create mode 100644 generated/src/aws-cpp-sdk-snowball/include/aws/snowball/SnowballWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sns/include/aws/sns/SNSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-socialmessaging/include/aws/socialmessaging/SocialMessagingWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sqs/include/aws/sqs/SQSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ssm-contacts/include/aws/ssm-contacts/SSMContactsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ssm-guiconnect/include/aws/ssm-guiconnect/SSMGuiConnectWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ssm-quicksetup/include/aws/ssm-quicksetup/SSMQuickSetupWaiter.h create mode 100644 generated/src/aws-cpp-sdk-ssm-sap/include/aws/ssm-sap/SsmSapWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sso-admin/include/aws/sso-admin/SSOAdminWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sso-oidc/include/aws/sso-oidc/SSOOIDCWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sso/include/aws/sso/SSOWaiter.h create mode 100644 generated/src/aws-cpp-sdk-states/include/aws/states/SFNWaiter.h create mode 100644 generated/src/aws-cpp-sdk-storagegateway/include/aws/storagegateway/StorageGatewayWaiter.h create mode 100644 generated/src/aws-cpp-sdk-sts/include/aws/sts/STSWaiter.h create mode 100644 generated/src/aws-cpp-sdk-supplychain/include/aws/supplychain/SupplyChainWaiter.h create mode 100644 generated/src/aws-cpp-sdk-support-app/include/aws/support-app/SupportAppWaiter.h create mode 100644 generated/src/aws-cpp-sdk-support/include/aws/support/SupportWaiter.h create mode 100644 generated/src/aws-cpp-sdk-swf/include/aws/swf/SWFWaiter.h create mode 100644 generated/src/aws-cpp-sdk-synthetics/include/aws/synthetics/SyntheticsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-taxsettings/include/aws/taxsettings/TaxSettingsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-textract/include/aws/textract/TextractWaiter.h create mode 100644 generated/src/aws-cpp-sdk-timestream-influxdb/include/aws/timestream-influxdb/TimestreamInfluxDBWaiter.h create mode 100644 generated/src/aws-cpp-sdk-timestream-query/include/aws/timestream-query/TimestreamQueryWaiter.h create mode 100644 generated/src/aws-cpp-sdk-timestream-write/include/aws/timestream-write/TimestreamWriteWaiter.h create mode 100644 generated/src/aws-cpp-sdk-tnb/include/aws/tnb/TnbWaiter.h create mode 100644 generated/src/aws-cpp-sdk-transcribestreaming/include/aws/transcribestreaming/TranscribeStreamingServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-translate/include/aws/translate/TranslateWaiter.h create mode 100644 generated/src/aws-cpp-sdk-trustedadvisor/include/aws/trustedadvisor/TrustedAdvisorWaiter.h create mode 100644 generated/src/aws-cpp-sdk-verifiedpermissions/include/aws/verifiedpermissions/VerifiedPermissionsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-voice-id/include/aws/voice-id/VoiceIDWaiter.h create mode 100644 generated/src/aws-cpp-sdk-vpc-lattice/include/aws/vpc-lattice/VPCLatticeWaiter.h create mode 100644 generated/src/aws-cpp-sdk-waf-regional/include/aws/waf-regional/WAFRegionalWaiter.h create mode 100644 generated/src/aws-cpp-sdk-waf/include/aws/waf/WAFWaiter.h create mode 100644 generated/src/aws-cpp-sdk-wafv2/include/aws/wafv2/WAFV2Waiter.h create mode 100644 generated/src/aws-cpp-sdk-wellarchitected/include/aws/wellarchitected/WellArchitectedWaiter.h create mode 100644 generated/src/aws-cpp-sdk-wickr/include/aws/wickr/WickrWaiter.h create mode 100644 generated/src/aws-cpp-sdk-wisdom/include/aws/wisdom/ConnectWisdomServiceWaiter.h create mode 100644 generated/src/aws-cpp-sdk-workdocs/include/aws/workdocs/WorkDocsWaiter.h create mode 100644 generated/src/aws-cpp-sdk-workmail/include/aws/workmail/WorkMailWaiter.h create mode 100644 generated/src/aws-cpp-sdk-workmailmessageflow/include/aws/workmailmessageflow/WorkMailMessageFlowWaiter.h create mode 100644 generated/src/aws-cpp-sdk-workspaces-instances/include/aws/workspaces-instances/WorkspacesInstancesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-workspaces-thin-client/include/aws/workspaces-thin-client/WorkSpacesThinClientWaiter.h create mode 100644 generated/src/aws-cpp-sdk-workspaces-web/include/aws/workspaces-web/WorkSpacesWebWaiter.h create mode 100644 generated/src/aws-cpp-sdk-workspaces/include/aws/workspaces/WorkSpacesWaiter.h create mode 100644 generated/src/aws-cpp-sdk-xray/include/aws/xray/XRayWaiter.h diff --git a/generated/src/aws-cpp-sdk-AWSMigrationHub/include/aws/AWSMigrationHub/MigrationHubWaiter.h b/generated/src/aws-cpp-sdk-AWSMigrationHub/include/aws/AWSMigrationHub/MigrationHubWaiter.h new file mode 100644 index 00000000000..5748eafd262 --- /dev/null +++ b/generated/src/aws-cpp-sdk-AWSMigrationHub/include/aws/AWSMigrationHub/MigrationHubWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MigrationHub { + +template +class MigrationHubWaiter { + public: +}; +} // namespace MigrationHub +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerWaiter.h b/generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerWaiter.h new file mode 100644 index 00000000000..926079e1c50 --- /dev/null +++ b/generated/src/aws-cpp-sdk-accessanalyzer/include/aws/accessanalyzer/AccessAnalyzerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AccessAnalyzer { + +template +class AccessAnalyzerWaiter { + public: +}; +} // namespace AccessAnalyzer +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-account/include/aws/account/AccountWaiter.h b/generated/src/aws-cpp-sdk-account/include/aws/account/AccountWaiter.h new file mode 100644 index 00000000000..a659addb499 --- /dev/null +++ b/generated/src/aws-cpp-sdk-account/include/aws/account/AccountWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Account { + +template +class AccountWaiter { + public: +}; +} // namespace Account +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h b/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h index 057dfc9bfc5..522ed80968f 100644 --- a/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h +++ b/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h @@ -13,6 +13,7 @@ #include #include #include +#include #include @@ -24,55 +25,63 @@ class ACMPCAWaiter { public: Aws::Utils::WaiterOutcome WaitUntilAuditReportCreated( const Model::DescribeCertificateAuthorityAuditReportRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCESS"), - [](const Model::DescribeCertificateAuthorityAuditReportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AuditReportStatusMapper::GetNameForAuditReportStatus(result.GetAuditReportStatus()) == expected.get(); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeCertificateAuthorityAuditReportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AuditReportStatusMapper::GetNameForAuditReportStatus(result.GetAuditReportStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("AccessDeniedException")}); + using OutcomeT = Model::DescribeCertificateAuthorityAuditReportOutcome; + using RequestT = Model::DescribeCertificateAuthorityAuditReportRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AuditReportCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"), + [](const Model::DescribeCertificateAuthorityAuditReportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AuditReportStatusMapper::GetNameForAuditReportStatus(result.GetAuditReportStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AuditReportCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeCertificateAuthorityAuditReportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AuditReportStatusMapper::GetNameForAuditReportStatus(result.GetAuditReportStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AuditReportCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("AccessDeniedException"))); - auto operation = [this](const Model::DescribeCertificateAuthorityAuditReportRequest& req) { + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCertificateAuthorityAuditReport(req); }; - Aws::Utils::Waiter waiter( - 3, 60, acceptors, operation, "WaitUntilAuditReportCreated"); + Aws::Utils::Waiter waiter(3, 60, std::move(acceptors), operation, "WaitUntilAuditReportCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilCertificateIssued(const Model::GetCertificateRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("RequestInProgressException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("AccessDeniedException")}); + using OutcomeT = Model::GetCertificateOutcome; + using RequestT = Model::GetCertificateRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("CertificateIssuedWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>("CertificateIssuedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("RequestInProgressException"))); + acceptors.emplace_back(Aws::MakeUnique>("CertificateIssuedWaiter", Aws::Utils::WaiterState::FAILURE, + Aws::String("AccessDeniedException"))); - auto operation = [this](const Model::GetCertificateRequest& req) { return static_cast(this)->GetCertificate(req); }; - Aws::Utils::Waiter waiter(1, 60, acceptors, operation, - "WaitUntilCertificateIssued"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetCertificate(req); }; + Aws::Utils::Waiter waiter(1, 60, std::move(acceptors), operation, "WaitUntilCertificateIssued"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilCertificateAuthorityCSRCreated( const Model::GetCertificateAuthorityCsrRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("RequestInProgressException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("AccessDeniedException")}); + using OutcomeT = Model::GetCertificateAuthorityCsrOutcome; + using RequestT = Model::GetCertificateAuthorityCsrRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("CertificateAuthorityCSRCreatedWaiter", + Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>( + "CertificateAuthorityCSRCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("RequestInProgressException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "CertificateAuthorityCSRCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("AccessDeniedException"))); - auto operation = [this](const Model::GetCertificateAuthorityCsrRequest& req) { - return static_cast(this)->GetCertificateAuthorityCsr(req); - }; - Aws::Utils::Waiter waiter( - 3, 60, acceptors, operation, "WaitUntilCertificateAuthorityCSRCreated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetCertificateAuthorityCsr(req); }; + Aws::Utils::Waiter waiter(3, 60, std::move(acceptors), operation, "WaitUntilCertificateAuthorityCSRCreated"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h b/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h index 240e3870d29..59a7716fce4 100644 --- a/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h +++ b/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h @@ -9,6 +9,7 @@ #include #include #include +#include #include @@ -20,41 +21,40 @@ class ACMWaiter { public: Aws::Utils::WaiterOutcome WaitUntilCertificateValidated( const Model::DescribeCertificateRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCESS"), - [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetCertificate().GetDomainValidationOptions().begin(), - result.GetCertificate().GetDomainValidationOptions().end(), - [&](const Model::DomainValidation& item) { - return item.GetValidationStatus() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING_VALIDATION"), - [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetCertificate().GetDomainValidationOptions().begin(), - result.GetCertificate().GetDomainValidationOptions().end(), - [&](const Model::DomainValidation& item) { - return item.GetValidationStatus() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CertificateStatusMapper::GetNameForCertificateStatus(result.GetCertificate().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::DescribeCertificateOutcome; + using RequestT = Model::DescribeCertificateRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "CertificateValidatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"), + [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetCertificate().GetDomainValidationOptions().begin(), result.GetCertificate().GetDomainValidationOptions().end(), + [&](const Model::DomainValidation& item) { return item.GetValidationStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CertificateValidatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING_VALIDATION"), + [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetCertificate().GetDomainValidationOptions().begin(), result.GetCertificate().GetDomainValidationOptions().end(), + [&](const Model::DomainValidation& item) { return item.GetValidationStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CertificateValidatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CertificateStatusMapper::GetNameForCertificateStatus(result.GetCertificate().GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CertificateValidatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::DescribeCertificateRequest& req) { - return static_cast(this)->DescribeCertificate(req); - }; - Aws::Utils::Waiter waiter(60, 2, acceptors, operation, - "WaitUntilCertificateValidated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCertificate(req); }; + Aws::Utils::Waiter waiter(60, 2, std::move(acceptors), operation, "WaitUntilCertificateValidated"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-aiops/include/aws/aiops/AIOpsWaiter.h b/generated/src/aws-cpp-sdk-aiops/include/aws/aiops/AIOpsWaiter.h new file mode 100644 index 00000000000..13c77135532 --- /dev/null +++ b/generated/src/aws-cpp-sdk-aiops/include/aws/aiops/AIOpsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AIOps { + +template +class AIOpsWaiter { + public: +}; +} // namespace AIOps +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h b/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h index 09c83a8ac72..d6d5dc914ab 100644 --- a/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h +++ b/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h @@ -13,6 +13,7 @@ #include #include #include +#include #include @@ -24,138 +25,150 @@ class PrometheusServiceWaiter { public: Aws::Utils::WaiterOutcome WaitUntilAnomalyDetectorActive( const Model::DescribeAnomalyDetectorRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( - result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( - result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), - [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( - result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); - }}); + using OutcomeT = Model::DescribeAnomalyDetectorOutcome; + using RequestT = Model::DescribeAnomalyDetectorRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AnomalyDetectorActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( + result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnomalyDetectorActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( + result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnomalyDetectorActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), + [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( + result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); + })); - auto operation = [this](const Model::DescribeAnomalyDetectorRequest& req) { - return static_cast(this)->DescribeAnomalyDetector(req); - }; - Aws::Utils::Waiter waiter( - 2, 60, acceptors, operation, "WaitUntilAnomalyDetectorActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAnomalyDetector(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilAnomalyDetectorActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilAnomalyDetectorDeleted( const Model::DescribeAnomalyDetectorRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( - result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); - }}); + using OutcomeT = Model::DescribeAnomalyDetectorOutcome; + using RequestT = Model::DescribeAnomalyDetectorRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AnomalyDetectorDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "AnomalyDetectorDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AnomalyDetectorStatusCodeMapper::GetNameForAnomalyDetectorStatusCode( + result.GetAnomalyDetector().GetStatus().GetStatusCode()) == expected.get(); + })); - auto operation = [this](const Model::DescribeAnomalyDetectorRequest& req) { - return static_cast(this)->DescribeAnomalyDetector(req); - }; - Aws::Utils::Waiter waiter( - 2, 60, acceptors, operation, "WaitUntilAnomalyDetectorDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAnomalyDetector(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilAnomalyDetectorDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilScraperActive(const Model::DescribeScraperRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATION_FAILED"), - [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); - }}); + using OutcomeT = Model::DescribeScraperOutcome; + using RequestT = Model::DescribeScraperRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ScraperActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ScraperActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATION_FAILED"), + [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); + })); - auto operation = [this](const Model::DescribeScraperRequest& req) { return static_cast(this)->DescribeScraper(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, - "WaitUntilScraperActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeScraper(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilScraperActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilScraperDeleted(const Model::DescribeScraperRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETION_FAILED"), - [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); - }}); + using OutcomeT = Model::DescribeScraperOutcome; + using RequestT = Model::DescribeScraperRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("ScraperDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "ScraperDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETION_FAILED"), + [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); + })); - auto operation = [this](const Model::DescribeScraperRequest& req) { return static_cast(this)->DescribeScraper(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, - "WaitUntilScraperDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeScraper(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilScraperDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilWorkspaceActive(const Model::DescribeWorkspaceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), - [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); - }}); + using OutcomeT = Model::DescribeWorkspaceOutcome; + using RequestT = Model::DescribeWorkspaceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "WorkspaceActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WorkspaceActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), + [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WorkspaceActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + })); - auto operation = [this](const Model::DescribeWorkspaceRequest& req) { - return static_cast(this)->DescribeWorkspace(req); - }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, - "WaitUntilWorkspaceActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeWorkspace(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilWorkspaceActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilWorkspaceDeleted(const Model::DescribeWorkspaceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); - }}); + using OutcomeT = Model::DescribeWorkspaceOutcome; + using RequestT = Model::DescribeWorkspaceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("WorkspaceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "WorkspaceDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + })); - auto operation = [this](const Model::DescribeWorkspaceRequest& req) { - return static_cast(this)->DescribeWorkspace(req); - }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, - "WaitUntilWorkspaceDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeWorkspace(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilWorkspaceDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-amplify/include/aws/amplify/AmplifyWaiter.h b/generated/src/aws-cpp-sdk-amplify/include/aws/amplify/AmplifyWaiter.h new file mode 100644 index 00000000000..f95fd490090 --- /dev/null +++ b/generated/src/aws-cpp-sdk-amplify/include/aws/amplify/AmplifyWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Amplify { + +template +class AmplifyWaiter { + public: +}; +} // namespace Amplify +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-amplifybackend/include/aws/amplifybackend/AmplifyBackendWaiter.h b/generated/src/aws-cpp-sdk-amplifybackend/include/aws/amplifybackend/AmplifyBackendWaiter.h new file mode 100644 index 00000000000..3119dfeb0d5 --- /dev/null +++ b/generated/src/aws-cpp-sdk-amplifybackend/include/aws/amplifybackend/AmplifyBackendWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AmplifyBackend { + +template +class AmplifyBackendWaiter { + public: +}; +} // namespace AmplifyBackend +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-amplifyuibuilder/include/aws/amplifyuibuilder/AmplifyUIBuilderWaiter.h b/generated/src/aws-cpp-sdk-amplifyuibuilder/include/aws/amplifyuibuilder/AmplifyUIBuilderWaiter.h new file mode 100644 index 00000000000..fa4b8252bd4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-amplifyuibuilder/include/aws/amplifyuibuilder/AmplifyUIBuilderWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AmplifyUIBuilder { + +template +class AmplifyUIBuilderWaiter { + public: +}; +} // namespace AmplifyUIBuilder +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-apigateway/include/aws/apigateway/APIGatewayWaiter.h b/generated/src/aws-cpp-sdk-apigateway/include/aws/apigateway/APIGatewayWaiter.h new file mode 100644 index 00000000000..d0a5b7e4230 --- /dev/null +++ b/generated/src/aws-cpp-sdk-apigateway/include/aws/apigateway/APIGatewayWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace APIGateway { + +template +class APIGatewayWaiter { + public: +}; +} // namespace APIGateway +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-apigatewaymanagementapi/include/aws/apigatewaymanagementapi/ApiGatewayManagementApiWaiter.h b/generated/src/aws-cpp-sdk-apigatewaymanagementapi/include/aws/apigatewaymanagementapi/ApiGatewayManagementApiWaiter.h new file mode 100644 index 00000000000..9c13e47676a --- /dev/null +++ b/generated/src/aws-cpp-sdk-apigatewaymanagementapi/include/aws/apigatewaymanagementapi/ApiGatewayManagementApiWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ApiGatewayManagementApi { + +template +class ApiGatewayManagementApiWaiter { + public: +}; +} // namespace ApiGatewayManagementApi +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-apigatewayv2/include/aws/apigatewayv2/ApiGatewayV2Waiter.h b/generated/src/aws-cpp-sdk-apigatewayv2/include/aws/apigatewayv2/ApiGatewayV2Waiter.h new file mode 100644 index 00000000000..ff5af6f2f58 --- /dev/null +++ b/generated/src/aws-cpp-sdk-apigatewayv2/include/aws/apigatewayv2/ApiGatewayV2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ApiGatewayV2 { + +template +class ApiGatewayV2Waiter { + public: +}; +} // namespace ApiGatewayV2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h b/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h index fc68f897c4d..d346f829260 100644 --- a/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h +++ b/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h @@ -12,6 +12,7 @@ #include #include #include +#include #include @@ -22,60 +23,65 @@ template class AppConfigWaiter { public: Aws::Utils::WaiterOutcome WaitUntilDeploymentComplete(const Model::GetDeploymentRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETE"), - [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::DeploymentStateMapper::GetNameForDeploymentState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLED_BACK"), - [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::DeploymentStateMapper::GetNameForDeploymentState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REVERTED"), - [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::DeploymentStateMapper::GetNameForDeploymentState(result.GetState()) == expected.get(); - }}); + using OutcomeT = Model::GetDeploymentOutcome; + using RequestT = Model::GetDeploymentRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DeploymentCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETE"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStateMapper::GetNameForDeploymentState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DeploymentCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ROLLED_BACK"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStateMapper::GetNameForDeploymentState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DeploymentCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REVERTED"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStateMapper::GetNameForDeploymentState(result.GetState()) == expected.get(); + })); - auto operation = [this](const Model::GetDeploymentRequest& req) { return static_cast(this)->GetDeployment(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilDeploymentComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetDeployment(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilDeploymentComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilEnvironmentReadyForDeployment( const Model::GetEnvironmentRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ReadyForDeployment"), - [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::EnvironmentStateMapper::GetNameForEnvironmentState(result.GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("RolledBack"), - [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::EnvironmentStateMapper::GetNameForEnvironmentState(result.GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Reverted"), - [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::EnvironmentStateMapper::GetNameForEnvironmentState(result.GetState()) == - expected.get(); - }}); + using OutcomeT = Model::GetEnvironmentOutcome; + using RequestT = Model::GetEnvironmentRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentReadyForDeploymentWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ReadyForDeployment"), + [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EnvironmentStateMapper::GetNameForEnvironmentState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentReadyForDeploymentWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("RolledBack"), + [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EnvironmentStateMapper::GetNameForEnvironmentState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentReadyForDeploymentWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Reverted"), + [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EnvironmentStateMapper::GetNameForEnvironmentState(result.GetState()) == expected.get(); + })); - auto operation = [this](const Model::GetEnvironmentRequest& req) { return static_cast(this)->GetEnvironment(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilEnvironmentReadyForDeployment"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetEnvironment(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilEnvironmentReadyForDeployment"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-appconfigdata/include/aws/appconfigdata/AppConfigDataWaiter.h b/generated/src/aws-cpp-sdk-appconfigdata/include/aws/appconfigdata/AppConfigDataWaiter.h new file mode 100644 index 00000000000..e47ec14ced4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-appconfigdata/include/aws/appconfigdata/AppConfigDataWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AppConfigData { + +template +class AppConfigDataWaiter { + public: +}; +} // namespace AppConfigData +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-appfabric/include/aws/appfabric/AppFabricWaiter.h b/generated/src/aws-cpp-sdk-appfabric/include/aws/appfabric/AppFabricWaiter.h new file mode 100644 index 00000000000..4e66d449931 --- /dev/null +++ b/generated/src/aws-cpp-sdk-appfabric/include/aws/appfabric/AppFabricWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AppFabric { + +template +class AppFabricWaiter { + public: +}; +} // namespace AppFabric +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-appflow/include/aws/appflow/AppflowWaiter.h b/generated/src/aws-cpp-sdk-appflow/include/aws/appflow/AppflowWaiter.h new file mode 100644 index 00000000000..41ed6eb75be --- /dev/null +++ b/generated/src/aws-cpp-sdk-appflow/include/aws/appflow/AppflowWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Appflow { + +template +class AppflowWaiter { + public: +}; +} // namespace Appflow +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-appintegrations/include/aws/appintegrations/AppIntegrationsServiceWaiter.h b/generated/src/aws-cpp-sdk-appintegrations/include/aws/appintegrations/AppIntegrationsServiceWaiter.h new file mode 100644 index 00000000000..d5bfdd8c0c4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-appintegrations/include/aws/appintegrations/AppIntegrationsServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AppIntegrationsService { + +template +class AppIntegrationsServiceWaiter { + public: +}; +} // namespace AppIntegrationsService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-application-autoscaling/include/aws/application-autoscaling/ApplicationAutoScalingWaiter.h b/generated/src/aws-cpp-sdk-application-autoscaling/include/aws/application-autoscaling/ApplicationAutoScalingWaiter.h new file mode 100644 index 00000000000..4bf14df846a --- /dev/null +++ b/generated/src/aws-cpp-sdk-application-autoscaling/include/aws/application-autoscaling/ApplicationAutoScalingWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ApplicationAutoScaling { + +template +class ApplicationAutoScalingWaiter { + public: +}; +} // namespace ApplicationAutoScaling +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-application-insights/include/aws/application-insights/ApplicationInsightsWaiter.h b/generated/src/aws-cpp-sdk-application-insights/include/aws/application-insights/ApplicationInsightsWaiter.h new file mode 100644 index 00000000000..79e5fa9e826 --- /dev/null +++ b/generated/src/aws-cpp-sdk-application-insights/include/aws/application-insights/ApplicationInsightsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ApplicationInsights { + +template +class ApplicationInsightsWaiter { + public: +}; +} // namespace ApplicationInsights +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-application-signals/include/aws/application-signals/ApplicationSignalsWaiter.h b/generated/src/aws-cpp-sdk-application-signals/include/aws/application-signals/ApplicationSignalsWaiter.h new file mode 100644 index 00000000000..c5500a7993f --- /dev/null +++ b/generated/src/aws-cpp-sdk-application-signals/include/aws/application-signals/ApplicationSignalsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ApplicationSignals { + +template +class ApplicationSignalsWaiter { + public: +}; +} // namespace ApplicationSignals +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-applicationcostprofiler/include/aws/applicationcostprofiler/ApplicationCostProfilerWaiter.h b/generated/src/aws-cpp-sdk-applicationcostprofiler/include/aws/applicationcostprofiler/ApplicationCostProfilerWaiter.h new file mode 100644 index 00000000000..7aadaf7ada5 --- /dev/null +++ b/generated/src/aws-cpp-sdk-applicationcostprofiler/include/aws/applicationcostprofiler/ApplicationCostProfilerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ApplicationCostProfiler { + +template +class ApplicationCostProfilerWaiter { + public: +}; +} // namespace ApplicationCostProfiler +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-appmesh/include/aws/appmesh/AppMeshWaiter.h b/generated/src/aws-cpp-sdk-appmesh/include/aws/appmesh/AppMeshWaiter.h new file mode 100644 index 00000000000..2304fe68186 --- /dev/null +++ b/generated/src/aws-cpp-sdk-appmesh/include/aws/appmesh/AppMeshWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AppMesh { + +template +class AppMeshWaiter { + public: +}; +} // namespace AppMesh +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-apprunner/include/aws/apprunner/AppRunnerWaiter.h b/generated/src/aws-cpp-sdk-apprunner/include/aws/apprunner/AppRunnerWaiter.h new file mode 100644 index 00000000000..f5e4e9bf3c8 --- /dev/null +++ b/generated/src/aws-cpp-sdk-apprunner/include/aws/apprunner/AppRunnerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AppRunner { + +template +class AppRunnerWaiter { + public: +}; +} // namespace AppRunner +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h b/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h index 6b76f6b7882..49d6faf465e 100644 --- a/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h +++ b/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h @@ -9,6 +9,7 @@ #include #include #include +#include #include @@ -19,68 +20,76 @@ template class AppStreamWaiter { public: Aws::Utils::WaiterOutcome WaitUntilFleetStarted(const Model::DescribeFleetsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), - [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { - return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), - [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { - return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), - [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { - return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeFleetsOutcome; + using RequestT = Model::DescribeFleetsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FleetStartedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FleetStartedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("STOPPING"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FleetStartedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("STOPPED"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + })); - auto operation = [this](const Model::DescribeFleetsRequest& req) { return static_cast(this)->DescribeFleets(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilFleetStarted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeFleets(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilFleetStarted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFleetStopped(const Model::DescribeFleetsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), - [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { - return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), - [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { - return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), - [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { - return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeFleetsOutcome; + using RequestT = Model::DescribeFleetsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FleetStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FleetStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("STARTING"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FleetStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("RUNNING"), + [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFleets().begin(), result.GetFleets().end(), [&](const Model::Fleet& item) { + return Model::FleetStateMapper::GetNameForFleetState(item.GetState()) == expected.get(); + }); + })); - auto operation = [this](const Model::DescribeFleetsRequest& req) { return static_cast(this)->DescribeFleets(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilFleetStopped"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeFleets(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilFleetStopped"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-appsync/include/aws/appsync/AppSyncWaiter.h b/generated/src/aws-cpp-sdk-appsync/include/aws/appsync/AppSyncWaiter.h new file mode 100644 index 00000000000..af793a77ddb --- /dev/null +++ b/generated/src/aws-cpp-sdk-appsync/include/aws/appsync/AppSyncWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AppSync { + +template +class AppSyncWaiter { + public: +}; +} // namespace AppSync +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h b/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h index aa3e2de2fd9..c516bdb1e78 100644 --- a/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h +++ b/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h @@ -12,6 +12,7 @@ #include #include #include +#include #include @@ -23,78 +24,78 @@ class ARCRegionswitchWaiter { public: Aws::Utils::WaiterOutcome WaitUntilPlanEvaluationStatusPassed( const Model::GetPlanEvaluationStatusRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("passed"), - [](const Model::GetPlanEvaluationStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::EvaluationStatusMapper::GetNameForEvaluationStatus(result.GetEvaluationState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("actionRequired"), - [](const Model::GetPlanEvaluationStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::EvaluationStatusMapper::GetNameForEvaluationStatus(result.GetEvaluationState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("pendingEvaluation"), - [](const Model::GetPlanEvaluationStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::EvaluationStatusMapper::GetNameForEvaluationStatus(result.GetEvaluationState()) == - expected.get(); - }}); + using OutcomeT = Model::GetPlanEvaluationStatusOutcome; + using RequestT = Model::GetPlanEvaluationStatusRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "PlanEvaluationStatusPassedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("passed"), + [](const Model::GetPlanEvaluationStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EvaluationStatusMapper::GetNameForEvaluationStatus(result.GetEvaluationState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PlanEvaluationStatusPassedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("actionRequired"), + [](const Model::GetPlanEvaluationStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EvaluationStatusMapper::GetNameForEvaluationStatus(result.GetEvaluationState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PlanEvaluationStatusPassedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("pendingEvaluation"), + [](const Model::GetPlanEvaluationStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EvaluationStatusMapper::GetNameForEvaluationStatus(result.GetEvaluationState()) == expected.get(); + })); - auto operation = [this](const Model::GetPlanEvaluationStatusRequest& req) { - return static_cast(this)->GetPlanEvaluationStatus(req); - }; - Aws::Utils::Waiter waiter( - 30, 4, acceptors, operation, "WaitUntilPlanEvaluationStatusPassed"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetPlanEvaluationStatus(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilPlanEvaluationStatusPassed"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPlanExecutionCompleted(const Model::GetPlanExecutionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), - [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completedWithExceptions"), - [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("canceled"), - [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("planExecutionTimedOut"), - [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == - expected.get(); - }}); + using OutcomeT = Model::GetPlanExecutionOutcome; + using RequestT = Model::GetPlanExecutionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "PlanExecutionCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), + [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PlanExecutionCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completedWithExceptions"), + [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PlanExecutionCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PlanExecutionCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("canceled"), + [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PlanExecutionCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("planExecutionTimedOut"), + [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExecutionStateMapper::GetNameForExecutionState(result.GetExecutionState()) == expected.get(); + })); - auto operation = [this](const Model::GetPlanExecutionRequest& req) { return static_cast(this)->GetPlanExecution(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilPlanExecutionCompleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetPlanExecution(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilPlanExecutionCompleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/ARCZonalShiftWaiter.h b/generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/ARCZonalShiftWaiter.h new file mode 100644 index 00000000000..e5f3a2b60c0 --- /dev/null +++ b/generated/src/aws-cpp-sdk-arc-zonal-shift/include/aws/arc-zonal-shift/ARCZonalShiftWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ARCZonalShift { + +template +class ARCZonalShiftWaiter { + public: +}; +} // namespace ARCZonalShift +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-artifact/include/aws/artifact/ArtifactWaiter.h b/generated/src/aws-cpp-sdk-artifact/include/aws/artifact/ArtifactWaiter.h new file mode 100644 index 00000000000..9818f263efb --- /dev/null +++ b/generated/src/aws-cpp-sdk-artifact/include/aws/artifact/ArtifactWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Artifact { + +template +class ArtifactWaiter { + public: +}; +} // namespace Artifact +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-athena/include/aws/athena/AthenaWaiter.h b/generated/src/aws-cpp-sdk-athena/include/aws/athena/AthenaWaiter.h new file mode 100644 index 00000000000..6bd194faa4c --- /dev/null +++ b/generated/src/aws-cpp-sdk-athena/include/aws/athena/AthenaWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Athena { + +template +class AthenaWaiter { + public: +}; +} // namespace Athena +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-auditmanager/include/aws/auditmanager/AuditManagerWaiter.h b/generated/src/aws-cpp-sdk-auditmanager/include/aws/auditmanager/AuditManagerWaiter.h new file mode 100644 index 00000000000..6f9ccc70ea6 --- /dev/null +++ b/generated/src/aws-cpp-sdk-auditmanager/include/aws/auditmanager/AuditManagerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AuditManager { + +template +class AuditManagerWaiter { + public: +}; +} // namespace AuditManager +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-autoscaling-plans/include/aws/autoscaling-plans/AutoScalingPlansWaiter.h b/generated/src/aws-cpp-sdk-autoscaling-plans/include/aws/autoscaling-plans/AutoScalingPlansWaiter.h new file mode 100644 index 00000000000..f59afff6695 --- /dev/null +++ b/generated/src/aws-cpp-sdk-autoscaling-plans/include/aws/autoscaling-plans/AutoScalingPlansWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AutoScalingPlans { + +template +class AutoScalingPlansWaiter { + public: +}; +} // namespace AutoScalingPlans +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h index e4fe7116045..fceace9f270 100644 --- a/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h +++ b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h @@ -8,6 +8,7 @@ #include #include #include +#include #include @@ -19,85 +20,86 @@ class AutoScalingWaiter { public: Aws::Utils::WaiterOutcome WaitUntilGroupExists( const Model::DescribeAutoScalingGroupsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetAutoScalingGroups().size() > 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, false, - [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetAutoScalingGroups().size() > 0) == expected.get(); - }}); + using OutcomeT = Model::DescribeAutoScalingGroupsOutcome; + using RequestT = Model::DescribeAutoScalingGroupsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "GroupExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetAutoScalingGroups().size() > 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "GroupExistsWaiter", Aws::Utils::WaiterState::RETRY, false, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetAutoScalingGroups().size() > 0) == expected.get(); + })); - auto operation = [this](const Model::DescribeAutoScalingGroupsRequest& req) { - return static_cast(this)->DescribeAutoScalingGroups(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilGroupExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAutoScalingGroups(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilGroupExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilGroupInService( const Model::DescribeAutoScalingGroupsRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, false, - [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), - [](const Model::AutoScalingGroup& item) { - return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const auto& inner) { - return (inner.GetLifecycleState() == "InService"); - }) >= item.GetMinSize()); - }) == expected.get(); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), - [](const Model::AutoScalingGroup& item) { - return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const auto& inner) { - return (inner.GetLifecycleState() == "InService"); - }) >= item.GetMinSize()); - }) == expected.get(); - }}); + using OutcomeT = Model::DescribeAutoScalingGroupsOutcome; + using RequestT = Model::DescribeAutoScalingGroupsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "GroupInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, false, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), + [](const Model::AutoScalingGroup& item) { + return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const auto& inner) { + return (inner.GetLifecycleState() == "InService"); + }) >= item.GetMinSize()); + }) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "GroupInServiceWaiter", Aws::Utils::WaiterState::RETRY, true, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), + [](const Model::AutoScalingGroup& item) { + return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const auto& inner) { + return (inner.GetLifecycleState() == "InService"); + }) >= item.GetMinSize()); + }) == expected.get(); + })); - auto operation = [this](const Model::DescribeAutoScalingGroupsRequest& req) { - return static_cast(this)->DescribeAutoScalingGroups(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilGroupInService"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAutoScalingGroups(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilGroupInService"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilGroupNotExists( const Model::DescribeAutoScalingGroupsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, false, - [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetAutoScalingGroups().size() > 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetAutoScalingGroups().size() > 0) == expected.get(); - }}); + using OutcomeT = Model::DescribeAutoScalingGroupsOutcome; + using RequestT = Model::DescribeAutoScalingGroupsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "GroupNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetAutoScalingGroups().size() > 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "GroupNotExistsWaiter", Aws::Utils::WaiterState::RETRY, true, + [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetAutoScalingGroups().size() > 0) == expected.get(); + })); - auto operation = [this](const Model::DescribeAutoScalingGroupsRequest& req) { - return static_cast(this)->DescribeAutoScalingGroups(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilGroupNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAutoScalingGroups(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilGroupNotExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h b/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h index 770ba82aa6f..70e1f6a91cc 100644 --- a/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h +++ b/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h @@ -9,6 +9,7 @@ #include #include #include +#include #include @@ -19,44 +20,50 @@ template class TransferWaiter { public: Aws::Utils::WaiterOutcome WaitUntilServerOffline(const Model::DescribeServerRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("OFFLINE"), - [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STOP_FAILED"), - [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); - }}); + using OutcomeT = Model::DescribeServerOutcome; + using RequestT = Model::DescribeServerRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ServerOfflineWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("OFFLINE"), + [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServerOfflineWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("STOP_FAILED"), + [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); + })); - auto operation = [this](const Model::DescribeServerRequest& req) { return static_cast(this)->DescribeServer(req); }; - Aws::Utils::Waiter waiter(30, 120, acceptors, operation, - "WaitUntilServerOffline"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeServer(req); }; + Aws::Utils::Waiter waiter(30, 120, std::move(acceptors), operation, "WaitUntilServerOffline"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilServerOnline(const Model::DescribeServerRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ONLINE"), - [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("START_FAILED"), - [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); - }}); + using OutcomeT = Model::DescribeServerOutcome; + using RequestT = Model::DescribeServerRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ServerOnlineWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ONLINE"), + [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServerOnlineWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("START_FAILED"), + [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetServer().GetState()) == expected.get(); + })); - auto operation = [this](const Model::DescribeServerRequest& req) { return static_cast(this)->DescribeServer(req); }; - Aws::Utils::Waiter waiter(30, 120, acceptors, operation, - "WaitUntilServerOnline"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeServer(req); }; + Aws::Utils::Waiter waiter(30, 120, std::move(acceptors), operation, "WaitUntilServerOnline"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h b/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h index d2155574ea9..82850498999 100644 --- a/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h +++ b/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h @@ -9,6 +9,7 @@ #include #include #include +#include #include @@ -20,27 +21,26 @@ class B2BIWaiter { public: Aws::Utils::WaiterOutcome WaitUntilTransformerJobSucceeded( const Model::GetTransformerJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("succeeded"), - [](const Model::GetTransformerJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TransformerJobStatusMapper::GetNameForTransformerJobStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::GetTransformerJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TransformerJobStatusMapper::GetNameForTransformerJobStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetTransformerJobOutcome; + using RequestT = Model::GetTransformerJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TransformerJobSucceededWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("succeeded"), + [](const Model::GetTransformerJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TransformerJobStatusMapper::GetNameForTransformerJobStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TransformerJobSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::GetTransformerJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TransformerJobStatusMapper::GetNameForTransformerJobStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetTransformerJobRequest& req) { - return static_cast(this)->GetTransformerJob(req); - }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilTransformerJobSucceeded"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetTransformerJob(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilTransformerJobSucceeded"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-backup-gateway/include/aws/backup-gateway/BackupGatewayWaiter.h b/generated/src/aws-cpp-sdk-backup-gateway/include/aws/backup-gateway/BackupGatewayWaiter.h new file mode 100644 index 00000000000..0038b98c5d3 --- /dev/null +++ b/generated/src/aws-cpp-sdk-backup-gateway/include/aws/backup-gateway/BackupGatewayWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BackupGateway { + +template +class BackupGatewayWaiter { + public: +}; +} // namespace BackupGateway +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-backup/include/aws/backup/BackupWaiter.h b/generated/src/aws-cpp-sdk-backup/include/aws/backup/BackupWaiter.h new file mode 100644 index 00000000000..97c75eeddd5 --- /dev/null +++ b/generated/src/aws-cpp-sdk-backup/include/aws/backup/BackupWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Backup { + +template +class BackupWaiter { + public: +}; +} // namespace Backup +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-backupsearch/include/aws/backupsearch/BackupSearchWaiter.h b/generated/src/aws-cpp-sdk-backupsearch/include/aws/backupsearch/BackupSearchWaiter.h new file mode 100644 index 00000000000..4b2bf55278f --- /dev/null +++ b/generated/src/aws-cpp-sdk-backupsearch/include/aws/backupsearch/BackupSearchWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BackupSearch { + +template +class BackupSearchWaiter { + public: +}; +} // namespace BackupSearch +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-batch/include/aws/batch/BatchWaiter.h b/generated/src/aws-cpp-sdk-batch/include/aws/batch/BatchWaiter.h new file mode 100644 index 00000000000..59fbee3bb01 --- /dev/null +++ b/generated/src/aws-cpp-sdk-batch/include/aws/batch/BatchWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Batch { + +template +class BatchWaiter { + public: +}; +} // namespace Batch +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bcm-dashboards/include/aws/bcm-dashboards/BCMDashboardsWaiter.h b/generated/src/aws-cpp-sdk-bcm-dashboards/include/aws/bcm-dashboards/BCMDashboardsWaiter.h new file mode 100644 index 00000000000..f9e255e7d7e --- /dev/null +++ b/generated/src/aws-cpp-sdk-bcm-dashboards/include/aws/bcm-dashboards/BCMDashboardsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BCMDashboards { + +template +class BCMDashboardsWaiter { + public: +}; +} // namespace BCMDashboards +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bcm-data-exports/include/aws/bcm-data-exports/BCMDataExportsWaiter.h b/generated/src/aws-cpp-sdk-bcm-data-exports/include/aws/bcm-data-exports/BCMDataExportsWaiter.h new file mode 100644 index 00000000000..2c747f48928 --- /dev/null +++ b/generated/src/aws-cpp-sdk-bcm-data-exports/include/aws/bcm-data-exports/BCMDataExportsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BCMDataExports { + +template +class BCMDataExportsWaiter { + public: +}; +} // namespace BCMDataExports +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bcm-pricing-calculator/include/aws/bcm-pricing-calculator/BCMPricingCalculatorWaiter.h b/generated/src/aws-cpp-sdk-bcm-pricing-calculator/include/aws/bcm-pricing-calculator/BCMPricingCalculatorWaiter.h new file mode 100644 index 00000000000..adff6e95cb9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-bcm-pricing-calculator/include/aws/bcm-pricing-calculator/BCMPricingCalculatorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BCMPricingCalculator { + +template +class BCMPricingCalculatorWaiter { + public: +}; +} // namespace BCMPricingCalculator +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bcm-recommended-actions/include/aws/bcm-recommended-actions/BCMRecommendedActionsWaiter.h b/generated/src/aws-cpp-sdk-bcm-recommended-actions/include/aws/bcm-recommended-actions/BCMRecommendedActionsWaiter.h new file mode 100644 index 00000000000..f0466c0780b --- /dev/null +++ b/generated/src/aws-cpp-sdk-bcm-recommended-actions/include/aws/bcm-recommended-actions/BCMRecommendedActionsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BCMRecommendedActions { + +template +class BCMRecommendedActionsWaiter { + public: +}; +} // namespace BCMRecommendedActions +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bedrock-agent-runtime/include/aws/bedrock-agent-runtime/BedrockAgentRuntimeWaiter.h b/generated/src/aws-cpp-sdk-bedrock-agent-runtime/include/aws/bedrock-agent-runtime/BedrockAgentRuntimeWaiter.h new file mode 100644 index 00000000000..143a43382b2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-bedrock-agent-runtime/include/aws/bedrock-agent-runtime/BedrockAgentRuntimeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BedrockAgentRuntime { + +template +class BedrockAgentRuntimeWaiter { + public: +}; +} // namespace BedrockAgentRuntime +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bedrock-agent/include/aws/bedrock-agent/BedrockAgentWaiter.h b/generated/src/aws-cpp-sdk-bedrock-agent/include/aws/bedrock-agent/BedrockAgentWaiter.h new file mode 100644 index 00000000000..b89fea68f7f --- /dev/null +++ b/generated/src/aws-cpp-sdk-bedrock-agent/include/aws/bedrock-agent/BedrockAgentWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BedrockAgent { + +template +class BedrockAgentWaiter { + public: +}; +} // namespace BedrockAgent +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h b/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h index abf208d9925..6040a010f7e 100644 --- a/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h +++ b/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h @@ -18,6 +18,7 @@ #include #include #include +#include #include @@ -28,191 +29,200 @@ template class BedrockAgentCoreControlWaiter { public: Aws::Utils::WaiterOutcome WaitUntilMemoryCreated(const Model::GetMemoryRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::GetMemoryOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MemoryStatusMapper::GetNameForMemoryStatus(result.GetMemory().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetMemoryOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MemoryStatusMapper::GetNameForMemoryStatus(result.GetMemory().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetMemoryOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MemoryStatusMapper::GetNameForMemoryStatus(result.GetMemory().GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetMemoryOutcome; + using RequestT = Model::GetMemoryRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "MemoryCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::GetMemoryOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MemoryStatusMapper::GetNameForMemoryStatus(result.GetMemory().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "MemoryCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetMemoryOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MemoryStatusMapper::GetNameForMemoryStatus(result.GetMemory().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "MemoryCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetMemoryOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MemoryStatusMapper::GetNameForMemoryStatus(result.GetMemory().GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetMemoryRequest& req) { return static_cast(this)->GetMemory(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilMemoryCreated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetMemory(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilMemoryCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPolicyActive(const Model::GetPolicyRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), - [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetPolicyOutcome; + using RequestT = Model::GetPolicyRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetPolicyRequest& req) { return static_cast(this)->GetPolicy(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilPolicyActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetPolicy(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilPolicyActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPolicyDeleted(const Model::GetPolicyRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetPolicyOutcome; + using RequestT = Model::GetPolicyRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("PolicyDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetPolicyRequest& req) { return static_cast(this)->GetPolicy(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilPolicyDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetPolicy(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilPolicyDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPolicyEngineActive(const Model::GetPolicyEngineRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), - [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetPolicyEngineOutcome; + using RequestT = Model::GetPolicyEngineRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyEngineActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyEngineActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyEngineActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyEngineActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetPolicyEngineRequest& req) { return static_cast(this)->GetPolicyEngine(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilPolicyEngineActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetPolicyEngine(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilPolicyEngineActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPolicyEngineDeleted(const Model::GetPolicyEngineRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetPolicyEngineOutcome; + using RequestT = Model::GetPolicyEngineRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyEngineDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyEngineDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyEngineStatusMapper::GetNameForPolicyEngineStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyEngineDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetPolicyEngineRequest& req) { return static_cast(this)->GetPolicyEngine(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, - "WaitUntilPolicyEngineDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetPolicyEngine(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilPolicyEngineDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPolicyGenerationCompleted( const Model::GetPolicyGenerationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("GENERATED"), - [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("GENERATING"), - [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("GENERATE_FAILED"), - [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetPolicyGenerationOutcome; + using RequestT = Model::GetPolicyGenerationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyGenerationCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("GENERATED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyGenerationCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("GENERATING"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyGenerationCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("GENERATE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PolicyGenerationCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PolicyGenerationStatusMapper::GetNameForPolicyGenerationStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetPolicyGenerationRequest& req) { - return static_cast(this)->GetPolicyGeneration(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilPolicyGenerationCompleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetPolicyGeneration(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilPolicyGenerationCompleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-bedrock-agentcore/include/aws/bedrock-agentcore/BedrockAgentCoreWaiter.h b/generated/src/aws-cpp-sdk-bedrock-agentcore/include/aws/bedrock-agentcore/BedrockAgentCoreWaiter.h new file mode 100644 index 00000000000..a0a08b79e64 --- /dev/null +++ b/generated/src/aws-cpp-sdk-bedrock-agentcore/include/aws/bedrock-agentcore/BedrockAgentCoreWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BedrockAgentCore { + +template +class BedrockAgentCoreWaiter { + public: +}; +} // namespace BedrockAgentCore +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bedrock-data-automation-runtime/include/aws/bedrock-data-automation-runtime/BedrockDataAutomationRuntimeWaiter.h b/generated/src/aws-cpp-sdk-bedrock-data-automation-runtime/include/aws/bedrock-data-automation-runtime/BedrockDataAutomationRuntimeWaiter.h new file mode 100644 index 00000000000..72b447de5db --- /dev/null +++ b/generated/src/aws-cpp-sdk-bedrock-data-automation-runtime/include/aws/bedrock-data-automation-runtime/BedrockDataAutomationRuntimeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BedrockDataAutomationRuntime { + +template +class BedrockDataAutomationRuntimeWaiter { + public: +}; +} // namespace BedrockDataAutomationRuntime +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/BedrockDataAutomationWaiter.h b/generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/BedrockDataAutomationWaiter.h new file mode 100644 index 00000000000..293bfb993fd --- /dev/null +++ b/generated/src/aws-cpp-sdk-bedrock-data-automation/include/aws/bedrock-data-automation/BedrockDataAutomationWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BedrockDataAutomation { + +template +class BedrockDataAutomationWaiter { + public: +}; +} // namespace BedrockDataAutomation +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/BedrockRuntimeWaiter.h b/generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/BedrockRuntimeWaiter.h new file mode 100644 index 00000000000..1f115ba9ac4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-bedrock-runtime/include/aws/bedrock-runtime/BedrockRuntimeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BedrockRuntime { + +template +class BedrockRuntimeWaiter { + public: +}; +} // namespace BedrockRuntime +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-bedrock/include/aws/bedrock/BedrockWaiter.h b/generated/src/aws-cpp-sdk-bedrock/include/aws/bedrock/BedrockWaiter.h new file mode 100644 index 00000000000..414f38218fd --- /dev/null +++ b/generated/src/aws-cpp-sdk-bedrock/include/aws/bedrock/BedrockWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Bedrock { + +template +class BedrockWaiter { + public: +}; +} // namespace Bedrock +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-billing/include/aws/billing/BillingWaiter.h b/generated/src/aws-cpp-sdk-billing/include/aws/billing/BillingWaiter.h new file mode 100644 index 00000000000..37a20a1e005 --- /dev/null +++ b/generated/src/aws-cpp-sdk-billing/include/aws/billing/BillingWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Billing { + +template +class BillingWaiter { + public: +}; +} // namespace Billing +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-billingconductor/include/aws/billingconductor/BillingConductorWaiter.h b/generated/src/aws-cpp-sdk-billingconductor/include/aws/billingconductor/BillingConductorWaiter.h new file mode 100644 index 00000000000..52987f2fe2c --- /dev/null +++ b/generated/src/aws-cpp-sdk-billingconductor/include/aws/billingconductor/BillingConductorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace BillingConductor { + +template +class BillingConductorWaiter { + public: +}; +} // namespace BillingConductor +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-braket/include/aws/braket/BraketWaiter.h b/generated/src/aws-cpp-sdk-braket/include/aws/braket/BraketWaiter.h new file mode 100644 index 00000000000..95d09620cc4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-braket/include/aws/braket/BraketWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Braket { + +template +class BraketWaiter { + public: +}; +} // namespace Braket +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-budgets/include/aws/budgets/BudgetsWaiter.h b/generated/src/aws-cpp-sdk-budgets/include/aws/budgets/BudgetsWaiter.h new file mode 100644 index 00000000000..913b178b0a9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-budgets/include/aws/budgets/BudgetsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Budgets { + +template +class BudgetsWaiter { + public: +}; +} // namespace Budgets +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ce/include/aws/ce/CostExplorerWaiter.h b/generated/src/aws-cpp-sdk-ce/include/aws/ce/CostExplorerWaiter.h new file mode 100644 index 00000000000..af830f8c2fd --- /dev/null +++ b/generated/src/aws-cpp-sdk-ce/include/aws/ce/CostExplorerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CostExplorer { + +template +class CostExplorerWaiter { + public: +}; +} // namespace CostExplorer +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-chatbot/include/aws/chatbot/ChatbotWaiter.h b/generated/src/aws-cpp-sdk-chatbot/include/aws/chatbot/ChatbotWaiter.h new file mode 100644 index 00000000000..2cc60221b8d --- /dev/null +++ b/generated/src/aws-cpp-sdk-chatbot/include/aws/chatbot/ChatbotWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace chatbot { + +template +class ChatbotWaiter { + public: +}; +} // namespace chatbot +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-chime-sdk-identity/include/aws/chime-sdk-identity/ChimeSDKIdentityWaiter.h b/generated/src/aws-cpp-sdk-chime-sdk-identity/include/aws/chime-sdk-identity/ChimeSDKIdentityWaiter.h new file mode 100644 index 00000000000..3f992389258 --- /dev/null +++ b/generated/src/aws-cpp-sdk-chime-sdk-identity/include/aws/chime-sdk-identity/ChimeSDKIdentityWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ChimeSDKIdentity { + +template +class ChimeSDKIdentityWaiter { + public: +}; +} // namespace ChimeSDKIdentity +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-chime-sdk-media-pipelines/include/aws/chime-sdk-media-pipelines/ChimeSDKMediaPipelinesWaiter.h b/generated/src/aws-cpp-sdk-chime-sdk-media-pipelines/include/aws/chime-sdk-media-pipelines/ChimeSDKMediaPipelinesWaiter.h new file mode 100644 index 00000000000..2770a4f0f94 --- /dev/null +++ b/generated/src/aws-cpp-sdk-chime-sdk-media-pipelines/include/aws/chime-sdk-media-pipelines/ChimeSDKMediaPipelinesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ChimeSDKMediaPipelines { + +template +class ChimeSDKMediaPipelinesWaiter { + public: +}; +} // namespace ChimeSDKMediaPipelines +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-chime-sdk-meetings/include/aws/chime-sdk-meetings/ChimeSDKMeetingsWaiter.h b/generated/src/aws-cpp-sdk-chime-sdk-meetings/include/aws/chime-sdk-meetings/ChimeSDKMeetingsWaiter.h new file mode 100644 index 00000000000..20f2ce3625e --- /dev/null +++ b/generated/src/aws-cpp-sdk-chime-sdk-meetings/include/aws/chime-sdk-meetings/ChimeSDKMeetingsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ChimeSDKMeetings { + +template +class ChimeSDKMeetingsWaiter { + public: +}; +} // namespace ChimeSDKMeetings +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-chime-sdk-messaging/include/aws/chime-sdk-messaging/ChimeSDKMessagingWaiter.h b/generated/src/aws-cpp-sdk-chime-sdk-messaging/include/aws/chime-sdk-messaging/ChimeSDKMessagingWaiter.h new file mode 100644 index 00000000000..ee3c3cff374 --- /dev/null +++ b/generated/src/aws-cpp-sdk-chime-sdk-messaging/include/aws/chime-sdk-messaging/ChimeSDKMessagingWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ChimeSDKMessaging { + +template +class ChimeSDKMessagingWaiter { + public: +}; +} // namespace ChimeSDKMessaging +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-chime-sdk-voice/include/aws/chime-sdk-voice/ChimeSDKVoiceWaiter.h b/generated/src/aws-cpp-sdk-chime-sdk-voice/include/aws/chime-sdk-voice/ChimeSDKVoiceWaiter.h new file mode 100644 index 00000000000..7a86ce67692 --- /dev/null +++ b/generated/src/aws-cpp-sdk-chime-sdk-voice/include/aws/chime-sdk-voice/ChimeSDKVoiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ChimeSDKVoice { + +template +class ChimeSDKVoiceWaiter { + public: +}; +} // namespace ChimeSDKVoice +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-chime/include/aws/chime/ChimeWaiter.h b/generated/src/aws-cpp-sdk-chime/include/aws/chime/ChimeWaiter.h new file mode 100644 index 00000000000..77bad26a98c --- /dev/null +++ b/generated/src/aws-cpp-sdk-chime/include/aws/chime/ChimeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Chime { + +template +class ChimeWaiter { + public: +}; +} // namespace Chime +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cleanrooms/include/aws/cleanrooms/CleanRoomsWaiter.h b/generated/src/aws-cpp-sdk-cleanrooms/include/aws/cleanrooms/CleanRoomsWaiter.h new file mode 100644 index 00000000000..69d9eb0515d --- /dev/null +++ b/generated/src/aws-cpp-sdk-cleanrooms/include/aws/cleanrooms/CleanRoomsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CleanRooms { + +template +class CleanRoomsWaiter { + public: +}; +} // namespace CleanRooms +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cleanroomsml/include/aws/cleanroomsml/CleanRoomsMLWaiter.h b/generated/src/aws-cpp-sdk-cleanroomsml/include/aws/cleanroomsml/CleanRoomsMLWaiter.h new file mode 100644 index 00000000000..b1f3fc4339a --- /dev/null +++ b/generated/src/aws-cpp-sdk-cleanroomsml/include/aws/cleanroomsml/CleanRoomsMLWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CleanRoomsML { + +template +class CleanRoomsMLWaiter { + public: +}; +} // namespace CleanRoomsML +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cloud9/include/aws/cloud9/Cloud9Waiter.h b/generated/src/aws-cpp-sdk-cloud9/include/aws/cloud9/Cloud9Waiter.h new file mode 100644 index 00000000000..030d46c1c6b --- /dev/null +++ b/generated/src/aws-cpp-sdk-cloud9/include/aws/cloud9/Cloud9Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Cloud9 { + +template +class Cloud9Waiter { + public: +}; +} // namespace Cloud9 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h b/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h index 4ad56fdd5b6..58c15e0262c 100644 --- a/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h +++ b/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h @@ -8,6 +8,7 @@ #include #include #include +#include #include @@ -19,31 +20,33 @@ class CloudControlApiWaiter { public: Aws::Utils::WaiterOutcome WaitUntilResourceRequestSuccess( const Model::GetResourceRequestStatusRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCESS"), - [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetProgressEvent().GetOperationStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetProgressEvent().GetOperationStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCEL_COMPLETE"), - [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetProgressEvent().GetOperationStatus() == expected.get(); - }}); + using OutcomeT = Model::GetResourceRequestStatusOutcome; + using RequestT = Model::GetResourceRequestStatusRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ResourceRequestSuccessWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"), + [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetProgressEvent().GetOperationStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ResourceRequestSuccessWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetProgressEvent().GetOperationStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ResourceRequestSuccessWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCEL_COMPLETE"), + [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetProgressEvent().GetOperationStatus() == expected.get(); + })); - auto operation = [this](const Model::GetResourceRequestStatusRequest& req) { - return static_cast(this)->GetResourceRequestStatus(req); - }; - Aws::Utils::Waiter waiter( - 5, 24, acceptors, operation, "WaitUntilResourceRequestSuccess"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetResourceRequestStatus(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilResourceRequestSuccess"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-clouddirectory/include/aws/clouddirectory/CloudDirectoryWaiter.h b/generated/src/aws-cpp-sdk-clouddirectory/include/aws/clouddirectory/CloudDirectoryWaiter.h new file mode 100644 index 00000000000..92ad4a6657d --- /dev/null +++ b/generated/src/aws-cpp-sdk-clouddirectory/include/aws/clouddirectory/CloudDirectoryWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CloudDirectory { + +template +class CloudDirectoryWaiter { + public: +}; +} // namespace CloudDirectory +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h b/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h index 01b745f9b35..b4d057477c3 100644 --- a/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h +++ b/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h @@ -19,6 +19,7 @@ #include #include #include +#include #include @@ -30,466 +31,515 @@ class CloudFormationWaiter { public: Aws::Utils::WaiterOutcome WaitUntilChangeSetCreateComplete( const Model::DescribeChangeSetRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), - [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StackRefactorStatusMapper::GetNameForStackRefactorStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeChangeSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChangeSetStatusMapper::GetNameForChangeSetStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + using OutcomeT = Model::DescribeChangeSetOutcome; + using RequestT = Model::DescribeChangeSetRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ChangeSetCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorStatusMapper::GetNameForStackRefactorStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChangeSetCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeChangeSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChangeSetStatusMapper::GetNameForChangeSetStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChangeSetCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationError"))); - auto operation = [this](const Model::DescribeChangeSetRequest& req) { - return static_cast(this)->DescribeChangeSet(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilChangeSetCreateComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeChangeSet(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilChangeSetCreateComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStackRefactorCreateComplete( const Model::DescribeStackRefactorRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), - [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StackRefactorStatusMapper::GetNameForStackRefactorStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StackRefactorStatusMapper::GetNameForStackRefactorStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + using OutcomeT = Model::DescribeStackRefactorOutcome; + using RequestT = Model::DescribeStackRefactorRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StackRefactorCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorStatusMapper::GetNameForStackRefactorStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackRefactorCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorStatusMapper::GetNameForStackRefactorStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackRefactorCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationError"))); - auto operation = [this](const Model::DescribeStackRefactorRequest& req) { - return static_cast(this)->DescribeStackRefactor(req); - }; - Aws::Utils::Waiter waiter( - 5, 24, acceptors, operation, "WaitUntilStackRefactorCreateComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStackRefactor(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilStackRefactorCreateComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStackRefactorExecuteComplete( const Model::DescribeStackRefactorRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("EXECUTE_COMPLETE"), - [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StackRefactorExecutionStatusMapper::GetNameForStackRefactorExecutionStatus( - result.GetExecutionStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("EXECUTE_FAILED"), - [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StackRefactorExecutionStatusMapper::GetNameForStackRefactorExecutionStatus( - result.GetExecutionStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_COMPLETE"), - [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StackRefactorExecutionStatusMapper::GetNameForStackRefactorExecutionStatus( - result.GetExecutionStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + using OutcomeT = Model::DescribeStackRefactorOutcome; + using RequestT = Model::DescribeStackRefactorRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StackRefactorExecuteCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("EXECUTE_COMPLETE"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorExecutionStatusMapper::GetNameForStackRefactorExecutionStatus(result.GetExecutionStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackRefactorExecuteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("EXECUTE_FAILED"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorExecutionStatusMapper::GetNameForStackRefactorExecutionStatus(result.GetExecutionStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackRefactorExecuteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ROLLBACK_COMPLETE"), + [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StackRefactorExecutionStatusMapper::GetNameForStackRefactorExecutionStatus(result.GetExecutionStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackRefactorExecuteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationError"))); - auto operation = [this](const Model::DescribeStackRefactorRequest& req) { - return static_cast(this)->DescribeStackRefactor(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilStackRefactorExecuteComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStackRefactor(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilStackRefactorExecuteComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStackCreateComplete(const Model::DescribeStacksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_IN_PROGRESS"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, - Aws::String("UPDATE_COMPLETE_CLEANUP_IN_PROGRESS"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_IN_PROGRESS"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, - Aws::String("UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + using OutcomeT = Model::DescribeStacksOutcome; + using RequestT = Model::DescribeStacksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_COMPLETE_CLEANUP_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_ROLLBACK_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_ROLLBACK_COMPLETE_CLEANUP_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationError"))); - auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilStackCreateComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilStackCreateComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStackDeleteComplete(const Model::DescribeStacksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_IN_PROGRESS"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeStacksOutcome; + using RequestT = Model::DescribeStacksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StackDeleteCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackDeleteCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ValidationError"))); + acceptors.emplace_back(Aws::MakeUnique>( + "StackDeleteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackDeleteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackDeleteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackDeleteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_ROLLBACK_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackDeleteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackDeleteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackDeleteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); - auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilStackDeleteComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilStackDeleteComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStackExists(const Model::DescribeStacksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + using OutcomeT = Model::DescribeStacksOutcome; + using RequestT = Model::DescribeStacksRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("StackExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>("StackExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ValidationError"))); - auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilStackExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilStackExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStackImportComplete(const Model::DescribeStacksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("IMPORT_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLBACK_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("IMPORT_ROLLBACK_IN_PROGRESS"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("IMPORT_ROLLBACK_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("IMPORT_ROLLBACK_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + using OutcomeT = Model::DescribeStacksOutcome; + using RequestT = Model::DescribeStacksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StackImportCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IMPORT_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackImportCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackImportCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackImportCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("IMPORT_ROLLBACK_IN_PROGRESS"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackImportCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("IMPORT_ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackImportCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("IMPORT_ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackImportCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationError"))); - auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilStackImportComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilStackImportComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStackRollbackComplete(const Model::DescribeStacksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + using OutcomeT = Model::DescribeStacksOutcome; + using RequestT = Model::DescribeStacksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StackRollbackCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackRollbackCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackRollbackCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackRollbackCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackRollbackCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationError"))); - auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilStackRollbackComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilStackRollbackComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStackUpdateComplete(const Model::DescribeStacksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_FAILED"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_ROLLBACK_COMPLETE"), - [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { - return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationError")}); + using OutcomeT = Model::DescribeStacksOutcome; + using RequestT = Model::DescribeStacksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StackUpdateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackUpdateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackUpdateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_ROLLBACK_FAILED"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackUpdateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_ROLLBACK_COMPLETE"), + [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetStacks().begin(), result.GetStacks().end(), [&](const Model::Stack& item) { + return Model::StackStatusMapper::GetNameForStackStatus(item.GetStackStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StackUpdateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationError"))); - auto operation = [this](const Model::DescribeStacksRequest& req) { return static_cast(this)->DescribeStacks(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilStackUpdateComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStacks(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilStackUpdateComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTypeRegistrationComplete( const Model::DescribeTypeRegistrationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETE"), - [](const Model::DescribeTypeRegistrationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RegistrationStatusMapper::GetNameForRegistrationStatus(result.GetProgressStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeTypeRegistrationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RegistrationStatusMapper::GetNameForRegistrationStatus(result.GetProgressStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeTypeRegistrationOutcome; + using RequestT = Model::DescribeTypeRegistrationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TypeRegistrationCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETE"), + [](const Model::DescribeTypeRegistrationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RegistrationStatusMapper::GetNameForRegistrationStatus(result.GetProgressStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TypeRegistrationCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeTypeRegistrationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RegistrationStatusMapper::GetNameForRegistrationStatus(result.GetProgressStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeTypeRegistrationRequest& req) { - return static_cast(this)->DescribeTypeRegistration(req); - }; - Aws::Utils::Waiter waiter( - 30, 4, acceptors, operation, "WaitUntilTypeRegistrationComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeTypeRegistration(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilTypeRegistrationComplete"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-cloudfront-keyvaluestore/include/aws/cloudfront-keyvaluestore/CloudFrontKeyValueStoreWaiter.h b/generated/src/aws-cpp-sdk-cloudfront-keyvaluestore/include/aws/cloudfront-keyvaluestore/CloudFrontKeyValueStoreWaiter.h new file mode 100644 index 00000000000..a8b546da4da --- /dev/null +++ b/generated/src/aws-cpp-sdk-cloudfront-keyvaluestore/include/aws/cloudfront-keyvaluestore/CloudFrontKeyValueStoreWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CloudFrontKeyValueStore { + +template +class CloudFrontKeyValueStoreWaiter { + public: +}; +} // namespace CloudFrontKeyValueStore +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h b/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h index bc1472ee733..61ee1f18196 100644 --- a/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h +++ b/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h @@ -14,6 +14,7 @@ #include #include #include +#include #include @@ -25,76 +26,76 @@ class CloudFrontWaiter { public: Aws::Utils::WaiterOutcome WaitUntilDistributionDeployed( const Model::GetDistribution2020_05_31Request& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Deployed"), - [](const Model::GetDistribution2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetDistribution().GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetDistribution2020_05_31Outcome; + using RequestT = Model::GetDistribution2020_05_31Request; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DistributionDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Deployed"), + [](const Model::GetDistribution2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetDistribution().GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetDistribution2020_05_31Request& req) { - return static_cast(this)->GetDistribution2020_05_31(req); - }; - Aws::Utils::Waiter waiter( - 60, 35, acceptors, operation, "WaitUntilDistributionDeployed"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetDistribution2020_05_31(req); }; + Aws::Utils::Waiter waiter(60, 35, std::move(acceptors), operation, "WaitUntilDistributionDeployed"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInvalidationCompleted( const Model::GetInvalidation2020_05_31Request& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), - [](const Model::GetInvalidationForDistributionTenant2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetInvalidation().GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetInvalidation2020_05_31Outcome; + using RequestT = Model::GetInvalidation2020_05_31Request; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InvalidationCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), + [](const Model::GetInvalidationForDistributionTenant2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetInvalidation().GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetInvalidation2020_05_31Request& req) { - return static_cast(this)->GetInvalidation2020_05_31(req); - }; - Aws::Utils::Waiter waiter( - 20, 30, acceptors, operation, "WaitUntilInvalidationCompleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetInvalidation2020_05_31(req); }; + Aws::Utils::Waiter waiter(20, 30, std::move(acceptors), operation, "WaitUntilInvalidationCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInvalidationForDistributionTenantCompleted(const Model::GetInvalidationForDistributionTenant2020_05_31Request& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), - [](const Model::GetInvalidationForDistributionTenant2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetInvalidation().GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetInvalidationForDistributionTenant2020_05_31Outcome; + using RequestT = Model::GetInvalidationForDistributionTenant2020_05_31Request; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InvalidationForDistributionTenantCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), + [](const Model::GetInvalidationForDistributionTenant2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetInvalidation().GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetInvalidationForDistributionTenant2020_05_31Request& req) { + auto operation = [this](const RequestT& req) { return static_cast(this)->GetInvalidationForDistributionTenant2020_05_31(req); }; - Aws::Utils::Waiter - waiter(20, 30, acceptors, operation, "WaitUntilInvalidationForDistributionTenantCompleted"); + Aws::Utils::Waiter waiter(20, 30, std::move(acceptors), operation, + "WaitUntilInvalidationForDistributionTenantCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStreamingDistributionDeployed( const Model::GetStreamingDistribution2020_05_31Request& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Deployed"), - [](const Model::GetStreamingDistribution2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStreamingDistribution().GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetStreamingDistribution2020_05_31Outcome; + using RequestT = Model::GetStreamingDistribution2020_05_31Request; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StreamingDistributionDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Deployed"), + [](const Model::GetStreamingDistribution2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStreamingDistribution().GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetStreamingDistribution2020_05_31Request& req) { - return static_cast(this)->GetStreamingDistribution2020_05_31(req); - }; - Aws::Utils::Waiter waiter( - 60, 25, acceptors, operation, "WaitUntilStreamingDistributionDeployed"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetStreamingDistribution2020_05_31(req); }; + Aws::Utils::Waiter waiter(60, 25, std::move(acceptors), operation, "WaitUntilStreamingDistributionDeployed"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-cloudhsm/include/aws/cloudhsm/CloudHSMWaiter.h b/generated/src/aws-cpp-sdk-cloudhsm/include/aws/cloudhsm/CloudHSMWaiter.h new file mode 100644 index 00000000000..088e5e2dad0 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cloudhsm/include/aws/cloudhsm/CloudHSMWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CloudHSM { + +template +class CloudHSMWaiter { + public: +}; +} // namespace CloudHSM +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cloudhsmv2/include/aws/cloudhsmv2/CloudHSMV2Waiter.h b/generated/src/aws-cpp-sdk-cloudhsmv2/include/aws/cloudhsmv2/CloudHSMV2Waiter.h new file mode 100644 index 00000000000..0b6c8ccd654 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cloudhsmv2/include/aws/cloudhsmv2/CloudHSMV2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CloudHSMV2 { + +template +class CloudHSMV2Waiter { + public: +}; +} // namespace CloudHSMV2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cloudsearch/include/aws/cloudsearch/CloudSearchWaiter.h b/generated/src/aws-cpp-sdk-cloudsearch/include/aws/cloudsearch/CloudSearchWaiter.h new file mode 100644 index 00000000000..a884fe2495f --- /dev/null +++ b/generated/src/aws-cpp-sdk-cloudsearch/include/aws/cloudsearch/CloudSearchWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CloudSearch { + +template +class CloudSearchWaiter { + public: +}; +} // namespace CloudSearch +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cloudsearchdomain/include/aws/cloudsearchdomain/CloudSearchDomainWaiter.h b/generated/src/aws-cpp-sdk-cloudsearchdomain/include/aws/cloudsearchdomain/CloudSearchDomainWaiter.h new file mode 100644 index 00000000000..b3341a70820 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cloudsearchdomain/include/aws/cloudsearchdomain/CloudSearchDomainWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CloudSearchDomain { + +template +class CloudSearchDomainWaiter { + public: +}; +} // namespace CloudSearchDomain +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cloudtrail-data/include/aws/cloudtrail-data/CloudTrailDataWaiter.h b/generated/src/aws-cpp-sdk-cloudtrail-data/include/aws/cloudtrail-data/CloudTrailDataWaiter.h new file mode 100644 index 00000000000..046959c401e --- /dev/null +++ b/generated/src/aws-cpp-sdk-cloudtrail-data/include/aws/cloudtrail-data/CloudTrailDataWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CloudTrailData { + +template +class CloudTrailDataWaiter { + public: +}; +} // namespace CloudTrailData +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cloudtrail/include/aws/cloudtrail/CloudTrailWaiter.h b/generated/src/aws-cpp-sdk-cloudtrail/include/aws/cloudtrail/CloudTrailWaiter.h new file mode 100644 index 00000000000..63b624cddf9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cloudtrail/include/aws/cloudtrail/CloudTrailWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CloudTrail { + +template +class CloudTrailWaiter { + public: +}; +} // namespace CloudTrail +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codeartifact/include/aws/codeartifact/CodeArtifactWaiter.h b/generated/src/aws-cpp-sdk-codeartifact/include/aws/codeartifact/CodeArtifactWaiter.h new file mode 100644 index 00000000000..e5c4cd34e76 --- /dev/null +++ b/generated/src/aws-cpp-sdk-codeartifact/include/aws/codeartifact/CodeArtifactWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CodeArtifact { + +template +class CodeArtifactWaiter { + public: +}; +} // namespace CodeArtifact +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/CodeBuildWaiter.h b/generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/CodeBuildWaiter.h new file mode 100644 index 00000000000..965eb120424 --- /dev/null +++ b/generated/src/aws-cpp-sdk-codebuild/include/aws/codebuild/CodeBuildWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CodeBuild { + +template +class CodeBuildWaiter { + public: +}; +} // namespace CodeBuild +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codecatalyst/include/aws/codecatalyst/CodeCatalystWaiter.h b/generated/src/aws-cpp-sdk-codecatalyst/include/aws/codecatalyst/CodeCatalystWaiter.h new file mode 100644 index 00000000000..b94863be3c1 --- /dev/null +++ b/generated/src/aws-cpp-sdk-codecatalyst/include/aws/codecatalyst/CodeCatalystWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CodeCatalyst { + +template +class CodeCatalystWaiter { + public: +}; +} // namespace CodeCatalyst +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codecommit/include/aws/codecommit/CodeCommitWaiter.h b/generated/src/aws-cpp-sdk-codecommit/include/aws/codecommit/CodeCommitWaiter.h new file mode 100644 index 00000000000..4d8f83803b9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-codecommit/include/aws/codecommit/CodeCommitWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CodeCommit { + +template +class CodeCommitWaiter { + public: +}; +} // namespace CodeCommit +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codeconnections/include/aws/codeconnections/CodeConnectionsWaiter.h b/generated/src/aws-cpp-sdk-codeconnections/include/aws/codeconnections/CodeConnectionsWaiter.h new file mode 100644 index 00000000000..03ed222ed6f --- /dev/null +++ b/generated/src/aws-cpp-sdk-codeconnections/include/aws/codeconnections/CodeConnectionsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CodeConnections { + +template +class CodeConnectionsWaiter { + public: +}; +} // namespace CodeConnections +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h b/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h index f5058c67956..8162e167346 100644 --- a/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h +++ b/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h @@ -9,6 +9,7 @@ #include #include #include +#include #include @@ -19,32 +20,36 @@ template class CodeDeployWaiter { public: Aws::Utils::WaiterOutcome WaitUntilDeploymentSuccessful(const Model::GetDeploymentRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Succeeded"), - [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetDeploymentInfo().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetDeploymentInfo().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Stopped"), - [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetDeploymentInfo().GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetDeploymentOutcome; + using RequestT = Model::GetDeploymentRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DeploymentSuccessfulWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Succeeded"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetDeploymentInfo().GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DeploymentSuccessfulWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetDeploymentInfo().GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DeploymentSuccessfulWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Stopped"), + [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetDeploymentInfo().GetStatus()) == + expected.get(); + })); - auto operation = [this](const Model::GetDeploymentRequest& req) { return static_cast(this)->GetDeployment(req); }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilDeploymentSuccessful"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetDeployment(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilDeploymentSuccessful"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h b/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h index 694f5f5118e..e55ac651cd6 100644 --- a/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h +++ b/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h @@ -12,6 +12,7 @@ #include #include #include +#include #include @@ -23,67 +24,68 @@ class CodeGuruReviewerWaiter { public: Aws::Utils::WaiterOutcome WaitUntilCodeReviewCompleted( const Model::DescribeCodeReviewRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), - [](const Model::DescribeCodeReviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobStateMapper::GetNameForJobState(result.GetCodeReview().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeCodeReviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobStateMapper::GetNameForJobState(result.GetCodeReview().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Pending"), - [](const Model::DescribeCodeReviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobStateMapper::GetNameForJobState(result.GetCodeReview().GetState()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeCodeReviewOutcome; + using RequestT = Model::DescribeCodeReviewRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "CodeReviewCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), + [](const Model::DescribeCodeReviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStateMapper::GetNameForJobState(result.GetCodeReview().GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CodeReviewCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeCodeReviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStateMapper::GetNameForJobState(result.GetCodeReview().GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CodeReviewCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("Pending"), + [](const Model::DescribeCodeReviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStateMapper::GetNameForJobState(result.GetCodeReview().GetState()) == expected.get(); + })); - auto operation = [this](const Model::DescribeCodeReviewRequest& req) { - return static_cast(this)->DescribeCodeReview(req); - }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilCodeReviewCompleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCodeReview(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilCodeReviewCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilRepositoryAssociationSucceeded( const Model::DescribeRepositoryAssociationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Associated"), - [](const Model::DescribeRepositoryAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RepositoryAssociationStateMapper::GetNameForRepositoryAssociationState( - result.GetRepositoryAssociation().GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeRepositoryAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RepositoryAssociationStateMapper::GetNameForRepositoryAssociationState( - result.GetRepositoryAssociation().GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Associating"), - [](const Model::DescribeRepositoryAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RepositoryAssociationStateMapper::GetNameForRepositoryAssociationState( - result.GetRepositoryAssociation().GetState()) == expected.get(); - }}); + using OutcomeT = Model::DescribeRepositoryAssociationOutcome; + using RequestT = Model::DescribeRepositoryAssociationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "RepositoryAssociationSucceededWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Associated"), + [](const Model::DescribeRepositoryAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RepositoryAssociationStateMapper::GetNameForRepositoryAssociationState( + result.GetRepositoryAssociation().GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RepositoryAssociationSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeRepositoryAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RepositoryAssociationStateMapper::GetNameForRepositoryAssociationState( + result.GetRepositoryAssociation().GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RepositoryAssociationSucceededWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("Associating"), + [](const Model::DescribeRepositoryAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RepositoryAssociationStateMapper::GetNameForRepositoryAssociationState( + result.GetRepositoryAssociation().GetState()) == expected.get(); + })); - auto operation = [this](const Model::DescribeRepositoryAssociationRequest& req) { - return static_cast(this)->DescribeRepositoryAssociation(req); - }; - Aws::Utils::Waiter waiter( - 10, 12, acceptors, operation, "WaitUntilRepositoryAssociationSucceeded"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeRepositoryAssociation(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilRepositoryAssociationSucceeded"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-codeguru-security/include/aws/codeguru-security/CodeGuruSecurityWaiter.h b/generated/src/aws-cpp-sdk-codeguru-security/include/aws/codeguru-security/CodeGuruSecurityWaiter.h new file mode 100644 index 00000000000..1750b98e600 --- /dev/null +++ b/generated/src/aws-cpp-sdk-codeguru-security/include/aws/codeguru-security/CodeGuruSecurityWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CodeGuruSecurity { + +template +class CodeGuruSecurityWaiter { + public: +}; +} // namespace CodeGuruSecurity +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codeguruprofiler/include/aws/codeguruprofiler/CodeGuruProfilerWaiter.h b/generated/src/aws-cpp-sdk-codeguruprofiler/include/aws/codeguruprofiler/CodeGuruProfilerWaiter.h new file mode 100644 index 00000000000..a25fb4a15fe --- /dev/null +++ b/generated/src/aws-cpp-sdk-codeguruprofiler/include/aws/codeguruprofiler/CodeGuruProfilerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CodeGuruProfiler { + +template +class CodeGuruProfilerWaiter { + public: +}; +} // namespace CodeGuruProfiler +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codepipeline/include/aws/codepipeline/CodePipelineWaiter.h b/generated/src/aws-cpp-sdk-codepipeline/include/aws/codepipeline/CodePipelineWaiter.h new file mode 100644 index 00000000000..2dbf9bad1a5 --- /dev/null +++ b/generated/src/aws-cpp-sdk-codepipeline/include/aws/codepipeline/CodePipelineWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CodePipeline { + +template +class CodePipelineWaiter { + public: +}; +} // namespace CodePipeline +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codestar-connections/include/aws/codestar-connections/CodeStarconnectionsWaiter.h b/generated/src/aws-cpp-sdk-codestar-connections/include/aws/codestar-connections/CodeStarconnectionsWaiter.h new file mode 100644 index 00000000000..9c777c4bc15 --- /dev/null +++ b/generated/src/aws-cpp-sdk-codestar-connections/include/aws/codestar-connections/CodeStarconnectionsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CodeStarconnections { + +template +class CodeStarconnectionsWaiter { + public: +}; +} // namespace CodeStarconnections +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsWaiter.h b/generated/src/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsWaiter.h new file mode 100644 index 00000000000..6e434eb7cac --- /dev/null +++ b/generated/src/aws-cpp-sdk-codestar-notifications/include/aws/codestar-notifications/CodeStarNotificationsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CodeStarNotifications { + +template +class CodeStarNotificationsWaiter { + public: +}; +} // namespace CodeStarNotifications +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cognito-identity/include/aws/cognito-identity/CognitoIdentityWaiter.h b/generated/src/aws-cpp-sdk-cognito-identity/include/aws/cognito-identity/CognitoIdentityWaiter.h new file mode 100644 index 00000000000..b263a6855a1 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cognito-identity/include/aws/cognito-identity/CognitoIdentityWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CognitoIdentity { + +template +class CognitoIdentityWaiter { + public: +}; +} // namespace CognitoIdentity +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cognito-idp/include/aws/cognito-idp/CognitoIdentityProviderWaiter.h b/generated/src/aws-cpp-sdk-cognito-idp/include/aws/cognito-idp/CognitoIdentityProviderWaiter.h new file mode 100644 index 00000000000..e4597ecfaf0 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cognito-idp/include/aws/cognito-idp/CognitoIdentityProviderWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CognitoIdentityProvider { + +template +class CognitoIdentityProviderWaiter { + public: +}; +} // namespace CognitoIdentityProvider +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cognito-sync/include/aws/cognito-sync/CognitoSyncWaiter.h b/generated/src/aws-cpp-sdk-cognito-sync/include/aws/cognito-sync/CognitoSyncWaiter.h new file mode 100644 index 00000000000..ee34f478740 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cognito-sync/include/aws/cognito-sync/CognitoSyncWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CognitoSync { + +template +class CognitoSyncWaiter { + public: +}; +} // namespace CognitoSync +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-comprehend/include/aws/comprehend/ComprehendWaiter.h b/generated/src/aws-cpp-sdk-comprehend/include/aws/comprehend/ComprehendWaiter.h new file mode 100644 index 00000000000..c025fa6823d --- /dev/null +++ b/generated/src/aws-cpp-sdk-comprehend/include/aws/comprehend/ComprehendWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Comprehend { + +template +class ComprehendWaiter { + public: +}; +} // namespace Comprehend +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-comprehendmedical/include/aws/comprehendmedical/ComprehendMedicalWaiter.h b/generated/src/aws-cpp-sdk-comprehendmedical/include/aws/comprehendmedical/ComprehendMedicalWaiter.h new file mode 100644 index 00000000000..f87aa814e99 --- /dev/null +++ b/generated/src/aws-cpp-sdk-comprehendmedical/include/aws/comprehendmedical/ComprehendMedicalWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ComprehendMedical { + +template +class ComprehendMedicalWaiter { + public: +}; +} // namespace ComprehendMedical +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-compute-optimizer-automation/include/aws/compute-optimizer-automation/ComputeOptimizerAutomationWaiter.h b/generated/src/aws-cpp-sdk-compute-optimizer-automation/include/aws/compute-optimizer-automation/ComputeOptimizerAutomationWaiter.h new file mode 100644 index 00000000000..6110a449ed0 --- /dev/null +++ b/generated/src/aws-cpp-sdk-compute-optimizer-automation/include/aws/compute-optimizer-automation/ComputeOptimizerAutomationWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ComputeOptimizerAutomation { + +template +class ComputeOptimizerAutomationWaiter { + public: +}; +} // namespace ComputeOptimizerAutomation +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-compute-optimizer/include/aws/compute-optimizer/ComputeOptimizerWaiter.h b/generated/src/aws-cpp-sdk-compute-optimizer/include/aws/compute-optimizer/ComputeOptimizerWaiter.h new file mode 100644 index 00000000000..b33b3c36fe4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-compute-optimizer/include/aws/compute-optimizer/ComputeOptimizerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ComputeOptimizer { + +template +class ComputeOptimizerWaiter { + public: +}; +} // namespace ComputeOptimizer +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-config/include/aws/config/ConfigServiceWaiter.h b/generated/src/aws-cpp-sdk-config/include/aws/config/ConfigServiceWaiter.h new file mode 100644 index 00000000000..c355495f995 --- /dev/null +++ b/generated/src/aws-cpp-sdk-config/include/aws/config/ConfigServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ConfigService { + +template +class ConfigServiceWaiter { + public: +}; +} // namespace ConfigService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-connect-contact-lens/include/aws/connect-contact-lens/ConnectContactLensWaiter.h b/generated/src/aws-cpp-sdk-connect-contact-lens/include/aws/connect-contact-lens/ConnectContactLensWaiter.h new file mode 100644 index 00000000000..08c392021f5 --- /dev/null +++ b/generated/src/aws-cpp-sdk-connect-contact-lens/include/aws/connect-contact-lens/ConnectContactLensWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ConnectContactLens { + +template +class ConnectContactLensWaiter { + public: +}; +} // namespace ConnectContactLens +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-connect/include/aws/connect/ConnectWaiter.h b/generated/src/aws-cpp-sdk-connect/include/aws/connect/ConnectWaiter.h new file mode 100644 index 00000000000..dbc3bd722a1 --- /dev/null +++ b/generated/src/aws-cpp-sdk-connect/include/aws/connect/ConnectWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Connect { + +template +class ConnectWaiter { + public: +}; +} // namespace Connect +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-connectcampaigns/include/aws/connectcampaigns/ConnectCampaignsWaiter.h b/generated/src/aws-cpp-sdk-connectcampaigns/include/aws/connectcampaigns/ConnectCampaignsWaiter.h new file mode 100644 index 00000000000..2afb31bc8d2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-connectcampaigns/include/aws/connectcampaigns/ConnectCampaignsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ConnectCampaigns { + +template +class ConnectCampaignsWaiter { + public: +}; +} // namespace ConnectCampaigns +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-connectcampaignsv2/include/aws/connectcampaignsv2/ConnectCampaignsV2Waiter.h b/generated/src/aws-cpp-sdk-connectcampaignsv2/include/aws/connectcampaignsv2/ConnectCampaignsV2Waiter.h new file mode 100644 index 00000000000..508731175a9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-connectcampaignsv2/include/aws/connectcampaignsv2/ConnectCampaignsV2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ConnectCampaignsV2 { + +template +class ConnectCampaignsV2Waiter { + public: +}; +} // namespace ConnectCampaignsV2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-connectcases/include/aws/connectcases/ConnectCasesWaiter.h b/generated/src/aws-cpp-sdk-connectcases/include/aws/connectcases/ConnectCasesWaiter.h new file mode 100644 index 00000000000..60cc49a70dd --- /dev/null +++ b/generated/src/aws-cpp-sdk-connectcases/include/aws/connectcases/ConnectCasesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ConnectCases { + +template +class ConnectCasesWaiter { + public: +}; +} // namespace ConnectCases +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-connecthealth/include/aws/connecthealth/ConnectHealthWaiter.h b/generated/src/aws-cpp-sdk-connecthealth/include/aws/connecthealth/ConnectHealthWaiter.h new file mode 100644 index 00000000000..0947ce14d5f --- /dev/null +++ b/generated/src/aws-cpp-sdk-connecthealth/include/aws/connecthealth/ConnectHealthWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ConnectHealth { + +template +class ConnectHealthWaiter { + public: +}; +} // namespace ConnectHealth +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantWaiter.h b/generated/src/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantWaiter.h new file mode 100644 index 00000000000..c76dff7bb68 --- /dev/null +++ b/generated/src/aws-cpp-sdk-connectparticipant/include/aws/connectparticipant/ConnectParticipantWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ConnectParticipant { + +template +class ConnectParticipantWaiter { + public: +}; +} // namespace ConnectParticipant +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-controlcatalog/include/aws/controlcatalog/ControlCatalogWaiter.h b/generated/src/aws-cpp-sdk-controlcatalog/include/aws/controlcatalog/ControlCatalogWaiter.h new file mode 100644 index 00000000000..7a02abf7dfc --- /dev/null +++ b/generated/src/aws-cpp-sdk-controlcatalog/include/aws/controlcatalog/ControlCatalogWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ControlCatalog { + +template +class ControlCatalogWaiter { + public: +}; +} // namespace ControlCatalog +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-controltower/include/aws/controltower/ControlTowerWaiter.h b/generated/src/aws-cpp-sdk-controltower/include/aws/controltower/ControlTowerWaiter.h new file mode 100644 index 00000000000..8742aee10ec --- /dev/null +++ b/generated/src/aws-cpp-sdk-controltower/include/aws/controltower/ControlTowerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ControlTower { + +template +class ControlTowerWaiter { + public: +}; +} // namespace ControlTower +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cost-optimization-hub/include/aws/cost-optimization-hub/CostOptimizationHubWaiter.h b/generated/src/aws-cpp-sdk-cost-optimization-hub/include/aws/cost-optimization-hub/CostOptimizationHubWaiter.h new file mode 100644 index 00000000000..dca9b76c1f0 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cost-optimization-hub/include/aws/cost-optimization-hub/CostOptimizationHubWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CostOptimizationHub { + +template +class CostOptimizationHubWaiter { + public: +}; +} // namespace CostOptimizationHub +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-cur/include/aws/cur/CostandUsageReportServiceWaiter.h b/generated/src/aws-cpp-sdk-cur/include/aws/cur/CostandUsageReportServiceWaiter.h new file mode 100644 index 00000000000..e145dcb3362 --- /dev/null +++ b/generated/src/aws-cpp-sdk-cur/include/aws/cur/CostandUsageReportServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CostandUsageReportService { + +template +class CostandUsageReportServiceWaiter { + public: +}; +} // namespace CostandUsageReportService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-customer-profiles/include/aws/customer-profiles/CustomerProfilesWaiter.h b/generated/src/aws-cpp-sdk-customer-profiles/include/aws/customer-profiles/CustomerProfilesWaiter.h new file mode 100644 index 00000000000..1525a6273b8 --- /dev/null +++ b/generated/src/aws-cpp-sdk-customer-profiles/include/aws/customer-profiles/CustomerProfilesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CustomerProfiles { + +template +class CustomerProfilesWaiter { + public: +}; +} // namespace CustomerProfiles +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-databrew/include/aws/databrew/GlueDataBrewWaiter.h b/generated/src/aws-cpp-sdk-databrew/include/aws/databrew/GlueDataBrewWaiter.h new file mode 100644 index 00000000000..d498665569c --- /dev/null +++ b/generated/src/aws-cpp-sdk-databrew/include/aws/databrew/GlueDataBrewWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace GlueDataBrew { + +template +class GlueDataBrewWaiter { + public: +}; +} // namespace GlueDataBrew +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-dataexchange/include/aws/dataexchange/DataExchangeWaiter.h b/generated/src/aws-cpp-sdk-dataexchange/include/aws/dataexchange/DataExchangeWaiter.h new file mode 100644 index 00000000000..eec92a2d67d --- /dev/null +++ b/generated/src/aws-cpp-sdk-dataexchange/include/aws/dataexchange/DataExchangeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DataExchange { + +template +class DataExchangeWaiter { + public: +}; +} // namespace DataExchange +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-datapipeline/include/aws/datapipeline/DataPipelineWaiter.h b/generated/src/aws-cpp-sdk-datapipeline/include/aws/datapipeline/DataPipelineWaiter.h new file mode 100644 index 00000000000..8a2e1e0b0ee --- /dev/null +++ b/generated/src/aws-cpp-sdk-datapipeline/include/aws/datapipeline/DataPipelineWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DataPipeline { + +template +class DataPipelineWaiter { + public: +}; +} // namespace DataPipeline +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-datasync/include/aws/datasync/DataSyncWaiter.h b/generated/src/aws-cpp-sdk-datasync/include/aws/datasync/DataSyncWaiter.h new file mode 100644 index 00000000000..97f27690d74 --- /dev/null +++ b/generated/src/aws-cpp-sdk-datasync/include/aws/datasync/DataSyncWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DataSync { + +template +class DataSyncWaiter { + public: +}; +} // namespace DataSync +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-datazone/include/aws/datazone/DataZoneWaiter.h b/generated/src/aws-cpp-sdk-datazone/include/aws/datazone/DataZoneWaiter.h new file mode 100644 index 00000000000..003a1223f9d --- /dev/null +++ b/generated/src/aws-cpp-sdk-datazone/include/aws/datazone/DataZoneWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DataZone { + +template +class DataZoneWaiter { + public: +}; +} // namespace DataZone +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-dax/include/aws/dax/DAXWaiter.h b/generated/src/aws-cpp-sdk-dax/include/aws/dax/DAXWaiter.h new file mode 100644 index 00000000000..810925fb1ec --- /dev/null +++ b/generated/src/aws-cpp-sdk-dax/include/aws/dax/DAXWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DAX { + +template +class DAXWaiter { + public: +}; +} // namespace DAX +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h b/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h index e9e2fca5432..ba3829f1140 100644 --- a/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h +++ b/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -35,291 +36,306 @@ template class DeadlineWaiter { public: Aws::Utils::WaiterOutcome WaitUntilFleetActive(const Model::GetFleetRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), - [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get(); - }}); + using OutcomeT = Model::GetFleetOutcome; + using RequestT = Model::GetFleetRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FleetActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FleetActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FleetActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"), + [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FleetStatusMapper::GetNameForFleetStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetFleetRequest& req) { return static_cast(this)->GetFleet(req); }; - Aws::Utils::Waiter waiter(5, 180, acceptors, operation, "WaitUntilFleetActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetFleet(req); }; + Aws::Utils::Waiter waiter(5, 180, std::move(acceptors), operation, "WaitUntilFleetActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilJobCreateComplete(const Model::GetJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_IN_PROGRESS"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_SUCCEEDED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPLOAD_FAILED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetJobOutcome; + using RequestT = Model::GetJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "JobCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_IN_PROGRESS"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_FAILED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_SUCCEEDED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPLOAD_FAILED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetJobRequest& req) { return static_cast(this)->GetJob(req); }; - Aws::Utils::Waiter waiter(1, 120, acceptors, operation, "WaitUntilJobCreateComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetJob(req); }; + Aws::Utils::Waiter waiter(1, 120, std::move(acceptors), operation, "WaitUntilJobCreateComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilJobComplete(const Model::GetJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUSPENDED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("NOT_COMPATIBLE"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ARCHIVED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetJobOutcome; + using RequestT = Model::GetJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("FAILED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CANCELED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUSPENDED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("NOT_COMPATIBLE"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ARCHIVED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetJobRequest& req) { return static_cast(this)->GetJob(req); }; - Aws::Utils::Waiter waiter(15, 240, acceptors, operation, "WaitUntilJobComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetJob(req); }; + Aws::Utils::Waiter waiter(15, 240, std::move(acceptors), operation, "WaitUntilJobComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilJobSucceeded(const Model::GetJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("SUSPENDED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("NOT_COMPATIBLE"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ARCHIVED"), - [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetJobOutcome; + using RequestT = Model::GetJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "JobSucceededWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("SUSPENDED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("NOT_COMPATIBLE"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TaskRunStatusMapper::GetNameForTaskRunStatus(result.GetTaskRunStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "JobSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ARCHIVED"), + [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobLifecycleStatusMapper::GetNameForJobLifecycleStatus(result.GetLifecycleStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetJobRequest& req) { return static_cast(this)->GetJob(req); }; - Aws::Utils::Waiter waiter(15, 240, acceptors, operation, "WaitUntilJobSucceeded"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetJob(req); }; + Aws::Utils::Waiter waiter(15, 240, std::move(acceptors), operation, "WaitUntilJobSucceeded"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilLicenseEndpointValid( const Model::GetLicenseEndpointRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("READY"), - [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("NOT_READY"), - [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetLicenseEndpointOutcome; + using RequestT = Model::GetLicenseEndpointRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "LicenseEndpointValidWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("READY"), + [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LicenseEndpointValidWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("NOT_READY"), + [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetLicenseEndpointRequest& req) { - return static_cast(this)->GetLicenseEndpoint(req); - }; - Aws::Utils::Waiter waiter(10, 114, acceptors, operation, - "WaitUntilLicenseEndpointValid"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetLicenseEndpoint(req); }; + Aws::Utils::Waiter waiter(10, 114, std::move(acceptors), operation, "WaitUntilLicenseEndpointValid"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilLicenseEndpointDeleted( const Model::GetLicenseEndpointRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("NOT_READY"), - [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetLicenseEndpointOutcome; + using RequestT = Model::GetLicenseEndpointRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "LicenseEndpointDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "LicenseEndpointDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("NOT_READY"), + [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LicenseEndpointStatusMapper::GetNameForLicenseEndpointStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetLicenseEndpointRequest& req) { - return static_cast(this)->GetLicenseEndpoint(req); - }; - Aws::Utils::Waiter waiter(10, 234, acceptors, operation, - "WaitUntilLicenseEndpointDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetLicenseEndpoint(req); }; + Aws::Utils::Waiter waiter(10, 234, std::move(acceptors), operation, "WaitUntilLicenseEndpointDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilQueueSchedulingBlocked(const Model::GetQueueRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SCHEDULING_BLOCKED"), - [](const Model::GetQueueOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::QueueStatusMapper::GetNameForQueueStatus(result.GetStatus()) == expected.get(); - }}); + using OutcomeT = Model::GetQueueOutcome; + using RequestT = Model::GetQueueRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "QueueSchedulingBlockedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SCHEDULING_BLOCKED"), + [](const Model::GetQueueOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::QueueStatusMapper::GetNameForQueueStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetQueueRequest& req) { return static_cast(this)->GetQueue(req); }; - Aws::Utils::Waiter waiter(10, 30, acceptors, operation, - "WaitUntilQueueSchedulingBlocked"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetQueue(req); }; + Aws::Utils::Waiter waiter(10, 30, std::move(acceptors), operation, "WaitUntilQueueSchedulingBlocked"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilQueueScheduling(const Model::GetQueueRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SCHEDULING"), - [](const Model::GetQueueOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::QueueStatusMapper::GetNameForQueueStatus(result.GetStatus()) == expected.get(); - }}); + using OutcomeT = Model::GetQueueOutcome; + using RequestT = Model::GetQueueRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "QueueSchedulingWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SCHEDULING"), + [](const Model::GetQueueOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::QueueStatusMapper::GetNameForQueueStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetQueueRequest& req) { return static_cast(this)->GetQueue(req); }; - Aws::Utils::Waiter waiter(10, 70, acceptors, operation, "WaitUntilQueueScheduling"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetQueue(req); }; + Aws::Utils::Waiter waiter(10, 70, std::move(acceptors), operation, "WaitUntilQueueScheduling"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilQueueFleetAssociationStopped( const Model::GetQueueFleetAssociationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), - [](const Model::GetQueueLimitAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::QueueLimitAssociationStatusMapper::GetNameForQueueLimitAssociationStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetQueueFleetAssociationOutcome; + using RequestT = Model::GetQueueFleetAssociationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "QueueFleetAssociationStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"), + [](const Model::GetQueueLimitAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::QueueLimitAssociationStatusMapper::GetNameForQueueLimitAssociationStatus(result.GetStatus()) == + expected.get(); + })); - auto operation = [this](const Model::GetQueueFleetAssociationRequest& req) { - return static_cast(this)->GetQueueFleetAssociation(req); - }; - Aws::Utils::Waiter waiter( - 10, 60, acceptors, operation, "WaitUntilQueueFleetAssociationStopped"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetQueueFleetAssociation(req); }; + Aws::Utils::Waiter waiter(10, 60, std::move(acceptors), operation, "WaitUntilQueueFleetAssociationStopped"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilQueueLimitAssociationStopped( const Model::GetQueueLimitAssociationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), - [](const Model::GetQueueLimitAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::QueueLimitAssociationStatusMapper::GetNameForQueueLimitAssociationStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetQueueLimitAssociationOutcome; + using RequestT = Model::GetQueueLimitAssociationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "QueueLimitAssociationStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"), + [](const Model::GetQueueLimitAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::QueueLimitAssociationStatusMapper::GetNameForQueueLimitAssociationStatus(result.GetStatus()) == + expected.get(); + })); - auto operation = [this](const Model::GetQueueLimitAssociationRequest& req) { - return static_cast(this)->GetQueueLimitAssociation(req); - }; - Aws::Utils::Waiter waiter( - 10, 60, acceptors, operation, "WaitUntilQueueLimitAssociationStopped"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetQueueLimitAssociation(req); }; + Aws::Utils::Waiter waiter(10, 60, std::move(acceptors), operation, "WaitUntilQueueLimitAssociationStopped"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-detective/include/aws/detective/DetectiveWaiter.h b/generated/src/aws-cpp-sdk-detective/include/aws/detective/DetectiveWaiter.h new file mode 100644 index 00000000000..edbaa5f3419 --- /dev/null +++ b/generated/src/aws-cpp-sdk-detective/include/aws/detective/DetectiveWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Detective { + +template +class DetectiveWaiter { + public: +}; +} // namespace Detective +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-devicefarm/include/aws/devicefarm/DeviceFarmWaiter.h b/generated/src/aws-cpp-sdk-devicefarm/include/aws/devicefarm/DeviceFarmWaiter.h new file mode 100644 index 00000000000..f633565b319 --- /dev/null +++ b/generated/src/aws-cpp-sdk-devicefarm/include/aws/devicefarm/DeviceFarmWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DeviceFarm { + +template +class DeviceFarmWaiter { + public: +}; +} // namespace DeviceFarm +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-devops-guru/include/aws/devops-guru/DevOpsGuruWaiter.h b/generated/src/aws-cpp-sdk-devops-guru/include/aws/devops-guru/DevOpsGuruWaiter.h new file mode 100644 index 00000000000..6836e1ebd84 --- /dev/null +++ b/generated/src/aws-cpp-sdk-devops-guru/include/aws/devops-guru/DevOpsGuruWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DevOpsGuru { + +template +class DevOpsGuruWaiter { + public: +}; +} // namespace DevOpsGuru +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/DirectConnectWaiter.h b/generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/DirectConnectWaiter.h new file mode 100644 index 00000000000..1a63705caba --- /dev/null +++ b/generated/src/aws-cpp-sdk-directconnect/include/aws/directconnect/DirectConnectWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DirectConnect { + +template +class DirectConnectWaiter { + public: +}; +} // namespace DirectConnect +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-directory-service-data/include/aws/directory-service-data/DirectoryServiceDataWaiter.h b/generated/src/aws-cpp-sdk-directory-service-data/include/aws/directory-service-data/DirectoryServiceDataWaiter.h new file mode 100644 index 00000000000..a3923298ee5 --- /dev/null +++ b/generated/src/aws-cpp-sdk-directory-service-data/include/aws/directory-service-data/DirectoryServiceDataWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DirectoryServiceData { + +template +class DirectoryServiceDataWaiter { + public: +}; +} // namespace DirectoryServiceData +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-discovery/include/aws/discovery/ApplicationDiscoveryServiceWaiter.h b/generated/src/aws-cpp-sdk-discovery/include/aws/discovery/ApplicationDiscoveryServiceWaiter.h new file mode 100644 index 00000000000..862ba407e6a --- /dev/null +++ b/generated/src/aws-cpp-sdk-discovery/include/aws/discovery/ApplicationDiscoveryServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ApplicationDiscoveryService { + +template +class ApplicationDiscoveryServiceWaiter { + public: +}; +} // namespace ApplicationDiscoveryService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-dlm/include/aws/dlm/DLMWaiter.h b/generated/src/aws-cpp-sdk-dlm/include/aws/dlm/DLMWaiter.h new file mode 100644 index 00000000000..c3154dc07da --- /dev/null +++ b/generated/src/aws-cpp-sdk-dlm/include/aws/dlm/DLMWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DLM { + +template +class DLMWaiter { + public: +}; +} // namespace DLM +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h b/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h index 51ee2c15659..d0b14b5eac9 100644 --- a/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h +++ b/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -25,431 +26,428 @@ class DatabaseMigrationServiceWaiter { public: Aws::Utils::WaiterOutcome WaitUntilTestConnectionSucceeds( const Model::DescribeConnectionsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("successful"), - [](const Model::DescribeConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetConnections().begin(), result.GetConnections().end(), - [&](const Model::Connection& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetConnections().begin(), result.GetConnections().end(), - [&](const Model::Connection& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeConnectionsOutcome; + using RequestT = Model::DescribeConnectionsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TestConnectionSucceedsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("successful"), + [](const Model::DescribeConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetConnections().begin(), result.GetConnections().end(), + [&](const Model::Connection& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TestConnectionSucceedsWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetConnections().begin(), result.GetConnections().end(), + [&](const Model::Connection& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeConnectionsRequest& req) { - return static_cast(this)->DescribeConnections(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilTestConnectionSucceeds"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeConnections(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilTestConnectionSucceeds"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilEndpointDeleted(const Model::DescribeEndpointsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundFault")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("active"), - [](const Model::DescribeEndpointsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetEndpoints().begin(), result.GetEndpoints().end(), - [&](const Model::Endpoint& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeEndpointsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetEndpoints().begin(), result.GetEndpoints().end(), - [&](const Model::Endpoint& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeEndpointsOutcome; + using RequestT = Model::DescribeEndpointsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("EndpointDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundFault"))); + acceptors.emplace_back(Aws::MakeUnique>( + "EndpointDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("active"), + [](const Model::DescribeEndpointsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetEndpoints().begin(), result.GetEndpoints().end(), + [&](const Model::Endpoint& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "EndpointDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeEndpointsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetEndpoints().begin(), result.GetEndpoints().end(), + [&](const Model::Endpoint& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeEndpointsRequest& req) { - return static_cast(this)->DescribeEndpoints(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilEndpointDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeEndpoints(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilEndpointDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReplicationInstanceAvailable( const Model::DescribeReplicationInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), - [&](const Model::ReplicationInstance& item) { - return item.GetReplicationInstanceStatus() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), - [&](const Model::ReplicationInstance& item) { - return item.GetReplicationInstanceStatus() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-credentials"), - [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), - [&](const Model::ReplicationInstance& item) { - return item.GetReplicationInstanceStatus() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-network"), - [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), - [&](const Model::ReplicationInstance& item) { - return item.GetReplicationInstanceStatus() == expected.get(); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("inaccessible-encryption-credentials"), - [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), - [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeReplicationInstancesOutcome; + using RequestT = Model::DescribeReplicationInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-credentials"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-network"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("inaccessible-encryption-credentials"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeReplicationInstancesRequest& req) { - return static_cast(this)->DescribeReplicationInstances(req); - }; - Aws::Utils::Waiter waiter( - 60, 2, acceptors, operation, "WaitUntilReplicationInstanceAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeReplicationInstances(req); }; + Aws::Utils::Waiter waiter(60, 2, std::move(acceptors), operation, "WaitUntilReplicationInstanceAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReplicationInstanceDeleted( const Model::DescribeReplicationInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), - [&](const Model::ReplicationInstance& item) { - return item.GetReplicationInstanceStatus() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundFault")}); + using OutcomeT = Model::DescribeReplicationInstancesOutcome; + using RequestT = Model::DescribeReplicationInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("available"), + [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetReplicationInstances().begin(), result.GetReplicationInstances().end(), + [&](const Model::ReplicationInstance& item) { return item.GetReplicationInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundFault"))); - auto operation = [this](const Model::DescribeReplicationInstancesRequest& req) { - return static_cast(this)->DescribeReplicationInstances(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilReplicationInstanceDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeReplicationInstances(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationInstanceDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReplicationTaskDeleted( const Model::DescribeReplicationTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ready"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopped"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("running"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundFault")}); + using OutcomeT = Model::DescribeReplicationTasksOutcome; + using RequestT = Model::DescribeReplicationTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ready"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopped"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("running"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundFault"))); - auto operation = [this](const Model::DescribeReplicationTasksRequest& req) { - return static_cast(this)->DescribeReplicationTasks(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilReplicationTaskDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeReplicationTasks(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReplicationTaskReady( const Model::DescribeReplicationTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ready"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("starting"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("running"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopping"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopped"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("testing"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeReplicationTasksOutcome; + using RequestT = Model::DescribeReplicationTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ready"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("starting"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("running"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopping"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopped"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("testing"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeReplicationTasksRequest& req) { - return static_cast(this)->DescribeReplicationTasks(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilReplicationTaskReady"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeReplicationTasks(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskReady"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReplicationTaskRunning( const Model::DescribeReplicationTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("running"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ready"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopping"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopped"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("testing"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeReplicationTasksOutcome; + using RequestT = Model::DescribeReplicationTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("running"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ready"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopping"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopped"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("testing"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeReplicationTasksRequest& req) { - return static_cast(this)->DescribeReplicationTasks(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilReplicationTaskRunning"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeReplicationTasks(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskRunning"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReplicationTaskStopped( const Model::DescribeReplicationTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("stopped"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ready"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("starting"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("testing"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), - [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeReplicationTasksOutcome; + using RequestT = Model::DescribeReplicationTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("stopped"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ready"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("starting"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("testing"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationTasks().begin(), result.GetReplicationTasks().end(), + [&](const Model::ReplicationTask& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeReplicationTasksRequest& req) { - return static_cast(this)->DescribeReplicationTasks(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilReplicationTaskStopped"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeReplicationTasks(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationTaskStopped"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-docdb-elastic/include/aws/docdb-elastic/DocDBElasticWaiter.h b/generated/src/aws-cpp-sdk-docdb-elastic/include/aws/docdb-elastic/DocDBElasticWaiter.h new file mode 100644 index 00000000000..d6f3bedd818 --- /dev/null +++ b/generated/src/aws-cpp-sdk-docdb-elastic/include/aws/docdb-elastic/DocDBElasticWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DocDBElastic { + +template +class DocDBElasticWaiter { + public: +}; +} // namespace DocDBElastic +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h b/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h index 0dd5a1405e7..7a7ada87a14 100644 --- a/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h +++ b/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,114 +20,113 @@ class DocDBWaiter { public: Aws::Utils::WaiterOutcome WaitUntilDBInstanceAvailable( const Model::DescribeDBInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBInstancesOutcome; + using RequestT = Model::DescribeDBInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBInstancesRequest& req) { - return static_cast(this)->DescribeDBInstances(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilDBInstanceAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBInstances(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilDBInstanceAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilDBInstanceDeleted( const Model::DescribeDBInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBInstanceNotFound")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBInstancesOutcome; + using RequestT = Model::DescribeDBInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>("DBInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("DBInstanceNotFound"))); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("rebooting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBInstancesRequest& req) { - return static_cast(this)->DescribeDBInstances(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilDBInstanceDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBInstances(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilDBInstanceDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-drs/include/aws/drs/DrsWaiter.h b/generated/src/aws-cpp-sdk-drs/include/aws/drs/DrsWaiter.h new file mode 100644 index 00000000000..8147ca2306e --- /dev/null +++ b/generated/src/aws-cpp-sdk-drs/include/aws/drs/DrsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace drs { + +template +class DrsWaiter { + public: +}; +} // namespace drs +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h b/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h index 74356c6383e..315f56d8109 100644 --- a/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h +++ b/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,31 +20,30 @@ class DirectoryServiceWaiter { public: Aws::Utils::WaiterOutcome WaitUntilHybridADUpdated( const Model::DescribeHybridADUpdateRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Updated"), - [](const Model::DescribeHybridADUpdateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetUpdateActivities().GetSelfManagedInstances().begin(), - result.GetUpdateActivities().GetSelfManagedInstances().end(), - [&](const Model::HybridUpdateInfoEntry& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UpdateFailed"), - [](const Model::DescribeHybridADUpdateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetUpdateActivities().GetSelfManagedInstances().begin(), - result.GetUpdateActivities().GetSelfManagedInstances().end(), - [&](const Model::HybridUpdateInfoEntry& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeHybridADUpdateOutcome; + using RequestT = Model::DescribeHybridADUpdateRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "HybridADUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Updated"), + [](const Model::DescribeHybridADUpdateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetUpdateActivities().GetSelfManagedInstances().begin(), + result.GetUpdateActivities().GetSelfManagedInstances().end(), + [&](const Model::HybridUpdateInfoEntry& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "HybridADUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UpdateFailed"), + [](const Model::DescribeHybridADUpdateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetUpdateActivities().GetSelfManagedInstances().begin(), + result.GetUpdateActivities().GetSelfManagedInstances().end(), + [&](const Model::HybridUpdateInfoEntry& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeHybridADUpdateRequest& req) { - return static_cast(this)->DescribeHybridADUpdate(req); - }; - Aws::Utils::Waiter waiter(120, 1, acceptors, operation, - "WaitUntilHybridADUpdated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeHybridADUpdate(req); }; + Aws::Utils::Waiter waiter(120, 1, std::move(acceptors), operation, "WaitUntilHybridADUpdated"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h b/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h index 6086aa48447..dd6b9658508 100644 --- a/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h +++ b/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,25 +20,31 @@ template class DSQLWaiter { public: Aws::Utils::WaiterOutcome WaitUntilClusterActive(const Model::GetClusterRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetStatus()) == expected.get(); - }}); + using OutcomeT = Model::GetClusterOutcome; + using RequestT = Model::GetClusterRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetClusterRequest& req) { return static_cast(this)->GetCluster(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilClusterActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetCluster(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilClusterActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilClusterNotExists(const Model::GetClusterRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::GetClusterOutcome; + using RequestT = Model::GetClusterRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("ClusterNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::GetClusterRequest& req) { return static_cast(this)->GetCluster(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilClusterNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetCluster(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilClusterNotExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h b/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h index ab044c80c62..88cc4920f2d 100644 --- a/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h +++ b/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -32,142 +33,152 @@ class DynamoDBWaiter { public: Aws::Utils::WaiterOutcome WaitUntilContributorInsightsEnabled( const Model::DescribeContributorInsightsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ENABLED"), - [](const Model::DescribeContributorInsightsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ContributorInsightsStatusMapper::GetNameForContributorInsightsStatus( - result.GetContributorInsightsStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeContributorInsightsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ContributorInsightsStatusMapper::GetNameForContributorInsightsStatus( - result.GetContributorInsightsStatus()) == expected.get(); - }}); + using OutcomeT = Model::DescribeContributorInsightsOutcome; + using RequestT = Model::DescribeContributorInsightsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ContributorInsightsEnabledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ENABLED"), + [](const Model::DescribeContributorInsightsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ContributorInsightsStatusMapper::GetNameForContributorInsightsStatus(result.GetContributorInsightsStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ContributorInsightsEnabledWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeContributorInsightsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ContributorInsightsStatusMapper::GetNameForContributorInsightsStatus(result.GetContributorInsightsStatus()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeContributorInsightsRequest& req) { - return static_cast(this)->DescribeContributorInsights(req); - }; - Aws::Utils::Waiter waiter( - 20, 6, acceptors, operation, "WaitUntilContributorInsightsEnabled"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeContributorInsights(req); }; + Aws::Utils::Waiter waiter(20, 6, std::move(acceptors), operation, "WaitUntilContributorInsightsEnabled"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilExportCompleted(const Model::DescribeExportRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportDescription().GetExportStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportDescription().GetExportStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeExportOutcome; + using RequestT = Model::DescribeExportRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ExportCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportDescription().GetExportStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ExportCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportDescription().GetExportStatus()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeExportRequest& req) { return static_cast(this)->DescribeExport(req); }; - Aws::Utils::Waiter waiter(20, 6, acceptors, operation, - "WaitUntilExportCompleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeExport(req); }; + Aws::Utils::Waiter waiter(20, 6, std::move(acceptors), operation, "WaitUntilExportCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilImportCompleted(const Model::DescribeImportRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportTableDescription().GetImportStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportTableDescription().GetImportStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportTableDescription().GetImportStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeImportOutcome; + using RequestT = Model::DescribeImportRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ImportCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportTableDescription().GetImportStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImportCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportTableDescription().GetImportStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImportCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportTableDescription().GetImportStatus()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeImportRequest& req) { return static_cast(this)->DescribeImport(req); }; - Aws::Utils::Waiter waiter(20, 6, acceptors, operation, - "WaitUntilImportCompleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImport(req); }; + Aws::Utils::Waiter waiter(20, 6, std::move(acceptors), operation, "WaitUntilImportCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilKinesisStreamingDestinationActive( const Model::DescribeKinesisStreamingDestinationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeKinesisStreamingDestinationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetKinesisDataStreamDestinations().begin(), result.GetKinesisDataStreamDestinations().end(), - [&](const Model::KinesisDataStreamDestination& item) { - return Model::DestinationStatusMapper::GetNameForDestinationStatus(item.GetDestinationStatus()) == - expected.get(); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeKinesisStreamingDestinationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return ((result.GetKinesisDataStreamDestinations().size() > 0) && - (std::count_if(result.GetKinesisDataStreamDestinations().begin(), result.GetKinesisDataStreamDestinations().end(), - [](const Model::KinesisDataStreamDestination& item) { - return ((item.GetDestinationStatus() == "DISABLED") || - (item.GetDestinationStatus() == "ENABLE_FAILED")); - }) == result.GetKinesisDataStreamDestinations().size())) == expected.get(); - }}); + using OutcomeT = Model::DescribeKinesisStreamingDestinationOutcome; + using RequestT = Model::DescribeKinesisStreamingDestinationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "KinesisStreamingDestinationActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeKinesisStreamingDestinationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetKinesisDataStreamDestinations().begin(), result.GetKinesisDataStreamDestinations().end(), + [&](const Model::KinesisDataStreamDestination& item) { + return Model::DestinationStatusMapper::GetNameForDestinationStatus(item.GetDestinationStatus()) == + expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "KinesisStreamingDestinationActiveWaiter", Aws::Utils::WaiterState::FAILURE, true, + [](const Model::DescribeKinesisStreamingDestinationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return ((result.GetKinesisDataStreamDestinations().size() > 0) && + (std::count_if(result.GetKinesisDataStreamDestinations().begin(), result.GetKinesisDataStreamDestinations().end(), + [](const Model::KinesisDataStreamDestination& item) { + return ((item.GetDestinationStatus() == "DISABLED") || (item.GetDestinationStatus() == "ENABLE_FAILED")); + }) == result.GetKinesisDataStreamDestinations().size())) == expected.get(); + })); - auto operation = [this](const Model::DescribeKinesisStreamingDestinationRequest& req) { - return static_cast(this)->DescribeKinesisStreamingDestination(req); - }; - Aws::Utils::Waiter waiter( - 20, 6, acceptors, operation, "WaitUntilKinesisStreamingDestinationActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeKinesisStreamingDestination(req); }; + Aws::Utils::Waiter waiter(20, 6, std::move(acceptors), operation, "WaitUntilKinesisStreamingDestinationActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTableExists(const Model::DescribeTableRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeTableOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TableStatusMapper::GetNameForTableStatus(result.GetTable().GetTableStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::DescribeTableOutcome; + using RequestT = Model::DescribeTableRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TableExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeTableOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TableStatusMapper::GetNameForTableStatus(result.GetTable().GetTableStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("TableExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::DescribeTableRequest& req) { return static_cast(this)->DescribeTable(req); }; - Aws::Utils::Waiter waiter(20, 6, acceptors, operation, - "WaitUntilTableExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeTable(req); }; + Aws::Utils::Waiter waiter(20, 6, std::move(acceptors), operation, "WaitUntilTableExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTableNotExists(const Model::DescribeTableRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::DescribeTableOutcome; + using RequestT = Model::DescribeTableRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("TableNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::DescribeTableRequest& req) { return static_cast(this)->DescribeTable(req); }; - Aws::Utils::Waiter waiter(20, 6, acceptors, operation, - "WaitUntilTableNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeTable(req); }; + Aws::Utils::Waiter waiter(20, 6, std::move(acceptors), operation, "WaitUntilTableNotExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-dynamodbstreams/include/aws/dynamodbstreams/DynamoDBStreamsWaiter.h b/generated/src/aws-cpp-sdk-dynamodbstreams/include/aws/dynamodbstreams/DynamoDBStreamsWaiter.h new file mode 100644 index 00000000000..71fbe460b27 --- /dev/null +++ b/generated/src/aws-cpp-sdk-dynamodbstreams/include/aws/dynamodbstreams/DynamoDBStreamsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace DynamoDBStreams { + +template +class DynamoDBStreamsWaiter { + public: +}; +} // namespace DynamoDBStreams +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ebs/include/aws/ebs/EBSWaiter.h b/generated/src/aws-cpp-sdk-ebs/include/aws/ebs/EBSWaiter.h new file mode 100644 index 00000000000..59b809c2b3f --- /dev/null +++ b/generated/src/aws-cpp-sdk-ebs/include/aws/ebs/EBSWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace EBS { + +template +class EBSWaiter { + public: +}; +} // namespace EBS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ec2-instance-connect/include/aws/ec2-instance-connect/EC2InstanceConnectWaiter.h b/generated/src/aws-cpp-sdk-ec2-instance-connect/include/aws/ec2-instance-connect/EC2InstanceConnectWaiter.h new file mode 100644 index 00000000000..1d1a79195c8 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ec2-instance-connect/include/aws/ec2-instance-connect/EC2InstanceConnectWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace EC2InstanceConnect { + +template +class EC2InstanceConnectWaiter { + public: +}; +} // namespace EC2InstanceConnect +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h b/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h index 351ad6000b9..729ed2d1cb6 100644 --- a/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h +++ b/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -86,1256 +87,1264 @@ class EC2Waiter { public: Aws::Utils::WaiterOutcome WaitUntilBundleTaskComplete( const Model::DescribeBundleTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("complete"), - [](const Model::DescribeBundleTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetBundleTasks().begin(), result.GetBundleTasks().end(), [&](const Model::BundleTask& item) { - return Model::BundleTaskStateMapper::GetNameForBundleTaskState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeBundleTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetBundleTasks().begin(), result.GetBundleTasks().end(), [&](const Model::BundleTask& item) { - return Model::BundleTaskStateMapper::GetNameForBundleTaskState(item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeBundleTasksRequest& req) { - return static_cast(this)->DescribeBundleTasks(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilBundleTaskComplete"); + using OutcomeT = Model::DescribeBundleTasksOutcome; + using RequestT = Model::DescribeBundleTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "BundleTaskCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("complete"), + [](const Model::DescribeBundleTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetBundleTasks().begin(), result.GetBundleTasks().end(), [&](const Model::BundleTask& item) { + return Model::BundleTaskStateMapper::GetNameForBundleTaskState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BundleTaskCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeBundleTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetBundleTasks().begin(), result.GetBundleTasks().end(), [&](const Model::BundleTask& item) { + return Model::BundleTaskStateMapper::GetNameForBundleTaskState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeBundleTasks(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilBundleTaskComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilConversionTaskCancelled( const Model::DescribeConversionTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("cancelled"), - [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetConversionTasks().begin(), result.GetConversionTasks().end(), - [&](const Model::ConversionTask& item) { - return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == - expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeConversionTasksRequest& req) { - return static_cast(this)->DescribeConversionTasks(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilConversionTaskCancelled"); + using OutcomeT = Model::DescribeConversionTasksOutcome; + using RequestT = Model::DescribeConversionTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ConversionTaskCancelledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("cancelled"), + [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetConversionTasks().begin(), result.GetConversionTasks().end(), [&](const Model::ConversionTask& item) { + return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeConversionTasks(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilConversionTaskCancelled"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilConversionTaskCompleted( const Model::DescribeConversionTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), - [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetConversionTasks().begin(), result.GetConversionTasks().end(), - [&](const Model::ConversionTask& item) { - return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == - expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("cancelled"), - [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetConversionTasks().begin(), result.GetConversionTasks().end(), - [&](const Model::ConversionTask& item) { - return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == - expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("cancelling"), - [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetConversionTasks().begin(), result.GetConversionTasks().end(), - [&](const Model::ConversionTask& item) { - return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == - expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeConversionTasksRequest& req) { - return static_cast(this)->DescribeConversionTasks(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilConversionTaskCompleted"); + using OutcomeT = Model::DescribeConversionTasksOutcome; + using RequestT = Model::DescribeConversionTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ConversionTaskCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), + [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetConversionTasks().begin(), result.GetConversionTasks().end(), [&](const Model::ConversionTask& item) { + return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ConversionTaskCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("cancelled"), + [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetConversionTasks().begin(), result.GetConversionTasks().end(), [&](const Model::ConversionTask& item) { + return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ConversionTaskCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("cancelling"), + [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetConversionTasks().begin(), result.GetConversionTasks().end(), [&](const Model::ConversionTask& item) { + return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeConversionTasks(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilConversionTaskCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilConversionTaskDeleted( const Model::DescribeConversionTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetConversionTasks().begin(), result.GetConversionTasks().end(), - [&](const Model::ConversionTask& item) { - return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == - expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeConversionTasksRequest& req) { - return static_cast(this)->DescribeConversionTasks(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilConversionTaskDeleted"); + using OutcomeT = Model::DescribeConversionTasksOutcome; + using RequestT = Model::DescribeConversionTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ConversionTaskDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), + [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetConversionTasks().begin(), result.GetConversionTasks().end(), [&](const Model::ConversionTask& item) { + return Model::ConversionTaskStateMapper::GetNameForConversionTaskState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeConversionTasks(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilConversionTaskDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilCustomerGatewayAvailable( const Model::DescribeCustomerGatewaysRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeCustomerGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetCustomerGateways().begin(), result.GetCustomerGateways().end(), - [&](const Model::CustomerGateway& item) { return item.GetState() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeCustomerGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetCustomerGateways().begin(), result.GetCustomerGateways().end(), - [&](const Model::CustomerGateway& item) { return item.GetState() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeCustomerGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetCustomerGateways().begin(), result.GetCustomerGateways().end(), - [&](const Model::CustomerGateway& item) { return item.GetState() == expected.get(); }); - }}); - - auto operation = [this](const Model::DescribeCustomerGatewaysRequest& req) { - return static_cast(this)->DescribeCustomerGateways(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilCustomerGatewayAvailable"); + using OutcomeT = Model::DescribeCustomerGatewaysOutcome; + using RequestT = Model::DescribeCustomerGatewaysRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "CustomerGatewayAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeCustomerGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetCustomerGateways().begin(), result.GetCustomerGateways().end(), + [&](const Model::CustomerGateway& item) { return item.GetState() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CustomerGatewayAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeCustomerGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCustomerGateways().begin(), result.GetCustomerGateways().end(), + [&](const Model::CustomerGateway& item) { return item.GetState() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CustomerGatewayAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeCustomerGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCustomerGateways().begin(), result.GetCustomerGateways().end(), + [&](const Model::CustomerGateway& item) { return item.GetState() == expected.get(); }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCustomerGateways(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilCustomerGatewayAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilExportTaskCancelled( const Model::DescribeExportTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("cancelled"), - [](const Model::DescribeExportTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetExportTasks().begin(), result.GetExportTasks().end(), [&](const Model::ExportTask& item) { - return Model::ExportTaskStateMapper::GetNameForExportTaskState(item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeExportTasksRequest& req) { - return static_cast(this)->DescribeExportTasks(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilExportTaskCancelled"); + using OutcomeT = Model::DescribeExportTasksOutcome; + using RequestT = Model::DescribeExportTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ExportTaskCancelledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("cancelled"), + [](const Model::DescribeExportTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetExportTasks().begin(), result.GetExportTasks().end(), [&](const Model::ExportTask& item) { + return Model::ExportTaskStateMapper::GetNameForExportTaskState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeExportTasks(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilExportTaskCancelled"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilExportTaskCompleted( const Model::DescribeExportTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), - [](const Model::DescribeExportTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetExportTasks().begin(), result.GetExportTasks().end(), [&](const Model::ExportTask& item) { - return Model::ExportTaskStateMapper::GetNameForExportTaskState(item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeExportTasksRequest& req) { - return static_cast(this)->DescribeExportTasks(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilExportTaskCompleted"); + using OutcomeT = Model::DescribeExportTasksOutcome; + using RequestT = Model::DescribeExportTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ExportTaskCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), + [](const Model::DescribeExportTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetExportTasks().begin(), result.GetExportTasks().end(), [&](const Model::ExportTask& item) { + return Model::ExportTaskStateMapper::GetNameForExportTaskState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeExportTasks(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilExportTaskCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilImageAvailable(const Model::DescribeImagesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeImagesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetImages().begin(), result.GetImages().end(), [&](const Model::Image& item) { - return Model::ImageStateMapper::GetNameForImageState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeImagesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetImages().begin(), result.GetImages().end(), [&](const Model::Image& item) { - return Model::ImageStateMapper::GetNameForImageState(item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeImagesRequest& req) { return static_cast(this)->DescribeImages(req); }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilImageAvailable"); + using OutcomeT = Model::DescribeImagesOutcome; + using RequestT = Model::DescribeImagesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ImageAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeImagesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetImages().begin(), result.GetImages().end(), [&](const Model::Image& item) { + return Model::ImageStateMapper::GetNameForImageState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImageAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeImagesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetImages().begin(), result.GetImages().end(), [&](const Model::Image& item) { + return Model::ImageStateMapper::GetNameForImageState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImages(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilImageAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilImageExists(const Model::DescribeImagesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeImagesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetImages().size() > 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidAMIID.NotFound")}); - - auto operation = [this](const Model::DescribeImagesRequest& req) { return static_cast(this)->DescribeImages(req); }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilImageExists"); + using OutcomeT = Model::DescribeImagesOutcome; + using RequestT = Model::DescribeImagesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ImageExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeImagesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetImages().size() > 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ImageExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InvalidAMIID.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImages(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilImageExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilImageUsageReportAvailable( const Model::DescribeImageUsageReportsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeImageUsageReportsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetImageUsageReports().begin(), result.GetImageUsageReports().end(), - [&](const Model::ImageUsageReport& item) { return item.GetState() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeImageUsageReportsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetImageUsageReports().begin(), result.GetImageUsageReports().end(), - [&](const Model::ImageUsageReport& item) { return item.GetState() == expected.get(); }); - }}); - - auto operation = [this](const Model::DescribeImageUsageReportsRequest& req) { - return static_cast(this)->DescribeImageUsageReports(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilImageUsageReportAvailable"); + using OutcomeT = Model::DescribeImageUsageReportsOutcome; + using RequestT = Model::DescribeImageUsageReportsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ImageUsageReportAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeImageUsageReportsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetImageUsageReports().begin(), result.GetImageUsageReports().end(), + [&](const Model::ImageUsageReport& item) { return item.GetState() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImageUsageReportAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeImageUsageReportsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetImageUsageReports().begin(), result.GetImageUsageReports().end(), + [&](const Model::ImageUsageReport& item) { return item.GetState() == expected.get(); }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImageUsageReports(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilImageUsageReportAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSnapshotImported( const Model::DescribeImportSnapshotTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), - [](const Model::DescribeImportSnapshotTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetImportSnapshotTasks().begin(), result.GetImportSnapshotTasks().end(), - [&](const Model::ImportSnapshotTask& item) { - return item.GetSnapshotTaskDetail().GetStatus() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("error"), - [](const Model::DescribeImportSnapshotTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetImportSnapshotTasks().begin(), result.GetImportSnapshotTasks().end(), - [&](const Model::ImportSnapshotTask& item) { - return item.GetSnapshotTaskDetail().GetStatus() == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeImportSnapshotTasksRequest& req) { - return static_cast(this)->DescribeImportSnapshotTasks(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilSnapshotImported"); + using OutcomeT = Model::DescribeImportSnapshotTasksOutcome; + using RequestT = Model::DescribeImportSnapshotTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SnapshotImportedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), + [](const Model::DescribeImportSnapshotTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetImportSnapshotTasks().begin(), result.GetImportSnapshotTasks().end(), + [&](const Model::ImportSnapshotTask& item) { + return item.GetSnapshotTaskDetail().GetStatus() == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SnapshotImportedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("error"), + [](const Model::DescribeImportSnapshotTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetImportSnapshotTasks().begin(), result.GetImportSnapshotTasks().end(), + [&](const Model::ImportSnapshotTask& item) { + return item.GetSnapshotTaskDetail().GetStatus() == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImportSnapshotTasks(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilSnapshotImported"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInstanceExists(const Model::DescribeInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetReservations().size() > 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstanceID.NotFound")}); - - auto operation = [this](const Model::DescribeInstancesRequest& req) { - return static_cast(this)->DescribeInstances(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilInstanceExists"); + using OutcomeT = Model::DescribeInstancesOutcome; + using RequestT = Model::DescribeInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetReservations().size() > 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("InstanceExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InvalidInstanceID.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInstances(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilInstanceExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInstanceRunning(const Model::DescribeInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("running"), - [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { - return std::all_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { - return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == - expected.get(); - }); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("shutting-down"), - [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { - return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { - return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == - expected.get(); - }); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("terminated"), - [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { - return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { - return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == - expected.get(); - }); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopping"), - [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { - return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { - return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == - expected.get(); - }); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstanceID.NotFound")}); - - auto operation = [this](const Model::DescribeInstancesRequest& req) { - return static_cast(this)->DescribeInstances(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilInstanceRunning"); + using OutcomeT = Model::DescribeInstancesOutcome; + using RequestT = Model::DescribeInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("running"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::all_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == expected.get(); + }); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("shutting-down"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == expected.get(); + }); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("terminated"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == expected.get(); + }); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopping"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == expected.get(); + }); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>("InstanceRunningWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InvalidInstanceID.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInstances(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilInstanceRunning"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInstanceStopped(const Model::DescribeInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("stopped"), - [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { - return std::all_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { - return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == - expected.get(); - }); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("pending"), - [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { - return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { - return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == - expected.get(); - }); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("terminated"), - [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { - return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { - return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == - expected.get(); - }); - }); - }}); - - auto operation = [this](const Model::DescribeInstancesRequest& req) { - return static_cast(this)->DescribeInstances(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilInstanceStopped"); + using OutcomeT = Model::DescribeInstancesOutcome; + using RequestT = Model::DescribeInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("stopped"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::all_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == expected.get(); + }); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("pending"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == expected.get(); + }); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("terminated"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == expected.get(); + }); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInstances(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilInstanceStopped"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInstanceTerminated(const Model::DescribeInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("terminated"), - [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { - return std::all_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { - return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == - expected.get(); - }); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("pending"), - [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { - return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { - return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == - expected.get(); - }); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("stopping"), - [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { - return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { - return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == - expected.get(); - }); - }); - }}); - - auto operation = [this](const Model::DescribeInstancesRequest& req) { - return static_cast(this)->DescribeInstances(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilInstanceTerminated"); + using OutcomeT = Model::DescribeInstancesOutcome; + using RequestT = Model::DescribeInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceTerminatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("terminated"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::all_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == expected.get(); + }); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceTerminatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("pending"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == expected.get(); + }); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceTerminatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("stopping"), + [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReservations().begin(), result.GetReservations().end(), [&](const Model::Reservation& item0) { + return std::any_of(item0.GetInstances().begin(), item0.GetInstances().end(), [&](const Model::Instance& item1) { + return Model::InstanceStateNameMapper::GetNameForInstanceStateName(item1.GetState().GetName()) == expected.get(); + }); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInstances(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilInstanceTerminated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInstanceStatusOk( const Model::DescribeInstanceStatusRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ok"), - [](const Model::DescribeInstanceStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetInstanceStatuses().begin(), result.GetInstanceStatuses().end(), - [&](const Model::InstanceStatus& item) { - return Model::SummaryStatusMapper::GetNameForSummaryStatus( - item.GetInstanceStatus().GetStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstanceID.NotFound")}); - - auto operation = [this](const Model::DescribeInstanceStatusRequest& req) { - return static_cast(this)->DescribeInstanceStatus(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilInstanceStatusOk"); + using OutcomeT = Model::DescribeInstanceStatusOutcome; + using RequestT = Model::DescribeInstanceStatusRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceStatusOkWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ok"), + [](const Model::DescribeInstanceStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetInstanceStatuses().begin(), result.GetInstanceStatuses().end(), + [&](const Model::InstanceStatus& item) { + return Model::SummaryStatusMapper::GetNameForSummaryStatus(item.GetInstanceStatus().GetStatus()) == + expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>("InstanceStatusOkWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InvalidInstanceID.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInstanceStatus(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilInstanceStatusOk"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSystemStatusOk( const Model::DescribeInstanceStatusRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ok"), - [](const Model::DescribeInstanceStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetInstanceStatuses().begin(), result.GetInstanceStatuses().end(), - [&](const Model::InstanceStatus& item) { - return Model::SummaryStatusMapper::GetNameForSummaryStatus( - item.GetSystemStatus().GetStatus()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeInstanceStatusRequest& req) { - return static_cast(this)->DescribeInstanceStatus(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilSystemStatusOk"); + using OutcomeT = Model::DescribeInstanceStatusOutcome; + using RequestT = Model::DescribeInstanceStatusRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SystemStatusOkWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ok"), + [](const Model::DescribeInstanceStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetInstanceStatuses().begin(), result.GetInstanceStatuses().end(), + [&](const Model::InstanceStatus& item) { + return Model::SummaryStatusMapper::GetNameForSummaryStatus(item.GetSystemStatus().GetStatus()) == + expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInstanceStatus(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilSystemStatusOk"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInternetGatewayExists( const Model::DescribeInternetGatewaysRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeInternetGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetInternetGateways().size() > 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInternetGateway.NotFound")}); - - auto operation = [this](const Model::DescribeInternetGatewaysRequest& req) { - return static_cast(this)->DescribeInternetGateways(req); - }; - Aws::Utils::Waiter waiter( - 5, 24, acceptors, operation, "WaitUntilInternetGatewayExists"); + using OutcomeT = Model::DescribeInternetGatewaysOutcome; + using RequestT = Model::DescribeInternetGatewaysRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InternetGatewayExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeInternetGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetInternetGateways().size() > 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InternetGatewayExistsWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InvalidInternetGateway.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInternetGateways(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilInternetGatewayExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilKeyPairExists(const Model::DescribeKeyPairsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeKeyPairsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetKeyPairs().size() > 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidKeyPair.NotFound")}); - - auto operation = [this](const Model::DescribeKeyPairsRequest& req) { return static_cast(this)->DescribeKeyPairs(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilKeyPairExists"); + using OutcomeT = Model::DescribeKeyPairsOutcome; + using RequestT = Model::DescribeKeyPairsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "KeyPairExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeKeyPairsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetKeyPairs().size() > 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("KeyPairExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InvalidKeyPair.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeKeyPairs(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilKeyPairExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilNatGatewayAvailable( const Model::DescribeNatGatewaysRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { - return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { - return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { - return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { - return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NatGatewayNotFound")}); - - auto operation = [this](const Model::DescribeNatGatewaysRequest& req) { - return static_cast(this)->DescribeNatGateways(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilNatGatewayAvailable"); + using OutcomeT = Model::DescribeNatGatewaysOutcome; + using RequestT = Model::DescribeNatGatewaysRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "NatGatewayAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { + return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "NatGatewayAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { + return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "NatGatewayAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { + return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "NatGatewayAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { + return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>("NatGatewayAvailableWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("NatGatewayNotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeNatGateways(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilNatGatewayAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilNatGatewayDeleted( const Model::DescribeNatGatewaysRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { - return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("NatGatewayNotFound")}); - - auto operation = [this](const Model::DescribeNatGatewaysRequest& req) { - return static_cast(this)->DescribeNatGateways(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilNatGatewayDeleted"); + using OutcomeT = Model::DescribeNatGatewaysOutcome; + using RequestT = Model::DescribeNatGatewaysRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "NatGatewayDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), + [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetNatGateways().begin(), result.GetNatGateways().end(), [&](const Model::NatGateway& item) { + return Model::NatGatewayStateMapper::GetNameForNatGatewayState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>("NatGatewayDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("NatGatewayNotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeNatGateways(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilNatGatewayDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilNetworkInterfaceAvailable( const Model::DescribeNetworkInterfacesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeNetworkInterfacesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetNetworkInterfaces().begin(), result.GetNetworkInterfaces().end(), - [&](const Model::NetworkInterface& item) { - return Model::NetworkInterfaceStatusMapper::GetNameForNetworkInterfaceStatus( - item.GetStatus()) == expected.get(); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidNetworkInterfaceID.NotFound")}); - - auto operation = [this](const Model::DescribeNetworkInterfacesRequest& req) { - return static_cast(this)->DescribeNetworkInterfaces(req); - }; - Aws::Utils::Waiter waiter( - 20, 6, acceptors, operation, "WaitUntilNetworkInterfaceAvailable"); + using OutcomeT = Model::DescribeNetworkInterfacesOutcome; + using RequestT = Model::DescribeNetworkInterfacesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "NetworkInterfaceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeNetworkInterfacesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetNetworkInterfaces().begin(), result.GetNetworkInterfaces().end(), + [&](const Model::NetworkInterface& item) { + return Model::NetworkInterfaceStatusMapper::GetNameForNetworkInterfaceStatus(item.GetStatus()) == + expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "NetworkInterfaceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("InvalidNetworkInterfaceID.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeNetworkInterfaces(req); }; + Aws::Utils::Waiter waiter(20, 6, std::move(acceptors), operation, "WaitUntilNetworkInterfaceAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSecondaryNetworkCreateComplete( const Model::DescribeSecondaryNetworksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("create-complete"), - [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), - [&](const Model::SecondaryNetwork& item) { - return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState( - item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("create-failed"), - [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), - [&](const Model::SecondaryNetwork& item) { - return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState( - item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidSecondaryNetworkId.NotFound")}); - - auto operation = [this](const Model::DescribeSecondaryNetworksRequest& req) { - return static_cast(this)->DescribeSecondaryNetworks(req); - }; - Aws::Utils::Waiter waiter( - 10, 12, acceptors, operation, "WaitUntilSecondaryNetworkCreateComplete"); + using OutcomeT = Model::DescribeSecondaryNetworksOutcome; + using RequestT = Model::DescribeSecondaryNetworksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SecondaryNetworkCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("create-complete"), + [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), [&](const Model::SecondaryNetwork& item) { + return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SecondaryNetworkCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("create-failed"), + [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), [&](const Model::SecondaryNetwork& item) { + return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SecondaryNetworkCreateCompleteWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InvalidSecondaryNetworkId.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeSecondaryNetworks(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilSecondaryNetworkCreateComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSecondaryNetworkDeleteComplete( const Model::DescribeSecondaryNetworksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("delete-complete"), - [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), - [&](const Model::SecondaryNetwork& item) { - return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState( - item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("delete-failed"), - [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), - [&](const Model::SecondaryNetwork& item) { - return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState( - item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeSecondaryNetworksRequest& req) { - return static_cast(this)->DescribeSecondaryNetworks(req); - }; - Aws::Utils::Waiter waiter( - 10, 12, acceptors, operation, "WaitUntilSecondaryNetworkDeleteComplete"); + using OutcomeT = Model::DescribeSecondaryNetworksOutcome; + using RequestT = Model::DescribeSecondaryNetworksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SecondaryNetworkDeleteCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("delete-complete"), + [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), [&](const Model::SecondaryNetwork& item) { + return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SecondaryNetworkDeleteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("delete-failed"), + [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSecondaryNetworks().begin(), result.GetSecondaryNetworks().end(), [&](const Model::SecondaryNetwork& item) { + return Model::SecondaryNetworkStateMapper::GetNameForSecondaryNetworkState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeSecondaryNetworks(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilSecondaryNetworkDeleteComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSecondarySubnetCreateComplete( const Model::DescribeSecondarySubnetsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("create-complete"), - [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), - [&](const Model::SecondarySubnet& item) { - return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == - expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("delete-failed"), - [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), - [&](const Model::SecondarySubnet& item) { - return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == - expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidSecondarySubnetId.NotFound")}); - - auto operation = [this](const Model::DescribeSecondarySubnetsRequest& req) { - return static_cast(this)->DescribeSecondarySubnets(req); - }; - Aws::Utils::Waiter waiter( - 10, 12, acceptors, operation, "WaitUntilSecondarySubnetCreateComplete"); + using OutcomeT = Model::DescribeSecondarySubnetsOutcome; + using RequestT = Model::DescribeSecondarySubnetsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SecondarySubnetCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("create-complete"), + [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), [&](const Model::SecondarySubnet& item) { + return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SecondarySubnetCreateCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("delete-failed"), + [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), [&](const Model::SecondarySubnet& item) { + return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SecondarySubnetCreateCompleteWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InvalidSecondarySubnetId.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeSecondarySubnets(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilSecondarySubnetCreateComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSecondarySubnetDeleteComplete( const Model::DescribeSecondarySubnetsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("delete-complete"), - [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), - [&](const Model::SecondarySubnet& item) { - return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == - expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("delete-failed"), - [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), - [&](const Model::SecondarySubnet& item) { - return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == - expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeSecondarySubnetsRequest& req) { - return static_cast(this)->DescribeSecondarySubnets(req); - }; - Aws::Utils::Waiter waiter( - 10, 12, acceptors, operation, "WaitUntilSecondarySubnetDeleteComplete"); + using OutcomeT = Model::DescribeSecondarySubnetsOutcome; + using RequestT = Model::DescribeSecondarySubnetsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SecondarySubnetDeleteCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("delete-complete"), + [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), [&](const Model::SecondarySubnet& item) { + return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SecondarySubnetDeleteCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("delete-failed"), + [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSecondarySubnets().begin(), result.GetSecondarySubnets().end(), [&](const Model::SecondarySubnet& item) { + return Model::SecondarySubnetStateMapper::GetNameForSecondarySubnetState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeSecondarySubnets(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilSecondarySubnetDeleteComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSecurityGroupExists( const Model::DescribeSecurityGroupsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeSecurityGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetSecurityGroups().size() > 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidGroup.NotFound")}); - - auto operation = [this](const Model::DescribeSecurityGroupsRequest& req) { - return static_cast(this)->DescribeSecurityGroups(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilSecurityGroupExists"); + using OutcomeT = Model::DescribeSecurityGroupsOutcome; + using RequestT = Model::DescribeSecurityGroupsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SecurityGroupExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeSecurityGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetSecurityGroups().size() > 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("SecurityGroupExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InvalidGroup.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeSecurityGroups(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilSecurityGroupExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSecurityGroupVpcAssociationAssociated( const Model::DescribeSecurityGroupVpcAssociationsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("associated"), - [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), - [&](const Model::SecurityGroupVpcAssociation& item) { - return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( - item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("associating"), - [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), - [&](const Model::SecurityGroupVpcAssociation& item) { - return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( - item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("association-failed"), - [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), - [&](const Model::SecurityGroupVpcAssociation& item) { - return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( - item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeSecurityGroupVpcAssociationsRequest& req) { - return static_cast(this)->DescribeSecurityGroupVpcAssociations(req); - }; - Aws::Utils::Waiter waiter( - 10, 12, acceptors, operation, "WaitUntilSecurityGroupVpcAssociationAssociated"); + using OutcomeT = Model::DescribeSecurityGroupVpcAssociationsOutcome; + using RequestT = Model::DescribeSecurityGroupVpcAssociationsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SecurityGroupVpcAssociationAssociatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("associated"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SecurityGroupVpcAssociationAssociatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("associating"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SecurityGroupVpcAssociationAssociatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("association-failed"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeSecurityGroupVpcAssociations(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, + "WaitUntilSecurityGroupVpcAssociationAssociated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSecurityGroupVpcAssociationDisassociated( const Model::DescribeSecurityGroupVpcAssociationsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("disassociated"), - [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), - [&](const Model::SecurityGroupVpcAssociation& item) { - return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( - item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("disassociating"), - [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), - [&](const Model::SecurityGroupVpcAssociation& item) { - return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( - item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("disassociation-failed"), - [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), - [&](const Model::SecurityGroupVpcAssociation& item) { - return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( - item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetSecurityGroupVpcAssociations().size() == 0) == expected.get(); - }}); - - auto operation = [this](const Model::DescribeSecurityGroupVpcAssociationsRequest& req) { - return static_cast(this)->DescribeSecurityGroupVpcAssociations(req); - }; - Aws::Utils::Waiter waiter( - 10, 12, acceptors, operation, "WaitUntilSecurityGroupVpcAssociationDisassociated"); + using OutcomeT = Model::DescribeSecurityGroupVpcAssociationsOutcome; + using RequestT = Model::DescribeSecurityGroupVpcAssociationsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SecurityGroupVpcAssociationDisassociatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("disassociated"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SecurityGroupVpcAssociationDisassociatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("disassociating"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SecurityGroupVpcAssociationDisassociatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("disassociation-failed"), + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSecurityGroupVpcAssociations().begin(), result.GetSecurityGroupVpcAssociations().end(), + [&](const Model::SecurityGroupVpcAssociation& item) { + return Model::SecurityGroupVpcAssociationStateMapper::GetNameForSecurityGroupVpcAssociationState( + item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SecurityGroupVpcAssociationDisassociatedWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetSecurityGroupVpcAssociations().size() == 0) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeSecurityGroupVpcAssociations(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, + "WaitUntilSecurityGroupVpcAssociationDisassociated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSnapshotCompleted(const Model::DescribeSnapshotsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), - [](const Model::DescribeSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), [&](const Model::Snapshot& item) { - return Model::SnapshotStateMapper::GetNameForSnapshotState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("error"), - [](const Model::DescribeSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), [&](const Model::Snapshot& item) { - return Model::SnapshotStateMapper::GetNameForSnapshotState(item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeSnapshotsRequest& req) { - return static_cast(this)->DescribeSnapshots(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilSnapshotCompleted"); + using OutcomeT = Model::DescribeSnapshotsOutcome; + using RequestT = Model::DescribeSnapshotsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SnapshotCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), + [](const Model::DescribeSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), [&](const Model::Snapshot& item) { + return Model::SnapshotStateMapper::GetNameForSnapshotState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SnapshotCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("error"), + [](const Model::DescribeSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), [&](const Model::Snapshot& item) { + return Model::SnapshotStateMapper::GetNameForSnapshotState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeSnapshots(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilSnapshotCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSpotInstanceRequestFulfilled( const Model::DescribeSpotInstanceRequestsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("fulfilled"), - [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), - [&](const Model::SpotInstanceRequest& item) { - return item.GetStatus().GetCode() == expected.get(); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("request-canceled-and-instance-running"), - [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), - [&](const Model::SpotInstanceRequest& item) { return item.GetStatus().GetCode() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("schedule-expired"), - [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), - [&](const Model::SpotInstanceRequest& item) { - return item.GetStatus().GetCode() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("canceled-before-fulfillment"), - [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), - [&](const Model::SpotInstanceRequest& item) { - return item.GetStatus().GetCode() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("bad-parameters"), - [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), - [&](const Model::SpotInstanceRequest& item) { - return item.GetStatus().GetCode() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("system-error"), - [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), - [&](const Model::SpotInstanceRequest& item) { - return item.GetStatus().GetCode() == expected.get(); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidSpotInstanceRequestID.NotFound")}); - - auto operation = [this](const Model::DescribeSpotInstanceRequestsRequest& req) { - return static_cast(this)->DescribeSpotInstanceRequests(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilSpotInstanceRequestFulfilled"); + using OutcomeT = Model::DescribeSpotInstanceRequestsOutcome; + using RequestT = Model::DescribeSpotInstanceRequestsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SpotInstanceRequestFulfilledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("fulfilled"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { return item.GetStatus().GetCode() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SpotInstanceRequestFulfilledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("request-canceled-and-instance-running"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { return item.GetStatus().GetCode() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SpotInstanceRequestFulfilledWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("schedule-expired"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { return item.GetStatus().GetCode() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SpotInstanceRequestFulfilledWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("canceled-before-fulfillment"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { return item.GetStatus().GetCode() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SpotInstanceRequestFulfilledWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("bad-parameters"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { return item.GetStatus().GetCode() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SpotInstanceRequestFulfilledWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("system-error"), + [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetSpotInstanceRequests().begin(), result.GetSpotInstanceRequests().end(), + [&](const Model::SpotInstanceRequest& item) { return item.GetStatus().GetCode() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SpotInstanceRequestFulfilledWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InvalidSpotInstanceRequestID.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeSpotInstanceRequests(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilSpotInstanceRequestFulfilled"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStoreImageTaskComplete( const Model::DescribeStoreImageTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), - [](const Model::DescribeStoreImageTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetStoreImageTaskResults().begin(), result.GetStoreImageTaskResults().end(), - [&](const Model::StoreImageTaskResponse& item) { - return item.GetStoreTaskState() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeStoreImageTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStoreImageTaskResults().begin(), result.GetStoreImageTaskResults().end(), - [&](const Model::StoreImageTaskResponse& item) { - return item.GetStoreTaskState() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("InProgress"), - [](const Model::DescribeStoreImageTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetStoreImageTaskResults().begin(), result.GetStoreImageTaskResults().end(), - [&](const Model::StoreImageTaskResponse& item) { - return item.GetStoreTaskState() == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeStoreImageTasksRequest& req) { - return static_cast(this)->DescribeStoreImageTasks(req); - }; - Aws::Utils::Waiter waiter( - 5, 24, acceptors, operation, "WaitUntilStoreImageTaskComplete"); + using OutcomeT = Model::DescribeStoreImageTasksOutcome; + using RequestT = Model::DescribeStoreImageTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StoreImageTaskCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), + [](const Model::DescribeStoreImageTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetStoreImageTaskResults().begin(), result.GetStoreImageTaskResults().end(), + [&](const Model::StoreImageTaskResponse& item) { return item.GetStoreTaskState() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StoreImageTaskCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeStoreImageTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetStoreImageTaskResults().begin(), result.GetStoreImageTaskResults().end(), + [&](const Model::StoreImageTaskResponse& item) { return item.GetStoreTaskState() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StoreImageTaskCompleteWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InProgress"), + [](const Model::DescribeStoreImageTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of( + result.GetStoreImageTaskResults().begin(), result.GetStoreImageTaskResults().end(), + [&](const Model::StoreImageTaskResponse& item) { return item.GetStoreTaskState() == expected.get(); }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStoreImageTasks(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilStoreImageTaskComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSubnetAvailable(const Model::DescribeSubnetsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeSubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetSubnets().begin(), result.GetSubnets().end(), [&](const Model::Subnet& item) { - return Model::SubnetStateMapper::GetNameForSubnetState(item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeSubnetsRequest& req) { return static_cast(this)->DescribeSubnets(req); }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilSubnetAvailable"); + using OutcomeT = Model::DescribeSubnetsOutcome; + using RequestT = Model::DescribeSubnetsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SubnetAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeSubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSubnets().begin(), result.GetSubnets().end(), [&](const Model::Subnet& item) { + return Model::SubnetStateMapper::GetNameForSubnetState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeSubnets(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilSubnetAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVolumeAvailable(const Model::DescribeVolumesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { - return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { - return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeVolumesRequest& req) { return static_cast(this)->DescribeVolumes(req); }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilVolumeAvailable"); + using OutcomeT = Model::DescribeVolumesOutcome; + using RequestT = Model::DescribeVolumesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "VolumeAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { + return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VolumeAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { + return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeVolumes(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilVolumeAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVolumeDeleted(const Model::DescribeVolumesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { - return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidVolume.NotFound")}); - - auto operation = [this](const Model::DescribeVolumesRequest& req) { return static_cast(this)->DescribeVolumes(req); }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilVolumeDeleted"); + using OutcomeT = Model::DescribeVolumesOutcome; + using RequestT = Model::DescribeVolumesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "VolumeDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), + [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { + return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>("VolumeDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("InvalidVolume.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeVolumes(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilVolumeDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVolumeInUse(const Model::DescribeVolumesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("in-use"), - [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { - return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { - return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeVolumesRequest& req) { return static_cast(this)->DescribeVolumes(req); }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilVolumeInUse"); + using OutcomeT = Model::DescribeVolumesOutcome; + using RequestT = Model::DescribeVolumesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "VolumeInUseWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("in-use"), + [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { + return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VolumeInUseWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetVolumes().begin(), result.GetVolumes().end(), [&](const Model::Volume& item) { + return Model::VolumeStateMapper::GetNameForVolumeState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeVolumes(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilVolumeInUse"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVpcPeeringConnectionDeleted( const Model::DescribeVpcPeeringConnectionsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeVpcPeeringConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetVpcPeeringConnections().begin(), result.GetVpcPeeringConnections().end(), - [&](const Model::VpcPeeringConnection& item) { - return Model::VpcPeeringConnectionStateReasonCodeMapper::GetNameForVpcPeeringConnectionStateReasonCode( - item.GetStatus().GetCode()) == expected.get(); - }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidVpcPeeringConnectionID.NotFound")}); - - auto operation = [this](const Model::DescribeVpcPeeringConnectionsRequest& req) { - return static_cast(this)->DescribeVpcPeeringConnections(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilVpcPeeringConnectionDeleted"); + using OutcomeT = Model::DescribeVpcPeeringConnectionsOutcome; + using RequestT = Model::DescribeVpcPeeringConnectionsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "VpcPeeringConnectionDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), + [](const Model::DescribeVpcPeeringConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVpcPeeringConnections().begin(), result.GetVpcPeeringConnections().end(), + [&](const Model::VpcPeeringConnection& item) { + return Model::VpcPeeringConnectionStateReasonCodeMapper::GetNameForVpcPeeringConnectionStateReasonCode( + item.GetStatus().GetCode()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VpcPeeringConnectionDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InvalidVpcPeeringConnectionID.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeVpcPeeringConnections(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilVpcPeeringConnectionDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVpcPeeringConnectionExists( const Model::DescribeVpcPeeringConnectionsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back( - {Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidVpcPeeringConnectionID.NotFound")}); - - auto operation = [this](const Model::DescribeVpcPeeringConnectionsRequest& req) { - return static_cast(this)->DescribeVpcPeeringConnections(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilVpcPeeringConnectionExists"); + using OutcomeT = Model::DescribeVpcPeeringConnectionsOutcome; + using RequestT = Model::DescribeVpcPeeringConnectionsRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("VpcPeeringConnectionExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>( + "VpcPeeringConnectionExistsWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InvalidVpcPeeringConnectionID.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeVpcPeeringConnections(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilVpcPeeringConnectionExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVpcAvailable(const Model::DescribeVpcsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeVpcsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetVpcs().begin(), result.GetVpcs().end(), [&](const Model::Vpc& item) { - return Model::VpcStateMapper::GetNameForVpcState(item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeVpcsRequest& req) { return static_cast(this)->DescribeVpcs(req); }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, "WaitUntilVpcAvailable"); + using OutcomeT = Model::DescribeVpcsOutcome; + using RequestT = Model::DescribeVpcsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "VpcAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeVpcsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVpcs().begin(), result.GetVpcs().end(), [&](const Model::Vpc& item) { + return Model::VpcStateMapper::GetNameForVpcState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeVpcs(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilVpcAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVpcExists(const Model::DescribeVpcsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidVpcID.NotFound")}); - - auto operation = [this](const Model::DescribeVpcsRequest& req) { return static_cast(this)->DescribeVpcs(req); }; - Aws::Utils::Waiter waiter(1, 120, acceptors, operation, "WaitUntilVpcExists"); + using OutcomeT = Model::DescribeVpcsOutcome; + using RequestT = Model::DescribeVpcsRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("VpcExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>("VpcExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InvalidVpcID.NotFound"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeVpcs(req); }; + Aws::Utils::Waiter waiter(1, 120, std::move(acceptors), operation, "WaitUntilVpcExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVpnConnectionAvailable( const Model::DescribeVpnConnectionsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { - return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { - return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { - return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeVpnConnectionsRequest& req) { - return static_cast(this)->DescribeVpnConnections(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilVpnConnectionAvailable"); + using OutcomeT = Model::DescribeVpnConnectionsOutcome; + using RequestT = Model::DescribeVpnConnectionsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "VpnConnectionAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { + return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VpnConnectionAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { + return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VpnConnectionAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { + return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeVpnConnections(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilVpnConnectionAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVpnConnectionDeleted( const Model::DescribeVpnConnectionsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { - return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("pending"), - [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { - return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); - }); - }}); - - auto operation = [this](const Model::DescribeVpnConnectionsRequest& req) { - return static_cast(this)->DescribeVpnConnections(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilVpnConnectionDeleted"); + using OutcomeT = Model::DescribeVpnConnectionsOutcome; + using RequestT = Model::DescribeVpnConnectionsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "VpnConnectionDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), + [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { + return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VpnConnectionDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("pending"), + [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetVpnConnections().begin(), result.GetVpnConnections().end(), [&](const Model::VpnConnection& item) { + return Model::VpnStateMapper::GetNameForVpnState(item.GetState()) == expected.get(); + }); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeVpnConnections(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilVpnConnectionDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPasswordDataAvailable(const Model::GetPasswordDataRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::GetPasswordDataOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetPasswordData().size() > 0) == expected.get(); - }}); - - auto operation = [this](const Model::GetPasswordDataRequest& req) { return static_cast(this)->GetPasswordData(req); }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilPasswordDataAvailable"); + using OutcomeT = Model::GetPasswordDataOutcome; + using RequestT = Model::GetPasswordDataRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "PasswordDataAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::GetPasswordDataOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetPasswordData().size() > 0) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetPasswordData(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilPasswordDataAvailable"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-ecr-public/include/aws/ecr-public/ECRPublicWaiter.h b/generated/src/aws-cpp-sdk-ecr-public/include/aws/ecr-public/ECRPublicWaiter.h new file mode 100644 index 00000000000..f8fd3c52053 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ecr-public/include/aws/ecr-public/ECRPublicWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ECRPublic { + +template +class ECRPublicWaiter { + public: +}; +} // namespace ECRPublic +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h b/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h index 714f57d6621..4aa983567fb 100644 --- a/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h +++ b/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -23,53 +24,53 @@ class ECRWaiter { public: Aws::Utils::WaiterOutcome WaitUntilImageScanComplete( const Model::DescribeImageScanFindingsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETE"), - [](const Model::DescribeImageScanFindingsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ScanStatusMapper::GetNameForScanStatus(result.GetImageScanStatus().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeImageScanFindingsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ScanStatusMapper::GetNameForScanStatus(result.GetImageScanStatus().GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeImageScanFindingsOutcome; + using RequestT = Model::DescribeImageScanFindingsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ImageScanCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETE"), + [](const Model::DescribeImageScanFindingsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ScanStatusMapper::GetNameForScanStatus(result.GetImageScanStatus().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImageScanCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeImageScanFindingsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ScanStatusMapper::GetNameForScanStatus(result.GetImageScanStatus().GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeImageScanFindingsRequest& req) { - return static_cast(this)->DescribeImageScanFindings(req); - }; - Aws::Utils::Waiter waiter( - 5, 24, acceptors, operation, "WaitUntilImageScanComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImageScanFindings(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilImageScanComplete"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilLifecyclePolicyPreviewComplete( const Model::GetLifecyclePolicyPreviewRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETE"), - [](const Model::GetLifecyclePolicyPreviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LifecyclePolicyPreviewStatusMapper::GetNameForLifecyclePolicyPreviewStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetLifecyclePolicyPreviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LifecyclePolicyPreviewStatusMapper::GetNameForLifecyclePolicyPreviewStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetLifecyclePolicyPreviewOutcome; + using RequestT = Model::GetLifecyclePolicyPreviewRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "LifecyclePolicyPreviewCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETE"), + [](const Model::GetLifecyclePolicyPreviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LifecyclePolicyPreviewStatusMapper::GetNameForLifecyclePolicyPreviewStatus(result.GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LifecyclePolicyPreviewCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetLifecyclePolicyPreviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LifecyclePolicyPreviewStatusMapper::GetNameForLifecyclePolicyPreviewStatus(result.GetStatus()) == + expected.get(); + })); - auto operation = [this](const Model::GetLifecyclePolicyPreviewRequest& req) { - return static_cast(this)->GetLifecyclePolicyPreview(req); - }; - Aws::Utils::Waiter waiter( - 5, 24, acceptors, operation, "WaitUntilLifecyclePolicyPreviewComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetLifecyclePolicyPreview(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilLifecyclePolicyPreviewComplete"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h b/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h index 82c7823d2ac..724287bc881 100644 --- a/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h +++ b/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,109 +21,123 @@ template class ECSWaiter { public: Aws::Utils::WaiterOutcome WaitUntilServicesInactive(const Model::DescribeServicesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("MISSING"), - [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetFailures().begin(), result.GetFailures().end(), - [&](const Model::Failure& item) { return item.GetReason() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("INACTIVE"), - [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetServices().begin(), result.GetServices().end(), - [&](const Model::Service& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeServicesOutcome; + using RequestT = Model::DescribeServicesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ServicesInactiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("MISSING"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFailures().begin(), result.GetFailures().end(), + [&](const Model::Failure& item) { return item.GetReason() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServicesInactiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("INACTIVE"), + [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetServices().begin(), result.GetServices().end(), + [&](const Model::Service& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeServicesRequest& req) { return static_cast(this)->DescribeServices(req); }; - Aws::Utils::Waiter waiter(15, 40, acceptors, operation, - "WaitUntilServicesInactive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeServices(req); }; + Aws::Utils::Waiter waiter(15, 40, std::move(acceptors), operation, "WaitUntilServicesInactive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilServicesStable(const Model::DescribeServicesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("MISSING"), - [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetFailures().begin(), result.GetFailures().end(), - [&](const Model::Failure& item) { return item.GetReason() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DRAINING"), - [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetServices().begin(), result.GetServices().end(), - [&](const Model::Service& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("INACTIVE"), - [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetServices().begin(), result.GetServices().end(), - [&](const Model::Service& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (std::count_if(result.GetServices().begin(), result.GetServices().end(), [](const Model::Service& item) { - return !((item.GetDeployments().size() == 1) && (item.GetRunningCount() == item.GetDesiredCount())); - }) == 0) == expected.get(); - }}); + using OutcomeT = Model::DescribeServicesOutcome; + using RequestT = Model::DescribeServicesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ServicesStableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("MISSING"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFailures().begin(), result.GetFailures().end(), + [&](const Model::Failure& item) { return item.GetReason() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServicesStableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DRAINING"), + [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetServices().begin(), result.GetServices().end(), + [&](const Model::Service& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServicesStableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("INACTIVE"), + [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetServices().begin(), result.GetServices().end(), + [&](const Model::Service& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServicesStableWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeServicesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (std::count_if(result.GetServices().begin(), result.GetServices().end(), [](const Model::Service& item) { + return !((item.GetDeployments().size() == 1) && (item.GetRunningCount() == item.GetDesiredCount())); + }) == 0) == expected.get(); + })); - auto operation = [this](const Model::DescribeServicesRequest& req) { return static_cast(this)->DescribeServices(req); }; - Aws::Utils::Waiter waiter(15, 40, acceptors, operation, - "WaitUntilServicesStable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeServices(req); }; + Aws::Utils::Waiter waiter(15, 40, std::move(acceptors), operation, "WaitUntilServicesStable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTasksRunning(const Model::DescribeTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), - [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetTasks().begin(), result.GetTasks().end(), - [&](const Model::Task& item) { return item.GetLastStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("MISSING"), - [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetFailures().begin(), result.GetFailures().end(), - [&](const Model::Failure& item) { return item.GetReason() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), - [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetTasks().begin(), result.GetTasks().end(), - [&](const Model::Task& item) { return item.GetLastStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeTasksOutcome; + using RequestT = Model::DescribeTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TasksRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("STOPPED"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetTasks().begin(), result.GetTasks().end(), + [&](const Model::Task& item) { return item.GetLastStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TasksRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("MISSING"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetFailures().begin(), result.GetFailures().end(), + [&](const Model::Failure& item) { return item.GetReason() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TasksRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetTasks().begin(), result.GetTasks().end(), + [&](const Model::Task& item) { return item.GetLastStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeTasksRequest& req) { return static_cast(this)->DescribeTasks(req); }; - Aws::Utils::Waiter waiter(6, 100, acceptors, operation, - "WaitUntilTasksRunning"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeTasks(req); }; + Aws::Utils::Waiter waiter(6, 100, std::move(acceptors), operation, "WaitUntilTasksRunning"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTasksStopped(const Model::DescribeTasksRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), - [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetTasks().begin(), result.GetTasks().end(), - [&](const Model::Task& item) { return item.GetLastStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeTasksOutcome; + using RequestT = Model::DescribeTasksRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TasksStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"), + [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetTasks().begin(), result.GetTasks().end(), + [&](const Model::Task& item) { return item.GetLastStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeTasksRequest& req) { return static_cast(this)->DescribeTasks(req); }; - Aws::Utils::Waiter waiter(6, 100, acceptors, operation, - "WaitUntilTasksStopped"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeTasks(req); }; + Aws::Utils::Waiter waiter(6, 100, std::move(acceptors), operation, "WaitUntilTasksStopped"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-eks-auth/include/aws/eks-auth/EKSAuthWaiter.h b/generated/src/aws-cpp-sdk-eks-auth/include/aws/eks-auth/EKSAuthWaiter.h new file mode 100644 index 00000000000..6a6af7734fb --- /dev/null +++ b/generated/src/aws-cpp-sdk-eks-auth/include/aws/eks-auth/EKSAuthWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace EKSAuth { + +template +class EKSAuthWaiter { + public: +}; +} // namespace EKSAuth +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h b/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h index 98b64e430d3..91817e7dead 100644 --- a/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h +++ b/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -28,200 +29,207 @@ template class EKSWaiter { public: Aws::Utils::WaiterOutcome WaitUntilAddonActive(const Model::DescribeAddonRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DEGRADED"), - [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == - expected.get(); - }}); - - auto operation = [this](const Model::DescribeAddonRequest& req) { return static_cast(this)->DescribeAddon(req); }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilAddonActive"); + using OutcomeT = Model::DescribeAddonOutcome; + using RequestT = Model::DescribeAddonRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AddonActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AddonActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DEGRADED"), + [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AddonActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAddon(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilAddonActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilAddonDeleted(const Model::DescribeAddonRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - - auto operation = [this](const Model::DescribeAddonRequest& req) { return static_cast(this)->DescribeAddon(req); }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilAddonDeleted"); + using OutcomeT = Model::DescribeAddonOutcome; + using RequestT = Model::DescribeAddonRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AddonDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AddonStatusMapper::GetNameForAddonStatus(result.GetAddon().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("AddonDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAddon(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilAddonDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilClusterActive(const Model::DescribeClusterRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == - expected.get(); - }}); - - auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilClusterActive"); + using OutcomeT = Model::DescribeClusterOutcome; + using RequestT = Model::DescribeClusterRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilClusterActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClusterRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - - auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilClusterDeleted"); + using OutcomeT = Model::DescribeClusterOutcome; + using RequestT = Model::DescribeClusterRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ACTIVE"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("PENDING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStatusMapper::GetNameForClusterStatus(result.GetCluster().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilClusterDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFargateProfileActive( const Model::DescribeFargateProfileRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeFargateProfileOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::FargateProfileStatusMapper::GetNameForFargateProfileStatus( - result.GetFargateProfile().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeFargateProfileOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::FargateProfileStatusMapper::GetNameForFargateProfileStatus( - result.GetFargateProfile().GetStatus()) == expected.get(); - }}); - - auto operation = [this](const Model::DescribeFargateProfileRequest& req) { - return static_cast(this)->DescribeFargateProfile(req); - }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilFargateProfileActive"); + using OutcomeT = Model::DescribeFargateProfileOutcome; + using RequestT = Model::DescribeFargateProfileRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FargateProfileActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeFargateProfileOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FargateProfileStatusMapper::GetNameForFargateProfileStatus(result.GetFargateProfile().GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FargateProfileActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeFargateProfileOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FargateProfileStatusMapper::GetNameForFargateProfileStatus(result.GetFargateProfile().GetStatus()) == + expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeFargateProfile(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilFargateProfileActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFargateProfileDeleted( const Model::DescribeFargateProfileRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::DescribeFargateProfileOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::FargateProfileStatusMapper::GetNameForFargateProfileStatus( - result.GetFargateProfile().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - - auto operation = [this](const Model::DescribeFargateProfileRequest& req) { - return static_cast(this)->DescribeFargateProfile(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilFargateProfileDeleted"); + using OutcomeT = Model::DescribeFargateProfileOutcome; + using RequestT = Model::DescribeFargateProfileRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FargateProfileDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::DescribeFargateProfileOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FargateProfileStatusMapper::GetNameForFargateProfileStatus(result.GetFargateProfile().GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FargateProfileDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeFargateProfile(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilFargateProfileDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilNodegroupActive(const Model::DescribeNodegroupRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeNodegroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NodegroupStatusMapper::GetNameForNodegroupStatus(result.GetNodegroup().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeNodegroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NodegroupStatusMapper::GetNameForNodegroupStatus(result.GetNodegroup().GetStatus()) == - expected.get(); - }}); - - auto operation = [this](const Model::DescribeNodegroupRequest& req) { - return static_cast(this)->DescribeNodegroup(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilNodegroupActive"); + using OutcomeT = Model::DescribeNodegroupOutcome; + using RequestT = Model::DescribeNodegroupRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "NodegroupActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeNodegroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodegroupStatusMapper::GetNameForNodegroupStatus(result.GetNodegroup().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "NodegroupActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeNodegroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodegroupStatusMapper::GetNameForNodegroupStatus(result.GetNodegroup().GetStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeNodegroup(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilNodegroupActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilNodegroupDeleted(const Model::DescribeNodegroupRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::DescribeNodegroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NodegroupStatusMapper::GetNameForNodegroupStatus(result.GetNodegroup().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - - auto operation = [this](const Model::DescribeNodegroupRequest& req) { - return static_cast(this)->DescribeNodegroup(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilNodegroupDeleted"); + using OutcomeT = Model::DescribeNodegroupOutcome; + using RequestT = Model::DescribeNodegroupRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "NodegroupDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::DescribeNodegroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodegroupStatusMapper::GetNameForNodegroupStatus(result.GetNodegroup().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("NodegroupDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeNodegroup(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilNodegroupDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h b/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h index 89a35f1d6ff..9895a82ef24 100644 --- a/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h +++ b/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -21,179 +22,177 @@ class ElastiCacheWaiter { public: Aws::Utils::WaiterOutcome WaitUntilCacheClusterAvailable( const Model::DescribeCacheClustersRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-network"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("restore-failed"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeCacheClustersOutcome; + using RequestT = Model::DescribeCacheClustersRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-network"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("restore-failed"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeCacheClustersRequest& req) { - return static_cast(this)->DescribeCacheClusters(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilCacheClusterAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCacheClusters(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilCacheClusterAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilCacheClusterDeleted( const Model::DescribeCacheClustersRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("CacheClusterNotFound")}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-network"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("restore-failed"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); - acceptors.push_back( - {Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("snapshotting"), - [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), - [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeCacheClustersOutcome; + using RequestT = Model::DescribeCacheClustersRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CacheClusterNotFound"))); + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("available"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-network"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("restore-failed"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CacheClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("snapshotting"), + [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetCacheClusters().begin(), result.GetCacheClusters().end(), + [&](const Model::CacheCluster& item) { return item.GetCacheClusterStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeCacheClustersRequest& req) { - return static_cast(this)->DescribeCacheClusters(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilCacheClusterDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCacheClusters(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilCacheClusterDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReplicationGroupAvailable( const Model::DescribeReplicationGroupsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), - [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), - [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeReplicationGroupsOutcome; + using RequestT = Model::DescribeReplicationGroupsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationGroupAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), + [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationGroupAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), + [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeReplicationGroupsRequest& req) { - return static_cast(this)->DescribeReplicationGroups(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilReplicationGroupAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeReplicationGroups(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationGroupAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReplicationGroupDeleted( const Model::DescribeReplicationGroupsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), - [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), - [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ReplicationGroupNotFoundFault")}); + using OutcomeT = Model::DescribeReplicationGroupsOutcome; + using RequestT = Model::DescribeReplicationGroupsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationGroupDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), + [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), + [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationGroupDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("available"), + [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetReplicationGroups().begin(), result.GetReplicationGroups().end(), + [&](const Model::ReplicationGroup& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReplicationGroupDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ReplicationGroupNotFoundFault"))); - auto operation = [this](const Model::DescribeReplicationGroupsRequest& req) { - return static_cast(this)->DescribeReplicationGroups(req); - }; - Aws::Utils::Waiter waiter( - 15, 8, acceptors, operation, "WaitUntilReplicationGroupDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeReplicationGroups(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilReplicationGroupDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h b/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h index a36fedc4ae5..3d99aea503a 100644 --- a/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h +++ b/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,97 +21,94 @@ class ElasticBeanstalkWaiter { public: Aws::Utils::WaiterOutcome WaitUntilEnvironmentExists( const Model::DescribeEnvironmentsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Ready"), - [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), - [&](const Model::EnvironmentDescription& item) { - return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == - expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Launching"), - [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), - [&](const Model::EnvironmentDescription& item) { - return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == - expected.get(); - }); - }}); + using OutcomeT = Model::DescribeEnvironmentsOutcome; + using RequestT = Model::DescribeEnvironmentsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Ready"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetEnvironments().begin(), result.GetEnvironments().end(), [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentExistsWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("Launching"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetEnvironments().begin(), result.GetEnvironments().end(), [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == expected.get(); + }); + })); - auto operation = [this](const Model::DescribeEnvironmentsRequest& req) { - return static_cast(this)->DescribeEnvironments(req); - }; - Aws::Utils::Waiter waiter(20, 6, acceptors, operation, - "WaitUntilEnvironmentExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeEnvironments(req); }; + Aws::Utils::Waiter waiter(20, 6, std::move(acceptors), operation, "WaitUntilEnvironmentExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilEnvironmentTerminated( const Model::DescribeEnvironmentsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Terminated"), - [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), - [&](const Model::EnvironmentDescription& item) { - return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == - expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Terminating"), - [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), - [&](const Model::EnvironmentDescription& item) { - return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == - expected.get(); - }); - }}); + using OutcomeT = Model::DescribeEnvironmentsOutcome; + using RequestT = Model::DescribeEnvironmentsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentTerminatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Terminated"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetEnvironments().begin(), result.GetEnvironments().end(), [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentTerminatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("Terminating"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetEnvironments().begin(), result.GetEnvironments().end(), [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == expected.get(); + }); + })); - auto operation = [this](const Model::DescribeEnvironmentsRequest& req) { - return static_cast(this)->DescribeEnvironments(req); - }; - Aws::Utils::Waiter waiter(20, 6, acceptors, operation, - "WaitUntilEnvironmentTerminated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeEnvironments(req); }; + Aws::Utils::Waiter waiter(20, 6, std::move(acceptors), operation, "WaitUntilEnvironmentTerminated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilEnvironmentUpdated( const Model::DescribeEnvironmentsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Ready"), - [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), - [&](const Model::EnvironmentDescription& item) { - return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == - expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Updating"), - [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetEnvironments().begin(), result.GetEnvironments().end(), - [&](const Model::EnvironmentDescription& item) { - return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == - expected.get(); - }); - }}); + using OutcomeT = Model::DescribeEnvironmentsOutcome; + using RequestT = Model::DescribeEnvironmentsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Ready"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetEnvironments().begin(), result.GetEnvironments().end(), [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentUpdatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("Updating"), + [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of( + result.GetEnvironments().begin(), result.GetEnvironments().end(), [&](const Model::EnvironmentDescription& item) { + return Model::EnvironmentStatusMapper::GetNameForEnvironmentStatus(item.GetStatus()) == expected.get(); + }); + })); - auto operation = [this](const Model::DescribeEnvironmentsRequest& req) { - return static_cast(this)->DescribeEnvironments(req); - }; - Aws::Utils::Waiter waiter(20, 6, acceptors, operation, - "WaitUntilEnvironmentUpdated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeEnvironments(req); }; + Aws::Utils::Waiter waiter(20, 6, std::move(acceptors), operation, "WaitUntilEnvironmentUpdated"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-elasticfilesystem/include/aws/elasticfilesystem/EFSWaiter.h b/generated/src/aws-cpp-sdk-elasticfilesystem/include/aws/elasticfilesystem/EFSWaiter.h new file mode 100644 index 00000000000..b63722847c6 --- /dev/null +++ b/generated/src/aws-cpp-sdk-elasticfilesystem/include/aws/elasticfilesystem/EFSWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace EFS { + +template +class EFSWaiter { + public: +}; +} // namespace EFS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h b/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h index d127584435a..8ff606a46db 100644 --- a/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h +++ b/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,63 +20,62 @@ class ElasticLoadBalancingWaiter { public: Aws::Utils::WaiterOutcome WaitUntilAnyInstanceInService( const Model::DescribeInstanceHealthRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("InService"), - [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetInstanceStates().begin(), result.GetInstanceStates().end(), - [&](const Model::InstanceState& item) { return item.GetState() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeInstanceHealthOutcome; + using RequestT = Model::DescribeInstanceHealthRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AnyInstanceInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InService"), + [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetInstanceStates().begin(), result.GetInstanceStates().end(), + [&](const Model::InstanceState& item) { return item.GetState() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeInstanceHealthRequest& req) { - return static_cast(this)->DescribeInstanceHealth(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilAnyInstanceInService"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInstanceHealth(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilAnyInstanceInService"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInstanceDeregistered( const Model::DescribeInstanceHealthRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("OutOfService"), - [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetInstanceStates().begin(), result.GetInstanceStates().end(), - [&](const Model::InstanceState& item) { return item.GetState() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstance")}); + using OutcomeT = Model::DescribeInstanceHealthOutcome; + using RequestT = Model::DescribeInstanceHealthRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceDeregisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("OutOfService"), + [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetInstanceStates().begin(), result.GetInstanceStates().end(), + [&](const Model::InstanceState& item) { return item.GetState() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceDeregisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InvalidInstance"))); - auto operation = [this](const Model::DescribeInstanceHealthRequest& req) { - return static_cast(this)->DescribeInstanceHealth(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilInstanceDeregistered"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInstanceHealth(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilInstanceDeregistered"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInstanceInService( const Model::DescribeInstanceHealthRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("InService"), - [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetInstanceStates().begin(), result.GetInstanceStates().end(), - [&](const Model::InstanceState& item) { return item.GetState() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstance")}); + using OutcomeT = Model::DescribeInstanceHealthOutcome; + using RequestT = Model::DescribeInstanceHealthRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InService"), + [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetInstanceStates().begin(), result.GetInstanceStates().end(), + [&](const Model::InstanceState& item) { return item.GetState() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>("InstanceInServiceWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InvalidInstance"))); - auto operation = [this](const Model::DescribeInstanceHealthRequest& req) { - return static_cast(this)->DescribeInstanceHealth(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilInstanceInService"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInstanceHealth(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilInstanceInService"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h b/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h index 86320ef300c..46dcc1bee15 100644 --- a/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h +++ b/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -23,117 +24,120 @@ class ElasticLoadBalancingv2Waiter { public: Aws::Utils::WaiterOutcome WaitUntilLoadBalancerAvailable( const Model::DescribeLoadBalancersRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("active"), - [](const Model::DescribeLoadBalancersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetLoadBalancers().begin(), result.GetLoadBalancers().end(), [&](const Model::LoadBalancer& item) { - return Model::LoadBalancerStateEnumMapper::GetNameForLoadBalancerStateEnum(item.GetState().GetCode()) == - expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("provisioning"), - [](const Model::DescribeLoadBalancersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetLoadBalancers().begin(), result.GetLoadBalancers().end(), [&](const Model::LoadBalancer& item) { - return Model::LoadBalancerStateEnumMapper::GetNameForLoadBalancerStateEnum(item.GetState().GetCode()) == - expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("LoadBalancerNotFound")}); + using OutcomeT = Model::DescribeLoadBalancersOutcome; + using RequestT = Model::DescribeLoadBalancersRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "LoadBalancerAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("active"), + [](const Model::DescribeLoadBalancersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetLoadBalancers().begin(), result.GetLoadBalancers().end(), [&](const Model::LoadBalancer& item) { + return Model::LoadBalancerStateEnumMapper::GetNameForLoadBalancerStateEnum(item.GetState().GetCode()) == + expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LoadBalancerAvailableWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("provisioning"), + [](const Model::DescribeLoadBalancersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetLoadBalancers().begin(), result.GetLoadBalancers().end(), [&](const Model::LoadBalancer& item) { + return Model::LoadBalancerStateEnumMapper::GetNameForLoadBalancerStateEnum(item.GetState().GetCode()) == + expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LoadBalancerAvailableWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("LoadBalancerNotFound"))); - auto operation = [this](const Model::DescribeLoadBalancersRequest& req) { - return static_cast(this)->DescribeLoadBalancers(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilLoadBalancerAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeLoadBalancers(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilLoadBalancerAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilLoadBalancerExists( const Model::DescribeLoadBalancersRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("LoadBalancerNotFound")}); + using OutcomeT = Model::DescribeLoadBalancersOutcome; + using RequestT = Model::DescribeLoadBalancersRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("LoadBalancerExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>("LoadBalancerExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("LoadBalancerNotFound"))); - auto operation = [this](const Model::DescribeLoadBalancersRequest& req) { - return static_cast(this)->DescribeLoadBalancers(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilLoadBalancerExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeLoadBalancers(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilLoadBalancerExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilLoadBalancersDeleted( const Model::DescribeLoadBalancersRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("active"), - [](const Model::DescribeLoadBalancersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetLoadBalancers().begin(), result.GetLoadBalancers().end(), [&](const Model::LoadBalancer& item) { - return Model::LoadBalancerStateEnumMapper::GetNameForLoadBalancerStateEnum(item.GetState().GetCode()) == - expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("LoadBalancerNotFound")}); + using OutcomeT = Model::DescribeLoadBalancersOutcome; + using RequestT = Model::DescribeLoadBalancersRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "LoadBalancersDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("active"), + [](const Model::DescribeLoadBalancersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetLoadBalancers().begin(), result.GetLoadBalancers().end(), [&](const Model::LoadBalancer& item) { + return Model::LoadBalancerStateEnumMapper::GetNameForLoadBalancerStateEnum(item.GetState().GetCode()) == + expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LoadBalancersDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("LoadBalancerNotFound"))); - auto operation = [this](const Model::DescribeLoadBalancersRequest& req) { - return static_cast(this)->DescribeLoadBalancers(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilLoadBalancersDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeLoadBalancers(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilLoadBalancersDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTargetDeregistered( const Model::DescribeTargetHealthRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidTarget")}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("unused"), - [](const Model::DescribeTargetHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetTargetHealthDescriptions().begin(), result.GetTargetHealthDescriptions().end(), - [&](const Model::TargetHealthDescription& item) { - return Model::TargetHealthStateEnumMapper::GetNameForTargetHealthStateEnum( - item.GetTargetHealth().GetState()) == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeTargetHealthOutcome; + using RequestT = Model::DescribeTargetHealthRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TargetDeregisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InvalidTarget"))); + acceptors.emplace_back(Aws::MakeUnique>( + "TargetDeregisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("unused"), + [](const Model::DescribeTargetHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetTargetHealthDescriptions().begin(), result.GetTargetHealthDescriptions().end(), + [&](const Model::TargetHealthDescription& item) { + return Model::TargetHealthStateEnumMapper::GetNameForTargetHealthStateEnum( + item.GetTargetHealth().GetState()) == expected.get(); + }); + })); - auto operation = [this](const Model::DescribeTargetHealthRequest& req) { - return static_cast(this)->DescribeTargetHealth(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilTargetDeregistered"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeTargetHealth(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilTargetDeregistered"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTargetInService( const Model::DescribeTargetHealthRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("healthy"), - [](const Model::DescribeTargetHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetTargetHealthDescriptions().begin(), result.GetTargetHealthDescriptions().end(), - [&](const Model::TargetHealthDescription& item) { - return Model::TargetHealthStateEnumMapper::GetNameForTargetHealthStateEnum( - item.GetTargetHealth().GetState()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvalidInstance")}); + using OutcomeT = Model::DescribeTargetHealthOutcome; + using RequestT = Model::DescribeTargetHealthRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TargetInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("healthy"), + [](const Model::DescribeTargetHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetTargetHealthDescriptions().begin(), result.GetTargetHealthDescriptions().end(), + [&](const Model::TargetHealthDescription& item) { + return Model::TargetHealthStateEnumMapper::GetNameForTargetHealthStateEnum( + item.GetTargetHealth().GetState()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>("TargetInServiceWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InvalidInstance"))); - auto operation = [this](const Model::DescribeTargetHealthRequest& req) { - return static_cast(this)->DescribeTargetHealth(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilTargetInService"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeTargetHealth(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilTargetInService"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h b/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h index def18de2786..6971ac661ac 100644 --- a/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h +++ b/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -22,98 +23,109 @@ template class EMRWaiter { public: Aws::Utils::WaiterOutcome WaitUntilClusterRunning(const Model::DescribeClusterRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("WAITING"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TERMINATING"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TERMINATED"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TERMINATED_WITH_ERRORS"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeClusterOutcome; + using RequestT = Model::DescribeClusterRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("WAITING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("TERMINATING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("TERMINATED"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("TERMINATED_WITH_ERRORS"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilClusterRunning"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilClusterRunning"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilClusterTerminated(const Model::DescribeClusterRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("TERMINATED"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TERMINATED_WITH_ERRORS"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeClusterOutcome; + using RequestT = Model::DescribeClusterRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterTerminatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("TERMINATED"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterTerminatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("TERMINATED_WITH_ERRORS"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ClusterStateMapper::GetNameForClusterState(result.GetCluster().GetStatus().GetState()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilClusterTerminated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilClusterTerminated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStepComplete(const Model::DescribeStepRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::DescribeStepOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StepStateMapper::GetNameForStepState(result.GetStep().GetStatus().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeStepOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StepStateMapper::GetNameForStepState(result.GetStep().GetStatus().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::DescribeStepOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StepStateMapper::GetNameForStepState(result.GetStep().GetStatus().GetState()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeStepOutcome; + using RequestT = Model::DescribeStepRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StepCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::DescribeStepOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StepStateMapper::GetNameForStepState(result.GetStep().GetStatus().GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StepCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeStepOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StepStateMapper::GetNameForStepState(result.GetStep().GetStatus().GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StepCompleteWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), + [](const Model::DescribeStepOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StepStateMapper::GetNameForStepState(result.GetStep().GetStatus().GetState()) == expected.get(); + })); - auto operation = [this](const Model::DescribeStepRequest& req) { return static_cast(this)->DescribeStep(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, "WaitUntilStepComplete"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStep(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilStepComplete"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h b/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h index dfe8a036f90..10d2ebaee22 100644 --- a/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h +++ b/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,25 +20,32 @@ template class ElementalInferenceWaiter { public: Aws::Utils::WaiterOutcome WaitUntilFeedDeleted(const Model::GetFeedRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetFeedOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::FeedStatusMapper::GetNameForFeedStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetFeedOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::FeedStatusMapper::GetNameForFeedStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("TooManyRequestException")}); + using OutcomeT = Model::GetFeedOutcome; + using RequestT = Model::GetFeedRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("FeedDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "FeedDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::GetFeedOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FeedStatusMapper::GetNameForFeedStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FeedDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::GetFeedOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::FeedStatusMapper::GetNameForFeedStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("FeedDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("FeedDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("TooManyRequestException"))); - auto operation = [this](const Model::GetFeedRequest& req) { return static_cast(this)->GetFeed(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, "WaitUntilFeedDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetFeed(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilFeedDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h b/generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h index ce44d60c2b9..a53d4c531f7 100644 --- a/generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h +++ b/generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,24 +21,23 @@ class SESWaiter { public: Aws::Utils::WaiterOutcome WaitUntilIdentityExists( const Model::GetIdentityVerificationAttributesRequest& request) { - std::vector> acceptors; - acceptors.push_back( - {Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Success"), - [](const Model::GetIdentityVerificationAttributesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetVerificationAttributes().begin(), result.GetVerificationAttributes().end(), [&](const auto& pair0) { - const auto& item = pair0.second; - return Model::VerificationStatusMapper::GetNameForVerificationStatus(item.GetVerificationStatus()) == - expected.get(); - }); - }}); + using OutcomeT = Model::GetIdentityVerificationAttributesOutcome; + using RequestT = Model::GetIdentityVerificationAttributesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "IdentityExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Success"), + [](const Model::GetIdentityVerificationAttributesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetVerificationAttributes().begin(), result.GetVerificationAttributes().end(), [&](const auto& pair0) { + const auto& item = pair0.second; + return Model::VerificationStatusMapper::GetNameForVerificationStatus(item.GetVerificationStatus()) == + expected.get(); + }); + })); - auto operation = [this](const Model::GetIdentityVerificationAttributesRequest& req) { - return static_cast(this)->GetIdentityVerificationAttributes(req); - }; - Aws::Utils::Waiter waiter( - 3, 40, acceptors, operation, "WaitUntilIdentityExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetIdentityVerificationAttributes(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilIdentityExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-emr-containers/include/aws/emr-containers/EMRContainersWaiter.h b/generated/src/aws-cpp-sdk-emr-containers/include/aws/emr-containers/EMRContainersWaiter.h new file mode 100644 index 00000000000..ac64dbf6eab --- /dev/null +++ b/generated/src/aws-cpp-sdk-emr-containers/include/aws/emr-containers/EMRContainersWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace EMRContainers { + +template +class EMRContainersWaiter { + public: +}; +} // namespace EMRContainers +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-emr-serverless/include/aws/emr-serverless/EMRServerlessWaiter.h b/generated/src/aws-cpp-sdk-emr-serverless/include/aws/emr-serverless/EMRServerlessWaiter.h new file mode 100644 index 00000000000..7c1bb919c20 --- /dev/null +++ b/generated/src/aws-cpp-sdk-emr-serverless/include/aws/emr-serverless/EMRServerlessWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace EMRServerless { + +template +class EMRServerlessWaiter { + public: +}; +} // namespace EMRServerless +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-entityresolution/include/aws/entityresolution/EntityResolutionWaiter.h b/generated/src/aws-cpp-sdk-entityresolution/include/aws/entityresolution/EntityResolutionWaiter.h new file mode 100644 index 00000000000..15395c5f15d --- /dev/null +++ b/generated/src/aws-cpp-sdk-entityresolution/include/aws/entityresolution/EntityResolutionWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace EntityResolution { + +template +class EntityResolutionWaiter { + public: +}; +} // namespace EntityResolution +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-es/include/aws/es/ElasticsearchServiceWaiter.h b/generated/src/aws-cpp-sdk-es/include/aws/es/ElasticsearchServiceWaiter.h new file mode 100644 index 00000000000..14ceefc616f --- /dev/null +++ b/generated/src/aws-cpp-sdk-es/include/aws/es/ElasticsearchServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ElasticsearchService { + +template +class ElasticsearchServiceWaiter { + public: +}; +} // namespace ElasticsearchService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-eventbridge/include/aws/eventbridge/EventBridgeWaiter.h b/generated/src/aws-cpp-sdk-eventbridge/include/aws/eventbridge/EventBridgeWaiter.h new file mode 100644 index 00000000000..271c23bcee7 --- /dev/null +++ b/generated/src/aws-cpp-sdk-eventbridge/include/aws/eventbridge/EventBridgeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace EventBridge { + +template +class EventBridgeWaiter { + public: +}; +} // namespace EventBridge +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-events/include/aws/events/CloudWatchEventsWaiter.h b/generated/src/aws-cpp-sdk-events/include/aws/events/CloudWatchEventsWaiter.h new file mode 100644 index 00000000000..f9bc2658e62 --- /dev/null +++ b/generated/src/aws-cpp-sdk-events/include/aws/events/CloudWatchEventsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CloudWatchEvents { + +template +class CloudWatchEventsWaiter { + public: +}; +} // namespace CloudWatchEvents +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-evs/include/aws/evs/EVSWaiter.h b/generated/src/aws-cpp-sdk-evs/include/aws/evs/EVSWaiter.h new file mode 100644 index 00000000000..c2b8e9dd04a --- /dev/null +++ b/generated/src/aws-cpp-sdk-evs/include/aws/evs/EVSWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace EVS { + +template +class EVSWaiter { + public: +}; +} // namespace EVS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-finspace-data/include/aws/finspace-data/FinSpaceDataWaiter.h b/generated/src/aws-cpp-sdk-finspace-data/include/aws/finspace-data/FinSpaceDataWaiter.h new file mode 100644 index 00000000000..e2249256b41 --- /dev/null +++ b/generated/src/aws-cpp-sdk-finspace-data/include/aws/finspace-data/FinSpaceDataWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace FinSpaceData { + +template +class FinSpaceDataWaiter { + public: +}; +} // namespace FinSpaceData +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-finspace/include/aws/finspace/FinspaceWaiter.h b/generated/src/aws-cpp-sdk-finspace/include/aws/finspace/FinspaceWaiter.h new file mode 100644 index 00000000000..fbcce1d3012 --- /dev/null +++ b/generated/src/aws-cpp-sdk-finspace/include/aws/finspace/FinspaceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace finspace { + +template +class FinspaceWaiter { + public: +}; +} // namespace finspace +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-firehose/include/aws/firehose/FirehoseWaiter.h b/generated/src/aws-cpp-sdk-firehose/include/aws/firehose/FirehoseWaiter.h new file mode 100644 index 00000000000..9bf96852818 --- /dev/null +++ b/generated/src/aws-cpp-sdk-firehose/include/aws/firehose/FirehoseWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Firehose { + +template +class FirehoseWaiter { + public: +}; +} // namespace Firehose +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-fis/include/aws/fis/FISWaiter.h b/generated/src/aws-cpp-sdk-fis/include/aws/fis/FISWaiter.h new file mode 100644 index 00000000000..a2c74b55e17 --- /dev/null +++ b/generated/src/aws-cpp-sdk-fis/include/aws/fis/FISWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace FIS { + +template +class FISWaiter { + public: +}; +} // namespace FIS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-fms/include/aws/fms/FMSWaiter.h b/generated/src/aws-cpp-sdk-fms/include/aws/fms/FMSWaiter.h new file mode 100644 index 00000000000..5a98711df1f --- /dev/null +++ b/generated/src/aws-cpp-sdk-fms/include/aws/fms/FMSWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace FMS { + +template +class FMSWaiter { + public: +}; +} // namespace FMS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-forecast/include/aws/forecast/ForecastServiceWaiter.h b/generated/src/aws-cpp-sdk-forecast/include/aws/forecast/ForecastServiceWaiter.h new file mode 100644 index 00000000000..d9d72f9ac12 --- /dev/null +++ b/generated/src/aws-cpp-sdk-forecast/include/aws/forecast/ForecastServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ForecastService { + +template +class ForecastServiceWaiter { + public: +}; +} // namespace ForecastService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-forecastquery/include/aws/forecastquery/ForecastQueryServiceWaiter.h b/generated/src/aws-cpp-sdk-forecastquery/include/aws/forecastquery/ForecastQueryServiceWaiter.h new file mode 100644 index 00000000000..7d798aca36a --- /dev/null +++ b/generated/src/aws-cpp-sdk-forecastquery/include/aws/forecastquery/ForecastQueryServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ForecastQueryService { + +template +class ForecastQueryServiceWaiter { + public: +}; +} // namespace ForecastQueryService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-frauddetector/include/aws/frauddetector/FraudDetectorWaiter.h b/generated/src/aws-cpp-sdk-frauddetector/include/aws/frauddetector/FraudDetectorWaiter.h new file mode 100644 index 00000000000..46b82246db1 --- /dev/null +++ b/generated/src/aws-cpp-sdk-frauddetector/include/aws/frauddetector/FraudDetectorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace FraudDetector { + +template +class FraudDetectorWaiter { + public: +}; +} // namespace FraudDetector +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-freetier/include/aws/freetier/FreeTierWaiter.h b/generated/src/aws-cpp-sdk-freetier/include/aws/freetier/FreeTierWaiter.h new file mode 100644 index 00000000000..6b09e67d2df --- /dev/null +++ b/generated/src/aws-cpp-sdk-freetier/include/aws/freetier/FreeTierWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace FreeTier { + +template +class FreeTierWaiter { + public: +}; +} // namespace FreeTier +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-fsx/include/aws/fsx/FSxWaiter.h b/generated/src/aws-cpp-sdk-fsx/include/aws/fsx/FSxWaiter.h new file mode 100644 index 00000000000..6761a6e9d46 --- /dev/null +++ b/generated/src/aws-cpp-sdk-fsx/include/aws/fsx/FSxWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace FSx { + +template +class FSxWaiter { + public: +}; +} // namespace FSx +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-gamelift/include/aws/gamelift/GameLiftWaiter.h b/generated/src/aws-cpp-sdk-gamelift/include/aws/gamelift/GameLiftWaiter.h new file mode 100644 index 00000000000..1dd836462d0 --- /dev/null +++ b/generated/src/aws-cpp-sdk-gamelift/include/aws/gamelift/GameLiftWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace GameLift { + +template +class GameLiftWaiter { + public: +}; +} // namespace GameLift +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h b/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h index ef46a41c6e1..2f7eda6d2bb 100644 --- a/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h +++ b/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -25,105 +26,112 @@ template class GameLiftStreamsWaiter { public: Aws::Utils::WaiterOutcome WaitUntilApplicationReady(const Model::GetApplicationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("READY"), - [](const Model::GetApplicationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ApplicationStatusMapper::GetNameForApplicationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetApplicationOutcome; + using RequestT = Model::GetApplicationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ApplicationReadyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("READY"), + [](const Model::GetApplicationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ApplicationStatusMapper::GetNameForApplicationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ApplicationReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetApplicationRequest& req) { return static_cast(this)->GetApplication(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, - "WaitUntilApplicationReady"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetApplication(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilApplicationReady"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilApplicationDeleted(const Model::GetApplicationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::GetApplicationOutcome; + using RequestT = Model::GetApplicationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ApplicationDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::GetApplicationRequest& req) { return static_cast(this)->GetApplication(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, - "WaitUntilApplicationDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetApplication(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilApplicationDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStreamGroupActive(const Model::GetStreamGroupRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE_WITH_ERRORS"), - [](const Model::GetStreamGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StreamGroupStatusMapper::GetNameForStreamGroupStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetStreamGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StreamGroupStatusMapper::GetNameForStreamGroupStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetStreamGroupOutcome; + using RequestT = Model::GetStreamGroupRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StreamGroupActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StreamGroupActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StreamGroupActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ACTIVE_WITH_ERRORS"), + [](const Model::GetStreamGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamGroupStatusMapper::GetNameForStreamGroupStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StreamGroupActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETING"), + [](const Model::GetStreamGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamGroupStatusMapper::GetNameForStreamGroupStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetStreamGroupRequest& req) { return static_cast(this)->GetStreamGroup(req); }; - Aws::Utils::Waiter waiter(30, 120, acceptors, operation, - "WaitUntilStreamGroupActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetStreamGroup(req); }; + Aws::Utils::Waiter waiter(30, 120, std::move(acceptors), operation, "WaitUntilStreamGroupActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStreamGroupDeleted(const Model::GetStreamGroupRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::GetStreamGroupOutcome; + using RequestT = Model::GetStreamGroupRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StreamGroupDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::GetStreamGroupRequest& req) { return static_cast(this)->GetStreamGroup(req); }; - Aws::Utils::Waiter waiter(30, 60, acceptors, operation, - "WaitUntilStreamGroupDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetStreamGroup(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilStreamGroupDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStreamSessionActive(const Model::GetStreamSessionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetStreamSessionOutcome; + using RequestT = Model::GetStreamSessionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StreamSessionActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "StreamSessionActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamSessionStatusMapper::GetNameForStreamSessionStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetStreamSessionRequest& req) { return static_cast(this)->GetStreamSession(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, - "WaitUntilStreamSessionActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetStreamSession(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilStreamSessionActive"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-geo-maps/include/aws/geo-maps/GeoMapsWaiter.h b/generated/src/aws-cpp-sdk-geo-maps/include/aws/geo-maps/GeoMapsWaiter.h new file mode 100644 index 00000000000..b7785872d4c --- /dev/null +++ b/generated/src/aws-cpp-sdk-geo-maps/include/aws/geo-maps/GeoMapsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace GeoMaps { + +template +class GeoMapsWaiter { + public: +}; +} // namespace GeoMaps +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-geo-places/include/aws/geo-places/GeoPlacesWaiter.h b/generated/src/aws-cpp-sdk-geo-places/include/aws/geo-places/GeoPlacesWaiter.h new file mode 100644 index 00000000000..f229a59e725 --- /dev/null +++ b/generated/src/aws-cpp-sdk-geo-places/include/aws/geo-places/GeoPlacesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace GeoPlaces { + +template +class GeoPlacesWaiter { + public: +}; +} // namespace GeoPlaces +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-geo-routes/include/aws/geo-routes/GeoRoutesWaiter.h b/generated/src/aws-cpp-sdk-geo-routes/include/aws/geo-routes/GeoRoutesWaiter.h new file mode 100644 index 00000000000..11ec948b0c7 --- /dev/null +++ b/generated/src/aws-cpp-sdk-geo-routes/include/aws/geo-routes/GeoRoutesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace GeoRoutes { + +template +class GeoRoutesWaiter { + public: +}; +} // namespace GeoRoutes +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h b/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h index 25bc0010ece..2c06fe19ee5 100644 --- a/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h +++ b/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -18,24 +19,30 @@ template class GlacierWaiter { public: Aws::Utils::WaiterOutcome WaitUntilVaultExists(const Model::DescribeVaultRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::DescribeVaultOutcome; + using RequestT = Model::DescribeVaultRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("VaultExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>("VaultExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::DescribeVaultRequest& req) { return static_cast(this)->DescribeVault(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilVaultExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeVault(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilVaultExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVaultNotExists(const Model::DescribeVaultRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::DescribeVaultOutcome; + using RequestT = Model::DescribeVaultRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("VaultNotExistsWaiter", Aws::Utils::WaiterState::RETRY, false)); + acceptors.emplace_back(Aws::MakeUnique>("VaultNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::DescribeVaultRequest& req) { return static_cast(this)->DescribeVault(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilVaultNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeVault(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilVaultNotExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-globalaccelerator/include/aws/globalaccelerator/GlobalAcceleratorWaiter.h b/generated/src/aws-cpp-sdk-globalaccelerator/include/aws/globalaccelerator/GlobalAcceleratorWaiter.h new file mode 100644 index 00000000000..e6ff2463c84 --- /dev/null +++ b/generated/src/aws-cpp-sdk-globalaccelerator/include/aws/globalaccelerator/GlobalAcceleratorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace GlobalAccelerator { + +template +class GlobalAcceleratorWaiter { + public: +}; +} // namespace GlobalAccelerator +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-glue/include/aws/glue/GlueWaiter.h b/generated/src/aws-cpp-sdk-glue/include/aws/glue/GlueWaiter.h new file mode 100644 index 00000000000..f79e424a5b1 --- /dev/null +++ b/generated/src/aws-cpp-sdk-glue/include/aws/glue/GlueWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Glue { + +template +class GlueWaiter { + public: +}; +} // namespace Glue +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-grafana/include/aws/grafana/ManagedGrafanaWaiter.h b/generated/src/aws-cpp-sdk-grafana/include/aws/grafana/ManagedGrafanaWaiter.h new file mode 100644 index 00000000000..4df53c993d0 --- /dev/null +++ b/generated/src/aws-cpp-sdk-grafana/include/aws/grafana/ManagedGrafanaWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ManagedGrafana { + +template +class ManagedGrafanaWaiter { + public: +}; +} // namespace ManagedGrafana +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-greengrass/include/aws/greengrass/GreengrassWaiter.h b/generated/src/aws-cpp-sdk-greengrass/include/aws/greengrass/GreengrassWaiter.h new file mode 100644 index 00000000000..a49adccf22a --- /dev/null +++ b/generated/src/aws-cpp-sdk-greengrass/include/aws/greengrass/GreengrassWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Greengrass { + +template +class GreengrassWaiter { + public: +}; +} // namespace Greengrass +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-greengrassv2/include/aws/greengrassv2/GreengrassV2Waiter.h b/generated/src/aws-cpp-sdk-greengrassv2/include/aws/greengrassv2/GreengrassV2Waiter.h new file mode 100644 index 00000000000..e78ab5c472d --- /dev/null +++ b/generated/src/aws-cpp-sdk-greengrassv2/include/aws/greengrassv2/GreengrassV2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace GreengrassV2 { + +template +class GreengrassV2Waiter { + public: +}; +} // namespace GreengrassV2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h b/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h index 651684b06d4..1d5519dfdad 100644 --- a/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h +++ b/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,25 +20,26 @@ template class GroundStationWaiter { public: Aws::Utils::WaiterOutcome WaitUntilContactScheduled(const Model::DescribeContactRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED_TO_SCHEDULE"), - [](const Model::DescribeContactOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ContactStatusMapper::GetNameForContactStatus(result.GetContactStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SCHEDULED"), - [](const Model::DescribeContactOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ContactStatusMapper::GetNameForContactStatus(result.GetContactStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeContactOutcome; + using RequestT = Model::DescribeContactRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ContactScheduledWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED_TO_SCHEDULE"), + [](const Model::DescribeContactOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ContactStatusMapper::GetNameForContactStatus(result.GetContactStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ContactScheduledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SCHEDULED"), + [](const Model::DescribeContactOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ContactStatusMapper::GetNameForContactStatus(result.GetContactStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeContactRequest& req) { return static_cast(this)->DescribeContact(req); }; - Aws::Utils::Waiter waiter(5, 180, acceptors, operation, - "WaitUntilContactScheduled"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeContact(req); }; + Aws::Utils::Waiter waiter(5, 180, std::move(acceptors), operation, "WaitUntilContactScheduled"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-guardduty/include/aws/guardduty/GuardDutyWaiter.h b/generated/src/aws-cpp-sdk-guardduty/include/aws/guardduty/GuardDutyWaiter.h new file mode 100644 index 00000000000..2ce366ada52 --- /dev/null +++ b/generated/src/aws-cpp-sdk-guardduty/include/aws/guardduty/GuardDutyWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace GuardDuty { + +template +class GuardDutyWaiter { + public: +}; +} // namespace GuardDuty +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-health/include/aws/health/HealthWaiter.h b/generated/src/aws-cpp-sdk-health/include/aws/health/HealthWaiter.h new file mode 100644 index 00000000000..ac3531d771e --- /dev/null +++ b/generated/src/aws-cpp-sdk-health/include/aws/health/HealthWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Health { + +template +class HealthWaiter { + public: +}; +} // namespace Health +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h b/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h index 01c6c851498..35290566d81 100644 --- a/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h +++ b/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -25,133 +26,133 @@ class HealthLakeWaiter { public: Aws::Utils::WaiterOutcome WaitUntilFHIRDatastoreActive( const Model::DescribeFHIRDatastoreRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::DatastoreStatusMapper::GetNameForDatastoreStatus( - result.GetDatastoreProperties().GetDatastoreStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::DatastoreStatusMapper::GetNameForDatastoreStatus( - result.GetDatastoreProperties().GetDatastoreStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::DatastoreStatusMapper::GetNameForDatastoreStatus( - result.GetDatastoreProperties().GetDatastoreStatus()) == expected.get(); - }}); + using OutcomeT = Model::DescribeFHIRDatastoreOutcome; + using RequestT = Model::DescribeFHIRDatastoreRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRDatastoreActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DatastoreStatusMapper::GetNameForDatastoreStatus(result.GetDatastoreProperties().GetDatastoreStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRDatastoreActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DatastoreStatusMapper::GetNameForDatastoreStatus(result.GetDatastoreProperties().GetDatastoreStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRDatastoreActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETED"), + [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DatastoreStatusMapper::GetNameForDatastoreStatus(result.GetDatastoreProperties().GetDatastoreStatus()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeFHIRDatastoreRequest& req) { - return static_cast(this)->DescribeFHIRDatastore(req); - }; - Aws::Utils::Waiter waiter(60, 2, acceptors, operation, - "WaitUntilFHIRDatastoreActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeFHIRDatastore(req); }; + Aws::Utils::Waiter waiter(60, 2, std::move(acceptors), operation, "WaitUntilFHIRDatastoreActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFHIRDatastoreDeleted( const Model::DescribeFHIRDatastoreRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::DatastoreStatusMapper::GetNameForDatastoreStatus( - result.GetDatastoreProperties().GetDatastoreStatus()) == expected.get(); - }}); + using OutcomeT = Model::DescribeFHIRDatastoreOutcome; + using RequestT = Model::DescribeFHIRDatastoreRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRDatastoreDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::DatastoreStatusMapper::GetNameForDatastoreStatus(result.GetDatastoreProperties().GetDatastoreStatus()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeFHIRDatastoreRequest& req) { - return static_cast(this)->DescribeFHIRDatastore(req); - }; - Aws::Utils::Waiter waiter(120, 1, acceptors, operation, - "WaitUntilFHIRDatastoreDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeFHIRDatastore(req); }; + Aws::Utils::Waiter waiter(120, 1, std::move(acceptors), operation, "WaitUntilFHIRDatastoreDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFHIRExportJobCompleted( const Model::DescribeFHIRExportJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_ERRORS"), - [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCEL_COMPLETED"), - [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCEL_FAILED"), - [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeFHIRExportJobOutcome; + using RequestT = Model::DescribeFHIRExportJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRExportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRExportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED_WITH_ERRORS"), + [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRExportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCEL_COMPLETED"), + [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRExportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRExportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCEL_FAILED"), + [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetExportJobProperties().GetJobStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeFHIRExportJobRequest& req) { - return static_cast(this)->DescribeFHIRExportJob(req); - }; - Aws::Utils::Waiter waiter(120, 1, acceptors, operation, - "WaitUntilFHIRExportJobCompleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeFHIRExportJob(req); }; + Aws::Utils::Waiter waiter(120, 1, std::move(acceptors), operation, "WaitUntilFHIRExportJobCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFHIRImportJobCompleted( const Model::DescribeFHIRImportJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::DescribeFHIRImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobStatusMapper::GetNameForJobStatus(result.GetImportJobProperties().GetJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_ERRORS"), - [](const Model::DescribeFHIRImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobStatusMapper::GetNameForJobStatus(result.GetImportJobProperties().GetJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeFHIRImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::JobStatusMapper::GetNameForJobStatus(result.GetImportJobProperties().GetJobStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeFHIRImportJobOutcome; + using RequestT = Model::DescribeFHIRImportJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRImportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::DescribeFHIRImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetImportJobProperties().GetJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRImportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED_WITH_ERRORS"), + [](const Model::DescribeFHIRImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetImportJobProperties().GetJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FHIRImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeFHIRImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetImportJobProperties().GetJobStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeFHIRImportJobRequest& req) { - return static_cast(this)->DescribeFHIRImportJob(req); - }; - Aws::Utils::Waiter waiter(120, 1, acceptors, operation, - "WaitUntilFHIRImportJobCompleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeFHIRImportJob(req); }; + Aws::Utils::Waiter waiter(120, 1, std::move(acceptors), operation, "WaitUntilFHIRImportJobCompleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h b/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h index e45fe1c7d6b..3bbaa76ab7b 100644 --- a/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h +++ b/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -25,45 +26,58 @@ class IAMWaiter { public: Aws::Utils::WaiterOutcome WaitUntilInstanceProfileExists( const Model::GetInstanceProfileRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NoSuchEntityException")}); + using OutcomeT = Model::GetInstanceProfileOutcome; + using RequestT = Model::GetInstanceProfileRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("InstanceProfileExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>( + "InstanceProfileExistsWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("NoSuchEntityException"))); - auto operation = [this](const Model::GetInstanceProfileRequest& req) { - return static_cast(this)->GetInstanceProfile(req); - }; - Aws::Utils::Waiter waiter(1, 120, acceptors, operation, - "WaitUntilInstanceProfileExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetInstanceProfile(req); }; + Aws::Utils::Waiter waiter(1, 120, std::move(acceptors), operation, "WaitUntilInstanceProfileExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPolicyExists(const Model::GetPolicyRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NoSuchEntity")}); + using OutcomeT = Model::GetPolicyOutcome; + using RequestT = Model::GetPolicyRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("PolicyExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>("PolicyExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("NoSuchEntity"))); - auto operation = [this](const Model::GetPolicyRequest& req) { return static_cast(this)->GetPolicy(req); }; - Aws::Utils::Waiter waiter(1, 120, acceptors, operation, "WaitUntilPolicyExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetPolicy(req); }; + Aws::Utils::Waiter waiter(1, 120, std::move(acceptors), operation, "WaitUntilPolicyExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilRoleExists(const Model::GetRoleRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NoSuchEntity")}); + using OutcomeT = Model::GetRoleOutcome; + using RequestT = Model::GetRoleRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("RoleExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>("RoleExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("NoSuchEntity"))); - auto operation = [this](const Model::GetRoleRequest& req) { return static_cast(this)->GetRole(req); }; - Aws::Utils::Waiter waiter(1, 120, acceptors, operation, "WaitUntilRoleExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRole(req); }; + Aws::Utils::Waiter waiter(1, 120, std::move(acceptors), operation, "WaitUntilRoleExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilUserExists(const Model::GetUserRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NoSuchEntity")}); + using OutcomeT = Model::GetUserOutcome; + using RequestT = Model::GetUserRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("UserExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>("UserExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("NoSuchEntity"))); - auto operation = [this](const Model::GetUserRequest& req) { return static_cast(this)->GetUser(req); }; - Aws::Utils::Waiter waiter(1, 120, acceptors, operation, "WaitUntilUserExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetUser(req); }; + Aws::Utils::Waiter waiter(1, 120, std::move(acceptors), operation, "WaitUntilUserExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-identitystore/include/aws/identitystore/IdentityStoreWaiter.h b/generated/src/aws-cpp-sdk-identitystore/include/aws/identitystore/IdentityStoreWaiter.h new file mode 100644 index 00000000000..2e17dbbd5b1 --- /dev/null +++ b/generated/src/aws-cpp-sdk-identitystore/include/aws/identitystore/IdentityStoreWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IdentityStore { + +template +class IdentityStoreWaiter { + public: +}; +} // namespace IdentityStore +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-imagebuilder/include/aws/imagebuilder/ImagebuilderWaiter.h b/generated/src/aws-cpp-sdk-imagebuilder/include/aws/imagebuilder/ImagebuilderWaiter.h new file mode 100644 index 00000000000..7b91349ae41 --- /dev/null +++ b/generated/src/aws-cpp-sdk-imagebuilder/include/aws/imagebuilder/ImagebuilderWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace imagebuilder { + +template +class ImagebuilderWaiter { + public: +}; +} // namespace imagebuilder +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-inspector-scan/include/aws/inspector-scan/InspectorscanWaiter.h b/generated/src/aws-cpp-sdk-inspector-scan/include/aws/inspector-scan/InspectorscanWaiter.h new file mode 100644 index 00000000000..f5f6fc5109d --- /dev/null +++ b/generated/src/aws-cpp-sdk-inspector-scan/include/aws/inspector-scan/InspectorscanWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace inspectorscan { + +template +class InspectorscanWaiter { + public: +}; +} // namespace inspectorscan +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-inspector/include/aws/inspector/InspectorWaiter.h b/generated/src/aws-cpp-sdk-inspector/include/aws/inspector/InspectorWaiter.h new file mode 100644 index 00000000000..9ef86c82215 --- /dev/null +++ b/generated/src/aws-cpp-sdk-inspector/include/aws/inspector/InspectorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Inspector { + +template +class InspectorWaiter { + public: +}; +} // namespace Inspector +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-inspector2/include/aws/inspector2/Inspector2Waiter.h b/generated/src/aws-cpp-sdk-inspector2/include/aws/inspector2/Inspector2Waiter.h new file mode 100644 index 00000000000..8befcde6604 --- /dev/null +++ b/generated/src/aws-cpp-sdk-inspector2/include/aws/inspector2/Inspector2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Inspector2 { + +template +class Inspector2Waiter { + public: +}; +} // namespace Inspector2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-internetmonitor/include/aws/internetmonitor/InternetMonitorWaiter.h b/generated/src/aws-cpp-sdk-internetmonitor/include/aws/internetmonitor/InternetMonitorWaiter.h new file mode 100644 index 00000000000..8a737503cdb --- /dev/null +++ b/generated/src/aws-cpp-sdk-internetmonitor/include/aws/internetmonitor/InternetMonitorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace InternetMonitor { + +template +class InternetMonitorWaiter { + public: +}; +} // namespace InternetMonitor +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-invoicing/include/aws/invoicing/InvoicingWaiter.h b/generated/src/aws-cpp-sdk-invoicing/include/aws/invoicing/InvoicingWaiter.h new file mode 100644 index 00000000000..08bc94db32a --- /dev/null +++ b/generated/src/aws-cpp-sdk-invoicing/include/aws/invoicing/InvoicingWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Invoicing { + +template +class InvoicingWaiter { + public: +}; +} // namespace Invoicing +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iot-data/include/aws/iot-data/IoTDataPlaneWaiter.h b/generated/src/aws-cpp-sdk-iot-data/include/aws/iot-data/IoTDataPlaneWaiter.h new file mode 100644 index 00000000000..beebcbd5388 --- /dev/null +++ b/generated/src/aws-cpp-sdk-iot-data/include/aws/iot-data/IoTDataPlaneWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoTDataPlane { + +template +class IoTDataPlaneWaiter { + public: +}; +} // namespace IoTDataPlane +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iot-jobs-data/include/aws/iot-jobs-data/IoTJobsDataPlaneWaiter.h b/generated/src/aws-cpp-sdk-iot-jobs-data/include/aws/iot-jobs-data/IoTJobsDataPlaneWaiter.h new file mode 100644 index 00000000000..b2824af154e --- /dev/null +++ b/generated/src/aws-cpp-sdk-iot-jobs-data/include/aws/iot-jobs-data/IoTJobsDataPlaneWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoTJobsDataPlane { + +template +class IoTJobsDataPlaneWaiter { + public: +}; +} // namespace IoTJobsDataPlane +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iot-managed-integrations/include/aws/iot-managed-integrations/IoTManagedIntegrationsWaiter.h b/generated/src/aws-cpp-sdk-iot-managed-integrations/include/aws/iot-managed-integrations/IoTManagedIntegrationsWaiter.h new file mode 100644 index 00000000000..571351a8b56 --- /dev/null +++ b/generated/src/aws-cpp-sdk-iot-managed-integrations/include/aws/iot-managed-integrations/IoTManagedIntegrationsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoTManagedIntegrations { + +template +class IoTManagedIntegrationsWaiter { + public: +}; +} // namespace IoTManagedIntegrations +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iot/include/aws/iot/IoTWaiter.h b/generated/src/aws-cpp-sdk-iot/include/aws/iot/IoTWaiter.h new file mode 100644 index 00000000000..cd1c5523bac --- /dev/null +++ b/generated/src/aws-cpp-sdk-iot/include/aws/iot/IoTWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoT { + +template +class IoTWaiter { + public: +}; +} // namespace IoT +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iotdeviceadvisor/include/aws/iotdeviceadvisor/IoTDeviceAdvisorWaiter.h b/generated/src/aws-cpp-sdk-iotdeviceadvisor/include/aws/iotdeviceadvisor/IoTDeviceAdvisorWaiter.h new file mode 100644 index 00000000000..563fb296416 --- /dev/null +++ b/generated/src/aws-cpp-sdk-iotdeviceadvisor/include/aws/iotdeviceadvisor/IoTDeviceAdvisorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoTDeviceAdvisor { + +template +class IoTDeviceAdvisorWaiter { + public: +}; +} // namespace IoTDeviceAdvisor +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iotevents-data/include/aws/iotevents-data/IoTEventsDataWaiter.h b/generated/src/aws-cpp-sdk-iotevents-data/include/aws/iotevents-data/IoTEventsDataWaiter.h new file mode 100644 index 00000000000..6ded61c37e8 --- /dev/null +++ b/generated/src/aws-cpp-sdk-iotevents-data/include/aws/iotevents-data/IoTEventsDataWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoTEventsData { + +template +class IoTEventsDataWaiter { + public: +}; +} // namespace IoTEventsData +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iotevents/include/aws/iotevents/IoTEventsWaiter.h b/generated/src/aws-cpp-sdk-iotevents/include/aws/iotevents/IoTEventsWaiter.h new file mode 100644 index 00000000000..af194a6f45c --- /dev/null +++ b/generated/src/aws-cpp-sdk-iotevents/include/aws/iotevents/IoTEventsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoTEvents { + +template +class IoTEventsWaiter { + public: +}; +} // namespace IoTEvents +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iotfleetwise/include/aws/iotfleetwise/IoTFleetWiseWaiter.h b/generated/src/aws-cpp-sdk-iotfleetwise/include/aws/iotfleetwise/IoTFleetWiseWaiter.h new file mode 100644 index 00000000000..a7c91ec046c --- /dev/null +++ b/generated/src/aws-cpp-sdk-iotfleetwise/include/aws/iotfleetwise/IoTFleetWiseWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoTFleetWise { + +template +class IoTFleetWiseWaiter { + public: +}; +} // namespace IoTFleetWise +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iotsecuretunneling/include/aws/iotsecuretunneling/IoTSecureTunnelingWaiter.h b/generated/src/aws-cpp-sdk-iotsecuretunneling/include/aws/iotsecuretunneling/IoTSecureTunnelingWaiter.h new file mode 100644 index 00000000000..5071e26e15f --- /dev/null +++ b/generated/src/aws-cpp-sdk-iotsecuretunneling/include/aws/iotsecuretunneling/IoTSecureTunnelingWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoTSecureTunneling { + +template +class IoTSecureTunnelingWaiter { + public: +}; +} // namespace IoTSecureTunneling +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h b/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h index 0c44c02ec2a..cff7ffee9b9 100644 --- a/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h +++ b/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -25,99 +26,106 @@ template class IoTSiteWiseWaiter { public: Aws::Utils::WaiterOutcome WaitUntilAssetActive(const Model::DescribeAssetRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeAssetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AssetStateMapper::GetNameForAssetState(result.GetAssetStatus().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeAssetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AssetStateMapper::GetNameForAssetState(result.GetAssetStatus().GetState()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeAssetOutcome; + using RequestT = Model::DescribeAssetRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AssetActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeAssetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AssetStateMapper::GetNameForAssetState(result.GetAssetStatus().GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AssetActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeAssetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AssetStateMapper::GetNameForAssetState(result.GetAssetStatus().GetState()) == expected.get(); + })); - auto operation = [this](const Model::DescribeAssetRequest& req) { return static_cast(this)->DescribeAsset(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilAssetActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAsset(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilAssetActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilAssetNotExists(const Model::DescribeAssetRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::DescribeAssetOutcome; + using RequestT = Model::DescribeAssetRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("AssetNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::DescribeAssetRequest& req) { return static_cast(this)->DescribeAsset(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilAssetNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAsset(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilAssetNotExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilAssetModelActive(const Model::DescribeAssetModelRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeAssetModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AssetModelStateMapper::GetNameForAssetModelState(result.GetAssetModelStatus().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeAssetModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::AssetModelStateMapper::GetNameForAssetModelState(result.GetAssetModelStatus().GetState()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeAssetModelOutcome; + using RequestT = Model::DescribeAssetModelRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AssetModelActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeAssetModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AssetModelStateMapper::GetNameForAssetModelState(result.GetAssetModelStatus().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AssetModelActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeAssetModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::AssetModelStateMapper::GetNameForAssetModelState(result.GetAssetModelStatus().GetState()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeAssetModelRequest& req) { - return static_cast(this)->DescribeAssetModel(req); - }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilAssetModelActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAssetModel(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilAssetModelActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilAssetModelNotExists( const Model::DescribeAssetModelRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::DescribeAssetModelOutcome; + using RequestT = Model::DescribeAssetModelRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AssetModelNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::DescribeAssetModelRequest& req) { - return static_cast(this)->DescribeAssetModel(req); - }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilAssetModelNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAssetModel(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilAssetModelNotExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPortalActive(const Model::DescribePortalRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribePortalOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PortalStateMapper::GetNameForPortalState(result.GetPortalStatus().GetState()) == - expected.get(); - }}); + using OutcomeT = Model::DescribePortalOutcome; + using RequestT = Model::DescribePortalRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "PortalActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribePortalOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PortalStateMapper::GetNameForPortalState(result.GetPortalStatus().GetState()) == expected.get(); + })); - auto operation = [this](const Model::DescribePortalRequest& req) { return static_cast(this)->DescribePortal(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilPortalActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribePortal(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilPortalActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPortalNotExists(const Model::DescribePortalRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::DescribePortalOutcome; + using RequestT = Model::DescribePortalRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("PortalNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::DescribePortalRequest& req) { return static_cast(this)->DescribePortal(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilPortalNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribePortal(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilPortalNotExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-iotthingsgraph/include/aws/iotthingsgraph/IoTThingsGraphWaiter.h b/generated/src/aws-cpp-sdk-iotthingsgraph/include/aws/iotthingsgraph/IoTThingsGraphWaiter.h new file mode 100644 index 00000000000..31d7706112d --- /dev/null +++ b/generated/src/aws-cpp-sdk-iotthingsgraph/include/aws/iotthingsgraph/IoTThingsGraphWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoTThingsGraph { + +template +class IoTThingsGraphWaiter { + public: +}; +} // namespace IoTThingsGraph +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iottwinmaker/include/aws/iottwinmaker/IoTTwinMakerWaiter.h b/generated/src/aws-cpp-sdk-iottwinmaker/include/aws/iottwinmaker/IoTTwinMakerWaiter.h new file mode 100644 index 00000000000..1cd56c594be --- /dev/null +++ b/generated/src/aws-cpp-sdk-iottwinmaker/include/aws/iottwinmaker/IoTTwinMakerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoTTwinMaker { + +template +class IoTTwinMakerWaiter { + public: +}; +} // namespace IoTTwinMaker +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-iotwireless/include/aws/iotwireless/IoTWirelessWaiter.h b/generated/src/aws-cpp-sdk-iotwireless/include/aws/iotwireless/IoTWirelessWaiter.h new file mode 100644 index 00000000000..22999d3406c --- /dev/null +++ b/generated/src/aws-cpp-sdk-iotwireless/include/aws/iotwireless/IoTWirelessWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IoTWireless { + +template +class IoTWirelessWaiter { + public: +}; +} // namespace IoTWireless +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ivs-realtime/include/aws/ivs-realtime/IvsrealtimeWaiter.h b/generated/src/aws-cpp-sdk-ivs-realtime/include/aws/ivs-realtime/IvsrealtimeWaiter.h new file mode 100644 index 00000000000..540768dc838 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ivs-realtime/include/aws/ivs-realtime/IvsrealtimeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ivsrealtime { + +template +class IvsrealtimeWaiter { + public: +}; +} // namespace ivsrealtime +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ivs/include/aws/ivs/IVSWaiter.h b/generated/src/aws-cpp-sdk-ivs/include/aws/ivs/IVSWaiter.h new file mode 100644 index 00000000000..7bc1f584e59 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ivs/include/aws/ivs/IVSWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace IVS { + +template +class IVSWaiter { + public: +}; +} // namespace IVS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ivschat/include/aws/ivschat/IvschatWaiter.h b/generated/src/aws-cpp-sdk-ivschat/include/aws/ivschat/IvschatWaiter.h new file mode 100644 index 00000000000..861ce4f2966 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ivschat/include/aws/ivschat/IvschatWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ivschat { + +template +class IvschatWaiter { + public: +}; +} // namespace ivschat +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kafka/include/aws/kafka/KafkaWaiter.h b/generated/src/aws-cpp-sdk-kafka/include/aws/kafka/KafkaWaiter.h new file mode 100644 index 00000000000..da379cb0c69 --- /dev/null +++ b/generated/src/aws-cpp-sdk-kafka/include/aws/kafka/KafkaWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Kafka { + +template +class KafkaWaiter { + public: +}; +} // namespace Kafka +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kafkaconnect/include/aws/kafkaconnect/KafkaConnectWaiter.h b/generated/src/aws-cpp-sdk-kafkaconnect/include/aws/kafkaconnect/KafkaConnectWaiter.h new file mode 100644 index 00000000000..783a0282d5a --- /dev/null +++ b/generated/src/aws-cpp-sdk-kafkaconnect/include/aws/kafkaconnect/KafkaConnectWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace KafkaConnect { + +template +class KafkaConnectWaiter { + public: +}; +} // namespace KafkaConnect +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kendra-ranking/include/aws/kendra-ranking/KendraRankingWaiter.h b/generated/src/aws-cpp-sdk-kendra-ranking/include/aws/kendra-ranking/KendraRankingWaiter.h new file mode 100644 index 00000000000..4b068a9928f --- /dev/null +++ b/generated/src/aws-cpp-sdk-kendra-ranking/include/aws/kendra-ranking/KendraRankingWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace KendraRanking { + +template +class KendraRankingWaiter { + public: +}; +} // namespace KendraRanking +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kendra/include/aws/kendra/KendraWaiter.h b/generated/src/aws-cpp-sdk-kendra/include/aws/kendra/KendraWaiter.h new file mode 100644 index 00000000000..45c2f360278 --- /dev/null +++ b/generated/src/aws-cpp-sdk-kendra/include/aws/kendra/KendraWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace kendra { + +template +class KendraWaiter { + public: +}; +} // namespace kendra +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-keyspaces/include/aws/keyspaces/KeyspacesWaiter.h b/generated/src/aws-cpp-sdk-keyspaces/include/aws/keyspaces/KeyspacesWaiter.h new file mode 100644 index 00000000000..3e4a8fb80b6 --- /dev/null +++ b/generated/src/aws-cpp-sdk-keyspaces/include/aws/keyspaces/KeyspacesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Keyspaces { + +template +class KeyspacesWaiter { + public: +}; +} // namespace Keyspaces +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-keyspacesstreams/include/aws/keyspacesstreams/KeyspacesStreamsWaiter.h b/generated/src/aws-cpp-sdk-keyspacesstreams/include/aws/keyspacesstreams/KeyspacesStreamsWaiter.h new file mode 100644 index 00000000000..a8c735046f9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-keyspacesstreams/include/aws/keyspacesstreams/KeyspacesStreamsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace KeyspacesStreams { + +template +class KeyspacesStreamsWaiter { + public: +}; +} // namespace KeyspacesStreams +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kinesis-video-archived-media/include/aws/kinesis-video-archived-media/KinesisVideoArchivedMediaWaiter.h b/generated/src/aws-cpp-sdk-kinesis-video-archived-media/include/aws/kinesis-video-archived-media/KinesisVideoArchivedMediaWaiter.h new file mode 100644 index 00000000000..6a080b1ad2e --- /dev/null +++ b/generated/src/aws-cpp-sdk-kinesis-video-archived-media/include/aws/kinesis-video-archived-media/KinesisVideoArchivedMediaWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace KinesisVideoArchivedMedia { + +template +class KinesisVideoArchivedMediaWaiter { + public: +}; +} // namespace KinesisVideoArchivedMedia +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kinesis-video-media/include/aws/kinesis-video-media/KinesisVideoMediaWaiter.h b/generated/src/aws-cpp-sdk-kinesis-video-media/include/aws/kinesis-video-media/KinesisVideoMediaWaiter.h new file mode 100644 index 00000000000..47ec25902b2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-kinesis-video-media/include/aws/kinesis-video-media/KinesisVideoMediaWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace KinesisVideoMedia { + +template +class KinesisVideoMediaWaiter { + public: +}; +} // namespace KinesisVideoMedia +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kinesis-video-signaling/include/aws/kinesis-video-signaling/KinesisVideoSignalingChannelsWaiter.h b/generated/src/aws-cpp-sdk-kinesis-video-signaling/include/aws/kinesis-video-signaling/KinesisVideoSignalingChannelsWaiter.h new file mode 100644 index 00000000000..7e06ae06636 --- /dev/null +++ b/generated/src/aws-cpp-sdk-kinesis-video-signaling/include/aws/kinesis-video-signaling/KinesisVideoSignalingChannelsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace KinesisVideoSignalingChannels { + +template +class KinesisVideoSignalingChannelsWaiter { + public: +}; +} // namespace KinesisVideoSignalingChannels +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kinesis-video-webrtc-storage/include/aws/kinesis-video-webrtc-storage/KinesisVideoWebRTCStorageWaiter.h b/generated/src/aws-cpp-sdk-kinesis-video-webrtc-storage/include/aws/kinesis-video-webrtc-storage/KinesisVideoWebRTCStorageWaiter.h new file mode 100644 index 00000000000..bfd3ef5fd5f --- /dev/null +++ b/generated/src/aws-cpp-sdk-kinesis-video-webrtc-storage/include/aws/kinesis-video-webrtc-storage/KinesisVideoWebRTCStorageWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace KinesisVideoWebRTCStorage { + +template +class KinesisVideoWebRTCStorageWaiter { + public: +}; +} // namespace KinesisVideoWebRTCStorage +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h b/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h index 9125b0f0b4d..3b8ddfc0bf9 100644 --- a/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h +++ b/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,28 +20,32 @@ template class KinesisWaiter { public: Aws::Utils::WaiterOutcome WaitUntilStreamExists(const Model::DescribeStreamRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeStreamOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StreamStatusMapper::GetNameForStreamStatus(result.GetStreamDescription().GetStreamStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeStreamOutcome; + using RequestT = Model::DescribeStreamRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "StreamExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeStreamOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StreamStatusMapper::GetNameForStreamStatus(result.GetStreamDescription().GetStreamStatus()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeStreamRequest& req) { return static_cast(this)->DescribeStream(req); }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilStreamExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStream(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilStreamExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilStreamNotExists(const Model::DescribeStreamRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::DescribeStreamOutcome; + using RequestT = Model::DescribeStreamRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("StreamNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::DescribeStreamRequest& req) { return static_cast(this)->DescribeStream(req); }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilStreamNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeStream(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilStreamNotExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-kinesisanalytics/include/aws/kinesisanalytics/KinesisAnalyticsWaiter.h b/generated/src/aws-cpp-sdk-kinesisanalytics/include/aws/kinesisanalytics/KinesisAnalyticsWaiter.h new file mode 100644 index 00000000000..2f522daafb4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-kinesisanalytics/include/aws/kinesisanalytics/KinesisAnalyticsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace KinesisAnalytics { + +template +class KinesisAnalyticsWaiter { + public: +}; +} // namespace KinesisAnalytics +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kinesisanalyticsv2/include/aws/kinesisanalyticsv2/KinesisAnalyticsV2Waiter.h b/generated/src/aws-cpp-sdk-kinesisanalyticsv2/include/aws/kinesisanalyticsv2/KinesisAnalyticsV2Waiter.h new file mode 100644 index 00000000000..4ec7d261b75 --- /dev/null +++ b/generated/src/aws-cpp-sdk-kinesisanalyticsv2/include/aws/kinesisanalyticsv2/KinesisAnalyticsV2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace KinesisAnalyticsV2 { + +template +class KinesisAnalyticsV2Waiter { + public: +}; +} // namespace KinesisAnalyticsV2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideoWaiter.h b/generated/src/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideoWaiter.h new file mode 100644 index 00000000000..1fe78472949 --- /dev/null +++ b/generated/src/aws-cpp-sdk-kinesisvideo/include/aws/kinesisvideo/KinesisVideoWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace KinesisVideo { + +template +class KinesisVideoWaiter { + public: +}; +} // namespace KinesisVideo +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-kms/include/aws/kms/KMSWaiter.h b/generated/src/aws-cpp-sdk-kms/include/aws/kms/KMSWaiter.h new file mode 100644 index 00000000000..5e418aac476 --- /dev/null +++ b/generated/src/aws-cpp-sdk-kms/include/aws/kms/KMSWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace KMS { + +template +class KMSWaiter { + public: +}; +} // namespace KMS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-lakeformation/include/aws/lakeformation/LakeFormationWaiter.h b/generated/src/aws-cpp-sdk-lakeformation/include/aws/lakeformation/LakeFormationWaiter.h new file mode 100644 index 00000000000..3f79d94dba0 --- /dev/null +++ b/generated/src/aws-cpp-sdk-lakeformation/include/aws/lakeformation/LakeFormationWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace LakeFormation { + +template +class LakeFormationWaiter { + public: +}; +} // namespace LakeFormation +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h b/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h index 68700c143c7..f5f33c4b8a4 100644 --- a/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h +++ b/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -22,162 +23,177 @@ template class LambdaWaiter { public: Aws::Utils::WaiterOutcome WaitUntilFunctionActiveV2(const Model::GetFunctionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Active"), - [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetConfiguration().GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetConfiguration().GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Pending"), - [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetConfiguration().GetState()) == expected.get(); - }}); + using OutcomeT = Model::GetFunctionOutcome; + using RequestT = Model::GetFunctionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionActiveV2Waiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Active"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetConfiguration().GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionActiveV2Waiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetConfiguration().GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionActiveV2Waiter", Aws::Utils::WaiterState::RETRY, Aws::String("Pending"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetConfiguration().GetState()) == expected.get(); + })); - auto operation = [this](const Model::GetFunctionRequest& req) { return static_cast(this)->GetFunction(req); }; - Aws::Utils::Waiter waiter(1, 300, acceptors, operation, - "WaitUntilFunctionActiveV2"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetFunction(req); }; + Aws::Utils::Waiter waiter(1, 300, std::move(acceptors), operation, "WaitUntilFunctionActiveV2"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFunctionExists(const Model::GetFunctionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::GetFunctionOutcome; + using RequestT = Model::GetFunctionRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("FunctionExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>("FunctionExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::GetFunctionRequest& req) { return static_cast(this)->GetFunction(req); }; - Aws::Utils::Waiter waiter(1, 20, acceptors, operation, "WaitUntilFunctionExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetFunction(req); }; + Aws::Utils::Waiter waiter(1, 20, std::move(acceptors), operation, "WaitUntilFunctionExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFunctionUpdatedV2(const Model::GetFunctionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Successful"), - [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus( - result.GetConfiguration().GetLastUpdateStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus( - result.GetConfiguration().GetLastUpdateStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("InProgress"), - [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus( - result.GetConfiguration().GetLastUpdateStatus()) == expected.get(); - }}); + using OutcomeT = Model::GetFunctionOutcome; + using RequestT = Model::GetFunctionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionUpdatedV2Waiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Successful"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetConfiguration().GetLastUpdateStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionUpdatedV2Waiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetConfiguration().GetLastUpdateStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionUpdatedV2Waiter", Aws::Utils::WaiterState::RETRY, Aws::String("InProgress"), + [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetConfiguration().GetLastUpdateStatus()) == + expected.get(); + })); - auto operation = [this](const Model::GetFunctionRequest& req) { return static_cast(this)->GetFunction(req); }; - Aws::Utils::Waiter waiter(1, 300, acceptors, operation, - "WaitUntilFunctionUpdatedV2"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetFunction(req); }; + Aws::Utils::Waiter waiter(1, 300, std::move(acceptors), operation, "WaitUntilFunctionUpdatedV2"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFunctionActive( const Model::GetFunctionConfigurationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Active"), - [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Pending"), - [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); - }}); + using OutcomeT = Model::GetFunctionConfigurationOutcome; + using RequestT = Model::GetFunctionConfigurationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Active"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("Pending"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + })); - auto operation = [this](const Model::GetFunctionConfigurationRequest& req) { - return static_cast(this)->GetFunctionConfiguration(req); - }; - Aws::Utils::Waiter waiter(5, 60, acceptors, operation, - "WaitUntilFunctionActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetFunctionConfiguration(req); }; + Aws::Utils::Waiter waiter(5, 60, std::move(acceptors), operation, "WaitUntilFunctionActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFunctionUpdated( const Model::GetFunctionConfigurationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Successful"), - [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetLastUpdateStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetLastUpdateStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("InProgress"), - [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetLastUpdateStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetFunctionConfigurationOutcome; + using RequestT = Model::GetFunctionConfigurationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Successful"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetLastUpdateStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetLastUpdateStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FunctionUpdatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InProgress"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LastUpdateStatusMapper::GetNameForLastUpdateStatus(result.GetLastUpdateStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetFunctionConfigurationRequest& req) { - return static_cast(this)->GetFunctionConfiguration(req); - }; - Aws::Utils::Waiter waiter(5, 60, acceptors, operation, - "WaitUntilFunctionUpdated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetFunctionConfiguration(req); }; + Aws::Utils::Waiter waiter(5, 60, std::move(acceptors), operation, "WaitUntilFunctionUpdated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPublishedVersionActive( const Model::GetFunctionConfigurationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Active"), - [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Pending"), - [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); - }}); + using OutcomeT = Model::GetFunctionConfigurationOutcome; + using RequestT = Model::GetFunctionConfigurationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "PublishedVersionActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Active"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PublishedVersionActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PublishedVersionActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("Pending"), + [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StateMapper::GetNameForState(result.GetState()) == expected.get(); + })); - auto operation = [this](const Model::GetFunctionConfigurationRequest& req) { - return static_cast(this)->GetFunctionConfiguration(req); - }; - Aws::Utils::Waiter waiter( - 5, 312, acceptors, operation, "WaitUntilPublishedVersionActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetFunctionConfiguration(req); }; + Aws::Utils::Waiter waiter(5, 312, std::move(acceptors), operation, "WaitUntilPublishedVersionActive"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-launch-wizard/include/aws/launch-wizard/LaunchWizardWaiter.h b/generated/src/aws-cpp-sdk-launch-wizard/include/aws/launch-wizard/LaunchWizardWaiter.h new file mode 100644 index 00000000000..9afbf742710 --- /dev/null +++ b/generated/src/aws-cpp-sdk-launch-wizard/include/aws/launch-wizard/LaunchWizardWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace LaunchWizard { + +template +class LaunchWizardWaiter { + public: +}; +} // namespace LaunchWizard +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-lex-models/include/aws/lex-models/LexModelBuildingServiceWaiter.h b/generated/src/aws-cpp-sdk-lex-models/include/aws/lex-models/LexModelBuildingServiceWaiter.h new file mode 100644 index 00000000000..ccbd3c4f673 --- /dev/null +++ b/generated/src/aws-cpp-sdk-lex-models/include/aws/lex-models/LexModelBuildingServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace LexModelBuildingService { + +template +class LexModelBuildingServiceWaiter { + public: +}; +} // namespace LexModelBuildingService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-lex/include/aws/lex/LexRuntimeServiceWaiter.h b/generated/src/aws-cpp-sdk-lex/include/aws/lex/LexRuntimeServiceWaiter.h new file mode 100644 index 00000000000..14bd2e0a10a --- /dev/null +++ b/generated/src/aws-cpp-sdk-lex/include/aws/lex/LexRuntimeServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace LexRuntimeService { + +template +class LexRuntimeServiceWaiter { + public: +}; +} // namespace LexRuntimeService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h b/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h index 41d6d1516d3..97b26074de2 100644 --- a/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h +++ b/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -33,287 +34,296 @@ template class LexModelsV2Waiter { public: Aws::Utils::WaiterOutcome WaitUntilBotAvailable(const Model::DescribeBotRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Available"), - [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), - [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Inactive"), - [](const Model::DescribeBotOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); - }}); + using OutcomeT = Model::DescribeBotOutcome; + using RequestT = Model::DescribeBotRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "BotAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Available"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Deleting"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Inactive"), + [](const Model::DescribeBotOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeBotRequest& req) { return static_cast(this)->DescribeBot(req); }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, "WaitUntilBotAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeBot(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilBotAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilBotAliasAvailable(const Model::DescribeBotAliasRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Available"), - [](const Model::DescribeBotAliasOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotAliasStatusMapper::GetNameForBotAliasStatus(result.GetBotAliasStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeBotAliasOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotAliasStatusMapper::GetNameForBotAliasStatus(result.GetBotAliasStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), - [](const Model::DescribeBotAliasOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotAliasStatusMapper::GetNameForBotAliasStatus(result.GetBotAliasStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeBotAliasOutcome; + using RequestT = Model::DescribeBotAliasRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "BotAliasAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Available"), + [](const Model::DescribeBotAliasOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotAliasStatusMapper::GetNameForBotAliasStatus(result.GetBotAliasStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotAliasAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeBotAliasOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotAliasStatusMapper::GetNameForBotAliasStatus(result.GetBotAliasStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotAliasAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Deleting"), + [](const Model::DescribeBotAliasOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotAliasStatusMapper::GetNameForBotAliasStatus(result.GetBotAliasStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeBotAliasRequest& req) { return static_cast(this)->DescribeBotAlias(req); }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilBotAliasAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeBotAlias(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilBotAliasAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilBotLocaleBuilt(const Model::DescribeBotLocaleRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Built"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("NotBuilt"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeBotLocaleOutcome; + using RequestT = Model::DescribeBotLocaleRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleBuiltWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Built"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleBuiltWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Deleting"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleBuiltWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleBuiltWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("NotBuilt"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeBotLocaleRequest& req) { - return static_cast(this)->DescribeBotLocale(req); - }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilBotLocaleBuilt"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeBotLocale(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilBotLocaleBuilt"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilBotLocaleCreated(const Model::DescribeBotLocaleRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Built"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ReadyExpressTesting"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("NotBuilt"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeBotLocaleOutcome; + using RequestT = Model::DescribeBotLocaleRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Built"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ReadyExpressTesting"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("NotBuilt"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Deleting"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeBotLocaleRequest& req) { - return static_cast(this)->DescribeBotLocale(req); - }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilBotLocaleCreated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeBotLocale(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilBotLocaleCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilBotLocaleExpressTestingAvailable( const Model::DescribeBotLocaleRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Built"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ReadyExpressTesting"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("NotBuilt"), - [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeBotLocaleOutcome; + using RequestT = Model::DescribeBotLocaleRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleExpressTestingAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Built"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleExpressTestingAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ReadyExpressTesting"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleExpressTestingAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Deleting"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleExpressTestingAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotLocaleExpressTestingAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("NotBuilt"), + [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotLocaleStatusMapper::GetNameForBotLocaleStatus(result.GetBotLocaleStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeBotLocaleRequest& req) { - return static_cast(this)->DescribeBotLocale(req); - }; - Aws::Utils::Waiter waiter( - 10, 12, acceptors, operation, "WaitUntilBotLocaleExpressTestingAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeBotLocale(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilBotLocaleExpressTestingAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilBotVersionAvailable( const Model::DescribeBotVersionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Available"), - [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), - [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::DescribeBotVersionOutcome; + using RequestT = Model::DescribeBotVersionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "BotVersionAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Available"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotVersionAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Deleting"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotVersionAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::BotStatusMapper::GetNameForBotStatus(result.GetBotStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("BotVersionAvailableWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::DescribeBotVersionRequest& req) { - return static_cast(this)->DescribeBotVersion(req); - }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilBotVersionAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeBotVersion(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilBotVersionAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilBotExportCompleted(const Model::DescribeExportRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), - [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), - [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeExportOutcome; + using RequestT = Model::DescribeExportRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "BotExportCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), + [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotExportCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Deleting"), + [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotExportCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeExportRequest& req) { return static_cast(this)->DescribeExport(req); }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilBotExportCompleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeExport(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilBotExportCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilBotImportCompleted(const Model::DescribeImportRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), - [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Deleting"), - [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeImportOutcome; + using RequestT = Model::DescribeImportRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "BotImportCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotImportCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Deleting"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BotImportCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportStatusMapper::GetNameForImportStatus(result.GetImportStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeImportRequest& req) { return static_cast(this)->DescribeImport(req); }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilBotImportCompleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImport(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilBotImportCompleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-lexv2-runtime/include/aws/lexv2-runtime/LexRuntimeV2Waiter.h b/generated/src/aws-cpp-sdk-lexv2-runtime/include/aws/lexv2-runtime/LexRuntimeV2Waiter.h new file mode 100644 index 00000000000..6a19d38b9f0 --- /dev/null +++ b/generated/src/aws-cpp-sdk-lexv2-runtime/include/aws/lexv2-runtime/LexRuntimeV2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace LexRuntimeV2 { + +template +class LexRuntimeV2Waiter { + public: +}; +} // namespace LexRuntimeV2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-license-manager-linux-subscriptions/include/aws/license-manager-linux-subscriptions/LicenseManagerLinuxSubscriptionsWaiter.h b/generated/src/aws-cpp-sdk-license-manager-linux-subscriptions/include/aws/license-manager-linux-subscriptions/LicenseManagerLinuxSubscriptionsWaiter.h new file mode 100644 index 00000000000..6b656453871 --- /dev/null +++ b/generated/src/aws-cpp-sdk-license-manager-linux-subscriptions/include/aws/license-manager-linux-subscriptions/LicenseManagerLinuxSubscriptionsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace LicenseManagerLinuxSubscriptions { + +template +class LicenseManagerLinuxSubscriptionsWaiter { + public: +}; +} // namespace LicenseManagerLinuxSubscriptions +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-license-manager-user-subscriptions/include/aws/license-manager-user-subscriptions/LicenseManagerUserSubscriptionsWaiter.h b/generated/src/aws-cpp-sdk-license-manager-user-subscriptions/include/aws/license-manager-user-subscriptions/LicenseManagerUserSubscriptionsWaiter.h new file mode 100644 index 00000000000..f7ff88bf633 --- /dev/null +++ b/generated/src/aws-cpp-sdk-license-manager-user-subscriptions/include/aws/license-manager-user-subscriptions/LicenseManagerUserSubscriptionsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace LicenseManagerUserSubscriptions { + +template +class LicenseManagerUserSubscriptionsWaiter { + public: +}; +} // namespace LicenseManagerUserSubscriptions +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-license-manager/include/aws/license-manager/LicenseManagerWaiter.h b/generated/src/aws-cpp-sdk-license-manager/include/aws/license-manager/LicenseManagerWaiter.h new file mode 100644 index 00000000000..cdba8a4d49d --- /dev/null +++ b/generated/src/aws-cpp-sdk-license-manager/include/aws/license-manager/LicenseManagerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace LicenseManager { + +template +class LicenseManagerWaiter { + public: +}; +} // namespace LicenseManager +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-lightsail/include/aws/lightsail/LightsailWaiter.h b/generated/src/aws-cpp-sdk-lightsail/include/aws/lightsail/LightsailWaiter.h new file mode 100644 index 00000000000..09c88be0bb9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-lightsail/include/aws/lightsail/LightsailWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Lightsail { + +template +class LightsailWaiter { + public: +}; +} // namespace Lightsail +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-location/include/aws/location/LocationServiceWaiter.h b/generated/src/aws-cpp-sdk-location/include/aws/location/LocationServiceWaiter.h new file mode 100644 index 00000000000..d9dae0a73b4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-location/include/aws/location/LocationServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace LocationService { + +template +class LocationServiceWaiter { + public: +}; +} // namespace LocationService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-logs/include/aws/logs/CloudWatchLogsWaiter.h b/generated/src/aws-cpp-sdk-logs/include/aws/logs/CloudWatchLogsWaiter.h new file mode 100644 index 00000000000..c78833c8900 --- /dev/null +++ b/generated/src/aws-cpp-sdk-logs/include/aws/logs/CloudWatchLogsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CloudWatchLogs { + +template +class CloudWatchLogsWaiter { + public: +}; +} // namespace CloudWatchLogs +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-lookoutequipment/include/aws/lookoutequipment/LookoutEquipmentWaiter.h b/generated/src/aws-cpp-sdk-lookoutequipment/include/aws/lookoutequipment/LookoutEquipmentWaiter.h new file mode 100644 index 00000000000..325a3acb33c --- /dev/null +++ b/generated/src/aws-cpp-sdk-lookoutequipment/include/aws/lookoutequipment/LookoutEquipmentWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace LookoutEquipment { + +template +class LookoutEquipmentWaiter { + public: +}; +} // namespace LookoutEquipment +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-m2/include/aws/m2/MainframeModernizationWaiter.h b/generated/src/aws-cpp-sdk-m2/include/aws/m2/MainframeModernizationWaiter.h new file mode 100644 index 00000000000..4a467fa01ae --- /dev/null +++ b/generated/src/aws-cpp-sdk-m2/include/aws/m2/MainframeModernizationWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MainframeModernization { + +template +class MainframeModernizationWaiter { + public: +}; +} // namespace MainframeModernization +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h b/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h index 69574a5a4c5..26f6ca992ea 100644 --- a/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h +++ b/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -26,110 +27,116 @@ class MachineLearningWaiter { public: Aws::Utils::WaiterOutcome WaitUntilBatchPredictionAvailable( const Model::DescribeBatchPredictionsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { - return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { - return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeBatchPredictionsOutcome; + using RequestT = Model::DescribeBatchPredictionsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "BatchPredictionAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "BatchPredictionAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + })); - auto operation = [this](const Model::DescribeBatchPredictionsRequest& req) { - return static_cast(this)->DescribeBatchPredictions(req); - }; - Aws::Utils::Waiter waiter( - 30, 4, acceptors, operation, "WaitUntilBatchPredictionAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeBatchPredictions(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilBatchPredictionAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilDataSourceAvailable( const Model::DescribeDataSourcesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { - return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { - return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeDataSourcesOutcome; + using RequestT = Model::DescribeDataSourcesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DataSourceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DataSourceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + })); - auto operation = [this](const Model::DescribeDataSourcesRequest& req) { - return static_cast(this)->DescribeDataSources(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilDataSourceAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDataSources(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilDataSourceAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilEvaluationAvailable( const Model::DescribeEvaluationsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { - return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { - return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeEvaluationsOutcome; + using RequestT = Model::DescribeEvaluationsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "EvaluationAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "EvaluationAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + })); - auto operation = [this](const Model::DescribeEvaluationsRequest& req) { - return static_cast(this)->DescribeEvaluations(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilEvaluationAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeEvaluations(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilEvaluationAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilMLModelAvailable(const Model::DescribeMLModelsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { - return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { - return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeMLModelsOutcome; + using RequestT = Model::DescribeMLModelsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "MLModelAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "MLModelAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetResults().begin(), result.GetResults().end(), [&](const Model::MLModel& item) { + return Model::EntityStatusMapper::GetNameForEntityStatus(item.GetStatus()) == expected.get(); + }); + })); - auto operation = [this](const Model::DescribeMLModelsRequest& req) { return static_cast(this)->DescribeMLModels(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilMLModelAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeMLModels(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilMLModelAvailable"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h b/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h index 1f254192860..4470614cf45 100644 --- a/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h +++ b/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,27 +21,26 @@ class Macie2Waiter { public: Aws::Utils::WaiterOutcome WaitUntilFindingRevealed( const Model::GetSensitiveDataOccurrencesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCESS"), - [](const Model::GetSensitiveDataOccurrencesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RevealRequestStatusMapper::GetNameForRevealRequestStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetSensitiveDataOccurrencesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RevealRequestStatusMapper::GetNameForRevealRequestStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetSensitiveDataOccurrencesOutcome; + using RequestT = Model::GetSensitiveDataOccurrencesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FindingRevealedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"), + [](const Model::GetSensitiveDataOccurrencesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RevealRequestStatusMapper::GetNameForRevealRequestStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FindingRevealedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ERROR"), + [](const Model::GetSensitiveDataOccurrencesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RevealRequestStatusMapper::GetNameForRevealRequestStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetSensitiveDataOccurrencesRequest& req) { - return static_cast(this)->GetSensitiveDataOccurrences(req); - }; - Aws::Utils::Waiter waiter( - 2, 60, acceptors, operation, "WaitUntilFindingRevealed"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetSensitiveDataOccurrences(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilFindingRevealed"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-mailmanager/include/aws/mailmanager/MailManagerWaiter.h b/generated/src/aws-cpp-sdk-mailmanager/include/aws/mailmanager/MailManagerWaiter.h new file mode 100644 index 00000000000..9a95f0d1850 --- /dev/null +++ b/generated/src/aws-cpp-sdk-mailmanager/include/aws/mailmanager/MailManagerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MailManager { + +template +class MailManagerWaiter { + public: +}; +} // namespace MailManager +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-managedblockchain-query/include/aws/managedblockchain-query/ManagedBlockchainQueryWaiter.h b/generated/src/aws-cpp-sdk-managedblockchain-query/include/aws/managedblockchain-query/ManagedBlockchainQueryWaiter.h new file mode 100644 index 00000000000..f12111c2d5b --- /dev/null +++ b/generated/src/aws-cpp-sdk-managedblockchain-query/include/aws/managedblockchain-query/ManagedBlockchainQueryWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ManagedBlockchainQuery { + +template +class ManagedBlockchainQueryWaiter { + public: +}; +} // namespace ManagedBlockchainQuery +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-managedblockchain/include/aws/managedblockchain/ManagedBlockchainWaiter.h b/generated/src/aws-cpp-sdk-managedblockchain/include/aws/managedblockchain/ManagedBlockchainWaiter.h new file mode 100644 index 00000000000..b8a5db256e9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-managedblockchain/include/aws/managedblockchain/ManagedBlockchainWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ManagedBlockchain { + +template +class ManagedBlockchainWaiter { + public: +}; +} // namespace ManagedBlockchain +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-marketplace-agreement/include/aws/marketplace-agreement/AgreementServiceWaiter.h b/generated/src/aws-cpp-sdk-marketplace-agreement/include/aws/marketplace-agreement/AgreementServiceWaiter.h new file mode 100644 index 00000000000..c2f9c1c0a1c --- /dev/null +++ b/generated/src/aws-cpp-sdk-marketplace-agreement/include/aws/marketplace-agreement/AgreementServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AgreementService { + +template +class AgreementServiceWaiter { + public: +}; +} // namespace AgreementService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-marketplace-catalog/include/aws/marketplace-catalog/MarketplaceCatalogWaiter.h b/generated/src/aws-cpp-sdk-marketplace-catalog/include/aws/marketplace-catalog/MarketplaceCatalogWaiter.h new file mode 100644 index 00000000000..62de397c838 --- /dev/null +++ b/generated/src/aws-cpp-sdk-marketplace-catalog/include/aws/marketplace-catalog/MarketplaceCatalogWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MarketplaceCatalog { + +template +class MarketplaceCatalogWaiter { + public: +}; +} // namespace MarketplaceCatalog +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-marketplace-deployment/include/aws/marketplace-deployment/MarketplaceDeploymentWaiter.h b/generated/src/aws-cpp-sdk-marketplace-deployment/include/aws/marketplace-deployment/MarketplaceDeploymentWaiter.h new file mode 100644 index 00000000000..126bdacea11 --- /dev/null +++ b/generated/src/aws-cpp-sdk-marketplace-deployment/include/aws/marketplace-deployment/MarketplaceDeploymentWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MarketplaceDeployment { + +template +class MarketplaceDeploymentWaiter { + public: +}; +} // namespace MarketplaceDeployment +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-marketplace-entitlement/include/aws/marketplace-entitlement/MarketplaceEntitlementServiceWaiter.h b/generated/src/aws-cpp-sdk-marketplace-entitlement/include/aws/marketplace-entitlement/MarketplaceEntitlementServiceWaiter.h new file mode 100644 index 00000000000..821aa6ccc33 --- /dev/null +++ b/generated/src/aws-cpp-sdk-marketplace-entitlement/include/aws/marketplace-entitlement/MarketplaceEntitlementServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MarketplaceEntitlementService { + +template +class MarketplaceEntitlementServiceWaiter { + public: +}; +} // namespace MarketplaceEntitlementService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-marketplace-reporting/include/aws/marketplace-reporting/MarketplaceReportingWaiter.h b/generated/src/aws-cpp-sdk-marketplace-reporting/include/aws/marketplace-reporting/MarketplaceReportingWaiter.h new file mode 100644 index 00000000000..ead3ee8cfa8 --- /dev/null +++ b/generated/src/aws-cpp-sdk-marketplace-reporting/include/aws/marketplace-reporting/MarketplaceReportingWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MarketplaceReporting { + +template +class MarketplaceReportingWaiter { + public: +}; +} // namespace MarketplaceReporting +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-marketplacecommerceanalytics/include/aws/marketplacecommerceanalytics/MarketplaceCommerceAnalyticsWaiter.h b/generated/src/aws-cpp-sdk-marketplacecommerceanalytics/include/aws/marketplacecommerceanalytics/MarketplaceCommerceAnalyticsWaiter.h new file mode 100644 index 00000000000..455120b1531 --- /dev/null +++ b/generated/src/aws-cpp-sdk-marketplacecommerceanalytics/include/aws/marketplacecommerceanalytics/MarketplaceCommerceAnalyticsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MarketplaceCommerceAnalytics { + +template +class MarketplaceCommerceAnalyticsWaiter { + public: +}; +} // namespace MarketplaceCommerceAnalytics +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h b/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h index 57d50fb1769..253a95ced3a 100644 --- a/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h +++ b/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -26,351 +27,424 @@ template class MediaConnectWaiter { public: Aws::Utils::WaiterOutcome WaitUntilFlowActive(const Model::DescribeFlowRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), - [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), - [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("STANDBY"), - [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); - }}); + using OutcomeT = Model::DescribeFlowOutcome; + using RequestT = Model::DescribeFlowRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FlowActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FlowActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FlowActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("FlowActiveWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("FlowActiveWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ServiceUnavailableException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "FlowActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("STANDBY"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FlowActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeFlowRequest& req) { return static_cast(this)->DescribeFlow(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, "WaitUntilFlowActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeFlow(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilFlowActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFlowDeleted(const Model::DescribeFlowRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("NotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); - }}); + using OutcomeT = Model::DescribeFlowOutcome; + using RequestT = Model::DescribeFlowRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("FlowDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("NotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "FlowDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("FlowDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("FlowDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ServiceUnavailableException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "FlowDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeFlowRequest& req) { return static_cast(this)->DescribeFlow(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, "WaitUntilFlowDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeFlow(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilFlowDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilFlowStandby(const Model::DescribeFlowRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STANDBY"), - [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), - [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); - }}); + using OutcomeT = Model::DescribeFlowOutcome; + using RequestT = Model::DescribeFlowRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "FlowStandbyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STANDBY"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "FlowStandbyWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("FlowStandbyWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("FlowStandbyWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ServiceUnavailableException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "FlowStandbyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetFlow().GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeFlowRequest& req) { return static_cast(this)->DescribeFlow(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, "WaitUntilFlowStandby"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeFlow(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilFlowStandby"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInputStandby(const Model::GetRouterInputRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STANDBY"), - [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), - [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == - expected.get(); - }}); + using OutcomeT = Model::GetRouterInputOutcome; + using RequestT = Model::GetRouterInputRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InputStandbyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STANDBY"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InputStandbyWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("InputStandbyWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("InputStandbyWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ServiceUnavailableException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "InputStandbyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + })); - auto operation = [this](const Model::GetRouterInputRequest& req) { return static_cast(this)->GetRouterInput(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilInputStandby"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRouterInput(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilInputStandby"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInputDeleted(const Model::GetRouterInputRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("NotFoundException")}); + using OutcomeT = Model::GetRouterInputOutcome; + using RequestT = Model::GetRouterInputRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InputDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("InputDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("InputDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ServiceUnavailableException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "InputDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("InputDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("NotFoundException"))); - auto operation = [this](const Model::GetRouterInputRequest& req) { return static_cast(this)->GetRouterInput(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilInputDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRouterInput(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilInputDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInputActive(const Model::GetRouterInputRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), - [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), - [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("MIGRATING"), - [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == - expected.get(); - }}); + using OutcomeT = Model::GetRouterInputOutcome; + using RequestT = Model::GetRouterInputRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InputActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InputActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InputActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InputActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("MIGRATING"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("InputActiveWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("InputActiveWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ServiceUnavailableException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "InputActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterInputStateMapper::GetNameForRouterInputState(result.GetRouterInput().GetState()) == + expected.get(); + })); - auto operation = [this](const Model::GetRouterInputRequest& req) { return static_cast(this)->GetRouterInput(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilInputActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRouterInput(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilInputActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilOutputUnrouted(const Model::GetRouterOutputRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UNROUTED"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState( - result.GetRouterOutput().GetRoutedState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("ROUTING"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState( - result.GetRouterOutput().GetRoutedState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + using OutcomeT = Model::GetRouterOutputOutcome; + using RequestT = Model::GetRouterOutputRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "OutputUnroutedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UNROUTED"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState(result.GetRouterOutput().GetRoutedState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "OutputUnroutedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("ROUTING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState(result.GetRouterOutput().GetRoutedState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("OutputUnroutedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("OutputUnroutedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ServiceUnavailableException"))); - auto operation = [this](const Model::GetRouterOutputRequest& req) { return static_cast(this)->GetRouterOutput(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilOutputUnrouted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRouterOutput(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilOutputUnrouted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilOutputDeleted(const Model::GetRouterOutputRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("NotFoundException")}); + using OutcomeT = Model::GetRouterOutputOutcome; + using RequestT = Model::GetRouterOutputRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "OutputDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("OutputDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("OutputDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ServiceUnavailableException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "OutputDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("OutputDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("NotFoundException"))); - auto operation = [this](const Model::GetRouterOutputRequest& req) { return static_cast(this)->GetRouterOutput(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilOutputDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRouterOutput(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilOutputDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilOutputActive(const Model::GetRouterOutputRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("MIGRATING"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == - expected.get(); - }}); + using OutcomeT = Model::GetRouterOutputOutcome; + using RequestT = Model::GetRouterOutputRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "OutputActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "OutputActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "OutputActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "OutputActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("MIGRATING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("OutputActiveWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("OutputActiveWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ServiceUnavailableException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "OutputActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + })); - auto operation = [this](const Model::GetRouterOutputRequest& req) { return static_cast(this)->GetRouterOutput(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilOutputActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRouterOutput(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilOutputActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilOutputStandby(const Model::GetRouterOutputRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STANDBY"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == - expected.get(); - }}); + using OutcomeT = Model::GetRouterOutputOutcome; + using RequestT = Model::GetRouterOutputRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "OutputStandbyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STANDBY"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "OutputStandbyWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("OutputStandbyWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("OutputStandbyWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ServiceUnavailableException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "OutputStandbyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputStateMapper::GetNameForRouterOutputState(result.GetRouterOutput().GetState()) == + expected.get(); + })); - auto operation = [this](const Model::GetRouterOutputRequest& req) { return static_cast(this)->GetRouterOutput(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilOutputStandby"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRouterOutput(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilOutputStandby"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilOutputRouted(const Model::GetRouterOutputRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ROUTED"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState( - result.GetRouterOutput().GetRoutedState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("ROUTING"), - [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState( - result.GetRouterOutput().GetRoutedState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ServiceUnavailableException")}); + using OutcomeT = Model::GetRouterOutputOutcome; + using RequestT = Model::GetRouterOutputRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "OutputRoutedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ROUTED"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState(result.GetRouterOutput().GetRoutedState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "OutputRoutedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("ROUTING"), + [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::RouterOutputRoutedStateMapper::GetNameForRouterOutputRoutedState(result.GetRouterOutput().GetRoutedState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("OutputRoutedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>("OutputRoutedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ServiceUnavailableException"))); - auto operation = [this](const Model::GetRouterOutputRequest& req) { return static_cast(this)->GetRouterOutput(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilOutputRouted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRouterOutput(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilOutputRouted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-mediaconvert/include/aws/mediaconvert/MediaConvertWaiter.h b/generated/src/aws-cpp-sdk-mediaconvert/include/aws/mediaconvert/MediaConvertWaiter.h new file mode 100644 index 00000000000..c6ba22ba761 --- /dev/null +++ b/generated/src/aws-cpp-sdk-mediaconvert/include/aws/mediaconvert/MediaConvertWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MediaConvert { + +template +class MediaConvertWaiter { + public: +}; +} // namespace MediaConvert +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h index 07b6395e3d8..42b96bd7e81 100644 --- a/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h +++ b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -38,604 +39,682 @@ template class MediaLiveWaiter { public: Aws::Utils::WaiterOutcome WaitUntilChannelCreated(const Model::DescribeChannelRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("IDLE"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - - auto operation = [this](const Model::DescribeChannelRequest& req) { return static_cast(this)->DescribeChannel(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilChannelCreated"); + using OutcomeT = Model::DescribeChannelOutcome; + using RequestT = Model::DescribeChannelRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ChannelCreatedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeChannel(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilChannelCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilChannelDeleted(const Model::DescribeChannelRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeChannelRequest& req) { return static_cast(this)->DescribeChannel(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilChannelDeleted"); + using OutcomeT = Model::DescribeChannelOutcome; + using RequestT = Model::DescribeChannelRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ChannelDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeChannel(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilChannelRunning(const Model::DescribeChannelRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeChannelRequest& req) { return static_cast(this)->DescribeChannel(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilChannelRunning"); + using OutcomeT = Model::DescribeChannelOutcome; + using RequestT = Model::DescribeChannelRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ChannelRunningWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeChannel(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelRunning"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilChannelStopped(const Model::DescribeChannelRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("IDLE"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeChannelRequest& req) { return static_cast(this)->DescribeChannel(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilChannelStopped"); + using OutcomeT = Model::DescribeChannelOutcome; + using RequestT = Model::DescribeChannelRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelStoppedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ChannelStoppedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeChannel(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelStopped"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilChannelPlacementGroupAssigned( const Model::DescribeChannelPlacementGroupRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ASSIGNED"), - [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("ASSIGNING"), - [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeChannelPlacementGroupRequest& req) { - return static_cast(this)->DescribeChannelPlacementGroup(req); - }; - Aws::Utils::Waiter waiter( - 3, 40, acceptors, operation, "WaitUntilChannelPlacementGroupAssigned"); + using OutcomeT = Model::DescribeChannelPlacementGroupOutcome; + using RequestT = Model::DescribeChannelPlacementGroupRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelPlacementGroupAssignedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ASSIGNED"), + [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelPlacementGroupAssignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("ASSIGNING"), + [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelPlacementGroupAssignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeChannelPlacementGroup(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilChannelPlacementGroupAssigned"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilChannelPlacementGroupDeleted( const Model::DescribeChannelPlacementGroupRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeChannelPlacementGroupRequest& req) { - return static_cast(this)->DescribeChannelPlacementGroup(req); - }; - Aws::Utils::Waiter waiter( - 5, 24, acceptors, operation, "WaitUntilChannelPlacementGroupDeleted"); + using OutcomeT = Model::DescribeChannelPlacementGroupOutcome; + using RequestT = Model::DescribeChannelPlacementGroupRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelPlacementGroupDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelPlacementGroupDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelPlacementGroupDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeChannelPlacementGroup(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelPlacementGroupDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilChannelPlacementGroupUnassigned( const Model::DescribeChannelPlacementGroupRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UNASSIGNED"), - [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UNASSIGNING"), - [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeChannelPlacementGroupRequest& req) { - return static_cast(this)->DescribeChannelPlacementGroup(req); - }; - Aws::Utils::Waiter waiter( - 5, 24, acceptors, operation, "WaitUntilChannelPlacementGroupUnassigned"); + using OutcomeT = Model::DescribeChannelPlacementGroupOutcome; + using RequestT = Model::DescribeChannelPlacementGroupRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelPlacementGroupUnassignedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UNASSIGNED"), + [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelPlacementGroupUnassignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UNASSIGNING"), + [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelPlacementGroupUnassignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeChannelPlacementGroup(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelPlacementGroupUnassigned"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilClusterCreated(const Model::DescribeClusterRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - - auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilClusterCreated"); + using OutcomeT = Model::DescribeClusterOutcome; + using RequestT = Model::DescribeClusterRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ClusterCreatedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilClusterCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClusterRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilClusterDeleted"); + using OutcomeT = Model::DescribeClusterOutcome; + using RequestT = Model::DescribeClusterRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ClusterDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilClusterDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInputAttached(const Model::DescribeInputRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ATTACHED"), - [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DETACHED"), - [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeInputRequest& req) { return static_cast(this)->DescribeInput(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilInputAttached"); + using OutcomeT = Model::DescribeInputOutcome; + using RequestT = Model::DescribeInputRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InputAttachedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ATTACHED"), + [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InputAttachedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DETACHED"), + [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("InputAttachedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInput(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilInputAttached"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInputDeleted(const Model::DescribeInputRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeInputRequest& req) { return static_cast(this)->DescribeInput(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilInputDeleted"); + using OutcomeT = Model::DescribeInputOutcome; + using RequestT = Model::DescribeInputRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InputDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InputDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("InputDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInput(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilInputDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilInputDetached(const Model::DescribeInputRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DETACHED"), - [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("ATTACHED"), - [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeInputRequest& req) { return static_cast(this)->DescribeInput(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilInputDetached"); + using OutcomeT = Model::DescribeInputOutcome; + using RequestT = Model::DescribeInputRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InputDetachedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DETACHED"), + [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InputDetachedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InputDetachedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("ATTACHED"), + [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("InputDetachedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeInput(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilInputDetached"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilMultiplexCreated(const Model::DescribeMultiplexRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("IDLE"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - - auto operation = [this](const Model::DescribeMultiplexRequest& req) { - return static_cast(this)->DescribeMultiplex(req); - }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilMultiplexCreated"); + using OutcomeT = Model::DescribeMultiplexOutcome; + using RequestT = Model::DescribeMultiplexRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "MultiplexCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "MultiplexCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("MultiplexCreatedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "MultiplexCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeMultiplex(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilMultiplexCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilMultiplexDeleted(const Model::DescribeMultiplexRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeMultiplexRequest& req) { - return static_cast(this)->DescribeMultiplex(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilMultiplexDeleted"); + using OutcomeT = Model::DescribeMultiplexOutcome; + using RequestT = Model::DescribeMultiplexRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "MultiplexDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "MultiplexDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("MultiplexDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeMultiplex(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilMultiplexDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilMultiplexRunning(const Model::DescribeMultiplexRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeMultiplexRequest& req) { - return static_cast(this)->DescribeMultiplex(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilMultiplexRunning"); + using OutcomeT = Model::DescribeMultiplexOutcome; + using RequestT = Model::DescribeMultiplexRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "MultiplexRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "MultiplexRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("MultiplexRunningWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeMultiplex(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilMultiplexRunning"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilMultiplexStopped(const Model::DescribeMultiplexRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("IDLE"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), - [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeMultiplexRequest& req) { - return static_cast(this)->DescribeMultiplex(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilMultiplexStopped"); + using OutcomeT = Model::DescribeMultiplexOutcome; + using RequestT = Model::DescribeMultiplexRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "MultiplexStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "MultiplexStoppedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"), + [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("MultiplexStoppedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeMultiplex(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilMultiplexStopped"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilNodeDeregistered(const Model::DescribeNodeRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DEREGISTERED"), - [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DEREGISTERING"), - [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DRAINING"), - [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeNodeRequest& req) { return static_cast(this)->DescribeNode(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilNodeDeregistered"); + using OutcomeT = Model::DescribeNodeOutcome; + using RequestT = Model::DescribeNodeRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "NodeDeregisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEREGISTERED"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "NodeDeregisteredWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DEREGISTERING"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "NodeDeregisteredWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DRAINING"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("NodeDeregisteredWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeNode(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilNodeDeregistered"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilNodeRegistered(const Model::DescribeNodeRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("REGISTERING"), - [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("NotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REGISTRATION_FAILED"), - [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerErrorException")}); - - auto operation = [this](const Model::DescribeNodeRequest& req) { return static_cast(this)->DescribeNode(req); }; - Aws::Utils::Waiter waiter(3, 40, acceptors, operation, - "WaitUntilNodeRegistered"); + using OutcomeT = Model::DescribeNodeOutcome; + using RequestT = Model::DescribeNodeRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "NodeRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "NodeRegisteredWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("REGISTERING"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("NodeRegisteredWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("NotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "NodeRegisteredWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REGISTRATION_FAILED"), + [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("NodeRegisteredWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerErrorException"))); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeNode(req); }; + Aws::Utils::Waiter waiter(3, 40, std::move(acceptors), operation, "WaitUntilNodeRegistered"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSignalMapCreated(const Model::GetSignalMapRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_IN_PROGRESS"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == - expected.get(); - }}); - - auto operation = [this](const Model::GetSignalMapRequest& req) { return static_cast(this)->GetSignalMap(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilSignalMapCreated"); + using OutcomeT = Model::GetSignalMapOutcome; + using RequestT = Model::GetSignalMapRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATE_IN_PROGRESS"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetSignalMap(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSignalMapMonitorDeleted(const Model::GetSignalMapRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_COMPLETE"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( - result.GetMonitorDeployment().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_IN_PROGRESS"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( - result.GetMonitorDeployment().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( - result.GetMonitorDeployment().GetStatus()) == expected.get(); - }}); - - auto operation = [this](const Model::GetSignalMapRequest& req) { return static_cast(this)->GetSignalMap(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilSignalMapMonitorDeleted"); + using OutcomeT = Model::GetSignalMapOutcome; + using RequestT = Model::GetSignalMapRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapMonitorDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETE_COMPLETE"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapMonitorDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETE_IN_PROGRESS"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapMonitorDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetSignalMap(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapMonitorDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSignalMapMonitorDeployed(const Model::GetSignalMapRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DRY_RUN_DEPLOYMENT_COMPLETE"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( - result.GetMonitorDeployment().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYMENT_COMPLETE"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( - result.GetMonitorDeployment().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DRY_RUN_DEPLOYMENT_IN_PROGRESS"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( - result.GetMonitorDeployment().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYMENT_IN_PROGRESS"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( - result.GetMonitorDeployment().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DRY_RUN_DEPLOYMENT_FAILED"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( - result.GetMonitorDeployment().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYMENT_FAILED"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( - result.GetMonitorDeployment().GetStatus()) == expected.get(); - }}); - - auto operation = [this](const Model::GetSignalMapRequest& req) { return static_cast(this)->GetSignalMap(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilSignalMapMonitorDeployed"); + using OutcomeT = Model::GetSignalMapOutcome; + using RequestT = Model::GetSignalMapRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DRY_RUN_DEPLOYMENT_COMPLETE"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEPLOYMENT_COMPLETE"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DRY_RUN_DEPLOYMENT_IN_PROGRESS"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DEPLOYMENT_IN_PROGRESS"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DRY_RUN_DEPLOYMENT_FAILED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DEPLOYMENT_FAILED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus( + result.GetMonitorDeployment().GetStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetSignalMap(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapMonitorDeployed"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSignalMapUpdated(const Model::GetSignalMapRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_COMPLETE"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_IN_PROGRESS"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_REVERTED"), - [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == - expected.get(); - }}); - - auto operation = [this](const Model::GetSignalMapRequest& req) { return static_cast(this)->GetSignalMap(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilSignalMapUpdated"); + using OutcomeT = Model::GetSignalMapOutcome; + using RequestT = Model::GetSignalMapRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_COMPLETE"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATE_IN_PROGRESS"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_REVERTED"), + [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetSignalMap(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapUpdated"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-mediapackage-vod/include/aws/mediapackage-vod/MediaPackageVodWaiter.h b/generated/src/aws-cpp-sdk-mediapackage-vod/include/aws/mediapackage-vod/MediaPackageVodWaiter.h new file mode 100644 index 00000000000..c427f0775be --- /dev/null +++ b/generated/src/aws-cpp-sdk-mediapackage-vod/include/aws/mediapackage-vod/MediaPackageVodWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MediaPackageVod { + +template +class MediaPackageVodWaiter { + public: +}; +} // namespace MediaPackageVod +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mediapackage/include/aws/mediapackage/MediaPackageWaiter.h b/generated/src/aws-cpp-sdk-mediapackage/include/aws/mediapackage/MediaPackageWaiter.h new file mode 100644 index 00000000000..ce4641e66a4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-mediapackage/include/aws/mediapackage/MediaPackageWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MediaPackage { + +template +class MediaPackageWaiter { + public: +}; +} // namespace MediaPackage +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h b/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h index fa139ae7dd1..c45278c1195 100644 --- a/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h +++ b/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,46 +20,47 @@ template class Mediapackagev2Waiter { public: Aws::Utils::WaiterOutcome WaitUntilHarvestJobFinished(const Model::GetHarvestJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("QUEUED"), - [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), - [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetHarvestJobOutcome; + using RequestT = Model::GetHarvestJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "HarvestJobFinishedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "HarvestJobFinishedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CANCELLED"), + [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "HarvestJobFinishedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "HarvestJobFinishedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("QUEUED"), + [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "HarvestJobFinishedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), + [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::HarvestJobStatusMapper::GetNameForHarvestJobStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetHarvestJobRequest& req) { return static_cast(this)->GetHarvestJob(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, - "WaitUntilHarvestJobFinished"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetHarvestJob(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilHarvestJobFinished"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-mediastore-data/include/aws/mediastore-data/MediaStoreDataWaiter.h b/generated/src/aws-cpp-sdk-mediastore-data/include/aws/mediastore-data/MediaStoreDataWaiter.h new file mode 100644 index 00000000000..c8dffcf4a5f --- /dev/null +++ b/generated/src/aws-cpp-sdk-mediastore-data/include/aws/mediastore-data/MediaStoreDataWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MediaStoreData { + +template +class MediaStoreDataWaiter { + public: +}; +} // namespace MediaStoreData +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreWaiter.h b/generated/src/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreWaiter.h new file mode 100644 index 00000000000..ed5d03befce --- /dev/null +++ b/generated/src/aws-cpp-sdk-mediastore/include/aws/mediastore/MediaStoreWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MediaStore { + +template +class MediaStoreWaiter { + public: +}; +} // namespace MediaStore +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mediatailor/include/aws/mediatailor/MediaTailorWaiter.h b/generated/src/aws-cpp-sdk-mediatailor/include/aws/mediatailor/MediaTailorWaiter.h new file mode 100644 index 00000000000..e2ec21eaa52 --- /dev/null +++ b/generated/src/aws-cpp-sdk-mediatailor/include/aws/mediatailor/MediaTailorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MediaTailor { + +template +class MediaTailorWaiter { + public: +}; +} // namespace MediaTailor +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-medical-imaging/include/aws/medical-imaging/MedicalImagingWaiter.h b/generated/src/aws-cpp-sdk-medical-imaging/include/aws/medical-imaging/MedicalImagingWaiter.h new file mode 100644 index 00000000000..be3bb245574 --- /dev/null +++ b/generated/src/aws-cpp-sdk-medical-imaging/include/aws/medical-imaging/MedicalImagingWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MedicalImaging { + +template +class MedicalImagingWaiter { + public: +}; +} // namespace MedicalImaging +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-memorydb/include/aws/memorydb/MemoryDBWaiter.h b/generated/src/aws-cpp-sdk-memorydb/include/aws/memorydb/MemoryDBWaiter.h new file mode 100644 index 00000000000..beaa8c281e6 --- /dev/null +++ b/generated/src/aws-cpp-sdk-memorydb/include/aws/memorydb/MemoryDBWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MemoryDB { + +template +class MemoryDBWaiter { + public: +}; +} // namespace MemoryDB +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-meteringmarketplace/include/aws/meteringmarketplace/MarketplaceMeteringWaiter.h b/generated/src/aws-cpp-sdk-meteringmarketplace/include/aws/meteringmarketplace/MarketplaceMeteringWaiter.h new file mode 100644 index 00000000000..a568c3ef407 --- /dev/null +++ b/generated/src/aws-cpp-sdk-meteringmarketplace/include/aws/meteringmarketplace/MarketplaceMeteringWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MarketplaceMetering { + +template +class MarketplaceMeteringWaiter { + public: +}; +} // namespace MarketplaceMetering +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mgn/include/aws/mgn/MgnWaiter.h b/generated/src/aws-cpp-sdk-mgn/include/aws/mgn/MgnWaiter.h new file mode 100644 index 00000000000..a516589376a --- /dev/null +++ b/generated/src/aws-cpp-sdk-mgn/include/aws/mgn/MgnWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace mgn { + +template +class MgnWaiter { + public: +}; +} // namespace mgn +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-migration-hub-refactor-spaces/include/aws/migration-hub-refactor-spaces/MigrationHubRefactorSpacesWaiter.h b/generated/src/aws-cpp-sdk-migration-hub-refactor-spaces/include/aws/migration-hub-refactor-spaces/MigrationHubRefactorSpacesWaiter.h new file mode 100644 index 00000000000..90934526242 --- /dev/null +++ b/generated/src/aws-cpp-sdk-migration-hub-refactor-spaces/include/aws/migration-hub-refactor-spaces/MigrationHubRefactorSpacesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MigrationHubRefactorSpaces { + +template +class MigrationHubRefactorSpacesWaiter { + public: +}; +} // namespace MigrationHubRefactorSpaces +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-migrationhub-config/include/aws/migrationhub-config/MigrationHubConfigWaiter.h b/generated/src/aws-cpp-sdk-migrationhub-config/include/aws/migrationhub-config/MigrationHubConfigWaiter.h new file mode 100644 index 00000000000..ca801bd0263 --- /dev/null +++ b/generated/src/aws-cpp-sdk-migrationhub-config/include/aws/migrationhub-config/MigrationHubConfigWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MigrationHubConfig { + +template +class MigrationHubConfigWaiter { + public: +}; +} // namespace MigrationHubConfig +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-migrationhuborchestrator/include/aws/migrationhuborchestrator/MigrationHubOrchestratorWaiter.h b/generated/src/aws-cpp-sdk-migrationhuborchestrator/include/aws/migrationhuborchestrator/MigrationHubOrchestratorWaiter.h new file mode 100644 index 00000000000..4e851290c5f --- /dev/null +++ b/generated/src/aws-cpp-sdk-migrationhuborchestrator/include/aws/migrationhuborchestrator/MigrationHubOrchestratorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MigrationHubOrchestrator { + +template +class MigrationHubOrchestratorWaiter { + public: +}; +} // namespace MigrationHubOrchestrator +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-migrationhubstrategy/include/aws/migrationhubstrategy/MigrationHubStrategyRecommendationsWaiter.h b/generated/src/aws-cpp-sdk-migrationhubstrategy/include/aws/migrationhubstrategy/MigrationHubStrategyRecommendationsWaiter.h new file mode 100644 index 00000000000..a6bbf722395 --- /dev/null +++ b/generated/src/aws-cpp-sdk-migrationhubstrategy/include/aws/migrationhubstrategy/MigrationHubStrategyRecommendationsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MigrationHubStrategyRecommendations { + +template +class MigrationHubStrategyRecommendationsWaiter { + public: +}; +} // namespace MigrationHubStrategyRecommendations +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h b/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h index bc8dc3ca072..fef3ea8cd50 100644 --- a/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h +++ b/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,43 +21,50 @@ template class CloudWatchWaiter { public: Aws::Utils::WaiterOutcome WaitUntilAlarmExists(const Model::DescribeAlarmsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeAlarmsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetMetricAlarms().size() > 0) == expected.get(); - }}); + using OutcomeT = Model::DescribeAlarmsOutcome; + using RequestT = Model::DescribeAlarmsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AlarmExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeAlarmsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetMetricAlarms().size() > 0) == expected.get(); + })); - auto operation = [this](const Model::DescribeAlarmsRequest& req) { return static_cast(this)->DescribeAlarms(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilAlarmExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAlarms(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilAlarmExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilCompositeAlarmExists(const Model::DescribeAlarmsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeAlarmsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetCompositeAlarms().size() > 0) == expected.get(); - }}); + using OutcomeT = Model::DescribeAlarmsOutcome; + using RequestT = Model::DescribeAlarmsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "CompositeAlarmExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeAlarmsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetCompositeAlarms().size() > 0) == expected.get(); + })); - auto operation = [this](const Model::DescribeAlarmsRequest& req) { return static_cast(this)->DescribeAlarms(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilCompositeAlarmExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAlarms(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilCompositeAlarmExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilAlarmMuteRuleExists(const Model::GetAlarmMuteRuleRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::GetAlarmMuteRuleOutcome; + using RequestT = Model::GetAlarmMuteRuleRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("AlarmMuteRuleExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back(Aws::MakeUnique>("AlarmMuteRuleExistsWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::GetAlarmMuteRuleRequest& req) { return static_cast(this)->GetAlarmMuteRule(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilAlarmMuteRuleExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetAlarmMuteRule(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilAlarmMuteRuleExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-mpa/include/aws/mpa/MPAWaiter.h b/generated/src/aws-cpp-sdk-mpa/include/aws/mpa/MPAWaiter.h new file mode 100644 index 00000000000..1c69880e029 --- /dev/null +++ b/generated/src/aws-cpp-sdk-mpa/include/aws/mpa/MPAWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MPA { + +template +class MPAWaiter { + public: +}; +} // namespace MPA +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mq/include/aws/mq/MQWaiter.h b/generated/src/aws-cpp-sdk-mq/include/aws/mq/MQWaiter.h new file mode 100644 index 00000000000..50b1a3dc2a2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-mq/include/aws/mq/MQWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MQ { + +template +class MQWaiter { + public: +}; +} // namespace MQ +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mturk-requester/include/aws/mturk-requester/MTurkWaiter.h b/generated/src/aws-cpp-sdk-mturk-requester/include/aws/mturk-requester/MTurkWaiter.h new file mode 100644 index 00000000000..e77a180c4dd --- /dev/null +++ b/generated/src/aws-cpp-sdk-mturk-requester/include/aws/mturk-requester/MTurkWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MTurk { + +template +class MTurkWaiter { + public: +}; +} // namespace MTurk +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mwaa-serverless/include/aws/mwaa-serverless/MWAAServerlessWaiter.h b/generated/src/aws-cpp-sdk-mwaa-serverless/include/aws/mwaa-serverless/MWAAServerlessWaiter.h new file mode 100644 index 00000000000..e686b86b16f --- /dev/null +++ b/generated/src/aws-cpp-sdk-mwaa-serverless/include/aws/mwaa-serverless/MWAAServerlessWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MWAAServerless { + +template +class MWAAServerlessWaiter { + public: +}; +} // namespace MWAAServerless +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-mwaa/include/aws/mwaa/MWAAWaiter.h b/generated/src/aws-cpp-sdk-mwaa/include/aws/mwaa/MWAAWaiter.h new file mode 100644 index 00000000000..79b2cdea859 --- /dev/null +++ b/generated/src/aws-cpp-sdk-mwaa/include/aws/mwaa/MWAAWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace MWAA { + +template +class MWAAWaiter { + public: +}; +} // namespace MWAA +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h b/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h index ace5ba6893e..a1c8396d78f 100644 --- a/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h +++ b/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -31,289 +32,320 @@ template class NeptuneGraphWaiter { public: Aws::Utils::WaiterOutcome WaitUntilExportTaskSuccessful(const Model::GetExportTaskRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), - [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), - [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetExportTaskOutcome; + using RequestT = Model::GetExportTaskRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ExportTaskSuccessfulWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLING"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ExportTaskSuccessfulWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ExportTaskSuccessfulWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ExportTaskSuccessfulWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetExportTaskRequest& req) { return static_cast(this)->GetExportTask(req); }; - Aws::Utils::Waiter waiter(60, 480, acceptors, operation, - "WaitUntilExportTaskSuccessful"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetExportTask(req); }; + Aws::Utils::Waiter waiter(60, 480, std::move(acceptors), operation, "WaitUntilExportTaskSuccessful"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilExportTaskCancelled(const Model::GetExportTaskRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, - [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return ((result.GetStatus() != "CANCELLING") && (result.GetStatus() != "CANCELLED")) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetExportTaskOutcome; + using RequestT = Model::GetExportTaskRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ExportTaskCancelledWaiter", Aws::Utils::WaiterState::FAILURE, true, + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return ((result.GetStatus() != "CANCELLING") && (result.GetStatus() != "CANCELLED")) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ExportTaskCancelledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CANCELLED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetExportTaskRequest& req) { return static_cast(this)->GetExportTask(req); }; - Aws::Utils::Waiter waiter(60, 60, acceptors, operation, - "WaitUntilExportTaskCancelled"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetExportTask(req); }; + Aws::Utils::Waiter waiter(60, 60, std::move(acceptors), operation, "WaitUntilExportTaskCancelled"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilGraphAvailable(const Model::GetGraphRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("AVAILABLE"), - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetGraphOutcome; + using RequestT = Model::GetGraphRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "GraphAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETING"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "GraphAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "GraphAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("AVAILABLE"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + })); - auto operation = [this](const Model::GetGraphRequest& req) { return static_cast(this)->GetGraph(req); }; - Aws::Utils::Waiter waiter(60, 480, acceptors, operation, "WaitUntilGraphAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetGraph(req); }; + Aws::Utils::Waiter waiter(60, 480, std::move(acceptors), operation, "WaitUntilGraphAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilGraphDeleted(const Model::GetGraphRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetStatus() != "DELETING") == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::GetGraphOutcome; + using RequestT = Model::GetGraphRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "GraphDeletedWaiter", Aws::Utils::WaiterState::FAILURE, true, + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetStatus() != "DELETING") == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("GraphDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::GetGraphRequest& req) { return static_cast(this)->GetGraph(req); }; - Aws::Utils::Waiter waiter(60, 60, acceptors, operation, "WaitUntilGraphDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetGraph(req); }; + Aws::Utils::Waiter waiter(60, 60, std::move(acceptors), operation, "WaitUntilGraphDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilGraphStopped(const Model::GetGraphRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("STOPPED"), - [](const Model::GetGraphOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::GraphStatusMapper::GetNameForGraphStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, - [](const Model::GetGraphOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetStatus() != "STOPPING") == expected.get(); - }}); + using OutcomeT = Model::GetGraphOutcome; + using RequestT = Model::GetGraphRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "GraphStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"), + [](const Model::GetGraphOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::GraphStatusMapper::GetNameForGraphStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "GraphStoppedWaiter", Aws::Utils::WaiterState::FAILURE, true, + [](const Model::GetGraphOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetStatus() != "STOPPING") == expected.get(); + })); - auto operation = [this](const Model::GetGraphRequest& req) { return static_cast(this)->GetGraph(req); }; - Aws::Utils::Waiter waiter(20, 90, acceptors, operation, "WaitUntilGraphStopped"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetGraph(req); }; + Aws::Utils::Waiter waiter(20, 90, std::move(acceptors), operation, "WaitUntilGraphStopped"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilGraphSnapshotAvailable(const Model::GetGraphSnapshotRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("AVAILABLE"), - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetGraphSnapshotOutcome; + using RequestT = Model::GetGraphSnapshotRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "GraphSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETING"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "GraphSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "GraphSnapshotAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("AVAILABLE"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + })); - auto operation = [this](const Model::GetGraphSnapshotRequest& req) { return static_cast(this)->GetGraphSnapshot(req); }; - Aws::Utils::Waiter waiter(60, 120, acceptors, operation, - "WaitUntilGraphSnapshotAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetGraphSnapshot(req); }; + Aws::Utils::Waiter waiter(60, 120, std::move(acceptors), operation, "WaitUntilGraphSnapshotAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilGraphSnapshotDeleted(const Model::GetGraphSnapshotRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetStatus() != "DELETING") == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::GetGraphSnapshotOutcome; + using RequestT = Model::GetGraphSnapshotRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "GraphSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, true, + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetStatus() != "DELETING") == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "GraphSnapshotDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::GetGraphSnapshotRequest& req) { return static_cast(this)->GetGraphSnapshot(req); }; - Aws::Utils::Waiter waiter(60, 60, acceptors, operation, - "WaitUntilGraphSnapshotDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetGraphSnapshot(req); }; + Aws::Utils::Waiter waiter(60, 60, std::move(acceptors), operation, "WaitUntilGraphSnapshotDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilImportTaskSuccessful(const Model::GetImportTaskRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), - [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ROLLING_BACK"), - [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), - [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetImportTaskOutcome; + using RequestT = Model::GetImportTaskRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ImportTaskSuccessfulWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLING"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImportTaskSuccessfulWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImportTaskSuccessfulWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ROLLING_BACK"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImportTaskSuccessfulWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImportTaskSuccessfulWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetImportTaskRequest& req) { return static_cast(this)->GetImportTask(req); }; - Aws::Utils::Waiter waiter(60, 480, acceptors, operation, - "WaitUntilImportTaskSuccessful"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetImportTask(req); }; + Aws::Utils::Waiter waiter(60, 480, std::move(acceptors), operation, "WaitUntilImportTaskSuccessful"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilImportTaskCancelled(const Model::GetImportTaskRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, - [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return ((result.GetStatus() != "CANCELLING") && (result.GetStatus() != "CANCELLED")) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetImportTaskOutcome; + using RequestT = Model::GetImportTaskRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ImportTaskCancelledWaiter", Aws::Utils::WaiterState::FAILURE, true, + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return ((result.GetStatus() != "CANCELLING") && (result.GetStatus() != "CANCELLED")) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImportTaskCancelledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CANCELLED"), + [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImportTaskStatusMapper::GetNameForImportTaskStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetImportTaskRequest& req) { return static_cast(this)->GetImportTask(req); }; - Aws::Utils::Waiter waiter(60, 60, acceptors, operation, - "WaitUntilImportTaskCancelled"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetImportTask(req); }; + Aws::Utils::Waiter waiter(60, 60, std::move(acceptors), operation, "WaitUntilImportTaskCancelled"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPrivateGraphEndpointAvailable( const Model::GetPrivateGraphEndpointRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("AVAILABLE"), - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetPrivateGraphEndpointOutcome; + using RequestT = Model::GetPrivateGraphEndpointRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "PrivateGraphEndpointAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETING"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PrivateGraphEndpointAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PrivateGraphEndpointAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("AVAILABLE"), + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::PrivateGraphEndpointStatusMapper::GetNameForPrivateGraphEndpointStatus(result.GetStatus()) == + expected.get(); + })); - auto operation = [this](const Model::GetPrivateGraphEndpointRequest& req) { - return static_cast(this)->GetPrivateGraphEndpoint(req); - }; - Aws::Utils::Waiter waiter( - 10, 180, acceptors, operation, "WaitUntilPrivateGraphEndpointAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetPrivateGraphEndpoint(req); }; + Aws::Utils::Waiter waiter(10, 180, std::move(acceptors), operation, "WaitUntilPrivateGraphEndpointAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilPrivateGraphEndpointDeleted( const Model::GetPrivateGraphEndpointRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, true, - [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetStatus() != "DELETING") == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::GetPrivateGraphEndpointOutcome; + using RequestT = Model::GetPrivateGraphEndpointRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "PrivateGraphEndpointDeletedWaiter", Aws::Utils::WaiterState::FAILURE, true, + [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetStatus() != "DELETING") == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "PrivateGraphEndpointDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::GetPrivateGraphEndpointRequest& req) { - return static_cast(this)->GetPrivateGraphEndpoint(req); - }; - Aws::Utils::Waiter waiter( - 10, 180, acceptors, operation, "WaitUntilPrivateGraphEndpointDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetPrivateGraphEndpoint(req); }; + Aws::Utils::Waiter waiter(10, 180, std::move(acceptors), operation, "WaitUntilPrivateGraphEndpointDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h b/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h index f996df4f151..a574268552e 100644 --- a/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h +++ b/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,114 +20,113 @@ class NeptuneWaiter { public: Aws::Utils::WaiterOutcome WaitUntilDBInstanceAvailable( const Model::DescribeDBInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBInstancesOutcome; + using RequestT = Model::DescribeDBInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBInstancesRequest& req) { - return static_cast(this)->DescribeDBInstances(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilDBInstanceAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBInstances(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilDBInstanceAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilDBInstanceDeleted( const Model::DescribeDBInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBInstanceNotFound")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBInstancesOutcome; + using RequestT = Model::DescribeDBInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>("DBInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("DBInstanceNotFound"))); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("rebooting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBInstancesRequest& req) { - return static_cast(this)->DescribeDBInstances(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilDBInstanceDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBInstances(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilDBInstanceDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-neptunedata/include/aws/neptunedata/NeptunedataWaiter.h b/generated/src/aws-cpp-sdk-neptunedata/include/aws/neptunedata/NeptunedataWaiter.h new file mode 100644 index 00000000000..a32939065b2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-neptunedata/include/aws/neptunedata/NeptunedataWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace neptunedata { + +template +class NeptunedataWaiter { + public: +}; +} // namespace neptunedata +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-network-firewall/include/aws/network-firewall/NetworkFirewallWaiter.h b/generated/src/aws-cpp-sdk-network-firewall/include/aws/network-firewall/NetworkFirewallWaiter.h new file mode 100644 index 00000000000..f63a08cb361 --- /dev/null +++ b/generated/src/aws-cpp-sdk-network-firewall/include/aws/network-firewall/NetworkFirewallWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace NetworkFirewall { + +template +class NetworkFirewallWaiter { + public: +}; +} // namespace NetworkFirewall +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-networkflowmonitor/include/aws/networkflowmonitor/NetworkFlowMonitorWaiter.h b/generated/src/aws-cpp-sdk-networkflowmonitor/include/aws/networkflowmonitor/NetworkFlowMonitorWaiter.h new file mode 100644 index 00000000000..ffca2abd249 --- /dev/null +++ b/generated/src/aws-cpp-sdk-networkflowmonitor/include/aws/networkflowmonitor/NetworkFlowMonitorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace NetworkFlowMonitor { + +template +class NetworkFlowMonitorWaiter { + public: +}; +} // namespace NetworkFlowMonitor +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-networkmanager/include/aws/networkmanager/NetworkManagerWaiter.h b/generated/src/aws-cpp-sdk-networkmanager/include/aws/networkmanager/NetworkManagerWaiter.h new file mode 100644 index 00000000000..ee11768e6ac --- /dev/null +++ b/generated/src/aws-cpp-sdk-networkmanager/include/aws/networkmanager/NetworkManagerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace NetworkManager { + +template +class NetworkManagerWaiter { + public: +}; +} // namespace NetworkManager +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-networkmonitor/include/aws/networkmonitor/NetworkMonitorWaiter.h b/generated/src/aws-cpp-sdk-networkmonitor/include/aws/networkmonitor/NetworkMonitorWaiter.h new file mode 100644 index 00000000000..75c1bbf28ca --- /dev/null +++ b/generated/src/aws-cpp-sdk-networkmonitor/include/aws/networkmonitor/NetworkMonitorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace NetworkMonitor { + +template +class NetworkMonitorWaiter { + public: +}; +} // namespace NetworkMonitor +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-notifications/include/aws/notifications/NotificationsWaiter.h b/generated/src/aws-cpp-sdk-notifications/include/aws/notifications/NotificationsWaiter.h new file mode 100644 index 00000000000..639afdcccf0 --- /dev/null +++ b/generated/src/aws-cpp-sdk-notifications/include/aws/notifications/NotificationsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Notifications { + +template +class NotificationsWaiter { + public: +}; +} // namespace Notifications +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-notificationscontacts/include/aws/notificationscontacts/NotificationsContactsWaiter.h b/generated/src/aws-cpp-sdk-notificationscontacts/include/aws/notificationscontacts/NotificationsContactsWaiter.h new file mode 100644 index 00000000000..60ca7971a20 --- /dev/null +++ b/generated/src/aws-cpp-sdk-notificationscontacts/include/aws/notificationscontacts/NotificationsContactsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace NotificationsContacts { + +template +class NotificationsContactsWaiter { + public: +}; +} // namespace NotificationsContacts +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-nova-act/include/aws/nova-act/NovaActWaiter.h b/generated/src/aws-cpp-sdk-nova-act/include/aws/nova-act/NovaActWaiter.h new file mode 100644 index 00000000000..d06dc4c5222 --- /dev/null +++ b/generated/src/aws-cpp-sdk-nova-act/include/aws/nova-act/NovaActWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace NovaAct { + +template +class NovaActWaiter { + public: +}; +} // namespace NovaAct +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-oam/include/aws/oam/OAMWaiter.h b/generated/src/aws-cpp-sdk-oam/include/aws/oam/OAMWaiter.h new file mode 100644 index 00000000000..70bbe293999 --- /dev/null +++ b/generated/src/aws-cpp-sdk-oam/include/aws/oam/OAMWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace OAM { + +template +class OAMWaiter { + public: +}; +} // namespace OAM +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-observabilityadmin/include/aws/observabilityadmin/ObservabilityAdminWaiter.h b/generated/src/aws-cpp-sdk-observabilityadmin/include/aws/observabilityadmin/ObservabilityAdminWaiter.h new file mode 100644 index 00000000000..dbfb6f26c6f --- /dev/null +++ b/generated/src/aws-cpp-sdk-observabilityadmin/include/aws/observabilityadmin/ObservabilityAdminWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ObservabilityAdmin { + +template +class ObservabilityAdminWaiter { + public: +}; +} // namespace ObservabilityAdmin +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-odb/include/aws/odb/OdbWaiter.h b/generated/src/aws-cpp-sdk-odb/include/aws/odb/OdbWaiter.h new file mode 100644 index 00000000000..92e0fe8d0a8 --- /dev/null +++ b/generated/src/aws-cpp-sdk-odb/include/aws/odb/OdbWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace odb { + +template +class OdbWaiter { + public: +}; +} // namespace odb +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h b/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h index 981635b0a0d..a455e0dcdc4 100644 --- a/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h +++ b/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -43,710 +44,800 @@ class OmicsWaiter { public: Aws::Utils::WaiterOutcome WaitUntilAnnotationImportJobCreated( const Model::GetAnnotationImportJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetAnnotationImportJobRequest& req) { - return static_cast(this)->GetAnnotationImportJob(req); - }; - Aws::Utils::Waiter waiter( - 30, 20, acceptors, operation, "WaitUntilAnnotationImportJobCreated"); + using OutcomeT = Model::GetAnnotationImportJobOutcome; + using RequestT = Model::GetAnnotationImportJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationImportJobCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationImportJobCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationImportJobCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationImportJobCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationImportJobCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetAnnotationImportJob(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilAnnotationImportJobCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilAnnotationStoreCreated( const Model::GetAnnotationStoreRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetAnnotationStoreRequest& req) { - return static_cast(this)->GetAnnotationStore(req); - }; - Aws::Utils::Waiter waiter(30, 20, acceptors, operation, - "WaitUntilAnnotationStoreCreated"); + using OutcomeT = Model::GetAnnotationStoreOutcome; + using RequestT = Model::GetAnnotationStoreRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetAnnotationStore(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilAnnotationStoreCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilAnnotationStoreDeleted( const Model::GetAnnotationStoreRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetAnnotationStoreRequest& req) { - return static_cast(this)->GetAnnotationStore(req); - }; - Aws::Utils::Waiter waiter(30, 20, acceptors, operation, - "WaitUntilAnnotationStoreDeleted"); + using OutcomeT = Model::GetAnnotationStoreOutcome; + using RequestT = Model::GetAnnotationStoreRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetAnnotationStore(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilAnnotationStoreDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilAnnotationStoreVersionCreated( const Model::GetAnnotationStoreVersionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetAnnotationStoreVersionRequest& req) { - return static_cast(this)->GetAnnotationStoreVersion(req); - }; - Aws::Utils::Waiter waiter( - 30, 20, acceptors, operation, "WaitUntilAnnotationStoreVersionCreated"); + using OutcomeT = Model::GetAnnotationStoreVersionOutcome; + using RequestT = Model::GetAnnotationStoreVersionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreVersionCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreVersionCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreVersionCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreVersionCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetAnnotationStoreVersion(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilAnnotationStoreVersionCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilAnnotationStoreVersionDeleted( const Model::GetAnnotationStoreVersionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetAnnotationStoreVersionRequest& req) { - return static_cast(this)->GetAnnotationStoreVersion(req); - }; - Aws::Utils::Waiter waiter( - 30, 20, acceptors, operation, "WaitUntilAnnotationStoreVersionDeleted"); + using OutcomeT = Model::GetAnnotationStoreVersionOutcome; + using RequestT = Model::GetAnnotationStoreVersionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreVersionDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreVersionDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "AnnotationStoreVersionDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetAnnotationStoreVersion(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilAnnotationStoreVersionDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReadSetActivationJobCompleted( const Model::GetReadSetActivationJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), - [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_FAILURES"), - [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetReadSetActivationJobRequest& req) { - return static_cast(this)->GetReadSetActivationJob(req); - }; - Aws::Utils::Waiter waiter( - 30, 20, acceptors, operation, "WaitUntilReadSetActivationJobCompleted"); + using OutcomeT = Model::GetReadSetActivationJobOutcome; + using RequestT = Model::GetReadSetActivationJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CANCELLING"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("COMPLETED_WITH_FAILURES"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetReadSetActivationJob(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilReadSetActivationJobCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReadSetExportJobCompleted( const Model::GetReadSetExportJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), - [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_FAILURES"), - [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetReadSetExportJobRequest& req) { - return static_cast(this)->GetReadSetExportJob(req); - }; - Aws::Utils::Waiter waiter(30, 20, acceptors, operation, - "WaitUntilReadSetExportJobCompleted"); + using OutcomeT = Model::GetReadSetExportJobOutcome; + using RequestT = Model::GetReadSetExportJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CANCELLING"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("COMPLETED_WITH_FAILURES"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetReadSetExportJob(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilReadSetExportJobCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReadSetImportJobCompleted( const Model::GetReadSetImportJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), - [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_FAILURES"), - [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetReadSetImportJobRequest& req) { - return static_cast(this)->GetReadSetImportJob(req); - }; - Aws::Utils::Waiter waiter(30, 20, acceptors, operation, - "WaitUntilReadSetImportJobCompleted"); + using OutcomeT = Model::GetReadSetImportJobOutcome; + using RequestT = Model::GetReadSetImportJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CANCELLING"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("COMPLETED_WITH_FAILURES"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetReadSetImportJob(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilReadSetImportJobCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilReferenceImportJobCompleted( const Model::GetReferenceImportJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLING"), - [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED_WITH_FAILURES"), - [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetReferenceImportJobRequest& req) { - return static_cast(this)->GetReferenceImportJob(req); - }; - Aws::Utils::Waiter waiter( - 30, 20, acceptors, operation, "WaitUntilReferenceImportJobCompleted"); + using OutcomeT = Model::GetReferenceImportJobOutcome; + using RequestT = Model::GetReferenceImportJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CANCELLING"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("COMPLETED_WITH_FAILURES"), + [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetReferenceImportJob(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilReferenceImportJobCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilRunRunning(const Model::GetRunRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetRunRequest& req) { return static_cast(this)->GetRun(req); }; - Aws::Utils::Waiter waiter(30, 20, acceptors, operation, "WaitUntilRunRunning"); + using OutcomeT = Model::GetRunOutcome; + using RequestT = Model::GetRunRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "RunRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RunRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RunRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RunRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RunRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRun(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilRunRunning"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilRunCompleted(const Model::GetRunRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetRunRequest& req) { return static_cast(this)->GetRun(req); }; - Aws::Utils::Waiter waiter(30, 20, acceptors, operation, "WaitUntilRunCompleted"); + using OutcomeT = Model::GetRunOutcome; + using RequestT = Model::GetRunRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "RunCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RunCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RunCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RunCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("RUNNING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RunCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RunCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRun(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilRunCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTaskRunning(const Model::GetRunTaskRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetRunTaskRequest& req) { return static_cast(this)->GetRunTask(req); }; - Aws::Utils::Waiter waiter(30, 20, acceptors, operation, "WaitUntilTaskRunning"); + using OutcomeT = Model::GetRunTaskOutcome; + using RequestT = Model::GetRunTaskRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TaskRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TaskRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TaskRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRunTask(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilTaskRunning"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTaskCompleted(const Model::GetRunTaskRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STARTING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("STOPPING"), - [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetRunTaskRequest& req) { return static_cast(this)->GetRunTask(req); }; - Aws::Utils::Waiter waiter(30, 20, acceptors, operation, "WaitUntilTaskCompleted"); + using OutcomeT = Model::GetRunTaskOutcome; + using RequestT = Model::GetRunTaskRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TaskCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TaskCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TaskCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TaskCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("RUNNING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TaskCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"), + [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TaskCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRunTask(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilTaskCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVariantImportJobCreated( const Model::GetVariantImportJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("SUBMITTED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("IN_PROGRESS"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CANCELLED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetVariantImportJobRequest& req) { - return static_cast(this)->GetVariantImportJob(req); - }; - Aws::Utils::Waiter waiter(30, 20, acceptors, operation, - "WaitUntilVariantImportJobCreated"); + using OutcomeT = Model::GetVariantImportJobOutcome; + using RequestT = Model::GetVariantImportJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "VariantImportJobCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VariantImportJobCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VariantImportJobCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VariantImportJobCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CANCELLED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VariantImportJobCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetVariantImportJob(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilVariantImportJobCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVariantStoreCreated(const Model::GetVariantStoreRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetVariantStoreRequest& req) { return static_cast(this)->GetVariantStore(req); }; - Aws::Utils::Waiter waiter(30, 20, acceptors, operation, - "WaitUntilVariantStoreCreated"); + using OutcomeT = Model::GetVariantStoreOutcome; + using RequestT = Model::GetVariantStoreRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "VariantStoreCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VariantStoreCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VariantStoreCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VariantStoreCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetVariantStore(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilVariantStoreCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVariantStoreDeleted(const Model::GetVariantStoreRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetVariantStoreRequest& req) { return static_cast(this)->GetVariantStore(req); }; - Aws::Utils::Waiter waiter(30, 20, acceptors, operation, - "WaitUntilVariantStoreDeleted"); + using OutcomeT = Model::GetVariantStoreOutcome; + using RequestT = Model::GetVariantStoreRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "VariantStoreDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VariantStoreDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "VariantStoreDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetVariantStore(req); }; + Aws::Utils::Waiter waiter(30, 20, std::move(acceptors), operation, "WaitUntilVariantStoreDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilWorkflowActive(const Model::GetWorkflowRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetWorkflowRequest& req) { return static_cast(this)->GetWorkflow(req); }; - Aws::Utils::Waiter waiter(3, 10, acceptors, operation, "WaitUntilWorkflowActive"); + using OutcomeT = Model::GetWorkflowOutcome; + using RequestT = Model::GetWorkflowRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "WorkflowActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WorkflowActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WorkflowActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WorkflowActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetWorkflow(req); }; + Aws::Utils::Waiter waiter(3, 10, std::move(acceptors), operation, "WaitUntilWorkflowActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilWorkflowVersionActive( const Model::GetWorkflowVersionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - - auto operation = [this](const Model::GetWorkflowVersionRequest& req) { - return static_cast(this)->GetWorkflowVersion(req); - }; - Aws::Utils::Waiter waiter(3, 10, acceptors, operation, - "WaitUntilWorkflowVersionActive"); + using OutcomeT = Model::GetWorkflowVersionOutcome; + using RequestT = Model::GetWorkflowVersionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "WorkflowVersionActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WorkflowVersionActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WorkflowVersionActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WorkflowVersionActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetWorkflowVersion(req); }; + Aws::Utils::Waiter waiter(3, 10, std::move(acceptors), operation, "WaitUntilWorkflowVersionActive"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-opensearch/include/aws/opensearch/OpenSearchServiceWaiter.h b/generated/src/aws-cpp-sdk-opensearch/include/aws/opensearch/OpenSearchServiceWaiter.h new file mode 100644 index 00000000000..2ad24bc5b27 --- /dev/null +++ b/generated/src/aws-cpp-sdk-opensearch/include/aws/opensearch/OpenSearchServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace OpenSearchService { + +template +class OpenSearchServiceWaiter { + public: +}; +} // namespace OpenSearchService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-opensearchserverless/include/aws/opensearchserverless/OpenSearchServerlessWaiter.h b/generated/src/aws-cpp-sdk-opensearchserverless/include/aws/opensearchserverless/OpenSearchServerlessWaiter.h new file mode 100644 index 00000000000..483d9ad9390 --- /dev/null +++ b/generated/src/aws-cpp-sdk-opensearchserverless/include/aws/opensearchserverless/OpenSearchServerlessWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace OpenSearchServerless { + +template +class OpenSearchServerlessWaiter { + public: +}; +} // namespace OpenSearchServerless +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-organizations/include/aws/organizations/OrganizationsWaiter.h b/generated/src/aws-cpp-sdk-organizations/include/aws/organizations/OrganizationsWaiter.h new file mode 100644 index 00000000000..b840f4eaf2f --- /dev/null +++ b/generated/src/aws-cpp-sdk-organizations/include/aws/organizations/OrganizationsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Organizations { + +template +class OrganizationsWaiter { + public: +}; +} // namespace Organizations +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-osis/include/aws/osis/OSISWaiter.h b/generated/src/aws-cpp-sdk-osis/include/aws/osis/OSISWaiter.h new file mode 100644 index 00000000000..9da4027af07 --- /dev/null +++ b/generated/src/aws-cpp-sdk-osis/include/aws/osis/OSISWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace OSIS { + +template +class OSISWaiter { + public: +}; +} // namespace OSIS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-outposts/include/aws/outposts/OutpostsWaiter.h b/generated/src/aws-cpp-sdk-outposts/include/aws/outposts/OutpostsWaiter.h new file mode 100644 index 00000000000..c1c90fac30e --- /dev/null +++ b/generated/src/aws-cpp-sdk-outposts/include/aws/outposts/OutpostsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Outposts { + +template +class OutpostsWaiter { + public: +}; +} // namespace Outposts +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-panorama/include/aws/panorama/PanoramaWaiter.h b/generated/src/aws-cpp-sdk-panorama/include/aws/panorama/PanoramaWaiter.h new file mode 100644 index 00000000000..090fd38c77c --- /dev/null +++ b/generated/src/aws-cpp-sdk-panorama/include/aws/panorama/PanoramaWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Panorama { + +template +class PanoramaWaiter { + public: +}; +} // namespace Panorama +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-partnercentral-account/include/aws/partnercentral-account/PartnerCentralAccountWaiter.h b/generated/src/aws-cpp-sdk-partnercentral-account/include/aws/partnercentral-account/PartnerCentralAccountWaiter.h new file mode 100644 index 00000000000..e31b4995f39 --- /dev/null +++ b/generated/src/aws-cpp-sdk-partnercentral-account/include/aws/partnercentral-account/PartnerCentralAccountWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PartnerCentralAccount { + +template +class PartnerCentralAccountWaiter { + public: +}; +} // namespace PartnerCentralAccount +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-partnercentral-benefits/include/aws/partnercentral-benefits/PartnerCentralBenefitsWaiter.h b/generated/src/aws-cpp-sdk-partnercentral-benefits/include/aws/partnercentral-benefits/PartnerCentralBenefitsWaiter.h new file mode 100644 index 00000000000..18afe8ed624 --- /dev/null +++ b/generated/src/aws-cpp-sdk-partnercentral-benefits/include/aws/partnercentral-benefits/PartnerCentralBenefitsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PartnerCentralBenefits { + +template +class PartnerCentralBenefitsWaiter { + public: +}; +} // namespace PartnerCentralBenefits +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-partnercentral-channel/include/aws/partnercentral-channel/PartnerCentralChannelWaiter.h b/generated/src/aws-cpp-sdk-partnercentral-channel/include/aws/partnercentral-channel/PartnerCentralChannelWaiter.h new file mode 100644 index 00000000000..db279cb4ccc --- /dev/null +++ b/generated/src/aws-cpp-sdk-partnercentral-channel/include/aws/partnercentral-channel/PartnerCentralChannelWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PartnerCentralChannel { + +template +class PartnerCentralChannelWaiter { + public: +}; +} // namespace PartnerCentralChannel +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-partnercentral-selling/include/aws/partnercentral-selling/PartnerCentralSellingWaiter.h b/generated/src/aws-cpp-sdk-partnercentral-selling/include/aws/partnercentral-selling/PartnerCentralSellingWaiter.h new file mode 100644 index 00000000000..af668576491 --- /dev/null +++ b/generated/src/aws-cpp-sdk-partnercentral-selling/include/aws/partnercentral-selling/PartnerCentralSellingWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PartnerCentralSelling { + +template +class PartnerCentralSellingWaiter { + public: +}; +} // namespace PartnerCentralSelling +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-payment-cryptography-data/include/aws/payment-cryptography-data/PaymentCryptographyDataWaiter.h b/generated/src/aws-cpp-sdk-payment-cryptography-data/include/aws/payment-cryptography-data/PaymentCryptographyDataWaiter.h new file mode 100644 index 00000000000..e9101ce99d9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-payment-cryptography-data/include/aws/payment-cryptography-data/PaymentCryptographyDataWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PaymentCryptographyData { + +template +class PaymentCryptographyDataWaiter { + public: +}; +} // namespace PaymentCryptographyData +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/PaymentCryptographyWaiter.h b/generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/PaymentCryptographyWaiter.h new file mode 100644 index 00000000000..e32f0b4bf27 --- /dev/null +++ b/generated/src/aws-cpp-sdk-payment-cryptography/include/aws/payment-cryptography/PaymentCryptographyWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PaymentCryptography { + +template +class PaymentCryptographyWaiter { + public: +}; +} // namespace PaymentCryptography +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-pca-connector-ad/include/aws/pca-connector-ad/PcaConnectorAdWaiter.h b/generated/src/aws-cpp-sdk-pca-connector-ad/include/aws/pca-connector-ad/PcaConnectorAdWaiter.h new file mode 100644 index 00000000000..73bd54805e2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-pca-connector-ad/include/aws/pca-connector-ad/PcaConnectorAdWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PcaConnectorAd { + +template +class PcaConnectorAdWaiter { + public: +}; +} // namespace PcaConnectorAd +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-pca-connector-scep/include/aws/pca-connector-scep/PcaConnectorScepWaiter.h b/generated/src/aws-cpp-sdk-pca-connector-scep/include/aws/pca-connector-scep/PcaConnectorScepWaiter.h new file mode 100644 index 00000000000..cd5ca02fd39 --- /dev/null +++ b/generated/src/aws-cpp-sdk-pca-connector-scep/include/aws/pca-connector-scep/PcaConnectorScepWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PcaConnectorScep { + +template +class PcaConnectorScepWaiter { + public: +}; +} // namespace PcaConnectorScep +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-pcs/include/aws/pcs/PCSWaiter.h b/generated/src/aws-cpp-sdk-pcs/include/aws/pcs/PCSWaiter.h new file mode 100644 index 00000000000..1506b1a4b83 --- /dev/null +++ b/generated/src/aws-cpp-sdk-pcs/include/aws/pcs/PCSWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PCS { + +template +class PCSWaiter { + public: +}; +} // namespace PCS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-personalize-events/include/aws/personalize-events/PersonalizeEventsWaiter.h b/generated/src/aws-cpp-sdk-personalize-events/include/aws/personalize-events/PersonalizeEventsWaiter.h new file mode 100644 index 00000000000..bd327724aad --- /dev/null +++ b/generated/src/aws-cpp-sdk-personalize-events/include/aws/personalize-events/PersonalizeEventsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PersonalizeEvents { + +template +class PersonalizeEventsWaiter { + public: +}; +} // namespace PersonalizeEvents +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-personalize-runtime/include/aws/personalize-runtime/PersonalizeRuntimeWaiter.h b/generated/src/aws-cpp-sdk-personalize-runtime/include/aws/personalize-runtime/PersonalizeRuntimeWaiter.h new file mode 100644 index 00000000000..b2fcaed9b31 --- /dev/null +++ b/generated/src/aws-cpp-sdk-personalize-runtime/include/aws/personalize-runtime/PersonalizeRuntimeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PersonalizeRuntime { + +template +class PersonalizeRuntimeWaiter { + public: +}; +} // namespace PersonalizeRuntime +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-personalize/include/aws/personalize/PersonalizeWaiter.h b/generated/src/aws-cpp-sdk-personalize/include/aws/personalize/PersonalizeWaiter.h new file mode 100644 index 00000000000..66dfa0c8e3b --- /dev/null +++ b/generated/src/aws-cpp-sdk-personalize/include/aws/personalize/PersonalizeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Personalize { + +template +class PersonalizeWaiter { + public: +}; +} // namespace Personalize +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-pi/include/aws/pi/PIWaiter.h b/generated/src/aws-cpp-sdk-pi/include/aws/pi/PIWaiter.h new file mode 100644 index 00000000000..e6cad46ada7 --- /dev/null +++ b/generated/src/aws-cpp-sdk-pi/include/aws/pi/PIWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PI { + +template +class PIWaiter { + public: +}; +} // namespace PI +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-pinpoint-email/include/aws/pinpoint-email/PinpointEmailWaiter.h b/generated/src/aws-cpp-sdk-pinpoint-email/include/aws/pinpoint-email/PinpointEmailWaiter.h new file mode 100644 index 00000000000..561d8919d7c --- /dev/null +++ b/generated/src/aws-cpp-sdk-pinpoint-email/include/aws/pinpoint-email/PinpointEmailWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PinpointEmail { + +template +class PinpointEmailWaiter { + public: +}; +} // namespace PinpointEmail +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-pinpoint-sms-voice-v2/include/aws/pinpoint-sms-voice-v2/PinpointSMSVoiceV2Waiter.h b/generated/src/aws-cpp-sdk-pinpoint-sms-voice-v2/include/aws/pinpoint-sms-voice-v2/PinpointSMSVoiceV2Waiter.h new file mode 100644 index 00000000000..15e3557ae02 --- /dev/null +++ b/generated/src/aws-cpp-sdk-pinpoint-sms-voice-v2/include/aws/pinpoint-sms-voice-v2/PinpointSMSVoiceV2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PinpointSMSVoiceV2 { + +template +class PinpointSMSVoiceV2Waiter { + public: +}; +} // namespace PinpointSMSVoiceV2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-pinpoint/include/aws/pinpoint/PinpointWaiter.h b/generated/src/aws-cpp-sdk-pinpoint/include/aws/pinpoint/PinpointWaiter.h new file mode 100644 index 00000000000..31c0975f056 --- /dev/null +++ b/generated/src/aws-cpp-sdk-pinpoint/include/aws/pinpoint/PinpointWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Pinpoint { + +template +class PinpointWaiter { + public: +}; +} // namespace Pinpoint +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-pipes/include/aws/pipes/PipesWaiter.h b/generated/src/aws-cpp-sdk-pipes/include/aws/pipes/PipesWaiter.h new file mode 100644 index 00000000000..d0611efaab3 --- /dev/null +++ b/generated/src/aws-cpp-sdk-pipes/include/aws/pipes/PipesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Pipes { + +template +class PipesWaiter { + public: +}; +} // namespace Pipes +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-polly/include/aws/polly/PollyWaiter.h b/generated/src/aws-cpp-sdk-polly/include/aws/polly/PollyWaiter.h new file mode 100644 index 00000000000..1cc20592d6d --- /dev/null +++ b/generated/src/aws-cpp-sdk-polly/include/aws/polly/PollyWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Polly { + +template +class PollyWaiter { + public: +}; +} // namespace Polly +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-pricing/include/aws/pricing/PricingWaiter.h b/generated/src/aws-cpp-sdk-pricing/include/aws/pricing/PricingWaiter.h new file mode 100644 index 00000000000..3396d2df77a --- /dev/null +++ b/generated/src/aws-cpp-sdk-pricing/include/aws/pricing/PricingWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Pricing { + +template +class PricingWaiter { + public: +}; +} // namespace Pricing +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h b/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h index aeafcfe5a85..1d816f747dd 100644 --- a/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h +++ b/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -28,250 +29,284 @@ template class ProtonWaiter { public: Aws::Utils::WaiterOutcome WaitUntilComponentDeployed(const Model::GetComponentRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), - [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetComponent().GetDeploymentStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetComponent().GetDeploymentStatus() == expected.get(); - }}); + using OutcomeT = Model::GetComponentOutcome; + using RequestT = Model::GetComponentRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ComponentDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), + [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetComponent().GetDeploymentStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ComponentDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetComponent().GetDeploymentStatus() == expected.get(); + })); - auto operation = [this](const Model::GetComponentRequest& req) { return static_cast(this)->GetComponent(req); }; - Aws::Utils::Waiter waiter(5, 999, acceptors, operation, - "WaitUntilComponentDeployed"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetComponent(req); }; + Aws::Utils::Waiter waiter(5, 999, std::move(acceptors), operation, "WaitUntilComponentDeployed"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilComponentDeleted(const Model::GetComponentRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetComponent().GetDeploymentStatus() == expected.get(); - }}); + using OutcomeT = Model::GetComponentOutcome; + using RequestT = Model::GetComponentRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("ComponentDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "ComponentDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetComponent().GetDeploymentStatus() == expected.get(); + })); - auto operation = [this](const Model::GetComponentRequest& req) { return static_cast(this)->GetComponent(req); }; - Aws::Utils::Waiter waiter(5, 999, acceptors, operation, - "WaitUntilComponentDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetComponent(req); }; + Aws::Utils::Waiter waiter(5, 999, std::move(acceptors), operation, "WaitUntilComponentDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilEnvironmentDeployed(const Model::GetEnvironmentRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), - [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetEnvironment().GetDeploymentStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetEnvironment().GetDeploymentStatus() == expected.get(); - }}); + using OutcomeT = Model::GetEnvironmentOutcome; + using RequestT = Model::GetEnvironmentRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), + [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetEnvironment().GetDeploymentStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetEnvironment().GetDeploymentStatus() == expected.get(); + })); - auto operation = [this](const Model::GetEnvironmentRequest& req) { return static_cast(this)->GetEnvironment(req); }; - Aws::Utils::Waiter waiter(5, 999, acceptors, operation, - "WaitUntilEnvironmentDeployed"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetEnvironment(req); }; + Aws::Utils::Waiter waiter(5, 999, std::move(acceptors), operation, "WaitUntilEnvironmentDeployed"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilEnvironmentTemplateVersionRegistered( const Model::GetEnvironmentTemplateVersionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DRAFT"), - [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("PUBLISHED"), - [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REGISTRATION_FAILED"), - [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetEnvironmentTemplateVersionOutcome; + using RequestT = Model::GetEnvironmentTemplateVersionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DRAFT"), + [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("PUBLISHED"), + [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "EnvironmentTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REGISTRATION_FAILED"), + [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetEnvironmentTemplateVersionRequest& req) { - return static_cast(this)->GetEnvironmentTemplateVersion(req); - }; - Aws::Utils::Waiter waiter( - 2, 150, acceptors, operation, "WaitUntilEnvironmentTemplateVersionRegistered"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetEnvironmentTemplateVersion(req); }; + Aws::Utils::Waiter waiter(2, 150, std::move(acceptors), operation, "WaitUntilEnvironmentTemplateVersionRegistered"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilServiceCreated(const Model::GetServiceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED_CLEANUP_COMPLETE"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED_CLEANUP_FAILED"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetServiceOutcome; + using RequestT = Model::GetServiceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED_CLEANUP_COMPLETE"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED_CLEANUP_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetServiceRequest& req) { return static_cast(this)->GetService(req); }; - Aws::Utils::Waiter waiter(5, 999, acceptors, operation, "WaitUntilServiceCreated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetService(req); }; + Aws::Utils::Waiter waiter(5, 999, std::move(acceptors), operation, "WaitUntilServiceCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilServiceUpdated(const Model::GetServiceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED_CLEANUP_COMPLETE"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED_CLEANUP_FAILED"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_COMPLETE_CLEANUP_FAILED"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetServiceOutcome; + using RequestT = Model::GetServiceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED_CLEANUP_COMPLETE"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED_CLEANUP_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_COMPLETE_CLEANUP_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetServiceRequest& req) { return static_cast(this)->GetService(req); }; - Aws::Utils::Waiter waiter(5, 999, acceptors, operation, "WaitUntilServiceUpdated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetService(req); }; + Aws::Utils::Waiter waiter(5, 999, std::move(acceptors), operation, "WaitUntilServiceUpdated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilServiceDeleted(const Model::GetServiceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetServiceOutcome; + using RequestT = Model::GetServiceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("ServiceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetServiceRequest& req) { return static_cast(this)->GetService(req); }; - Aws::Utils::Waiter waiter(5, 999, acceptors, operation, "WaitUntilServiceDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetService(req); }; + Aws::Utils::Waiter waiter(5, 999, std::move(acceptors), operation, "WaitUntilServiceDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilServicePipelineDeployed(const Model::GetServiceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetPipeline().GetDeploymentStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetService().GetPipeline().GetDeploymentStatus() == expected.get(); - }}); + using OutcomeT = Model::GetServiceOutcome; + using RequestT = Model::GetServiceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ServicePipelineDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetPipeline().GetDeploymentStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServicePipelineDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetService().GetPipeline().GetDeploymentStatus() == expected.get(); + })); - auto operation = [this](const Model::GetServiceRequest& req) { return static_cast(this)->GetService(req); }; - Aws::Utils::Waiter waiter(10, 360, acceptors, operation, - "WaitUntilServicePipelineDeployed"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetService(req); }; + Aws::Utils::Waiter waiter(10, 360, std::move(acceptors), operation, "WaitUntilServicePipelineDeployed"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilServiceInstanceDeployed( const Model::GetServiceInstanceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), - [](const Model::GetServiceInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetServiceInstance().GetDeploymentStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetServiceInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetServiceInstance().GetDeploymentStatus() == expected.get(); - }}); + using OutcomeT = Model::GetServiceInstanceOutcome; + using RequestT = Model::GetServiceInstanceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceInstanceDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), + [](const Model::GetServiceInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetServiceInstance().GetDeploymentStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceInstanceDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetServiceInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetServiceInstance().GetDeploymentStatus() == expected.get(); + })); - auto operation = [this](const Model::GetServiceInstanceRequest& req) { - return static_cast(this)->GetServiceInstance(req); - }; - Aws::Utils::Waiter waiter(5, 999, acceptors, operation, - "WaitUntilServiceInstanceDeployed"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetServiceInstance(req); }; + Aws::Utils::Waiter waiter(5, 999, std::move(acceptors), operation, "WaitUntilServiceInstanceDeployed"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilServiceTemplateVersionRegistered( const Model::GetServiceTemplateVersionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DRAFT"), - [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetServiceTemplateVersion().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("PUBLISHED"), - [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetServiceTemplateVersion().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REGISTRATION_FAILED"), - [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetServiceTemplateVersion().GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetServiceTemplateVersionOutcome; + using RequestT = Model::GetServiceTemplateVersionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DRAFT"), + [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetServiceTemplateVersion().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("PUBLISHED"), + [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetServiceTemplateVersion().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ServiceTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REGISTRATION_FAILED"), + [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetServiceTemplateVersion().GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetServiceTemplateVersionRequest& req) { - return static_cast(this)->GetServiceTemplateVersion(req); - }; - Aws::Utils::Waiter waiter( - 2, 150, acceptors, operation, "WaitUntilServiceTemplateVersionRegistered"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetServiceTemplateVersion(req); }; + Aws::Utils::Waiter waiter(2, 150, std::move(acceptors), operation, "WaitUntilServiceTemplateVersionRegistered"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-qapps/include/aws/qapps/QAppsWaiter.h b/generated/src/aws-cpp-sdk-qapps/include/aws/qapps/QAppsWaiter.h new file mode 100644 index 00000000000..d8135b6f960 --- /dev/null +++ b/generated/src/aws-cpp-sdk-qapps/include/aws/qapps/QAppsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace QApps { + +template +class QAppsWaiter { + public: +}; +} // namespace QApps +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-qbusiness/include/aws/qbusiness/QBusinessWaiter.h b/generated/src/aws-cpp-sdk-qbusiness/include/aws/qbusiness/QBusinessWaiter.h new file mode 100644 index 00000000000..9855132e75d --- /dev/null +++ b/generated/src/aws-cpp-sdk-qbusiness/include/aws/qbusiness/QBusinessWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace QBusiness { + +template +class QBusinessWaiter { + public: +}; +} // namespace QBusiness +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-qconnect/include/aws/qconnect/QConnectWaiter.h b/generated/src/aws-cpp-sdk-qconnect/include/aws/qconnect/QConnectWaiter.h new file mode 100644 index 00000000000..2265c6cb0de --- /dev/null +++ b/generated/src/aws-cpp-sdk-qconnect/include/aws/qconnect/QConnectWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace QConnect { + +template +class QConnectWaiter { + public: +}; +} // namespace QConnect +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-quicksight/include/aws/quicksight/QuickSightWaiter.h b/generated/src/aws-cpp-sdk-quicksight/include/aws/quicksight/QuickSightWaiter.h new file mode 100644 index 00000000000..448055bc839 --- /dev/null +++ b/generated/src/aws-cpp-sdk-quicksight/include/aws/quicksight/QuickSightWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace QuickSight { + +template +class QuickSightWaiter { + public: +}; +} // namespace QuickSight +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ram/include/aws/ram/RAMWaiter.h b/generated/src/aws-cpp-sdk-ram/include/aws/ram/RAMWaiter.h new file mode 100644 index 00000000000..6685dc10c5a --- /dev/null +++ b/generated/src/aws-cpp-sdk-ram/include/aws/ram/RAMWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace RAM { + +template +class RAMWaiter { + public: +}; +} // namespace RAM +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-rbin/include/aws/rbin/RecycleBinWaiter.h b/generated/src/aws-cpp-sdk-rbin/include/aws/rbin/RecycleBinWaiter.h new file mode 100644 index 00000000000..b95f5a2e8b7 --- /dev/null +++ b/generated/src/aws-cpp-sdk-rbin/include/aws/rbin/RecycleBinWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace RecycleBin { + +template +class RecycleBinWaiter { + public: +}; +} // namespace RecycleBin +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-rds-data/include/aws/rds-data/RDSDataServiceWaiter.h b/generated/src/aws-cpp-sdk-rds-data/include/aws/rds-data/RDSDataServiceWaiter.h new file mode 100644 index 00000000000..d0120281626 --- /dev/null +++ b/generated/src/aws-cpp-sdk-rds-data/include/aws/rds-data/RDSDataServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace RDSDataService { + +template +class RDSDataServiceWaiter { + public: +}; +} // namespace RDSDataService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h b/generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h index bf86d384b87..1303c879c28 100644 --- a/generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h +++ b/generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -26,507 +27,507 @@ template class RDSWaiter { public: Aws::Utils::WaiterOutcome WaitUntilDBClusterAvailable(const Model::DescribeDBClustersRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetDBClusters().begin(), result.GetDBClusters().end(), - [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusters().begin(), result.GetDBClusters().end(), - [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusters().begin(), result.GetDBClusters().end(), - [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusters().begin(), result.GetDBClusters().end(), - [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), - [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusters().begin(), result.GetDBClusters().end(), - [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), - [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusters().begin(), result.GetDBClusters().end(), - [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBClustersOutcome; + using RequestT = Model::DescribeDBClustersRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBClustersRequest& req) { - return static_cast(this)->DescribeDBClusters(req); - }; - Aws::Utils::Waiter waiter(30, 60, acceptors, operation, - "WaitUntilDBClusterAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBClusters(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBClusterAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilDBClusterDeleted(const Model::DescribeDBClustersRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetDBClusters().size() == 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBClusterNotFoundFault")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusters().begin(), result.GetDBClusters().end(), - [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), - [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusters().begin(), result.GetDBClusters().end(), - [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), - [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusters().begin(), result.GetDBClusters().end(), - [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), - [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusters().begin(), result.GetDBClusters().end(), - [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBClustersOutcome; + using RequestT = Model::DescribeDBClustersRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetDBClusters().size() == 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("DBClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("DBClusterNotFoundFault"))); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("rebooting"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusters().begin(), result.GetDBClusters().end(), + [&](const Model::DBCluster& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBClustersRequest& req) { - return static_cast(this)->DescribeDBClusters(req); - }; - Aws::Utils::Waiter waiter(30, 60, acceptors, operation, - "WaitUntilDBClusterDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBClusters(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBClusterDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilDBClusterSnapshotAvailable( const Model::DescribeDBClusterSnapshotsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), - [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), - [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), - [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), - [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), - [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), - [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), - [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), - [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBClusterSnapshotsOutcome; + using RequestT = Model::DescribeDBClusterSnapshotsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBClusterSnapshotsRequest& req) { - return static_cast(this)->DescribeDBClusterSnapshots(req); - }; - Aws::Utils::Waiter waiter( - 30, 60, acceptors, operation, "WaitUntilDBClusterSnapshotAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBClusterSnapshots(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBClusterSnapshotAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilDBClusterSnapshotDeleted( const Model::DescribeDBClusterSnapshotsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetDBClusterSnapshots().size() == 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBClusterSnapshotNotFoundFault")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), - [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), - [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), - [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), - [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), - [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), - [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), - [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBClusterSnapshotsOutcome; + using RequestT = Model::DescribeDBClusterSnapshotsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetDBClusterSnapshots().size() == 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DBClusterSnapshotNotFoundFault"))); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("rebooting"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBClusterSnapshots().begin(), result.GetDBClusterSnapshots().end(), + [&](const Model::DBClusterSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBClusterSnapshotsRequest& req) { - return static_cast(this)->DescribeDBClusterSnapshots(req); - }; - Aws::Utils::Waiter waiter( - 30, 60, acceptors, operation, "WaitUntilDBClusterSnapshotDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBClusterSnapshots(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBClusterSnapshotDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilDBInstanceAvailable( const Model::DescribeDBInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBInstancesOutcome; + using RequestT = Model::DescribeDBInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBInstancesRequest& req) { - return static_cast(this)->DescribeDBInstances(req); - }; - Aws::Utils::Waiter waiter(30, 60, acceptors, operation, - "WaitUntilDBInstanceAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBInstances(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBInstanceAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilDBInstanceDeleted( const Model::DescribeDBInstancesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetDBInstances().size() == 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBInstanceNotFound")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), - [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBInstances().begin(), result.GetDBInstances().end(), - [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBInstancesOutcome; + using RequestT = Model::DescribeDBInstancesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetDBInstances().size() == 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("DBInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("DBInstanceNotFound"))); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("rebooting"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBInstances().begin(), result.GetDBInstances().end(), + [&](const Model::DBInstance& item) { return item.GetDBInstanceStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBInstancesRequest& req) { - return static_cast(this)->DescribeDBInstances(req); - }; - Aws::Utils::Waiter waiter(30, 60, acceptors, operation, - "WaitUntilDBInstanceDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBInstances(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBInstanceDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilDBSnapshotAvailable( const Model::DescribeDBSnapshotsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), - [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), - [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), - [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), - [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), - [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), - [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), - [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), - [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBSnapshotsOutcome; + using RequestT = Model::DescribeDBSnapshotsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBSnapshotsRequest& req) { - return static_cast(this)->DescribeDBSnapshots(req); - }; - Aws::Utils::Waiter waiter(30, 60, acceptors, operation, - "WaitUntilDBSnapshotAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBSnapshots(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBSnapshotAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilDBSnapshotDeleted( const Model::DescribeDBSnapshotsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetDBSnapshots().size() == 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBSnapshotNotFound")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), - [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), - [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), - [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("rebooting"), - [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), - [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("resetting-master-credentials"), - [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), - [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeDBSnapshotsOutcome; + using RequestT = Model::DescribeDBSnapshotsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetDBSnapshots().size() == 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("DBSnapshotNotFound"))); + acceptors.emplace_back(Aws::MakeUnique>( + "DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("rebooting"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("resetting-master-credentials"), + [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetDBSnapshots().begin(), result.GetDBSnapshots().end(), + [&](const Model::DBSnapshot& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeDBSnapshotsRequest& req) { - return static_cast(this)->DescribeDBSnapshots(req); - }; - Aws::Utils::Waiter waiter(30, 60, acceptors, operation, - "WaitUntilDBSnapshotDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeDBSnapshots(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilDBSnapshotDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTenantDatabaseAvailable( const Model::DescribeTenantDatabasesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of( - result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), - [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), - [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-parameters"), - [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), - [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("incompatible-restore"), - [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of( - result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), - [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeTenantDatabasesOutcome; + using RequestT = Model::DescribeTenantDatabasesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TenantDatabaseAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), + [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TenantDatabaseAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), + [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TenantDatabaseAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-parameters"), + [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), + [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TenantDatabaseAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("incompatible-restore"), + [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetTenantDatabases().begin(), result.GetTenantDatabases().end(), + [&](const Model::TenantDatabase& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeTenantDatabasesRequest& req) { - return static_cast(this)->DescribeTenantDatabases(req); - }; - Aws::Utils::Waiter waiter( - 30, 60, acceptors, operation, "WaitUntilTenantDatabaseAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeTenantDatabases(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilTenantDatabaseAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTenantDatabaseDeleted( const Model::DescribeTenantDatabasesRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, true, - [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return (result.GetTenantDatabases().size() == 0) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("DBInstanceNotFoundFault")}); + using OutcomeT = Model::DescribeTenantDatabasesOutcome; + using RequestT = Model::DescribeTenantDatabasesRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TenantDatabaseDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true, + [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return (result.GetTenantDatabases().size() == 0) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TenantDatabaseDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DBInstanceNotFoundFault"))); - auto operation = [this](const Model::DescribeTenantDatabasesRequest& req) { - return static_cast(this)->DescribeTenantDatabases(req); - }; - Aws::Utils::Waiter waiter( - 30, 60, acceptors, operation, "WaitUntilTenantDatabaseDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeTenantDatabases(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilTenantDatabaseDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-redshift-data/include/aws/redshift-data/RedshiftDataAPIServiceWaiter.h b/generated/src/aws-cpp-sdk-redshift-data/include/aws/redshift-data/RedshiftDataAPIServiceWaiter.h new file mode 100644 index 00000000000..bbe08f32082 --- /dev/null +++ b/generated/src/aws-cpp-sdk-redshift-data/include/aws/redshift-data/RedshiftDataAPIServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace RedshiftDataAPIService { + +template +class RedshiftDataAPIServiceWaiter { + public: +}; +} // namespace RedshiftDataAPIService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-redshift-serverless/include/aws/redshift-serverless/RedshiftServerlessWaiter.h b/generated/src/aws-cpp-sdk-redshift-serverless/include/aws/redshift-serverless/RedshiftServerlessWaiter.h new file mode 100644 index 00000000000..3e5baa2957b --- /dev/null +++ b/generated/src/aws-cpp-sdk-redshift-serverless/include/aws/redshift-serverless/RedshiftServerlessWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace RedshiftServerless { + +template +class RedshiftServerlessWaiter { + public: +}; +} // namespace RedshiftServerless +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h b/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h index e101cf93d59..8343ccc0602 100644 --- a/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h +++ b/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,112 +21,120 @@ template class RedshiftWaiter { public: Aws::Utils::WaiterOutcome WaitUntilClusterAvailable(const Model::DescribeClustersRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { - return item.GetClusterStatus() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { - return item.GetClusterStatus() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("ClusterNotFound")}); + using OutcomeT = Model::DescribeClustersOutcome; + using RequestT = Model::DescribeClustersRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetClusters().begin(), result.GetClusters().end(), + [&](const Model::Cluster& item) { return item.GetClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), + [&](const Model::Cluster& item) { return item.GetClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>("ClusterAvailableWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("ClusterNotFound"))); - auto operation = [this](const Model::DescribeClustersRequest& req) { return static_cast(this)->DescribeClusters(req); }; - Aws::Utils::Waiter waiter(60, 2, acceptors, operation, - "WaitUntilClusterAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeClusters(req); }; + Aws::Utils::Waiter waiter(60, 2, std::move(acceptors), operation, "WaitUntilClusterAvailable"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClustersRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ClusterNotFound")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("creating"), - [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { - return item.GetClusterStatus() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("modifying"), - [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { - return item.GetClusterStatus() == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeClustersOutcome; + using RequestT = Model::DescribeClustersRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("ClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ClusterNotFound"))); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("creating"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), + [&](const Model::Cluster& item) { return item.GetClusterStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("modifying"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), + [&](const Model::Cluster& item) { return item.GetClusterStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeClustersRequest& req) { return static_cast(this)->DescribeClusters(req); }; - Aws::Utils::Waiter waiter(60, 2, acceptors, operation, - "WaitUntilClusterDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeClusters(req); }; + Aws::Utils::Waiter waiter(60, 2, std::move(acceptors), operation, "WaitUntilClusterDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilClusterRestored(const Model::DescribeClustersRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("completed"), - [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { - return item.GetRestoreStatus().GetStatus() == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleting"), - [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { - return item.GetClusterStatus() == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeClustersOutcome; + using RequestT = Model::DescribeClustersRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterRestoredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetClusters().begin(), result.GetClusters().end(), [&](const Model::Cluster& item) { + return item.GetRestoreStatus().GetStatus() == expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterRestoredWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleting"), + [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetClusters().begin(), result.GetClusters().end(), + [&](const Model::Cluster& item) { return item.GetClusterStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeClustersRequest& req) { return static_cast(this)->DescribeClusters(req); }; - Aws::Utils::Waiter waiter(60, 2, acceptors, operation, - "WaitUntilClusterRestored"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeClusters(req); }; + Aws::Utils::Waiter waiter(60, 2, std::move(acceptors), operation, "WaitUntilClusterRestored"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSnapshotAvailable( const Model::DescribeClusterSnapshotsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("available"), - [](const Model::DescribeClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), - [&](const Model::Snapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("failed"), - [](const Model::DescribeClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), - [&](const Model::Snapshot& item) { return item.GetStatus() == expected.get(); }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("deleted"), - [](const Model::DescribeClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), - [&](const Model::Snapshot& item) { return item.GetStatus() == expected.get(); }); - }}); + using OutcomeT = Model::DescribeClusterSnapshotsOutcome; + using RequestT = Model::DescribeClusterSnapshotsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SnapshotAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), + [](const Model::DescribeClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), + [&](const Model::Snapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("failed"), + [](const Model::DescribeClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), + [&](const Model::Snapshot& item) { return item.GetStatus() == expected.get(); }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("deleted"), + [](const Model::DescribeClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetSnapshots().begin(), result.GetSnapshots().end(), + [&](const Model::Snapshot& item) { return item.GetStatus() == expected.get(); }); + })); - auto operation = [this](const Model::DescribeClusterSnapshotsRequest& req) { - return static_cast(this)->DescribeClusterSnapshots(req); - }; - Aws::Utils::Waiter waiter(15, 8, acceptors, operation, - "WaitUntilSnapshotAvailable"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeClusterSnapshots(req); }; + Aws::Utils::Waiter waiter(15, 8, std::move(acceptors), operation, "WaitUntilSnapshotAvailable"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h b/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h index cfc8fa0532b..0b799fdcdac 100644 --- a/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h +++ b/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,65 +21,67 @@ class RekognitionWaiter { public: Aws::Utils::WaiterOutcome WaitUntilProjectVersionRunning( const Model::DescribeProjectVersionsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("RUNNING"), - [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), - [&](const Model::ProjectVersionDescription& item) { - return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus( - item.GetStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), - [&](const Model::ProjectVersionDescription& item) { - return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus( - item.GetStatus()) == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeProjectVersionsOutcome; + using RequestT = Model::DescribeProjectVersionsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ProjectVersionRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), + [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), + [&](const Model::ProjectVersionDescription& item) { + return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus(item.GetStatus()) == + expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ProjectVersionRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), + [&](const Model::ProjectVersionDescription& item) { + return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus(item.GetStatus()) == + expected.get(); + }); + })); - auto operation = [this](const Model::DescribeProjectVersionsRequest& req) { - return static_cast(this)->DescribeProjectVersions(req); - }; - Aws::Utils::Waiter waiter( - 30, 4, acceptors, operation, "WaitUntilProjectVersionRunning"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeProjectVersions(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilProjectVersionRunning"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilProjectVersionTrainingCompleted( const Model::DescribeProjectVersionsRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("TRAINING_COMPLETED"), - [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::all_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), - [&](const Model::ProjectVersionDescription& item) { - return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus( - item.GetStatus()) == expected.get(); - }); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TRAINING_FAILED"), - [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return std::any_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), - [&](const Model::ProjectVersionDescription& item) { - return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus( - item.GetStatus()) == expected.get(); - }); - }}); + using OutcomeT = Model::DescribeProjectVersionsOutcome; + using RequestT = Model::DescribeProjectVersionsRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ProjectVersionTrainingCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("TRAINING_COMPLETED"), + [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::all_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), + [&](const Model::ProjectVersionDescription& item) { + return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus(item.GetStatus()) == + expected.get(); + }); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ProjectVersionTrainingCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("TRAINING_FAILED"), + [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return std::any_of(result.GetProjectVersionDescriptions().begin(), result.GetProjectVersionDescriptions().end(), + [&](const Model::ProjectVersionDescription& item) { + return Model::ProjectVersionStatusMapper::GetNameForProjectVersionStatus(item.GetStatus()) == + expected.get(); + }); + })); - auto operation = [this](const Model::DescribeProjectVersionsRequest& req) { - return static_cast(this)->DescribeProjectVersions(req); - }; - Aws::Utils::Waiter waiter( - 120, 1, acceptors, operation, "WaitUntilProjectVersionTrainingCompleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeProjectVersions(req); }; + Aws::Utils::Waiter waiter(120, 1, std::move(acceptors), operation, "WaitUntilProjectVersionTrainingCompleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h b/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h index 462ae9070bd..2ac39311af4 100644 --- a/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h +++ b/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -21,114 +22,130 @@ template class RepostspaceWaiter { public: Aws::Utils::WaiterOutcome WaitUntilChannelCreated(const Model::GetChannelRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATED"), - [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetChannelOutcome; + using RequestT = Model::GetChannelRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATED"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetChannelRequest& req) { return static_cast(this)->GetChannel(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilChannelCreated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetChannel(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilChannelCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilChannelDeleted(const Model::GetChannelRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetChannelOutcome; + using RequestT = Model::GetChannelRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("ChannelDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ChannelDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChannelStatusMapper::GetNameForChannelStatus(result.GetChannelStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetChannelRequest& req) { return static_cast(this)->GetChannel(req); }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, "WaitUntilChannelDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetChannel(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilChannelDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSpaceCreated(const Model::GetSpaceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATED"), - [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetSpaceOutcome; + using RequestT = Model::GetSpaceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SpaceCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATED"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SpaceCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SpaceCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetSpaceRequest& req) { return static_cast(this)->GetSpace(req); }; - Aws::Utils::Waiter waiter(300, 24, acceptors, operation, "WaitUntilSpaceCreated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetSpace(req); }; + Aws::Utils::Waiter waiter(300, 24, std::move(acceptors), operation, "WaitUntilSpaceCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilSpaceDeleted(const Model::GetSpaceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetSpaceOutcome; + using RequestT = Model::GetSpaceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("SpaceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "SpaceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SpaceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SpaceDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetSpaceRequest& req) { return static_cast(this)->GetSpace(req); }; - Aws::Utils::Waiter waiter(300, 24, acceptors, operation, "WaitUntilSpaceDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetSpace(req); }; + Aws::Utils::Waiter waiter(300, 24, std::move(acceptors), operation, "WaitUntilSpaceDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-resiliencehub/include/aws/resiliencehub/ResilienceHubWaiter.h b/generated/src/aws-cpp-sdk-resiliencehub/include/aws/resiliencehub/ResilienceHubWaiter.h new file mode 100644 index 00000000000..154db9a0dee --- /dev/null +++ b/generated/src/aws-cpp-sdk-resiliencehub/include/aws/resiliencehub/ResilienceHubWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ResilienceHub { + +template +class ResilienceHubWaiter { + public: +}; +} // namespace ResilienceHub +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-resource-explorer-2/include/aws/resource-explorer-2/ResourceExplorer2Waiter.h b/generated/src/aws-cpp-sdk-resource-explorer-2/include/aws/resource-explorer-2/ResourceExplorer2Waiter.h new file mode 100644 index 00000000000..207067ca19b --- /dev/null +++ b/generated/src/aws-cpp-sdk-resource-explorer-2/include/aws/resource-explorer-2/ResourceExplorer2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ResourceExplorer2 { + +template +class ResourceExplorer2Waiter { + public: +}; +} // namespace ResourceExplorer2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-resource-groups/include/aws/resource-groups/ResourceGroupsWaiter.h b/generated/src/aws-cpp-sdk-resource-groups/include/aws/resource-groups/ResourceGroupsWaiter.h new file mode 100644 index 00000000000..aa1d300c3a8 --- /dev/null +++ b/generated/src/aws-cpp-sdk-resource-groups/include/aws/resource-groups/ResourceGroupsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ResourceGroups { + +template +class ResourceGroupsWaiter { + public: +}; +} // namespace ResourceGroups +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-resourcegroupstaggingapi/include/aws/resourcegroupstaggingapi/ResourceGroupsTaggingAPIWaiter.h b/generated/src/aws-cpp-sdk-resourcegroupstaggingapi/include/aws/resourcegroupstaggingapi/ResourceGroupsTaggingAPIWaiter.h new file mode 100644 index 00000000000..76b9f47278e --- /dev/null +++ b/generated/src/aws-cpp-sdk-resourcegroupstaggingapi/include/aws/resourcegroupstaggingapi/ResourceGroupsTaggingAPIWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ResourceGroupsTaggingAPI { + +template +class ResourceGroupsTaggingAPIWaiter { + public: +}; +} // namespace ResourceGroupsTaggingAPI +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-rolesanywhere/include/aws/rolesanywhere/RolesAnywhereWaiter.h b/generated/src/aws-cpp-sdk-rolesanywhere/include/aws/rolesanywhere/RolesAnywhereWaiter.h new file mode 100644 index 00000000000..4748fa0d9d7 --- /dev/null +++ b/generated/src/aws-cpp-sdk-rolesanywhere/include/aws/rolesanywhere/RolesAnywhereWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace RolesAnywhere { + +template +class RolesAnywhereWaiter { + public: +}; +} // namespace RolesAnywhere +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-route53-recovery-cluster/include/aws/route53-recovery-cluster/Route53RecoveryClusterWaiter.h b/generated/src/aws-cpp-sdk-route53-recovery-cluster/include/aws/route53-recovery-cluster/Route53RecoveryClusterWaiter.h new file mode 100644 index 00000000000..405f828a872 --- /dev/null +++ b/generated/src/aws-cpp-sdk-route53-recovery-cluster/include/aws/route53-recovery-cluster/Route53RecoveryClusterWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Route53RecoveryCluster { + +template +class Route53RecoveryClusterWaiter { + public: +}; +} // namespace Route53RecoveryCluster +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h b/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h index e971eb189a5..1be1c09b72c 100644 --- a/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h +++ b/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -23,137 +24,147 @@ template class Route53RecoveryControlConfigWaiter { public: Aws::Utils::WaiterOutcome WaitUntilClusterCreated(const Model::DescribeClusterRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYED"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetCluster().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetCluster().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + using OutcomeT = Model::DescribeClusterOutcome; + using RequestT = Model::DescribeClusterRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEPLOYED"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetCluster().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetCluster().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ClusterCreatedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerException"))); - auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilClusterCreated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilClusterCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClusterRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING_DELETION"), - [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetCluster().GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + using OutcomeT = Model::DescribeClusterOutcome; + using RequestT = Model::DescribeClusterRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("ClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "ClusterDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING_DELETION"), + [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetCluster().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ClusterDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerException"))); - auto operation = [this](const Model::DescribeClusterRequest& req) { return static_cast(this)->DescribeCluster(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilClusterDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCluster(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilClusterDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilControlPanelCreated( const Model::DescribeControlPanelRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYED"), - [](const Model::DescribeControlPanelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetControlPanel().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), - [](const Model::DescribeControlPanelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetControlPanel().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + using OutcomeT = Model::DescribeControlPanelOutcome; + using RequestT = Model::DescribeControlPanelRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ControlPanelCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEPLOYED"), + [](const Model::DescribeControlPanelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetControlPanel().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ControlPanelCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING"), + [](const Model::DescribeControlPanelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetControlPanel().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ControlPanelCreatedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerException"))); - auto operation = [this](const Model::DescribeControlPanelRequest& req) { - return static_cast(this)->DescribeControlPanel(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilControlPanelCreated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeControlPanel(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilControlPanelCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilControlPanelDeleted( const Model::DescribeControlPanelRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING_DELETION"), - [](const Model::DescribeControlPanelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetControlPanel().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + using OutcomeT = Model::DescribeControlPanelOutcome; + using RequestT = Model::DescribeControlPanelRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ControlPanelDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "ControlPanelDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING_DELETION"), + [](const Model::DescribeControlPanelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetControlPanel().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ControlPanelDeletedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InternalServerException"))); - auto operation = [this](const Model::DescribeControlPanelRequest& req) { - return static_cast(this)->DescribeControlPanel(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilControlPanelDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeControlPanel(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilControlPanelDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilRoutingControlCreated( const Model::DescribeRoutingControlRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DEPLOYED"), - [](const Model::DescribeRoutingControlOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetRoutingControl().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING"), - [](const Model::DescribeRoutingControlOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetRoutingControl().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + using OutcomeT = Model::DescribeRoutingControlOutcome; + using RequestT = Model::DescribeRoutingControlRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "RoutingControlCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEPLOYED"), + [](const Model::DescribeRoutingControlOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetRoutingControl().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RoutingControlCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING"), + [](const Model::DescribeRoutingControlOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetRoutingControl().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RoutingControlCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InternalServerException"))); - auto operation = [this](const Model::DescribeRoutingControlRequest& req) { - return static_cast(this)->DescribeRoutingControl(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilRoutingControlCreated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeRoutingControl(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilRoutingControlCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilRoutingControlDeleted( const Model::DescribeRoutingControlRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("PENDING_DELETION"), - [](const Model::DescribeRoutingControlOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::StatusMapper::GetNameForStatus(result.GetRoutingControl().GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InternalServerException")}); + using OutcomeT = Model::DescribeRoutingControlOutcome; + using RequestT = Model::DescribeRoutingControlRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "RoutingControlDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "RoutingControlDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING_DELETION"), + [](const Model::DescribeRoutingControlOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::StatusMapper::GetNameForStatus(result.GetRoutingControl().GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RoutingControlDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InternalServerException"))); - auto operation = [this](const Model::DescribeRoutingControlRequest& req) { - return static_cast(this)->DescribeRoutingControl(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilRoutingControlDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeRoutingControl(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilRoutingControlDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-route53-recovery-readiness/include/aws/route53-recovery-readiness/Route53RecoveryReadinessWaiter.h b/generated/src/aws-cpp-sdk-route53-recovery-readiness/include/aws/route53-recovery-readiness/Route53RecoveryReadinessWaiter.h new file mode 100644 index 00000000000..f73a27b710d --- /dev/null +++ b/generated/src/aws-cpp-sdk-route53-recovery-readiness/include/aws/route53-recovery-readiness/Route53RecoveryReadinessWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Route53RecoveryReadiness { + +template +class Route53RecoveryReadinessWaiter { + public: +}; +} // namespace Route53RecoveryReadiness +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h b/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h index c10191addea..bbe7360830b 100644 --- a/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h +++ b/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,18 +20,19 @@ template class Route53Waiter { public: Aws::Utils::WaiterOutcome WaitUntilResourceRecordSetsChanged(const Model::GetChangeRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("INSYNC"), - [](const Model::GetChangeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ChangeStatusMapper::GetNameForChangeStatus(result.GetChangeInfo().GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetChangeOutcome; + using RequestT = Model::GetChangeRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ResourceRecordSetsChangedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("INSYNC"), + [](const Model::GetChangeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ChangeStatusMapper::GetNameForChangeStatus(result.GetChangeInfo().GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetChangeRequest& req) { return static_cast(this)->GetChange(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilResourceRecordSetsChanged"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetChange(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilResourceRecordSetsChanged"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-route53domains/include/aws/route53domains/Route53DomainsWaiter.h b/generated/src/aws-cpp-sdk-route53domains/include/aws/route53domains/Route53DomainsWaiter.h new file mode 100644 index 00000000000..6e63f6997cf --- /dev/null +++ b/generated/src/aws-cpp-sdk-route53domains/include/aws/route53domains/Route53DomainsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Route53Domains { + +template +class Route53DomainsWaiter { + public: +}; +} // namespace Route53Domains +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-route53globalresolver/include/aws/route53globalresolver/Route53GlobalResolverWaiter.h b/generated/src/aws-cpp-sdk-route53globalresolver/include/aws/route53globalresolver/Route53GlobalResolverWaiter.h new file mode 100644 index 00000000000..13f6ccee1fa --- /dev/null +++ b/generated/src/aws-cpp-sdk-route53globalresolver/include/aws/route53globalresolver/Route53GlobalResolverWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Route53GlobalResolver { + +template +class Route53GlobalResolverWaiter { + public: +}; +} // namespace Route53GlobalResolver +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-route53profiles/include/aws/route53profiles/Route53ProfilesWaiter.h b/generated/src/aws-cpp-sdk-route53profiles/include/aws/route53profiles/Route53ProfilesWaiter.h new file mode 100644 index 00000000000..e4729d0792c --- /dev/null +++ b/generated/src/aws-cpp-sdk-route53profiles/include/aws/route53profiles/Route53ProfilesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Route53Profiles { + +template +class Route53ProfilesWaiter { + public: +}; +} // namespace Route53Profiles +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverWaiter.h b/generated/src/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverWaiter.h new file mode 100644 index 00000000000..f7e839ad78a --- /dev/null +++ b/generated/src/aws-cpp-sdk-route53resolver/include/aws/route53resolver/Route53ResolverWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Route53Resolver { + +template +class Route53ResolverWaiter { + public: +}; +} // namespace Route53Resolver +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h b/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h index 4764a573396..7c4e0101df4 100644 --- a/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h +++ b/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -30,274 +31,283 @@ class RTBFabricWaiter { public: Aws::Utils::WaiterOutcome WaitUntilInboundExternalLinkActive( const Model::GetInboundExternalLinkRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REJECTED"), - [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ISOLATED"), - [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); - }}); + using OutcomeT = Model::GetInboundExternalLinkOutcome; + using RequestT = Model::GetInboundExternalLinkRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "InboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REJECTED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "InboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ISOLATED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetInboundExternalLinkRequest& req) { - return static_cast(this)->GetInboundExternalLink(req); - }; - Aws::Utils::Waiter waiter( - 30, 4, acceptors, operation, "WaitUntilInboundExternalLinkActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetInboundExternalLink(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilInboundExternalLinkActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilLinkAccepted(const Model::GetLinkRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACCEPTED"), - [](const Model::GetLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REJECTED"), - [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetLinkOutcome; + using RequestT = Model::GetLinkRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "LinkAcceptedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACCEPTED"), + [](const Model::GetLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LinkAcceptedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REJECTED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LinkAcceptedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LinkAcceptedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetLinkRequest& req) { return static_cast(this)->GetLink(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, "WaitUntilLinkAccepted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetLink(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilLinkAccepted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilLinkActive(const Model::GetLinkRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REJECTED"), - [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetLinkOutcome; + using RequestT = Model::GetLinkRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "LinkActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LinkActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REJECTED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LinkActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LinkActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetLinkRequest& req) { return static_cast(this)->GetLink(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, "WaitUntilLinkActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetLink(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilLinkActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilOutboundExternalLinkActive( const Model::GetOutboundExternalLinkRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("REJECTED"), - [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ISOLATED"), - [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); - }}); + using OutcomeT = Model::GetOutboundExternalLinkOutcome; + using RequestT = Model::GetOutboundExternalLinkRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "OutboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "OutboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REJECTED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "OutboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "OutboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "OutboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ISOLATED"), + [](const Model::GetOutboundExternalLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::LinkStatusMapper::GetNameForLinkStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetOutboundExternalLinkRequest& req) { - return static_cast(this)->GetOutboundExternalLink(req); - }; - Aws::Utils::Waiter waiter( - 30, 4, acceptors, operation, "WaitUntilOutboundExternalLinkActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetOutboundExternalLink(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilOutboundExternalLinkActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilRequesterGatewayActive( const Model::GetRequesterGatewayRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetRequesterGatewayOutcome; + using RequestT = Model::GetRequesterGatewayRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "RequesterGatewayActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RequesterGatewayActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RequesterGatewayActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetRequesterGatewayRequest& req) { - return static_cast(this)->GetRequesterGateway(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilRequesterGatewayActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRequesterGateway(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilRequesterGatewayActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilRequesterGatewayDeleted( const Model::GetRequesterGatewayRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetRequesterGatewayOutcome; + using RequestT = Model::GetRequesterGatewayRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "RequesterGatewayDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "RequesterGatewayDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetRequesterGatewayRequest& req) { - return static_cast(this)->GetRequesterGateway(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilRequesterGatewayDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetRequesterGateway(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilRequesterGatewayDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilResponderGatewayActive( const Model::GetResponderGatewayRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetResponderGatewayOutcome; + using RequestT = Model::GetResponderGatewayRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ResponderGatewayActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ResponderGatewayActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ResponderGatewayActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetResponderGatewayRequest& req) { - return static_cast(this)->GetResponderGateway(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilResponderGatewayActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetResponderGateway(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilResponderGatewayActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilResponderGatewayDeleted( const Model::GetResponderGatewayRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("DELETED"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("ERROR"), - [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetResponderGatewayOutcome; + using RequestT = Model::GetResponderGatewayRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ResponderGatewayDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ResponderGatewayDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ERROR"), + [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ResponderGatewayStatusMapper::GetNameForResponderGatewayStatus(result.GetStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetResponderGatewayRequest& req) { - return static_cast(this)->GetResponderGateway(req); - }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, - "WaitUntilResponderGatewayDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetResponderGateway(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilResponderGatewayDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-rum/include/aws/rum/CloudWatchRUMWaiter.h b/generated/src/aws-cpp-sdk-rum/include/aws/rum/CloudWatchRUMWaiter.h new file mode 100644 index 00000000000..0908fa120c2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-rum/include/aws/rum/CloudWatchRUMWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace CloudWatchRUM { + +template +class CloudWatchRUMWaiter { + public: +}; +} // namespace CloudWatchRUM +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h b/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h index 722b0ee1bd7..819ea52a25f 100644 --- a/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h +++ b/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,40 +21,54 @@ template class S3CrtWaiter { public: Aws::Utils::WaiterOutcome WaitUntilBucketExists(const Model::HeadBucketRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::STATUS, 404}); + using OutcomeT = Model::HeadBucketOutcome; + using RequestT = Model::HeadBucketRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("BucketExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back( + Aws::MakeUnique>("BucketExistsWaiter", Aws::Utils::WaiterState::RETRY, 404)); - auto operation = [this](const Model::HeadBucketRequest& req) { return static_cast(this)->HeadBucket(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilBucketExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->HeadBucket(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilBucketExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilBucketNotExists(const Model::HeadBucketRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::STATUS, 404}); + using OutcomeT = Model::HeadBucketOutcome; + using RequestT = Model::HeadBucketRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("BucketNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, 404)); - auto operation = [this](const Model::HeadBucketRequest& req) { return static_cast(this)->HeadBucket(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilBucketNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->HeadBucket(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilBucketNotExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilObjectExists(const Model::HeadObjectRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::STATUS, 404}); + using OutcomeT = Model::HeadObjectOutcome; + using RequestT = Model::HeadObjectRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("ObjectExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back( + Aws::MakeUnique>("ObjectExistsWaiter", Aws::Utils::WaiterState::RETRY, 404)); - auto operation = [this](const Model::HeadObjectRequest& req) { return static_cast(this)->HeadObject(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilObjectExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->HeadObject(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilObjectExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilObjectNotExists(const Model::HeadObjectRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::STATUS, 404}); + using OutcomeT = Model::HeadObjectOutcome; + using RequestT = Model::HeadObjectRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("ObjectNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, 404)); - auto operation = [this](const Model::HeadObjectRequest& req) { return static_cast(this)->HeadObject(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilObjectNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->HeadObject(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilObjectNotExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h b/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h index 2c3bb8afcdf..cd4ad9636c7 100644 --- a/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h +++ b/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,40 +21,54 @@ template class S3Waiter { public: Aws::Utils::WaiterOutcome WaitUntilBucketExists(const Model::HeadBucketRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::STATUS, 404}); + using OutcomeT = Model::HeadBucketOutcome; + using RequestT = Model::HeadBucketRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("BucketExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back( + Aws::MakeUnique>("BucketExistsWaiter", Aws::Utils::WaiterState::RETRY, 404)); - auto operation = [this](const Model::HeadBucketRequest& req) { return static_cast(this)->HeadBucket(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilBucketExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->HeadBucket(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilBucketExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilBucketNotExists(const Model::HeadBucketRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::STATUS, 404}); + using OutcomeT = Model::HeadBucketOutcome; + using RequestT = Model::HeadBucketRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("BucketNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, 404)); - auto operation = [this](const Model::HeadBucketRequest& req) { return static_cast(this)->HeadBucket(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilBucketNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->HeadBucket(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilBucketNotExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilObjectExists(const Model::HeadObjectRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, false}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::STATUS, 404}); + using OutcomeT = Model::HeadObjectOutcome; + using RequestT = Model::HeadObjectRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("ObjectExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); + acceptors.emplace_back( + Aws::MakeUnique>("ObjectExistsWaiter", Aws::Utils::WaiterState::RETRY, 404)); - auto operation = [this](const Model::HeadObjectRequest& req) { return static_cast(this)->HeadObject(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilObjectExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->HeadObject(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilObjectExists"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilObjectNotExists(const Model::HeadObjectRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::STATUS, 404}); + using OutcomeT = Model::HeadObjectOutcome; + using RequestT = Model::HeadObjectRequest; + std::vector>> acceptors; + acceptors.emplace_back( + Aws::MakeUnique>("ObjectNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, 404)); - auto operation = [this](const Model::HeadObjectRequest& req) { return static_cast(this)->HeadObject(req); }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, "WaitUntilObjectNotExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->HeadObject(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilObjectNotExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-s3control/include/aws/s3control/S3ControlWaiter.h b/generated/src/aws-cpp-sdk-s3control/include/aws/s3control/S3ControlWaiter.h new file mode 100644 index 00000000000..c54d9399ac8 --- /dev/null +++ b/generated/src/aws-cpp-sdk-s3control/include/aws/s3control/S3ControlWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace S3Control { + +template +class S3ControlWaiter { + public: +}; +} // namespace S3Control +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-s3outposts/include/aws/s3outposts/S3OutpostsWaiter.h b/generated/src/aws-cpp-sdk-s3outposts/include/aws/s3outposts/S3OutpostsWaiter.h new file mode 100644 index 00000000000..2ddbec558d3 --- /dev/null +++ b/generated/src/aws-cpp-sdk-s3outposts/include/aws/s3outposts/S3OutpostsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace S3Outposts { + +template +class S3OutpostsWaiter { + public: +}; +} // namespace S3Outposts +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-s3tables/include/aws/s3tables/S3TablesWaiter.h b/generated/src/aws-cpp-sdk-s3tables/include/aws/s3tables/S3TablesWaiter.h new file mode 100644 index 00000000000..0a2637b592e --- /dev/null +++ b/generated/src/aws-cpp-sdk-s3tables/include/aws/s3tables/S3TablesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace S3Tables { + +template +class S3TablesWaiter { + public: +}; +} // namespace S3Tables +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-s3vectors/include/aws/s3vectors/S3VectorsWaiter.h b/generated/src/aws-cpp-sdk-s3vectors/include/aws/s3vectors/S3VectorsWaiter.h new file mode 100644 index 00000000000..58c16a6bd83 --- /dev/null +++ b/generated/src/aws-cpp-sdk-s3vectors/include/aws/s3vectors/S3VectorsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace S3Vectors { + +template +class S3VectorsWaiter { + public: +}; +} // namespace S3Vectors +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sagemaker-a2i-runtime/include/aws/sagemaker-a2i-runtime/AugmentedAIRuntimeWaiter.h b/generated/src/aws-cpp-sdk-sagemaker-a2i-runtime/include/aws/sagemaker-a2i-runtime/AugmentedAIRuntimeWaiter.h new file mode 100644 index 00000000000..9b830b7efde --- /dev/null +++ b/generated/src/aws-cpp-sdk-sagemaker-a2i-runtime/include/aws/sagemaker-a2i-runtime/AugmentedAIRuntimeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AugmentedAIRuntime { + +template +class AugmentedAIRuntimeWaiter { + public: +}; +} // namespace AugmentedAIRuntime +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sagemaker-edge/include/aws/sagemaker-edge/SagemakerEdgeManagerWaiter.h b/generated/src/aws-cpp-sdk-sagemaker-edge/include/aws/sagemaker-edge/SagemakerEdgeManagerWaiter.h new file mode 100644 index 00000000000..117294f045b --- /dev/null +++ b/generated/src/aws-cpp-sdk-sagemaker-edge/include/aws/sagemaker-edge/SagemakerEdgeManagerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SagemakerEdgeManager { + +template +class SagemakerEdgeManagerWaiter { + public: +}; +} // namespace SagemakerEdgeManager +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sagemaker-featurestore-runtime/include/aws/sagemaker-featurestore-runtime/SageMakerFeatureStoreRuntimeWaiter.h b/generated/src/aws-cpp-sdk-sagemaker-featurestore-runtime/include/aws/sagemaker-featurestore-runtime/SageMakerFeatureStoreRuntimeWaiter.h new file mode 100644 index 00000000000..07de24148d9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-sagemaker-featurestore-runtime/include/aws/sagemaker-featurestore-runtime/SageMakerFeatureStoreRuntimeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SageMakerFeatureStoreRuntime { + +template +class SageMakerFeatureStoreRuntimeWaiter { + public: +}; +} // namespace SageMakerFeatureStoreRuntime +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sagemaker-geospatial/include/aws/sagemaker-geospatial/SageMakerGeospatialWaiter.h b/generated/src/aws-cpp-sdk-sagemaker-geospatial/include/aws/sagemaker-geospatial/SageMakerGeospatialWaiter.h new file mode 100644 index 00000000000..5b1112c02bd --- /dev/null +++ b/generated/src/aws-cpp-sdk-sagemaker-geospatial/include/aws/sagemaker-geospatial/SageMakerGeospatialWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SageMakerGeospatial { + +template +class SageMakerGeospatialWaiter { + public: +}; +} // namespace SageMakerGeospatial +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sagemaker-metrics/include/aws/sagemaker-metrics/SageMakerMetricsWaiter.h b/generated/src/aws-cpp-sdk-sagemaker-metrics/include/aws/sagemaker-metrics/SageMakerMetricsWaiter.h new file mode 100644 index 00000000000..9c1021141ff --- /dev/null +++ b/generated/src/aws-cpp-sdk-sagemaker-metrics/include/aws/sagemaker-metrics/SageMakerMetricsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SageMakerMetrics { + +template +class SageMakerMetricsWaiter { + public: +}; +} // namespace SageMakerMetrics +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sagemaker-runtime-http2/include/aws/sagemaker-runtime-http2/SageMakerRuntimeHTTP2Waiter.h b/generated/src/aws-cpp-sdk-sagemaker-runtime-http2/include/aws/sagemaker-runtime-http2/SageMakerRuntimeHTTP2Waiter.h new file mode 100644 index 00000000000..0b19adfcc0c --- /dev/null +++ b/generated/src/aws-cpp-sdk-sagemaker-runtime-http2/include/aws/sagemaker-runtime-http2/SageMakerRuntimeHTTP2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SageMakerRuntimeHTTP2 { + +template +class SageMakerRuntimeHTTP2Waiter { + public: +}; +} // namespace SageMakerRuntimeHTTP2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sagemaker-runtime/include/aws/sagemaker-runtime/SageMakerRuntimeWaiter.h b/generated/src/aws-cpp-sdk-sagemaker-runtime/include/aws/sagemaker-runtime/SageMakerRuntimeWaiter.h new file mode 100644 index 00000000000..74a7e54f1e2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-sagemaker-runtime/include/aws/sagemaker-runtime/SageMakerRuntimeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SageMakerRuntime { + +template +class SageMakerRuntimeWaiter { + public: +}; +} // namespace SageMakerRuntime +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h b/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h index a22eff5855f..322371992a7 100644 --- a/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h +++ b/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -37,326 +38,355 @@ template class SageMakerWaiter { public: Aws::Utils::WaiterOutcome WaitUntilEndpointDeleted(const Model::DescribeEndpointRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::EndpointStatusMapper::GetNameForEndpointStatus(result.GetEndpointStatus()) == - expected.get(); - }}); + using OutcomeT = Model::DescribeEndpointOutcome; + using RequestT = Model::DescribeEndpointRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("EndpointDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ValidationException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "EndpointDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EndpointStatusMapper::GetNameForEndpointStatus(result.GetEndpointStatus()) == expected.get(); + })); - auto operation = [this](const Model::DescribeEndpointRequest& req) { return static_cast(this)->DescribeEndpoint(req); }; - Aws::Utils::Waiter waiter(30, 60, acceptors, operation, - "WaitUntilEndpointDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeEndpoint(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilEndpointDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilEndpointInService(const Model::DescribeEndpointRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("InService"), - [](const Model::DescribeEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::EndpointStatusMapper::GetNameForEndpointStatus(result.GetEndpointStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::EndpointStatusMapper::GetNameForEndpointStatus(result.GetEndpointStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + using OutcomeT = Model::DescribeEndpointOutcome; + using RequestT = Model::DescribeEndpointRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "EndpointInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InService"), + [](const Model::DescribeEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EndpointStatusMapper::GetNameForEndpointStatus(result.GetEndpointStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "EndpointInServiceWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::EndpointStatusMapper::GetNameForEndpointStatus(result.GetEndpointStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("EndpointInServiceWaiter", Aws::Utils::WaiterState::FAILURE, + Aws::String("ValidationException"))); - auto operation = [this](const Model::DescribeEndpointRequest& req) { return static_cast(this)->DescribeEndpoint(req); }; - Aws::Utils::Waiter waiter(30, 120, acceptors, operation, - "WaitUntilEndpointInService"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeEndpoint(req); }; + Aws::Utils::Waiter waiter(30, 120, std::move(acceptors), operation, "WaitUntilEndpointInService"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilImageCreated(const Model::DescribeImageRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATED"), - [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + using OutcomeT = Model::DescribeImageOutcome; + using RequestT = Model::DescribeImageRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ImageCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATED"), + [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImageCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ImageCreatedWaiter", Aws::Utils::WaiterState::FAILURE, + Aws::String("ValidationException"))); - auto operation = [this](const Model::DescribeImageRequest& req) { return static_cast(this)->DescribeImage(req); }; - Aws::Utils::Waiter waiter(60, 60, acceptors, operation, - "WaitUntilImageCreated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImage(req); }; + Aws::Utils::Waiter waiter(60, 60, std::move(acceptors), operation, "WaitUntilImageCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilImageDeleted(const Model::DescribeImageRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + using OutcomeT = Model::DescribeImageOutcome; + using RequestT = Model::DescribeImageRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>("ImageDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, + Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "ImageDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ImageDeletedWaiter", Aws::Utils::WaiterState::FAILURE, + Aws::String("ValidationException"))); - auto operation = [this](const Model::DescribeImageRequest& req) { return static_cast(this)->DescribeImage(req); }; - Aws::Utils::Waiter waiter(60, 60, acceptors, operation, - "WaitUntilImageDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImage(req); }; + Aws::Utils::Waiter waiter(60, 60, std::move(acceptors), operation, "WaitUntilImageDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilImageUpdated(const Model::DescribeImageRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATED"), - [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("UPDATE_FAILED"), - [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + using OutcomeT = Model::DescribeImageOutcome; + using RequestT = Model::DescribeImageRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ImageUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATED"), + [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImageUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"), + [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageStatusMapper::GetNameForImageStatus(result.GetImageStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("ImageUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, + Aws::String("ValidationException"))); - auto operation = [this](const Model::DescribeImageRequest& req) { return static_cast(this)->DescribeImage(req); }; - Aws::Utils::Waiter waiter(60, 60, acceptors, operation, - "WaitUntilImageUpdated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImage(req); }; + Aws::Utils::Waiter waiter(60, 60, std::move(acceptors), operation, "WaitUntilImageUpdated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilImageVersionCreated( const Model::DescribeImageVersionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATED"), - [](const Model::DescribeImageVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImageVersionStatusMapper::GetNameForImageVersionStatus(result.GetImageVersionStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeImageVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImageVersionStatusMapper::GetNameForImageVersionStatus(result.GetImageVersionStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + using OutcomeT = Model::DescribeImageVersionOutcome; + using RequestT = Model::DescribeImageVersionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ImageVersionCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATED"), + [](const Model::DescribeImageVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageVersionStatusMapper::GetNameForImageVersionStatus(result.GetImageVersionStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImageVersionCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeImageVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageVersionStatusMapper::GetNameForImageVersionStatus(result.GetImageVersionStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImageVersionCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationException"))); - auto operation = [this](const Model::DescribeImageVersionRequest& req) { - return static_cast(this)->DescribeImageVersion(req); - }; - Aws::Utils::Waiter waiter(60, 60, acceptors, operation, - "WaitUntilImageVersionCreated"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImageVersion(req); }; + Aws::Utils::Waiter waiter(60, 60, std::move(acceptors), operation, "WaitUntilImageVersionCreated"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilImageVersionDeleted( const Model::DescribeImageVersionRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("DELETE_FAILED"), - [](const Model::DescribeImageVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ImageVersionStatusMapper::GetNameForImageVersionStatus(result.GetImageVersionStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + using OutcomeT = Model::DescribeImageVersionOutcome; + using RequestT = Model::DescribeImageVersionRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ImageVersionDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "ImageVersionDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), + [](const Model::DescribeImageVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ImageVersionStatusMapper::GetNameForImageVersionStatus(result.GetImageVersionStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ImageVersionDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationException"))); - auto operation = [this](const Model::DescribeImageVersionRequest& req) { - return static_cast(this)->DescribeImageVersion(req); - }; - Aws::Utils::Waiter waiter(60, 60, acceptors, operation, - "WaitUntilImageVersionDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeImageVersion(req); }; + Aws::Utils::Waiter waiter(60, 60, std::move(acceptors), operation, "WaitUntilImageVersionDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilNotebookInstanceDeleted( const Model::DescribeNotebookInstanceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus( - result.GetNotebookInstanceStatus()) == expected.get(); - }}); + using OutcomeT = Model::DescribeNotebookInstanceOutcome; + using RequestT = Model::DescribeNotebookInstanceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "NotebookInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ValidationException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "NotebookInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus(result.GetNotebookInstanceStatus()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeNotebookInstanceRequest& req) { - return static_cast(this)->DescribeNotebookInstance(req); - }; - Aws::Utils::Waiter waiter( - 30, 60, acceptors, operation, "WaitUntilNotebookInstanceDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeNotebookInstance(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilNotebookInstanceDeleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilNotebookInstanceInService( const Model::DescribeNotebookInstanceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("InService"), - [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus( - result.GetNotebookInstanceStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus( - result.GetNotebookInstanceStatus()) == expected.get(); - }}); + using OutcomeT = Model::DescribeNotebookInstanceOutcome; + using RequestT = Model::DescribeNotebookInstanceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "NotebookInstanceInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InService"), + [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus(result.GetNotebookInstanceStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "NotebookInstanceInServiceWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus(result.GetNotebookInstanceStatus()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeNotebookInstanceRequest& req) { - return static_cast(this)->DescribeNotebookInstance(req); - }; - Aws::Utils::Waiter waiter( - 30, 60, acceptors, operation, "WaitUntilNotebookInstanceInService"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeNotebookInstance(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilNotebookInstanceInService"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilNotebookInstanceStopped( const Model::DescribeNotebookInstanceRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Stopped"), - [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus( - result.GetNotebookInstanceStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus( - result.GetNotebookInstanceStatus()) == expected.get(); - }}); + using OutcomeT = Model::DescribeNotebookInstanceOutcome; + using RequestT = Model::DescribeNotebookInstanceRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "NotebookInstanceStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Stopped"), + [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus(result.GetNotebookInstanceStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "NotebookInstanceStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::NotebookInstanceStatusMapper::GetNameForNotebookInstanceStatus(result.GetNotebookInstanceStatus()) == + expected.get(); + })); - auto operation = [this](const Model::DescribeNotebookInstanceRequest& req) { - return static_cast(this)->DescribeNotebookInstance(req); - }; - Aws::Utils::Waiter waiter( - 30, 60, acceptors, operation, "WaitUntilNotebookInstanceStopped"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeNotebookInstance(req); }; + Aws::Utils::Waiter waiter(30, 60, std::move(acceptors), operation, "WaitUntilNotebookInstanceStopped"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilProcessingJobCompletedOrStopped( const Model::DescribeProcessingJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), - [](const Model::DescribeProcessingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ProcessingJobStatusMapper::GetNameForProcessingJobStatus(result.GetProcessingJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Stopped"), - [](const Model::DescribeProcessingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ProcessingJobStatusMapper::GetNameForProcessingJobStatus(result.GetProcessingJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeProcessingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ProcessingJobStatusMapper::GetNameForProcessingJobStatus(result.GetProcessingJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + using OutcomeT = Model::DescribeProcessingJobOutcome; + using RequestT = Model::DescribeProcessingJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ProcessingJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), + [](const Model::DescribeProcessingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ProcessingJobStatusMapper::GetNameForProcessingJobStatus(result.GetProcessingJobStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ProcessingJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Stopped"), + [](const Model::DescribeProcessingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ProcessingJobStatusMapper::GetNameForProcessingJobStatus(result.GetProcessingJobStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ProcessingJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeProcessingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ProcessingJobStatusMapper::GetNameForProcessingJobStatus(result.GetProcessingJobStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ProcessingJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationException"))); - auto operation = [this](const Model::DescribeProcessingJobRequest& req) { - return static_cast(this)->DescribeProcessingJob(req); - }; - Aws::Utils::Waiter waiter( - 60, 60, acceptors, operation, "WaitUntilProcessingJobCompletedOrStopped"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeProcessingJob(req); }; + Aws::Utils::Waiter waiter(60, 60, std::move(acceptors), operation, "WaitUntilProcessingJobCompletedOrStopped"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTrainingJobCompletedOrStopped( const Model::DescribeTrainingJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), - [](const Model::DescribeTrainingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TrainingJobStatusMapper::GetNameForTrainingJobStatus(result.GetTrainingJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Stopped"), - [](const Model::DescribeTrainingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TrainingJobStatusMapper::GetNameForTrainingJobStatus(result.GetTrainingJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeTrainingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TrainingJobStatusMapper::GetNameForTrainingJobStatus(result.GetTrainingJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + using OutcomeT = Model::DescribeTrainingJobOutcome; + using RequestT = Model::DescribeTrainingJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TrainingJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), + [](const Model::DescribeTrainingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TrainingJobStatusMapper::GetNameForTrainingJobStatus(result.GetTrainingJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TrainingJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Stopped"), + [](const Model::DescribeTrainingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TrainingJobStatusMapper::GetNameForTrainingJobStatus(result.GetTrainingJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TrainingJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeTrainingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TrainingJobStatusMapper::GetNameForTrainingJobStatus(result.GetTrainingJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TrainingJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationException"))); - auto operation = [this](const Model::DescribeTrainingJobRequest& req) { - return static_cast(this)->DescribeTrainingJob(req); - }; - Aws::Utils::Waiter waiter( - 120, 180, acceptors, operation, "WaitUntilTrainingJobCompletedOrStopped"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeTrainingJob(req); }; + Aws::Utils::Waiter waiter(120, 180, std::move(acceptors), operation, "WaitUntilTrainingJobCompletedOrStopped"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTransformJobCompletedOrStopped( const Model::DescribeTransformJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Completed"), - [](const Model::DescribeTransformJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TransformJobStatusMapper::GetNameForTransformJobStatus(result.GetTransformJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Stopped"), - [](const Model::DescribeTransformJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TransformJobStatusMapper::GetNameForTransformJobStatus(result.GetTransformJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeTransformJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TransformJobStatusMapper::GetNameForTransformJobStatus(result.GetTransformJobStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ValidationException")}); + using OutcomeT = Model::DescribeTransformJobOutcome; + using RequestT = Model::DescribeTransformJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TransformJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), + [](const Model::DescribeTransformJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TransformJobStatusMapper::GetNameForTransformJobStatus(result.GetTransformJobStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TransformJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Stopped"), + [](const Model::DescribeTransformJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TransformJobStatusMapper::GetNameForTransformJobStatus(result.GetTransformJobStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TransformJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeTransformJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TransformJobStatusMapper::GetNameForTransformJobStatus(result.GetTransformJobStatus()) == + expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TransformJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ValidationException"))); - auto operation = [this](const Model::DescribeTransformJobRequest& req) { - return static_cast(this)->DescribeTransformJob(req); - }; - Aws::Utils::Waiter waiter( - 60, 60, acceptors, operation, "WaitUntilTransformJobCompletedOrStopped"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeTransformJob(req); }; + Aws::Utils::Waiter waiter(60, 60, std::move(acceptors), operation, "WaitUntilTransformJobCompletedOrStopped"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-savingsplans/include/aws/savingsplans/SavingsPlansWaiter.h b/generated/src/aws-cpp-sdk-savingsplans/include/aws/savingsplans/SavingsPlansWaiter.h new file mode 100644 index 00000000000..7539f513b2f --- /dev/null +++ b/generated/src/aws-cpp-sdk-savingsplans/include/aws/savingsplans/SavingsPlansWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SavingsPlans { + +template +class SavingsPlansWaiter { + public: +}; +} // namespace SavingsPlans +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-scheduler/include/aws/scheduler/SchedulerWaiter.h b/generated/src/aws-cpp-sdk-scheduler/include/aws/scheduler/SchedulerWaiter.h new file mode 100644 index 00000000000..9a08e14479a --- /dev/null +++ b/generated/src/aws-cpp-sdk-scheduler/include/aws/scheduler/SchedulerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Scheduler { + +template +class SchedulerWaiter { + public: +}; +} // namespace Scheduler +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h b/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h index f5c1a67fa58..a7f41a914c6 100644 --- a/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h +++ b/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,35 +21,35 @@ class SchemasWaiter { public: Aws::Utils::WaiterOutcome WaitUntilCodeBindingExists( const Model::DescribeCodeBindingRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_COMPLETE"), - [](const Model::DescribeCodeBindingOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CodeGenerationStatusMapper::GetNameForCodeGenerationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_IN_PROGRESS"), - [](const Model::DescribeCodeBindingOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CodeGenerationStatusMapper::GetNameForCodeGenerationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("CREATE_FAILED"), - [](const Model::DescribeCodeBindingOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CodeGenerationStatusMapper::GetNameForCodeGenerationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("NotFoundException")}); + using OutcomeT = Model::DescribeCodeBindingOutcome; + using RequestT = Model::DescribeCodeBindingRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "CodeBindingExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), + [](const Model::DescribeCodeBindingOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CodeGenerationStatusMapper::GetNameForCodeGenerationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CodeBindingExistsWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATE_IN_PROGRESS"), + [](const Model::DescribeCodeBindingOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CodeGenerationStatusMapper::GetNameForCodeGenerationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CodeBindingExistsWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), + [](const Model::DescribeCodeBindingOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CodeGenerationStatusMapper::GetNameForCodeGenerationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("CodeBindingExistsWaiter", Aws::Utils::WaiterState::FAILURE, + Aws::String("NotFoundException"))); - auto operation = [this](const Model::DescribeCodeBindingRequest& req) { - return static_cast(this)->DescribeCodeBinding(req); - }; - Aws::Utils::Waiter waiter(2, 60, acceptors, operation, - "WaitUntilCodeBindingExists"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeCodeBinding(req); }; + Aws::Utils::Waiter waiter(2, 60, std::move(acceptors), operation, "WaitUntilCodeBindingExists"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-secretsmanager/include/aws/secretsmanager/SecretsManagerWaiter.h b/generated/src/aws-cpp-sdk-secretsmanager/include/aws/secretsmanager/SecretsManagerWaiter.h new file mode 100644 index 00000000000..2c49272fc9a --- /dev/null +++ b/generated/src/aws-cpp-sdk-secretsmanager/include/aws/secretsmanager/SecretsManagerWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SecretsManager { + +template +class SecretsManagerWaiter { + public: +}; +} // namespace SecretsManager +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-security-ir/include/aws/security-ir/SecurityIRWaiter.h b/generated/src/aws-cpp-sdk-security-ir/include/aws/security-ir/SecurityIRWaiter.h new file mode 100644 index 00000000000..085d83f787b --- /dev/null +++ b/generated/src/aws-cpp-sdk-security-ir/include/aws/security-ir/SecurityIRWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SecurityIR { + +template +class SecurityIRWaiter { + public: +}; +} // namespace SecurityIR +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-securityhub/include/aws/securityhub/SecurityHubWaiter.h b/generated/src/aws-cpp-sdk-securityhub/include/aws/securityhub/SecurityHubWaiter.h new file mode 100644 index 00000000000..65ea2d30d40 --- /dev/null +++ b/generated/src/aws-cpp-sdk-securityhub/include/aws/securityhub/SecurityHubWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SecurityHub { + +template +class SecurityHubWaiter { + public: +}; +} // namespace SecurityHub +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-securitylake/include/aws/securitylake/SecurityLakeWaiter.h b/generated/src/aws-cpp-sdk-securitylake/include/aws/securitylake/SecurityLakeWaiter.h new file mode 100644 index 00000000000..9f4c8749892 --- /dev/null +++ b/generated/src/aws-cpp-sdk-securitylake/include/aws/securitylake/SecurityLakeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SecurityLake { + +template +class SecurityLakeWaiter { + public: +}; +} // namespace SecurityLake +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-serverlessrepo/include/aws/serverlessrepo/ServerlessApplicationRepositoryWaiter.h b/generated/src/aws-cpp-sdk-serverlessrepo/include/aws/serverlessrepo/ServerlessApplicationRepositoryWaiter.h new file mode 100644 index 00000000000..c7065a10026 --- /dev/null +++ b/generated/src/aws-cpp-sdk-serverlessrepo/include/aws/serverlessrepo/ServerlessApplicationRepositoryWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ServerlessApplicationRepository { + +template +class ServerlessApplicationRepositoryWaiter { + public: +}; +} // namespace ServerlessApplicationRepository +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-service-quotas/include/aws/service-quotas/ServiceQuotasWaiter.h b/generated/src/aws-cpp-sdk-service-quotas/include/aws/service-quotas/ServiceQuotasWaiter.h new file mode 100644 index 00000000000..6e235429f3c --- /dev/null +++ b/generated/src/aws-cpp-sdk-service-quotas/include/aws/service-quotas/ServiceQuotasWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ServiceQuotas { + +template +class ServiceQuotasWaiter { + public: +}; +} // namespace ServiceQuotas +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-servicecatalog-appregistry/include/aws/servicecatalog-appregistry/AppRegistryWaiter.h b/generated/src/aws-cpp-sdk-servicecatalog-appregistry/include/aws/servicecatalog-appregistry/AppRegistryWaiter.h new file mode 100644 index 00000000000..5c6ab8547b6 --- /dev/null +++ b/generated/src/aws-cpp-sdk-servicecatalog-appregistry/include/aws/servicecatalog-appregistry/AppRegistryWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace AppRegistry { + +template +class AppRegistryWaiter { + public: +}; +} // namespace AppRegistry +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-servicecatalog/include/aws/servicecatalog/ServiceCatalogWaiter.h b/generated/src/aws-cpp-sdk-servicecatalog/include/aws/servicecatalog/ServiceCatalogWaiter.h new file mode 100644 index 00000000000..268cd384bc6 --- /dev/null +++ b/generated/src/aws-cpp-sdk-servicecatalog/include/aws/servicecatalog/ServiceCatalogWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ServiceCatalog { + +template +class ServiceCatalogWaiter { + public: +}; +} // namespace ServiceCatalog +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-servicediscovery/include/aws/servicediscovery/ServiceDiscoveryWaiter.h b/generated/src/aws-cpp-sdk-servicediscovery/include/aws/servicediscovery/ServiceDiscoveryWaiter.h new file mode 100644 index 00000000000..403136e120d --- /dev/null +++ b/generated/src/aws-cpp-sdk-servicediscovery/include/aws/servicediscovery/ServiceDiscoveryWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ServiceDiscovery { + +template +class ServiceDiscoveryWaiter { + public: +}; +} // namespace ServiceDiscovery +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sesv2/include/aws/sesv2/SESV2Waiter.h b/generated/src/aws-cpp-sdk-sesv2/include/aws/sesv2/SESV2Waiter.h new file mode 100644 index 00000000000..0d29734b6f3 --- /dev/null +++ b/generated/src/aws-cpp-sdk-sesv2/include/aws/sesv2/SESV2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SESV2 { + +template +class SESV2Waiter { + public: +}; +} // namespace SESV2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-shield/include/aws/shield/ShieldWaiter.h b/generated/src/aws-cpp-sdk-shield/include/aws/shield/ShieldWaiter.h new file mode 100644 index 00000000000..32ee7b0e1ea --- /dev/null +++ b/generated/src/aws-cpp-sdk-shield/include/aws/shield/ShieldWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Shield { + +template +class ShieldWaiter { + public: +}; +} // namespace Shield +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-signer-data/include/aws/signer-data/SignerDataWaiter.h b/generated/src/aws-cpp-sdk-signer-data/include/aws/signer-data/SignerDataWaiter.h new file mode 100644 index 00000000000..99b0a050799 --- /dev/null +++ b/generated/src/aws-cpp-sdk-signer-data/include/aws/signer-data/SignerDataWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SignerData { + +template +class SignerDataWaiter { + public: +}; +} // namespace SignerData +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h b/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h index 250a82d68dd..39d2c6f5d27 100644 --- a/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h +++ b/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,26 +21,28 @@ class SignerWaiter { public: Aws::Utils::WaiterOutcome WaitUntilSuccessfulSigningJob( const Model::DescribeSigningJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Succeeded"), - [](const Model::DescribeSigningJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SigningStatusMapper::GetNameForSigningStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::DescribeSigningJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::SigningStatusMapper::GetNameForSigningStatus(result.GetStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); + using OutcomeT = Model::DescribeSigningJobOutcome; + using RequestT = Model::DescribeSigningJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "SuccessfulSigningJobWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Succeeded"), + [](const Model::DescribeSigningJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SigningStatusMapper::GetNameForSigningStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SuccessfulSigningJobWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::DescribeSigningJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::SigningStatusMapper::GetNameForSigningStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "SuccessfulSigningJobWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ResourceNotFoundException"))); - auto operation = [this](const Model::DescribeSigningJobRequest& req) { - return static_cast(this)->DescribeSigningJob(req); - }; - Aws::Utils::Waiter waiter(20, 6, acceptors, operation, - "WaitUntilSuccessfulSigningJob"); + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeSigningJob(req); }; + Aws::Utils::Waiter waiter(20, 6, std::move(acceptors), operation, "WaitUntilSuccessfulSigningJob"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-signin/include/aws/signin/SigninWaiter.h b/generated/src/aws-cpp-sdk-signin/include/aws/signin/SigninWaiter.h new file mode 100644 index 00000000000..03e013540d3 --- /dev/null +++ b/generated/src/aws-cpp-sdk-signin/include/aws/signin/SigninWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Signin { + +template +class SigninWaiter { + public: +}; +} // namespace Signin +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h b/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h index 6207cee11e9..338ff2fc528 100644 --- a/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h +++ b/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,24 +20,26 @@ template class SimpleDBv2Waiter { public: Aws::Utils::WaiterOutcome WaitUntilExportSucceeded(const Model::GetExportRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("SUCCEEDED"), - [](const Model::GetExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == - expected.get(); - }}); + using OutcomeT = Model::GetExportOutcome; + using RequestT = Model::GetExportRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "ExportSucceededWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), + [](const Model::GetExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "ExportSucceededWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ExportStatusMapper::GetNameForExportStatus(result.GetExportStatus()) == expected.get(); + })); - auto operation = [this](const Model::GetExportRequest& req) { return static_cast(this)->GetExport(req); }; - Aws::Utils::Waiter waiter(30, 4, acceptors, operation, "WaitUntilExportSucceeded"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetExport(req); }; + Aws::Utils::Waiter waiter(30, 4, std::move(acceptors), operation, "WaitUntilExportSucceeded"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-simspaceweaver/include/aws/simspaceweaver/SimSpaceWeaverWaiter.h b/generated/src/aws-cpp-sdk-simspaceweaver/include/aws/simspaceweaver/SimSpaceWeaverWaiter.h new file mode 100644 index 00000000000..f4af4147e1e --- /dev/null +++ b/generated/src/aws-cpp-sdk-simspaceweaver/include/aws/simspaceweaver/SimSpaceWeaverWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SimSpaceWeaver { + +template +class SimSpaceWeaverWaiter { + public: +}; +} // namespace SimSpaceWeaver +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sms-voice/include/aws/sms-voice/PinpointSMSVoiceWaiter.h b/generated/src/aws-cpp-sdk-sms-voice/include/aws/sms-voice/PinpointSMSVoiceWaiter.h new file mode 100644 index 00000000000..821f1647c95 --- /dev/null +++ b/generated/src/aws-cpp-sdk-sms-voice/include/aws/sms-voice/PinpointSMSVoiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace PinpointSMSVoice { + +template +class PinpointSMSVoiceWaiter { + public: +}; +} // namespace PinpointSMSVoice +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-snow-device-management/include/aws/snow-device-management/SnowDeviceManagementWaiter.h b/generated/src/aws-cpp-sdk-snow-device-management/include/aws/snow-device-management/SnowDeviceManagementWaiter.h new file mode 100644 index 00000000000..69204a8e432 --- /dev/null +++ b/generated/src/aws-cpp-sdk-snow-device-management/include/aws/snow-device-management/SnowDeviceManagementWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SnowDeviceManagement { + +template +class SnowDeviceManagementWaiter { + public: +}; +} // namespace SnowDeviceManagement +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-snowball/include/aws/snowball/SnowballWaiter.h b/generated/src/aws-cpp-sdk-snowball/include/aws/snowball/SnowballWaiter.h new file mode 100644 index 00000000000..3e38a17c272 --- /dev/null +++ b/generated/src/aws-cpp-sdk-snowball/include/aws/snowball/SnowballWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Snowball { + +template +class SnowballWaiter { + public: +}; +} // namespace Snowball +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sns/include/aws/sns/SNSWaiter.h b/generated/src/aws-cpp-sdk-sns/include/aws/sns/SNSWaiter.h new file mode 100644 index 00000000000..bf73050b7d7 --- /dev/null +++ b/generated/src/aws-cpp-sdk-sns/include/aws/sns/SNSWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SNS { + +template +class SNSWaiter { + public: +}; +} // namespace SNS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-socialmessaging/include/aws/socialmessaging/SocialMessagingWaiter.h b/generated/src/aws-cpp-sdk-socialmessaging/include/aws/socialmessaging/SocialMessagingWaiter.h new file mode 100644 index 00000000000..2d63849a74a --- /dev/null +++ b/generated/src/aws-cpp-sdk-socialmessaging/include/aws/socialmessaging/SocialMessagingWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SocialMessaging { + +template +class SocialMessagingWaiter { + public: +}; +} // namespace SocialMessaging +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sqs/include/aws/sqs/SQSWaiter.h b/generated/src/aws-cpp-sdk-sqs/include/aws/sqs/SQSWaiter.h new file mode 100644 index 00000000000..e3aba631d5a --- /dev/null +++ b/generated/src/aws-cpp-sdk-sqs/include/aws/sqs/SQSWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SQS { + +template +class SQSWaiter { + public: +}; +} // namespace SQS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ssm-contacts/include/aws/ssm-contacts/SSMContactsWaiter.h b/generated/src/aws-cpp-sdk-ssm-contacts/include/aws/ssm-contacts/SSMContactsWaiter.h new file mode 100644 index 00000000000..4b9ce445421 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ssm-contacts/include/aws/ssm-contacts/SSMContactsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SSMContacts { + +template +class SSMContactsWaiter { + public: +}; +} // namespace SSMContacts +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ssm-guiconnect/include/aws/ssm-guiconnect/SSMGuiConnectWaiter.h b/generated/src/aws-cpp-sdk-ssm-guiconnect/include/aws/ssm-guiconnect/SSMGuiConnectWaiter.h new file mode 100644 index 00000000000..9a9eaa85bb2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ssm-guiconnect/include/aws/ssm-guiconnect/SSMGuiConnectWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SSMGuiConnect { + +template +class SSMGuiConnectWaiter { + public: +}; +} // namespace SSMGuiConnect +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h b/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h index 57f3705fe19..f68026a2c01 100644 --- a/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h +++ b/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -19,62 +20,67 @@ class SSMIncidentsWaiter { public: Aws::Utils::WaiterOutcome WaitUntilWaitForReplicationSetActive( const Model::GetReplicationSetRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("ACTIVE"), - [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("CREATING"), - [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("UPDATING"), - [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetReplicationSetOutcome; + using RequestT = Model::GetReplicationSetRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "WaitForReplicationSetActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WaitForReplicationSetActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WaitForReplicationSetActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WaitForReplicationSetActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetReplicationSetRequest& req) { - return static_cast(this)->GetReplicationSet(req); - }; - Aws::Utils::Waiter waiter(30, 1, acceptors, operation, - "WaitUntilWaitForReplicationSetActive"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetReplicationSet(req); }; + Aws::Utils::Waiter waiter(30, 1, std::move(acceptors), operation, "WaitUntilWaitForReplicationSetActive"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilWaitForReplicationSetDeleted( const Model::GetReplicationSetRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::ERROR, Aws::String("ResourceNotFoundException")}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("DELETING"), - [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); - }}); + using OutcomeT = Model::GetReplicationSetOutcome; + using RequestT = Model::GetReplicationSetRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "WaitForReplicationSetDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); + acceptors.emplace_back(Aws::MakeUnique>( + "WaitForReplicationSetDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "WaitForReplicationSetDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return result.GetReplicationSet().GetStatus() == expected.get(); + })); - auto operation = [this](const Model::GetReplicationSetRequest& req) { - return static_cast(this)->GetReplicationSet(req); - }; - Aws::Utils::Waiter waiter(30, 1, acceptors, operation, - "WaitUntilWaitForReplicationSetDeleted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetReplicationSet(req); }; + Aws::Utils::Waiter waiter(30, 1, std::move(acceptors), operation, "WaitUntilWaitForReplicationSetDeleted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-ssm-quicksetup/include/aws/ssm-quicksetup/SSMQuickSetupWaiter.h b/generated/src/aws-cpp-sdk-ssm-quicksetup/include/aws/ssm-quicksetup/SSMQuickSetupWaiter.h new file mode 100644 index 00000000000..27534c90010 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ssm-quicksetup/include/aws/ssm-quicksetup/SSMQuickSetupWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SSMQuickSetup { + +template +class SSMQuickSetupWaiter { + public: +}; +} // namespace SSMQuickSetup +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ssm-sap/include/aws/ssm-sap/SsmSapWaiter.h b/generated/src/aws-cpp-sdk-ssm-sap/include/aws/ssm-sap/SsmSapWaiter.h new file mode 100644 index 00000000000..d0989eee4d5 --- /dev/null +++ b/generated/src/aws-cpp-sdk-ssm-sap/include/aws/ssm-sap/SsmSapWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SsmSap { + +template +class SsmSapWaiter { + public: +}; +} // namespace SsmSap +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h b/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h index 2f4d6f09610..1e06eef930e 100644 --- a/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h +++ b/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -20,70 +21,70 @@ class SSMWaiter { public: Aws::Utils::WaiterOutcome WaitUntilCommandExecuted( const Model::GetCommandInvocationRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Pending"), - [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("InProgress"), - [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::PATH, Aws::String("Delayed"), - [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("Success"), - [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Cancelled"), - [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("TimedOut"), - [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Failed"), - [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("Cancelling"), - [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::RETRY, Aws::Utils::MatcherType::ERROR, Aws::String("InvocationDoesNotExist")}); + using OutcomeT = Model::GetCommandInvocationOutcome; + using RequestT = Model::GetCommandInvocationRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "CommandExecutedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("Pending"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CommandExecutedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InProgress"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CommandExecutedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("Delayed"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CommandExecutedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Success"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CommandExecutedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Cancelled"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CommandExecutedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("TimedOut"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CommandExecutedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Failed"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CommandExecutedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("Cancelling"), + [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CommandInvocationStatusMapper::GetNameForCommandInvocationStatus(result.GetStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>("CommandExecutedWaiter", Aws::Utils::WaiterState::RETRY, + Aws::String("InvocationDoesNotExist"))); - auto operation = [this](const Model::GetCommandInvocationRequest& req) { - return static_cast(this)->GetCommandInvocation(req); - }; - Aws::Utils::Waiter waiter(5, 24, acceptors, operation, - "WaitUntilCommandExecuted"); + auto operation = [this](const RequestT& req) { return static_cast(this)->GetCommandInvocation(req); }; + Aws::Utils::Waiter waiter(5, 24, std::move(acceptors), operation, "WaitUntilCommandExecuted"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-sso-admin/include/aws/sso-admin/SSOAdminWaiter.h b/generated/src/aws-cpp-sdk-sso-admin/include/aws/sso-admin/SSOAdminWaiter.h new file mode 100644 index 00000000000..29f6b4e037a --- /dev/null +++ b/generated/src/aws-cpp-sdk-sso-admin/include/aws/sso-admin/SSOAdminWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SSOAdmin { + +template +class SSOAdminWaiter { + public: +}; +} // namespace SSOAdmin +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sso-oidc/include/aws/sso-oidc/SSOOIDCWaiter.h b/generated/src/aws-cpp-sdk-sso-oidc/include/aws/sso-oidc/SSOOIDCWaiter.h new file mode 100644 index 00000000000..173e40e7985 --- /dev/null +++ b/generated/src/aws-cpp-sdk-sso-oidc/include/aws/sso-oidc/SSOOIDCWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SSOOIDC { + +template +class SSOOIDCWaiter { + public: +}; +} // namespace SSOOIDC +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sso/include/aws/sso/SSOWaiter.h b/generated/src/aws-cpp-sdk-sso/include/aws/sso/SSOWaiter.h new file mode 100644 index 00000000000..975803596d4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-sso/include/aws/sso/SSOWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SSO { + +template +class SSOWaiter { + public: +}; +} // namespace SSO +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-states/include/aws/states/SFNWaiter.h b/generated/src/aws-cpp-sdk-states/include/aws/states/SFNWaiter.h new file mode 100644 index 00000000000..9607a8f3840 --- /dev/null +++ b/generated/src/aws-cpp-sdk-states/include/aws/states/SFNWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SFN { + +template +class SFNWaiter { + public: +}; +} // namespace SFN +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-storagegateway/include/aws/storagegateway/StorageGatewayWaiter.h b/generated/src/aws-cpp-sdk-storagegateway/include/aws/storagegateway/StorageGatewayWaiter.h new file mode 100644 index 00000000000..1f766d305d1 --- /dev/null +++ b/generated/src/aws-cpp-sdk-storagegateway/include/aws/storagegateway/StorageGatewayWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace StorageGateway { + +template +class StorageGatewayWaiter { + public: +}; +} // namespace StorageGateway +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-sts/include/aws/sts/STSWaiter.h b/generated/src/aws-cpp-sdk-sts/include/aws/sts/STSWaiter.h new file mode 100644 index 00000000000..cdc4f98af0c --- /dev/null +++ b/generated/src/aws-cpp-sdk-sts/include/aws/sts/STSWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace STS { + +template +class STSWaiter { + public: +}; +} // namespace STS +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-supplychain/include/aws/supplychain/SupplyChainWaiter.h b/generated/src/aws-cpp-sdk-supplychain/include/aws/supplychain/SupplyChainWaiter.h new file mode 100644 index 00000000000..48763c04cf1 --- /dev/null +++ b/generated/src/aws-cpp-sdk-supplychain/include/aws/supplychain/SupplyChainWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SupplyChain { + +template +class SupplyChainWaiter { + public: +}; +} // namespace SupplyChain +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-support-app/include/aws/support-app/SupportAppWaiter.h b/generated/src/aws-cpp-sdk-support-app/include/aws/support-app/SupportAppWaiter.h new file mode 100644 index 00000000000..ce8a40bfab2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-support-app/include/aws/support-app/SupportAppWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SupportApp { + +template +class SupportAppWaiter { + public: +}; +} // namespace SupportApp +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-support/include/aws/support/SupportWaiter.h b/generated/src/aws-cpp-sdk-support/include/aws/support/SupportWaiter.h new file mode 100644 index 00000000000..cfc0c5d6273 --- /dev/null +++ b/generated/src/aws-cpp-sdk-support/include/aws/support/SupportWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Support { + +template +class SupportWaiter { + public: +}; +} // namespace Support +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-swf/include/aws/swf/SWFWaiter.h b/generated/src/aws-cpp-sdk-swf/include/aws/swf/SWFWaiter.h new file mode 100644 index 00000000000..b2ab90053d7 --- /dev/null +++ b/generated/src/aws-cpp-sdk-swf/include/aws/swf/SWFWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace SWF { + +template +class SWFWaiter { + public: +}; +} // namespace SWF +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-synthetics/include/aws/synthetics/SyntheticsWaiter.h b/generated/src/aws-cpp-sdk-synthetics/include/aws/synthetics/SyntheticsWaiter.h new file mode 100644 index 00000000000..f4ff359a07b --- /dev/null +++ b/generated/src/aws-cpp-sdk-synthetics/include/aws/synthetics/SyntheticsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Synthetics { + +template +class SyntheticsWaiter { + public: +}; +} // namespace Synthetics +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-taxsettings/include/aws/taxsettings/TaxSettingsWaiter.h b/generated/src/aws-cpp-sdk-taxsettings/include/aws/taxsettings/TaxSettingsWaiter.h new file mode 100644 index 00000000000..fb17ab1b52e --- /dev/null +++ b/generated/src/aws-cpp-sdk-taxsettings/include/aws/taxsettings/TaxSettingsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace TaxSettings { + +template +class TaxSettingsWaiter { + public: +}; +} // namespace TaxSettings +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-textract/include/aws/textract/TextractWaiter.h b/generated/src/aws-cpp-sdk-textract/include/aws/textract/TextractWaiter.h new file mode 100644 index 00000000000..bd91ce82573 --- /dev/null +++ b/generated/src/aws-cpp-sdk-textract/include/aws/textract/TextractWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Textract { + +template +class TextractWaiter { + public: +}; +} // namespace Textract +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-timestream-influxdb/include/aws/timestream-influxdb/TimestreamInfluxDBWaiter.h b/generated/src/aws-cpp-sdk-timestream-influxdb/include/aws/timestream-influxdb/TimestreamInfluxDBWaiter.h new file mode 100644 index 00000000000..09d3fc26b03 --- /dev/null +++ b/generated/src/aws-cpp-sdk-timestream-influxdb/include/aws/timestream-influxdb/TimestreamInfluxDBWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace TimestreamInfluxDB { + +template +class TimestreamInfluxDBWaiter { + public: +}; +} // namespace TimestreamInfluxDB +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-timestream-query/include/aws/timestream-query/TimestreamQueryWaiter.h b/generated/src/aws-cpp-sdk-timestream-query/include/aws/timestream-query/TimestreamQueryWaiter.h new file mode 100644 index 00000000000..768bbb23f46 --- /dev/null +++ b/generated/src/aws-cpp-sdk-timestream-query/include/aws/timestream-query/TimestreamQueryWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace TimestreamQuery { + +template +class TimestreamQueryWaiter { + public: +}; +} // namespace TimestreamQuery +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-timestream-write/include/aws/timestream-write/TimestreamWriteWaiter.h b/generated/src/aws-cpp-sdk-timestream-write/include/aws/timestream-write/TimestreamWriteWaiter.h new file mode 100644 index 00000000000..8c01b16b5d3 --- /dev/null +++ b/generated/src/aws-cpp-sdk-timestream-write/include/aws/timestream-write/TimestreamWriteWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace TimestreamWrite { + +template +class TimestreamWriteWaiter { + public: +}; +} // namespace TimestreamWrite +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-tnb/include/aws/tnb/TnbWaiter.h b/generated/src/aws-cpp-sdk-tnb/include/aws/tnb/TnbWaiter.h new file mode 100644 index 00000000000..02938266d9d --- /dev/null +++ b/generated/src/aws-cpp-sdk-tnb/include/aws/tnb/TnbWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace tnb { + +template +class TnbWaiter { + public: +}; +} // namespace tnb +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h b/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h index 3025c06badf..2af7f090e77 100644 --- a/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h +++ b/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h @@ -5,6 +5,7 @@ #pragma once #include +#include #include #include #include @@ -36,180 +37,183 @@ class TranscribeServiceWaiter { public: Aws::Utils::WaiterOutcome WaitUntilLanguageModelCompleted( const Model::DescribeLanguageModelRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::DescribeLanguageModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ModelStatusMapper::GetNameForModelStatus(result.GetLanguageModel().GetModelStatus()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::DescribeLanguageModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::ModelStatusMapper::GetNameForModelStatus(result.GetLanguageModel().GetModelStatus()) == - expected.get(); - }}); - - auto operation = [this](const Model::DescribeLanguageModelRequest& req) { - return static_cast(this)->DescribeLanguageModel(req); - }; - Aws::Utils::Waiter waiter(120, 1, acceptors, operation, - "WaitUntilLanguageModelCompleted"); + using OutcomeT = Model::DescribeLanguageModelOutcome; + using RequestT = Model::DescribeLanguageModelRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "LanguageModelCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::DescribeLanguageModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ModelStatusMapper::GetNameForModelStatus(result.GetLanguageModel().GetModelStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "LanguageModelCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::DescribeLanguageModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::ModelStatusMapper::GetNameForModelStatus(result.GetLanguageModel().GetModelStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeLanguageModel(req); }; + Aws::Utils::Waiter waiter(120, 1, std::move(acceptors), operation, "WaitUntilLanguageModelCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilCallAnalyticsJobCompleted( const Model::GetCallAnalyticsJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetCallAnalyticsJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CallAnalyticsJobStatusMapper::GetNameForCallAnalyticsJobStatus( - result.GetCallAnalyticsJob().GetCallAnalyticsJobStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetCallAnalyticsJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::CallAnalyticsJobStatusMapper::GetNameForCallAnalyticsJobStatus( - result.GetCallAnalyticsJob().GetCallAnalyticsJobStatus()) == expected.get(); - }}); - - auto operation = [this](const Model::GetCallAnalyticsJobRequest& req) { - return static_cast(this)->GetCallAnalyticsJob(req); - }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilCallAnalyticsJobCompleted"); + using OutcomeT = Model::GetCallAnalyticsJobOutcome; + using RequestT = Model::GetCallAnalyticsJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "CallAnalyticsJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetCallAnalyticsJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CallAnalyticsJobStatusMapper::GetNameForCallAnalyticsJobStatus( + result.GetCallAnalyticsJob().GetCallAnalyticsJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "CallAnalyticsJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetCallAnalyticsJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::CallAnalyticsJobStatusMapper::GetNameForCallAnalyticsJobStatus( + result.GetCallAnalyticsJob().GetCallAnalyticsJobStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetCallAnalyticsJob(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilCallAnalyticsJobCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilMedicalScribeJobCompleted( const Model::GetMedicalScribeJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetMedicalScribeJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MedicalScribeJobStatusMapper::GetNameForMedicalScribeJobStatus( - result.GetMedicalScribeJob().GetMedicalScribeJobStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetMedicalScribeJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::MedicalScribeJobStatusMapper::GetNameForMedicalScribeJobStatus( - result.GetMedicalScribeJob().GetMedicalScribeJobStatus()) == expected.get(); - }}); - - auto operation = [this](const Model::GetMedicalScribeJobRequest& req) { - return static_cast(this)->GetMedicalScribeJob(req); - }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilMedicalScribeJobCompleted"); + using OutcomeT = Model::GetMedicalScribeJobOutcome; + using RequestT = Model::GetMedicalScribeJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "MedicalScribeJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetMedicalScribeJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MedicalScribeJobStatusMapper::GetNameForMedicalScribeJobStatus( + result.GetMedicalScribeJob().GetMedicalScribeJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "MedicalScribeJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetMedicalScribeJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::MedicalScribeJobStatusMapper::GetNameForMedicalScribeJobStatus( + result.GetMedicalScribeJob().GetMedicalScribeJobStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetMedicalScribeJob(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilMedicalScribeJobCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilMedicalTranscriptionJobCompleted( const Model::GetMedicalTranscriptionJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetMedicalTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( - result.GetMedicalTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetMedicalTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( - result.GetMedicalTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); - }}); - - auto operation = [this](const Model::GetMedicalTranscriptionJobRequest& req) { - return static_cast(this)->GetMedicalTranscriptionJob(req); - }; - Aws::Utils::Waiter waiter( - 10, 12, acceptors, operation, "WaitUntilMedicalTranscriptionJobCompleted"); + using OutcomeT = Model::GetMedicalTranscriptionJobOutcome; + using RequestT = Model::GetMedicalTranscriptionJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "MedicalTranscriptionJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetMedicalTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( + result.GetMedicalTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "MedicalTranscriptionJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetMedicalTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( + result.GetMedicalTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetMedicalTranscriptionJob(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilMedicalTranscriptionJobCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilMedicalVocabularyReady( const Model::GetMedicalVocabularyRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("READY"), - [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == - expected.get(); - }}); - - auto operation = [this](const Model::GetMedicalVocabularyRequest& req) { - return static_cast(this)->GetMedicalVocabulary(req); - }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilMedicalVocabularyReady"); + using OutcomeT = Model::GetMedicalVocabularyOutcome; + using RequestT = Model::GetMedicalVocabularyRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "MedicalVocabularyReadyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("READY"), + [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "MedicalVocabularyReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetMedicalVocabulary(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilMedicalVocabularyReady"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilTranscriptionJobCompleted( const Model::GetTranscriptionJobRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("COMPLETED"), - [](const Model::GetTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( - result.GetTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( - result.GetTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); - }}); - - auto operation = [this](const Model::GetTranscriptionJobRequest& req) { - return static_cast(this)->GetTranscriptionJob(req); - }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilTranscriptionJobCompleted"); + using OutcomeT = Model::GetTranscriptionJobOutcome; + using RequestT = Model::GetTranscriptionJobRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "TranscriptionJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), + [](const Model::GetTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( + result.GetTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "TranscriptionJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::TranscriptionJobStatusMapper::GetNameForTranscriptionJobStatus( + result.GetTranscriptionJob().GetTranscriptionJobStatus()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetTranscriptionJob(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilTranscriptionJobCompleted"); return waiter.Wait(request); } Aws::Utils::WaiterOutcome WaitUntilVocabularyReady(const Model::GetVocabularyRequest& request) { - std::vector> acceptors; - acceptors.push_back({Aws::Utils::WaiterState::SUCCESS, Aws::Utils::MatcherType::PATH, Aws::String("READY"), - [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == - expected.get(); - }}); - acceptors.push_back({Aws::Utils::WaiterState::FAILURE, Aws::Utils::MatcherType::PATH, Aws::String("FAILED"), - [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { - if (!outcome.IsSuccess()) return false; - const auto& result = outcome.GetResult(); - return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == - expected.get(); - }}); - - auto operation = [this](const Model::GetVocabularyRequest& req) { return static_cast(this)->GetVocabulary(req); }; - Aws::Utils::Waiter waiter(10, 12, acceptors, operation, - "WaitUntilVocabularyReady"); + using OutcomeT = Model::GetVocabularyOutcome; + using RequestT = Model::GetVocabularyRequest; + std::vector>> acceptors; + acceptors.emplace_back(Aws::MakeUnique>( + "VocabularyReadyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("READY"), + [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == expected.get(); + })); + acceptors.emplace_back(Aws::MakeUnique>( + "VocabularyReadyWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), + [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { + if (!outcome.IsSuccess()) return false; + const auto& result = outcome.GetResult(); + return Model::VocabularyStateMapper::GetNameForVocabularyState(result.GetVocabularyState()) == expected.get(); + })); + + auto operation = [this](const RequestT& req) { return static_cast(this)->GetVocabulary(req); }; + Aws::Utils::Waiter waiter(10, 12, std::move(acceptors), operation, "WaitUntilVocabularyReady"); return waiter.Wait(request); } }; diff --git a/generated/src/aws-cpp-sdk-transcribestreaming/include/aws/transcribestreaming/TranscribeStreamingServiceWaiter.h b/generated/src/aws-cpp-sdk-transcribestreaming/include/aws/transcribestreaming/TranscribeStreamingServiceWaiter.h new file mode 100644 index 00000000000..d9ff404acf9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-transcribestreaming/include/aws/transcribestreaming/TranscribeStreamingServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace TranscribeStreamingService { + +template +class TranscribeStreamingServiceWaiter { + public: +}; +} // namespace TranscribeStreamingService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-translate/include/aws/translate/TranslateWaiter.h b/generated/src/aws-cpp-sdk-translate/include/aws/translate/TranslateWaiter.h new file mode 100644 index 00000000000..b0691493cf4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-translate/include/aws/translate/TranslateWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Translate { + +template +class TranslateWaiter { + public: +}; +} // namespace Translate +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-trustedadvisor/include/aws/trustedadvisor/TrustedAdvisorWaiter.h b/generated/src/aws-cpp-sdk-trustedadvisor/include/aws/trustedadvisor/TrustedAdvisorWaiter.h new file mode 100644 index 00000000000..8c4806e76f6 --- /dev/null +++ b/generated/src/aws-cpp-sdk-trustedadvisor/include/aws/trustedadvisor/TrustedAdvisorWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace TrustedAdvisor { + +template +class TrustedAdvisorWaiter { + public: +}; +} // namespace TrustedAdvisor +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-verifiedpermissions/include/aws/verifiedpermissions/VerifiedPermissionsWaiter.h b/generated/src/aws-cpp-sdk-verifiedpermissions/include/aws/verifiedpermissions/VerifiedPermissionsWaiter.h new file mode 100644 index 00000000000..c556a267022 --- /dev/null +++ b/generated/src/aws-cpp-sdk-verifiedpermissions/include/aws/verifiedpermissions/VerifiedPermissionsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace VerifiedPermissions { + +template +class VerifiedPermissionsWaiter { + public: +}; +} // namespace VerifiedPermissions +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-voice-id/include/aws/voice-id/VoiceIDWaiter.h b/generated/src/aws-cpp-sdk-voice-id/include/aws/voice-id/VoiceIDWaiter.h new file mode 100644 index 00000000000..5e0f46dc2be --- /dev/null +++ b/generated/src/aws-cpp-sdk-voice-id/include/aws/voice-id/VoiceIDWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace VoiceID { + +template +class VoiceIDWaiter { + public: +}; +} // namespace VoiceID +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-vpc-lattice/include/aws/vpc-lattice/VPCLatticeWaiter.h b/generated/src/aws-cpp-sdk-vpc-lattice/include/aws/vpc-lattice/VPCLatticeWaiter.h new file mode 100644 index 00000000000..b0699d99d0f --- /dev/null +++ b/generated/src/aws-cpp-sdk-vpc-lattice/include/aws/vpc-lattice/VPCLatticeWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace VPCLattice { + +template +class VPCLatticeWaiter { + public: +}; +} // namespace VPCLattice +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-waf-regional/include/aws/waf-regional/WAFRegionalWaiter.h b/generated/src/aws-cpp-sdk-waf-regional/include/aws/waf-regional/WAFRegionalWaiter.h new file mode 100644 index 00000000000..5e157951e7a --- /dev/null +++ b/generated/src/aws-cpp-sdk-waf-regional/include/aws/waf-regional/WAFRegionalWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace WAFRegional { + +template +class WAFRegionalWaiter { + public: +}; +} // namespace WAFRegional +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-waf/include/aws/waf/WAFWaiter.h b/generated/src/aws-cpp-sdk-waf/include/aws/waf/WAFWaiter.h new file mode 100644 index 00000000000..d84f16fa6a8 --- /dev/null +++ b/generated/src/aws-cpp-sdk-waf/include/aws/waf/WAFWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace WAF { + +template +class WAFWaiter { + public: +}; +} // namespace WAF +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-wafv2/include/aws/wafv2/WAFV2Waiter.h b/generated/src/aws-cpp-sdk-wafv2/include/aws/wafv2/WAFV2Waiter.h new file mode 100644 index 00000000000..544ab89bdf2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-wafv2/include/aws/wafv2/WAFV2Waiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace WAFV2 { + +template +class WAFV2Waiter { + public: +}; +} // namespace WAFV2 +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-wellarchitected/include/aws/wellarchitected/WellArchitectedWaiter.h b/generated/src/aws-cpp-sdk-wellarchitected/include/aws/wellarchitected/WellArchitectedWaiter.h new file mode 100644 index 00000000000..04e0d8d6bcb --- /dev/null +++ b/generated/src/aws-cpp-sdk-wellarchitected/include/aws/wellarchitected/WellArchitectedWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace WellArchitected { + +template +class WellArchitectedWaiter { + public: +}; +} // namespace WellArchitected +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-wickr/include/aws/wickr/WickrWaiter.h b/generated/src/aws-cpp-sdk-wickr/include/aws/wickr/WickrWaiter.h new file mode 100644 index 00000000000..90f9a0bb3c4 --- /dev/null +++ b/generated/src/aws-cpp-sdk-wickr/include/aws/wickr/WickrWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace Wickr { + +template +class WickrWaiter { + public: +}; +} // namespace Wickr +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-wisdom/include/aws/wisdom/ConnectWisdomServiceWaiter.h b/generated/src/aws-cpp-sdk-wisdom/include/aws/wisdom/ConnectWisdomServiceWaiter.h new file mode 100644 index 00000000000..b7cb264010b --- /dev/null +++ b/generated/src/aws-cpp-sdk-wisdom/include/aws/wisdom/ConnectWisdomServiceWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace ConnectWisdomService { + +template +class ConnectWisdomServiceWaiter { + public: +}; +} // namespace ConnectWisdomService +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-workdocs/include/aws/workdocs/WorkDocsWaiter.h b/generated/src/aws-cpp-sdk-workdocs/include/aws/workdocs/WorkDocsWaiter.h new file mode 100644 index 00000000000..aa69feb955d --- /dev/null +++ b/generated/src/aws-cpp-sdk-workdocs/include/aws/workdocs/WorkDocsWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace WorkDocs { + +template +class WorkDocsWaiter { + public: +}; +} // namespace WorkDocs +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-workmail/include/aws/workmail/WorkMailWaiter.h b/generated/src/aws-cpp-sdk-workmail/include/aws/workmail/WorkMailWaiter.h new file mode 100644 index 00000000000..7ee2079c4b2 --- /dev/null +++ b/generated/src/aws-cpp-sdk-workmail/include/aws/workmail/WorkMailWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace WorkMail { + +template +class WorkMailWaiter { + public: +}; +} // namespace WorkMail +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-workmailmessageflow/include/aws/workmailmessageflow/WorkMailMessageFlowWaiter.h b/generated/src/aws-cpp-sdk-workmailmessageflow/include/aws/workmailmessageflow/WorkMailMessageFlowWaiter.h new file mode 100644 index 00000000000..32bfad407e8 --- /dev/null +++ b/generated/src/aws-cpp-sdk-workmailmessageflow/include/aws/workmailmessageflow/WorkMailMessageFlowWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace WorkMailMessageFlow { + +template +class WorkMailMessageFlowWaiter { + public: +}; +} // namespace WorkMailMessageFlow +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-workspaces-instances/include/aws/workspaces-instances/WorkspacesInstancesWaiter.h b/generated/src/aws-cpp-sdk-workspaces-instances/include/aws/workspaces-instances/WorkspacesInstancesWaiter.h new file mode 100644 index 00000000000..3b088375a47 --- /dev/null +++ b/generated/src/aws-cpp-sdk-workspaces-instances/include/aws/workspaces-instances/WorkspacesInstancesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace WorkspacesInstances { + +template +class WorkspacesInstancesWaiter { + public: +}; +} // namespace WorkspacesInstances +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-workspaces-thin-client/include/aws/workspaces-thin-client/WorkSpacesThinClientWaiter.h b/generated/src/aws-cpp-sdk-workspaces-thin-client/include/aws/workspaces-thin-client/WorkSpacesThinClientWaiter.h new file mode 100644 index 00000000000..14a65a12931 --- /dev/null +++ b/generated/src/aws-cpp-sdk-workspaces-thin-client/include/aws/workspaces-thin-client/WorkSpacesThinClientWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace WorkSpacesThinClient { + +template +class WorkSpacesThinClientWaiter { + public: +}; +} // namespace WorkSpacesThinClient +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-workspaces-web/include/aws/workspaces-web/WorkSpacesWebWaiter.h b/generated/src/aws-cpp-sdk-workspaces-web/include/aws/workspaces-web/WorkSpacesWebWaiter.h new file mode 100644 index 00000000000..456590aae24 --- /dev/null +++ b/generated/src/aws-cpp-sdk-workspaces-web/include/aws/workspaces-web/WorkSpacesWebWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace WorkSpacesWeb { + +template +class WorkSpacesWebWaiter { + public: +}; +} // namespace WorkSpacesWeb +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-workspaces/include/aws/workspaces/WorkSpacesWaiter.h b/generated/src/aws-cpp-sdk-workspaces/include/aws/workspaces/WorkSpacesWaiter.h new file mode 100644 index 00000000000..5d2d44c45c9 --- /dev/null +++ b/generated/src/aws-cpp-sdk-workspaces/include/aws/workspaces/WorkSpacesWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace WorkSpaces { + +template +class WorkSpacesWaiter { + public: +}; +} // namespace WorkSpaces +} // namespace Aws diff --git a/generated/src/aws-cpp-sdk-xray/include/aws/xray/XRayWaiter.h b/generated/src/aws-cpp-sdk-xray/include/aws/xray/XRayWaiter.h new file mode 100644 index 00000000000..56f94c000e6 --- /dev/null +++ b/generated/src/aws-cpp-sdk-xray/include/aws/xray/XRayWaiter.h @@ -0,0 +1,21 @@ +/** + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * SPDX-License-Identifier: Apache-2.0. + */ + +#pragma once +#include +#include +#include + +#include + +namespace Aws { +namespace XRay { + +template +class XRayWaiter { + public: +}; +} // namespace XRay +} // namespace Aws From eec297b9f04892d4953ff551a8c2599fc0f657b8 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Wed, 18 Mar 2026 13:16:26 -0400 Subject: [PATCH 15/21] Transition the waiter to the failure state if none of the acceptors are matched and an error was encountered --- src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h index 7c7a2f4b129..1edd3f3bd19 100644 --- a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h +++ b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h @@ -133,6 +133,10 @@ class Waiter { case WaiterState::RETRY: break; // continue polling } + } else if (!outcome.IsSuccess()) { + // No acceptor matched and an error was encountered: transition to failure + return WaiterOutcome(WaiterError(WaiterErrors::INVALID_ACTION, "", + "No acceptor matched and an error was encountered", false /*retryable*/)); } if (attempt < m_maxAttempts - 1) { From 0bb04ec72641239bd2abbe79597a0fe83401de35 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Wed, 18 Mar 2026 13:24:50 -0400 Subject: [PATCH 16/21] change std::vector to Aws::Vector (why do i forget this everytime) --- src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h | 4 ++-- .../generators/waiters/WaiterHeaderGenerator.java | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h index 1edd3f3bd19..e30ae602509 100644 --- a/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h +++ b/src/aws-cpp-sdk-core/include/aws/core/utils/Waiter.h @@ -108,7 +108,7 @@ class Waiter { public: using AcceptorPtr = Aws::UniquePtr>; - Waiter(int delay, int maxAttempts, std::vector acceptors, std::function op, + Waiter(int delay, int maxAttempts, Aws::Vector acceptors, std::function op, const Aws::String& waiterName = "Waiter") : m_delay(delay), m_maxAttempts(maxAttempts), @@ -150,7 +150,7 @@ class Waiter { private: int m_delay; int m_maxAttempts; - std::vector m_acceptors; + Aws::Vector m_acceptors; std::function m_operation; Aws::String m_name; diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java index a24333d0f3e..c9042d89dfa 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/WaiterHeaderGenerator.java @@ -125,7 +125,7 @@ private void writeWaiterMethod(CppWriter writer, WaiterOperationData data) { writer.write("using OutcomeT = $L;", outcomeType); writer.write("using RequestT = $L;", requestType); - writer.write("std::vector>> acceptors;"); + writer.write("Aws::Vector>> acceptors;"); for (Acceptor acceptor : data.getWaiter().getAcceptors()) { writeAcceptor(writer, acceptor, waiterTag, data); From a2fc44891b1d646c1e33c73c726b92311f177c7a Mon Sep 17 00:00:00 2001 From: sbaluja Date: Wed, 18 Mar 2026 13:52:55 -0400 Subject: [PATCH 17/21] Updated waiter files --- .../include/aws/acm-pca/ACMPCAWaiter.h | 6 +- .../include/aws/acm/ACMWaiter.h | 2 +- .../include/aws/amp/PrometheusServiceWaiter.h | 12 +-- .../include/aws/appconfig/AppConfigWaiter.h | 4 +- .../include/aws/appstream/AppStreamWaiter.h | 4 +- .../arc-region-switch/ARCRegionswitchWaiter.h | 4 +- .../aws/autoscaling/AutoScalingWaiter.h | 6 +- .../include/aws/awstransfer/TransferWaiter.h | 4 +- .../include/aws/b2bi/B2BIWaiter.h | 2 +- .../BedrockAgentCoreControlWaiter.h | 12 +-- .../aws/cloudcontrol/CloudControlApiWaiter.h | 2 +- .../aws/cloudformation/CloudFormationWaiter.h | 20 ++--- .../include/aws/cloudfront/CloudFrontWaiter.h | 8 +- .../include/aws/codedeploy/CodeDeployWaiter.h | 2 +- .../CodeGuruReviewerWaiter.h | 4 +- .../include/aws/deadline/DeadlineWaiter.h | 20 ++--- .../aws/dms/DatabaseMigrationServiceWaiter.h | 16 ++-- .../include/aws/docdb/DocDBWaiter.h | 4 +- .../include/aws/ds/DirectoryServiceWaiter.h | 2 +- .../include/aws/dsql/DSQLWaiter.h | 4 +- .../include/aws/dynamodb/DynamoDBWaiter.h | 12 +-- .../include/aws/ec2/EC2Waiter.h | 86 +++++++++---------- .../include/aws/ecr/ECRWaiter.h | 4 +- .../include/aws/ecs/ECSWaiter.h | 8 +- .../include/aws/eks/EKSWaiter.h | 16 ++-- .../aws/elasticache/ElastiCacheWaiter.h | 8 +- .../elasticbeanstalk/ElasticBeanstalkWaiter.h | 6 +- .../ElasticLoadBalancingWaiter.h | 6 +- .../ElasticLoadBalancingv2Waiter.h | 10 +-- .../include/aws/elasticmapreduce/EMRWaiter.h | 6 +- .../ElementalInferenceWaiter.h | 2 +- .../include/aws/email/SESWaiter.h | 2 +- .../gameliftstreams/GameLiftStreamsWaiter.h | 10 +-- .../include/aws/glacier/GlacierWaiter.h | 4 +- .../aws/groundstation/GroundStationWaiter.h | 2 +- .../include/aws/healthlake/HealthLakeWaiter.h | 8 +- .../include/aws/iam/IAMWaiter.h | 8 +- .../aws/iotsitewise/IoTSiteWiseWaiter.h | 12 +-- .../include/aws/kinesis/KinesisWaiter.h | 4 +- .../include/aws/lambda/LambdaWaiter.h | 12 +-- .../aws/lexv2-models/LexModelsV2Waiter.h | 16 ++-- .../machinelearning/MachineLearningWaiter.h | 8 +- .../include/aws/macie2/Macie2Waiter.h | 2 +- .../aws/mediaconnect/MediaConnectWaiter.h | 22 ++--- .../include/aws/medialive/MediaLiveWaiter.h | 44 +++++----- .../aws/mediapackagev2/Mediapackagev2Waiter.h | 2 +- .../include/aws/monitoring/CloudWatchWaiter.h | 6 +- .../aws/neptune-graph/NeptuneGraphWaiter.h | 22 ++--- .../include/aws/neptune/NeptuneWaiter.h | 4 +- .../include/aws/omics/OmicsWaiter.h | 36 ++++---- .../include/aws/proton/ProtonWaiter.h | 20 ++--- .../include/aws/rds/RDSWaiter.h | 20 ++--- .../include/aws/redshift/RedshiftWaiter.h | 8 +- .../aws/rekognition/RekognitionWaiter.h | 4 +- .../aws/repostspace/RepostspaceWaiter.h | 8 +- .../Route53RecoveryControlConfigWaiter.h | 12 +-- .../include/aws/route53/Route53Waiter.h | 2 +- .../include/aws/rtbfabric/RTBFabricWaiter.h | 16 ++-- .../include/aws/s3-crt/S3CrtWaiter.h | 8 +- .../aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h | 8 +- .../include/aws/sagemaker/SageMakerWaiter.h | 26 +++--- .../include/aws/schemas/SchemasWaiter.h | 2 +- .../include/aws/signer/SignerWaiter.h | 2 +- .../include/aws/simpledbv2/SimpleDBv2Waiter.h | 2 +- .../aws/ssm-incidents/SSMIncidentsWaiter.h | 4 +- .../include/aws/ssm/SSMWaiter.h | 2 +- .../aws/transcribe/TranscribeServiceWaiter.h | 14 +-- 67 files changed, 342 insertions(+), 342 deletions(-) diff --git a/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h b/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h index 522ed80968f..3c4a60c0c9c 100644 --- a/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h +++ b/generated/src/aws-cpp-sdk-acm-pca/include/aws/acm-pca/ACMPCAWaiter.h @@ -27,7 +27,7 @@ class ACMPCAWaiter { const Model::DescribeCertificateAuthorityAuditReportRequest& request) { using OutcomeT = Model::DescribeCertificateAuthorityAuditReportOutcome; using RequestT = Model::DescribeCertificateAuthorityAuditReportRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AuditReportCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"), [](const Model::DescribeCertificateAuthorityAuditReportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -55,7 +55,7 @@ class ACMPCAWaiter { Aws::Utils::WaiterOutcome WaitUntilCertificateIssued(const Model::GetCertificateRequest& request) { using OutcomeT = Model::GetCertificateOutcome; using RequestT = Model::GetCertificateRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("CertificateIssuedWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>("CertificateIssuedWaiter", Aws::Utils::WaiterState::RETRY, @@ -72,7 +72,7 @@ class ACMPCAWaiter { const Model::GetCertificateAuthorityCsrRequest& request) { using OutcomeT = Model::GetCertificateAuthorityCsrOutcome; using RequestT = Model::GetCertificateAuthorityCsrRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("CertificateAuthorityCSRCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>( diff --git a/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h b/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h index 59a7716fce4..301611ea5e8 100644 --- a/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h +++ b/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h @@ -23,7 +23,7 @@ class ACMWaiter { const Model::DescribeCertificateRequest& request) { using OutcomeT = Model::DescribeCertificateOutcome; using RequestT = Model::DescribeCertificateRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "CertificateValidatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"), [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h b/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h index d6d5dc914ab..1da690fff10 100644 --- a/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h +++ b/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h @@ -27,7 +27,7 @@ class PrometheusServiceWaiter { const Model::DescribeAnomalyDetectorRequest& request) { using OutcomeT = Model::DescribeAnomalyDetectorOutcome; using RequestT = Model::DescribeAnomalyDetectorRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AnomalyDetectorActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeAnomalyDetectorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -62,7 +62,7 @@ class PrometheusServiceWaiter { const Model::DescribeAnomalyDetectorRequest& request) { using OutcomeT = Model::DescribeAnomalyDetectorOutcome; using RequestT = Model::DescribeAnomalyDetectorRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AnomalyDetectorDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -82,7 +82,7 @@ class PrometheusServiceWaiter { Aws::Utils::WaiterOutcome WaitUntilScraperActive(const Model::DescribeScraperRequest& request) { using OutcomeT = Model::DescribeScraperOutcome; using RequestT = Model::DescribeScraperRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ScraperActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -106,7 +106,7 @@ class PrometheusServiceWaiter { Aws::Utils::WaiterOutcome WaitUntilScraperDeleted(const Model::DescribeScraperRequest& request) { using OutcomeT = Model::DescribeScraperOutcome; using RequestT = Model::DescribeScraperRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("ScraperDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -125,7 +125,7 @@ class PrometheusServiceWaiter { Aws::Utils::WaiterOutcome WaitUntilWorkspaceActive(const Model::DescribeWorkspaceRequest& request) { using OutcomeT = Model::DescribeWorkspaceOutcome; using RequestT = Model::DescribeWorkspaceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "WorkspaceActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -156,7 +156,7 @@ class PrometheusServiceWaiter { Aws::Utils::WaiterOutcome WaitUntilWorkspaceDeleted(const Model::DescribeWorkspaceRequest& request) { using OutcomeT = Model::DescribeWorkspaceOutcome; using RequestT = Model::DescribeWorkspaceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("WorkspaceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( diff --git a/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h b/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h index d346f829260..1be9ba74e1b 100644 --- a/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h +++ b/generated/src/aws-cpp-sdk-appconfig/include/aws/appconfig/AppConfigWaiter.h @@ -25,7 +25,7 @@ class AppConfigWaiter { Aws::Utils::WaiterOutcome WaitUntilDeploymentComplete(const Model::GetDeploymentRequest& request) { using OutcomeT = Model::GetDeploymentOutcome; using RequestT = Model::GetDeploymentRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DeploymentCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETE"), [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -57,7 +57,7 @@ class AppConfigWaiter { const Model::GetEnvironmentRequest& request) { using OutcomeT = Model::GetEnvironmentOutcome; using RequestT = Model::GetEnvironmentRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "EnvironmentReadyForDeploymentWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ReadyForDeployment"), [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h b/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h index 49d6faf465e..8491a72ec38 100644 --- a/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h +++ b/generated/src/aws-cpp-sdk-appstream/include/aws/appstream/AppStreamWaiter.h @@ -22,7 +22,7 @@ class AppStreamWaiter { Aws::Utils::WaiterOutcome WaitUntilFleetStarted(const Model::DescribeFleetsRequest& request) { using OutcomeT = Model::DescribeFleetsOutcome; using RequestT = Model::DescribeFleetsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FleetStartedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -59,7 +59,7 @@ class AppStreamWaiter { Aws::Utils::WaiterOutcome WaitUntilFleetStopped(const Model::DescribeFleetsRequest& request) { using OutcomeT = Model::DescribeFleetsOutcome; using RequestT = Model::DescribeFleetsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FleetStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"), [](const Model::DescribeFleetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h b/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h index c516bdb1e78..29bf58388db 100644 --- a/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h +++ b/generated/src/aws-cpp-sdk-arc-region-switch/include/aws/arc-region-switch/ARCRegionswitchWaiter.h @@ -26,7 +26,7 @@ class ARCRegionswitchWaiter { const Model::GetPlanEvaluationStatusRequest& request) { using OutcomeT = Model::GetPlanEvaluationStatusOutcome; using RequestT = Model::GetPlanEvaluationStatusRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "PlanEvaluationStatusPassedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("passed"), [](const Model::GetPlanEvaluationStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -57,7 +57,7 @@ class ARCRegionswitchWaiter { Aws::Utils::WaiterOutcome WaitUntilPlanExecutionCompleted(const Model::GetPlanExecutionRequest& request) { using OutcomeT = Model::GetPlanExecutionOutcome; using RequestT = Model::GetPlanExecutionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "PlanExecutionCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), [](const Model::GetPlanExecutionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h index fceace9f270..77bd512cd48 100644 --- a/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h +++ b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h @@ -22,7 +22,7 @@ class AutoScalingWaiter { const Model::DescribeAutoScalingGroupsRequest& request) { using OutcomeT = Model::DescribeAutoScalingGroupsOutcome; using RequestT = Model::DescribeAutoScalingGroupsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "GroupExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -47,7 +47,7 @@ class AutoScalingWaiter { const Model::DescribeAutoScalingGroupsRequest& request) { using OutcomeT = Model::DescribeAutoScalingGroupsOutcome; using RequestT = Model::DescribeAutoScalingGroupsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "GroupInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, false, [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -82,7 +82,7 @@ class AutoScalingWaiter { const Model::DescribeAutoScalingGroupsRequest& request) { using OutcomeT = Model::DescribeAutoScalingGroupsOutcome; using RequestT = Model::DescribeAutoScalingGroupsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "GroupNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false, [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h b/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h index 70e1f6a91cc..ec04a43ae8c 100644 --- a/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h +++ b/generated/src/aws-cpp-sdk-awstransfer/include/aws/awstransfer/TransferWaiter.h @@ -22,7 +22,7 @@ class TransferWaiter { Aws::Utils::WaiterOutcome WaitUntilServerOffline(const Model::DescribeServerRequest& request) { using OutcomeT = Model::DescribeServerOutcome; using RequestT = Model::DescribeServerRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ServerOfflineWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("OFFLINE"), [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -46,7 +46,7 @@ class TransferWaiter { Aws::Utils::WaiterOutcome WaitUntilServerOnline(const Model::DescribeServerRequest& request) { using OutcomeT = Model::DescribeServerOutcome; using RequestT = Model::DescribeServerRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ServerOnlineWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ONLINE"), [](const Model::DescribeServerOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h b/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h index 82850498999..032c3f5ac34 100644 --- a/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h +++ b/generated/src/aws-cpp-sdk-b2bi/include/aws/b2bi/B2BIWaiter.h @@ -23,7 +23,7 @@ class B2BIWaiter { const Model::GetTransformerJobRequest& request) { using OutcomeT = Model::GetTransformerJobOutcome; using RequestT = Model::GetTransformerJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TransformerJobSucceededWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("succeeded"), [](const Model::GetTransformerJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h b/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h index 6040a010f7e..fd7b1fd34a7 100644 --- a/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h +++ b/generated/src/aws-cpp-sdk-bedrock-agentcore-control/include/aws/bedrock-agentcore-control/BedrockAgentCoreControlWaiter.h @@ -31,7 +31,7 @@ class BedrockAgentCoreControlWaiter { Aws::Utils::WaiterOutcome WaitUntilMemoryCreated(const Model::GetMemoryRequest& request) { using OutcomeT = Model::GetMemoryOutcome; using RequestT = Model::GetMemoryRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "MemoryCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), [](const Model::GetMemoryOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -62,7 +62,7 @@ class BedrockAgentCoreControlWaiter { Aws::Utils::WaiterOutcome WaitUntilPolicyActive(const Model::GetPolicyRequest& request) { using OutcomeT = Model::GetPolicyOutcome; using RequestT = Model::GetPolicyRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "PolicyActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -100,7 +100,7 @@ class BedrockAgentCoreControlWaiter { Aws::Utils::WaiterOutcome WaitUntilPolicyDeleted(const Model::GetPolicyRequest& request) { using OutcomeT = Model::GetPolicyOutcome; using RequestT = Model::GetPolicyRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("PolicyDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -126,7 +126,7 @@ class BedrockAgentCoreControlWaiter { Aws::Utils::WaiterOutcome WaitUntilPolicyEngineActive(const Model::GetPolicyEngineRequest& request) { using OutcomeT = Model::GetPolicyEngineOutcome; using RequestT = Model::GetPolicyEngineRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "PolicyEngineActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetPolicyEngineOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -164,7 +164,7 @@ class BedrockAgentCoreControlWaiter { Aws::Utils::WaiterOutcome WaitUntilPolicyEngineDeleted(const Model::GetPolicyEngineRequest& request) { using OutcomeT = Model::GetPolicyEngineOutcome; using RequestT = Model::GetPolicyEngineRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "PolicyEngineDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -191,7 +191,7 @@ class BedrockAgentCoreControlWaiter { const Model::GetPolicyGenerationRequest& request) { using OutcomeT = Model::GetPolicyGenerationOutcome; using RequestT = Model::GetPolicyGenerationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "PolicyGenerationCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("GENERATED"), [](const Model::GetPolicyGenerationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h b/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h index 58c15e0262c..e1bf71f6c4b 100644 --- a/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h +++ b/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h @@ -22,7 +22,7 @@ class CloudControlApiWaiter { const Model::GetResourceRequestStatusRequest& request) { using OutcomeT = Model::GetResourceRequestStatusOutcome; using RequestT = Model::GetResourceRequestStatusRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ResourceRequestSuccessWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"), [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h b/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h index b4d057477c3..b186078ca1c 100644 --- a/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h +++ b/generated/src/aws-cpp-sdk-cloudformation/include/aws/cloudformation/CloudFormationWaiter.h @@ -33,7 +33,7 @@ class CloudFormationWaiter { const Model::DescribeChangeSetRequest& request) { using OutcomeT = Model::DescribeChangeSetOutcome; using RequestT = Model::DescribeChangeSetRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ChangeSetCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -60,7 +60,7 @@ class CloudFormationWaiter { const Model::DescribeStackRefactorRequest& request) { using OutcomeT = Model::DescribeStackRefactorOutcome; using RequestT = Model::DescribeStackRefactorRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StackRefactorCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -87,7 +87,7 @@ class CloudFormationWaiter { const Model::DescribeStackRefactorRequest& request) { using OutcomeT = Model::DescribeStackRefactorOutcome; using RequestT = Model::DescribeStackRefactorRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StackRefactorExecuteCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("EXECUTE_COMPLETE"), [](const Model::DescribeStackRefactorOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -123,7 +123,7 @@ class CloudFormationWaiter { Aws::Utils::WaiterOutcome WaitUntilStackCreateComplete(const Model::DescribeStacksRequest& request) { using OutcomeT = Model::DescribeStacksOutcome; using RequestT = Model::DescribeStacksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StackCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -261,7 +261,7 @@ class CloudFormationWaiter { Aws::Utils::WaiterOutcome WaitUntilStackDeleteComplete(const Model::DescribeStacksRequest& request) { using OutcomeT = Model::DescribeStacksOutcome; using RequestT = Model::DescribeStacksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StackDeleteCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETE_COMPLETE"), [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -345,7 +345,7 @@ class CloudFormationWaiter { Aws::Utils::WaiterOutcome WaitUntilStackExists(const Model::DescribeStacksRequest& request) { using OutcomeT = Model::DescribeStacksOutcome; using RequestT = Model::DescribeStacksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("StackExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>("StackExistsWaiter", Aws::Utils::WaiterState::RETRY, @@ -359,7 +359,7 @@ class CloudFormationWaiter { Aws::Utils::WaiterOutcome WaitUntilStackImportComplete(const Model::DescribeStacksRequest& request) { using OutcomeT = Model::DescribeStacksOutcome; using RequestT = Model::DescribeStacksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StackImportCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IMPORT_COMPLETE"), [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -425,7 +425,7 @@ class CloudFormationWaiter { Aws::Utils::WaiterOutcome WaitUntilStackRollbackComplete(const Model::DescribeStacksRequest& request) { using OutcomeT = Model::DescribeStacksOutcome; using RequestT = Model::DescribeStacksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StackRollbackCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_ROLLBACK_COMPLETE"), [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -473,7 +473,7 @@ class CloudFormationWaiter { Aws::Utils::WaiterOutcome WaitUntilStackUpdateComplete(const Model::DescribeStacksRequest& request) { using OutcomeT = Model::DescribeStacksOutcome; using RequestT = Model::DescribeStacksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StackUpdateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_COMPLETE"), [](const Model::DescribeStacksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -522,7 +522,7 @@ class CloudFormationWaiter { const Model::DescribeTypeRegistrationRequest& request) { using OutcomeT = Model::DescribeTypeRegistrationOutcome; using RequestT = Model::DescribeTypeRegistrationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TypeRegistrationCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETE"), [](const Model::DescribeTypeRegistrationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h b/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h index 61ee1f18196..ab87df67e2a 100644 --- a/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h +++ b/generated/src/aws-cpp-sdk-cloudfront/include/aws/cloudfront/CloudFrontWaiter.h @@ -28,7 +28,7 @@ class CloudFrontWaiter { const Model::GetDistribution2020_05_31Request& request) { using OutcomeT = Model::GetDistribution2020_05_31Outcome; using RequestT = Model::GetDistribution2020_05_31Request; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DistributionDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Deployed"), [](const Model::GetDistribution2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -46,7 +46,7 @@ class CloudFrontWaiter { const Model::GetInvalidation2020_05_31Request& request) { using OutcomeT = Model::GetInvalidation2020_05_31Outcome; using RequestT = Model::GetInvalidation2020_05_31Request; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InvalidationCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), [](const Model::GetInvalidationForDistributionTenant2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -64,7 +64,7 @@ class CloudFrontWaiter { WaitUntilInvalidationForDistributionTenantCompleted(const Model::GetInvalidationForDistributionTenant2020_05_31Request& request) { using OutcomeT = Model::GetInvalidationForDistributionTenant2020_05_31Outcome; using RequestT = Model::GetInvalidationForDistributionTenant2020_05_31Request; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InvalidationForDistributionTenantCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), [](const Model::GetInvalidationForDistributionTenant2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -85,7 +85,7 @@ class CloudFrontWaiter { const Model::GetStreamingDistribution2020_05_31Request& request) { using OutcomeT = Model::GetStreamingDistribution2020_05_31Outcome; using RequestT = Model::GetStreamingDistribution2020_05_31Request; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StreamingDistributionDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Deployed"), [](const Model::GetStreamingDistribution2020_05_31Outcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h b/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h index 8162e167346..cce8dbfbff2 100644 --- a/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h +++ b/generated/src/aws-cpp-sdk-codedeploy/include/aws/codedeploy/CodeDeployWaiter.h @@ -22,7 +22,7 @@ class CodeDeployWaiter { Aws::Utils::WaiterOutcome WaitUntilDeploymentSuccessful(const Model::GetDeploymentRequest& request) { using OutcomeT = Model::GetDeploymentOutcome; using RequestT = Model::GetDeploymentRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DeploymentSuccessfulWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Succeeded"), [](const Model::GetDeploymentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h b/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h index e55ac651cd6..02ab10506b4 100644 --- a/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h +++ b/generated/src/aws-cpp-sdk-codeguru-reviewer/include/aws/codeguru-reviewer/CodeGuruReviewerWaiter.h @@ -26,7 +26,7 @@ class CodeGuruReviewerWaiter { const Model::DescribeCodeReviewRequest& request) { using OutcomeT = Model::DescribeCodeReviewOutcome; using RequestT = Model::DescribeCodeReviewRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "CodeReviewCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), [](const Model::DescribeCodeReviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -58,7 +58,7 @@ class CodeGuruReviewerWaiter { const Model::DescribeRepositoryAssociationRequest& request) { using OutcomeT = Model::DescribeRepositoryAssociationOutcome; using RequestT = Model::DescribeRepositoryAssociationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "RepositoryAssociationSucceededWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Associated"), [](const Model::DescribeRepositoryAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h b/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h index ba3829f1140..2405b787243 100644 --- a/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h +++ b/generated/src/aws-cpp-sdk-deadline/include/aws/deadline/DeadlineWaiter.h @@ -38,7 +38,7 @@ class DeadlineWaiter { Aws::Utils::WaiterOutcome WaitUntilFleetActive(const Model::GetFleetRequest& request) { using OutcomeT = Model::GetFleetOutcome; using RequestT = Model::GetFleetRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FleetActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetFleetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -69,7 +69,7 @@ class DeadlineWaiter { Aws::Utils::WaiterOutcome WaitUntilJobCreateComplete(const Model::GetJobRequest& request) { using OutcomeT = Model::GetJobOutcome; using RequestT = Model::GetJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "JobCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -121,7 +121,7 @@ class DeadlineWaiter { Aws::Utils::WaiterOutcome WaitUntilJobComplete(const Model::GetJobRequest& request) { using OutcomeT = Model::GetJobOutcome; using RequestT = Model::GetJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "JobCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -173,7 +173,7 @@ class DeadlineWaiter { Aws::Utils::WaiterOutcome WaitUntilJobSucceeded(const Model::GetJobRequest& request) { using OutcomeT = Model::GetJobOutcome; using RequestT = Model::GetJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "JobSucceededWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), [](const Model::GetJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -226,7 +226,7 @@ class DeadlineWaiter { const Model::GetLicenseEndpointRequest& request) { using OutcomeT = Model::GetLicenseEndpointOutcome; using RequestT = Model::GetLicenseEndpointRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "LicenseEndpointValidWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("READY"), [](const Model::GetLicenseEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -251,7 +251,7 @@ class DeadlineWaiter { const Model::GetLicenseEndpointRequest& request) { using OutcomeT = Model::GetLicenseEndpointOutcome; using RequestT = Model::GetLicenseEndpointRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "LicenseEndpointDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -270,7 +270,7 @@ class DeadlineWaiter { Aws::Utils::WaiterOutcome WaitUntilQueueSchedulingBlocked(const Model::GetQueueRequest& request) { using OutcomeT = Model::GetQueueOutcome; using RequestT = Model::GetQueueRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "QueueSchedulingBlockedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SCHEDULING_BLOCKED"), [](const Model::GetQueueOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -287,7 +287,7 @@ class DeadlineWaiter { Aws::Utils::WaiterOutcome WaitUntilQueueScheduling(const Model::GetQueueRequest& request) { using OutcomeT = Model::GetQueueOutcome; using RequestT = Model::GetQueueRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "QueueSchedulingWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SCHEDULING"), [](const Model::GetQueueOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -305,7 +305,7 @@ class DeadlineWaiter { const Model::GetQueueFleetAssociationRequest& request) { using OutcomeT = Model::GetQueueFleetAssociationOutcome; using RequestT = Model::GetQueueFleetAssociationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "QueueFleetAssociationStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"), [](const Model::GetQueueLimitAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -324,7 +324,7 @@ class DeadlineWaiter { const Model::GetQueueLimitAssociationRequest& request) { using OutcomeT = Model::GetQueueLimitAssociationOutcome; using RequestT = Model::GetQueueLimitAssociationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "QueueLimitAssociationStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"), [](const Model::GetQueueLimitAssociationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h b/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h index d0b14b5eac9..403271831f1 100644 --- a/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h +++ b/generated/src/aws-cpp-sdk-dms/include/aws/dms/DatabaseMigrationServiceWaiter.h @@ -28,7 +28,7 @@ class DatabaseMigrationServiceWaiter { const Model::DescribeConnectionsRequest& request) { using OutcomeT = Model::DescribeConnectionsOutcome; using RequestT = Model::DescribeConnectionsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TestConnectionSucceedsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("successful"), [](const Model::DescribeConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -54,7 +54,7 @@ class DatabaseMigrationServiceWaiter { Aws::Utils::WaiterOutcome WaitUntilEndpointDeleted(const Model::DescribeEndpointsRequest& request) { using OutcomeT = Model::DescribeEndpointsOutcome; using RequestT = Model::DescribeEndpointsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("EndpointDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundFault"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -83,7 +83,7 @@ class DatabaseMigrationServiceWaiter { const Model::DescribeReplicationInstancesRequest& request) { using OutcomeT = Model::DescribeReplicationInstancesOutcome; using RequestT = Model::DescribeReplicationInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReplicationInstanceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -139,7 +139,7 @@ class DatabaseMigrationServiceWaiter { const Model::DescribeReplicationInstancesRequest& request) { using OutcomeT = Model::DescribeReplicationInstancesOutcome; using RequestT = Model::DescribeReplicationInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReplicationInstanceDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("available"), [](const Model::DescribeReplicationInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -161,7 +161,7 @@ class DatabaseMigrationServiceWaiter { const Model::DescribeReplicationTasksRequest& request) { using OutcomeT = Model::DescribeReplicationTasksOutcome; using RequestT = Model::DescribeReplicationTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReplicationTaskDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ready"), [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -214,7 +214,7 @@ class DatabaseMigrationServiceWaiter { const Model::DescribeReplicationTasksRequest& request) { using OutcomeT = Model::DescribeReplicationTasksOutcome; using RequestT = Model::DescribeReplicationTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReplicationTaskReadyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ready"), [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -297,7 +297,7 @@ class DatabaseMigrationServiceWaiter { const Model::DescribeReplicationTasksRequest& request) { using OutcomeT = Model::DescribeReplicationTasksOutcome; using RequestT = Model::DescribeReplicationTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReplicationTaskRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("running"), [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -380,7 +380,7 @@ class DatabaseMigrationServiceWaiter { const Model::DescribeReplicationTasksRequest& request) { using OutcomeT = Model::DescribeReplicationTasksOutcome; using RequestT = Model::DescribeReplicationTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReplicationTaskStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("stopped"), [](const Model::DescribeReplicationTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h b/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h index 7a7ada87a14..f2f03ddebb3 100644 --- a/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h +++ b/generated/src/aws-cpp-sdk-docdb/include/aws/docdb/DocDBWaiter.h @@ -22,7 +22,7 @@ class DocDBWaiter { const Model::DescribeDBInstancesRequest& request) { using OutcomeT = Model::DescribeDBInstancesOutcome; using RequestT = Model::DescribeDBInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -81,7 +81,7 @@ class DocDBWaiter { const Model::DescribeDBInstancesRequest& request) { using OutcomeT = Model::DescribeDBInstancesOutcome; using RequestT = Model::DescribeDBInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h b/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h index 315f56d8109..9cc087e4676 100644 --- a/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h +++ b/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h @@ -22,7 +22,7 @@ class DirectoryServiceWaiter { const Model::DescribeHybridADUpdateRequest& request) { using OutcomeT = Model::DescribeHybridADUpdateOutcome; using RequestT = Model::DescribeHybridADUpdateRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "HybridADUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Updated"), [](const Model::DescribeHybridADUpdateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h b/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h index dd6b9658508..b12005b3c34 100644 --- a/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h +++ b/generated/src/aws-cpp-sdk-dsql/include/aws/dsql/DSQLWaiter.h @@ -22,7 +22,7 @@ class DSQLWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterActive(const Model::GetClusterRequest& request) { using OutcomeT = Model::GetClusterOutcome; using RequestT = Model::GetClusterRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ClusterActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -39,7 +39,7 @@ class DSQLWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterNotExists(const Model::GetClusterRequest& request) { using OutcomeT = Model::GetClusterOutcome; using RequestT = Model::GetClusterRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("ClusterNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); diff --git a/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h b/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h index 88cc4920f2d..88a79cbecdf 100644 --- a/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h +++ b/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h @@ -35,7 +35,7 @@ class DynamoDBWaiter { const Model::DescribeContributorInsightsRequest& request) { using OutcomeT = Model::DescribeContributorInsightsOutcome; using RequestT = Model::DescribeContributorInsightsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ContributorInsightsEnabledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ENABLED"), [](const Model::DescribeContributorInsightsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -61,7 +61,7 @@ class DynamoDBWaiter { Aws::Utils::WaiterOutcome WaitUntilExportCompleted(const Model::DescribeExportRequest& request) { using OutcomeT = Model::DescribeExportOutcome; using RequestT = Model::DescribeExportRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ExportCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -87,7 +87,7 @@ class DynamoDBWaiter { Aws::Utils::WaiterOutcome WaitUntilImportCompleted(const Model::DescribeImportRequest& request) { using OutcomeT = Model::DescribeImportOutcome; using RequestT = Model::DescribeImportRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ImportCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -122,7 +122,7 @@ class DynamoDBWaiter { const Model::DescribeKinesisStreamingDestinationRequest& request) { using OutcomeT = Model::DescribeKinesisStreamingDestinationOutcome; using RequestT = Model::DescribeKinesisStreamingDestinationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "KinesisStreamingDestinationActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeKinesisStreamingDestinationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -154,7 +154,7 @@ class DynamoDBWaiter { Aws::Utils::WaiterOutcome WaitUntilTableExists(const Model::DescribeTableRequest& request) { using OutcomeT = Model::DescribeTableOutcome; using RequestT = Model::DescribeTableRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TableExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeTableOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -173,7 +173,7 @@ class DynamoDBWaiter { Aws::Utils::WaiterOutcome WaitUntilTableNotExists(const Model::DescribeTableRequest& request) { using OutcomeT = Model::DescribeTableOutcome; using RequestT = Model::DescribeTableRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("TableNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); diff --git a/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h b/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h index 729ed2d1cb6..28374592295 100644 --- a/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h +++ b/generated/src/aws-cpp-sdk-ec2/include/aws/ec2/EC2Waiter.h @@ -89,7 +89,7 @@ class EC2Waiter { const Model::DescribeBundleTasksRequest& request) { using OutcomeT = Model::DescribeBundleTasksOutcome; using RequestT = Model::DescribeBundleTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "BundleTaskCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("complete"), [](const Model::DescribeBundleTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -118,7 +118,7 @@ class EC2Waiter { const Model::DescribeConversionTasksRequest& request) { using OutcomeT = Model::DescribeConversionTasksOutcome; using RequestT = Model::DescribeConversionTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ConversionTaskCancelledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("cancelled"), [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -139,7 +139,7 @@ class EC2Waiter { const Model::DescribeConversionTasksRequest& request) { using OutcomeT = Model::DescribeConversionTasksOutcome; using RequestT = Model::DescribeConversionTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ConversionTaskCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -180,7 +180,7 @@ class EC2Waiter { const Model::DescribeConversionTasksRequest& request) { using OutcomeT = Model::DescribeConversionTasksOutcome; using RequestT = Model::DescribeConversionTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ConversionTaskDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), [](const Model::DescribeConversionTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -201,7 +201,7 @@ class EC2Waiter { const Model::DescribeCustomerGatewaysRequest& request) { using OutcomeT = Model::DescribeCustomerGatewaysOutcome; using RequestT = Model::DescribeCustomerGatewaysRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "CustomerGatewayAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeCustomerGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -236,7 +236,7 @@ class EC2Waiter { const Model::DescribeExportTasksRequest& request) { using OutcomeT = Model::DescribeExportTasksOutcome; using RequestT = Model::DescribeExportTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ExportTaskCancelledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("cancelled"), [](const Model::DescribeExportTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -256,7 +256,7 @@ class EC2Waiter { const Model::DescribeExportTasksRequest& request) { using OutcomeT = Model::DescribeExportTasksOutcome; using RequestT = Model::DescribeExportTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ExportTaskCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), [](const Model::DescribeExportTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -275,7 +275,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilImageAvailable(const Model::DescribeImagesRequest& request) { using OutcomeT = Model::DescribeImagesOutcome; using RequestT = Model::DescribeImagesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ImageAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeImagesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -303,7 +303,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilImageExists(const Model::DescribeImagesRequest& request) { using OutcomeT = Model::DescribeImagesOutcome; using RequestT = Model::DescribeImagesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ImageExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeImagesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -323,7 +323,7 @@ class EC2Waiter { const Model::DescribeImageUsageReportsRequest& request) { using OutcomeT = Model::DescribeImageUsageReportsOutcome; using RequestT = Model::DescribeImageUsageReportsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ImageUsageReportAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeImageUsageReportsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -350,7 +350,7 @@ class EC2Waiter { const Model::DescribeImportSnapshotTasksRequest& request) { using OutcomeT = Model::DescribeImportSnapshotTasksOutcome; using RequestT = Model::DescribeImportSnapshotTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SnapshotImportedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), [](const Model::DescribeImportSnapshotTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -380,7 +380,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilInstanceExists(const Model::DescribeInstancesRequest& request) { using OutcomeT = Model::DescribeInstancesOutcome; using RequestT = Model::DescribeInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InstanceExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -399,7 +399,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilInstanceRunning(const Model::DescribeInstancesRequest& request) { using OutcomeT = Model::DescribeInstancesOutcome; using RequestT = Model::DescribeInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InstanceRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("running"), [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -455,7 +455,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilInstanceStopped(const Model::DescribeInstancesRequest& request) { using OutcomeT = Model::DescribeInstancesOutcome; using RequestT = Model::DescribeInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InstanceStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("stopped"), [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -498,7 +498,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilInstanceTerminated(const Model::DescribeInstancesRequest& request) { using OutcomeT = Model::DescribeInstancesOutcome; using RequestT = Model::DescribeInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InstanceTerminatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("terminated"), [](const Model::DescribeInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -542,7 +542,7 @@ class EC2Waiter { const Model::DescribeInstanceStatusRequest& request) { using OutcomeT = Model::DescribeInstanceStatusOutcome; using RequestT = Model::DescribeInstanceStatusRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InstanceStatusOkWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ok"), [](const Model::DescribeInstanceStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -566,7 +566,7 @@ class EC2Waiter { const Model::DescribeInstanceStatusRequest& request) { using OutcomeT = Model::DescribeInstanceStatusOutcome; using RequestT = Model::DescribeInstanceStatusRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SystemStatusOkWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ok"), [](const Model::DescribeInstanceStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -588,7 +588,7 @@ class EC2Waiter { const Model::DescribeInternetGatewaysRequest& request) { using OutcomeT = Model::DescribeInternetGatewaysOutcome; using RequestT = Model::DescribeInternetGatewaysRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InternetGatewayExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeInternetGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -607,7 +607,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilKeyPairExists(const Model::DescribeKeyPairsRequest& request) { using OutcomeT = Model::DescribeKeyPairsOutcome; using RequestT = Model::DescribeKeyPairsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "KeyPairExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeKeyPairsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -627,7 +627,7 @@ class EC2Waiter { const Model::DescribeNatGatewaysRequest& request) { using OutcomeT = Model::DescribeNatGatewaysOutcome; using RequestT = Model::DescribeNatGatewaysRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "NatGatewayAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -676,7 +676,7 @@ class EC2Waiter { const Model::DescribeNatGatewaysRequest& request) { using OutcomeT = Model::DescribeNatGatewaysOutcome; using RequestT = Model::DescribeNatGatewaysRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "NatGatewayDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), [](const Model::DescribeNatGatewaysOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -698,7 +698,7 @@ class EC2Waiter { const Model::DescribeNetworkInterfacesRequest& request) { using OutcomeT = Model::DescribeNetworkInterfacesOutcome; using RequestT = Model::DescribeNetworkInterfacesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "NetworkInterfaceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeNetworkInterfacesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -722,7 +722,7 @@ class EC2Waiter { const Model::DescribeSecondaryNetworksRequest& request) { using OutcomeT = Model::DescribeSecondaryNetworksOutcome; using RequestT = Model::DescribeSecondaryNetworksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SecondaryNetworkCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("create-complete"), [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -755,7 +755,7 @@ class EC2Waiter { const Model::DescribeSecondaryNetworksRequest& request) { using OutcomeT = Model::DescribeSecondaryNetworksOutcome; using RequestT = Model::DescribeSecondaryNetworksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SecondaryNetworkDeleteCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("delete-complete"), [](const Model::DescribeSecondaryNetworksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -786,7 +786,7 @@ class EC2Waiter { const Model::DescribeSecondarySubnetsRequest& request) { using OutcomeT = Model::DescribeSecondarySubnetsOutcome; using RequestT = Model::DescribeSecondarySubnetsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SecondarySubnetCreateCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("create-complete"), [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -819,7 +819,7 @@ class EC2Waiter { const Model::DescribeSecondarySubnetsRequest& request) { using OutcomeT = Model::DescribeSecondarySubnetsOutcome; using RequestT = Model::DescribeSecondarySubnetsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SecondarySubnetDeleteCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("delete-complete"), [](const Model::DescribeSecondarySubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -850,7 +850,7 @@ class EC2Waiter { const Model::DescribeSecurityGroupsRequest& request) { using OutcomeT = Model::DescribeSecurityGroupsOutcome; using RequestT = Model::DescribeSecurityGroupsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SecurityGroupExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeSecurityGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -870,7 +870,7 @@ class EC2Waiter { const Model::DescribeSecurityGroupVpcAssociationsRequest& request) { using OutcomeT = Model::DescribeSecurityGroupVpcAssociationsOutcome; using RequestT = Model::DescribeSecurityGroupVpcAssociationsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SecurityGroupVpcAssociationAssociatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("associated"), [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -915,7 +915,7 @@ class EC2Waiter { const Model::DescribeSecurityGroupVpcAssociationsRequest& request) { using OutcomeT = Model::DescribeSecurityGroupVpcAssociationsOutcome; using RequestT = Model::DescribeSecurityGroupVpcAssociationsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SecurityGroupVpcAssociationDisassociatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("disassociated"), [](const Model::DescribeSecurityGroupVpcAssociationsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -966,7 +966,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilSnapshotCompleted(const Model::DescribeSnapshotsRequest& request) { using OutcomeT = Model::DescribeSnapshotsOutcome; using RequestT = Model::DescribeSnapshotsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SnapshotCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), [](const Model::DescribeSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -995,7 +995,7 @@ class EC2Waiter { const Model::DescribeSpotInstanceRequestsRequest& request) { using OutcomeT = Model::DescribeSpotInstanceRequestsOutcome; using RequestT = Model::DescribeSpotInstanceRequestsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SpotInstanceRequestFulfilledWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("fulfilled"), [](const Model::DescribeSpotInstanceRequestsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -1062,7 +1062,7 @@ class EC2Waiter { const Model::DescribeStoreImageTasksRequest& request) { using OutcomeT = Model::DescribeStoreImageTasksOutcome; using RequestT = Model::DescribeStoreImageTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StoreImageTaskCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), [](const Model::DescribeStoreImageTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -1099,7 +1099,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilSubnetAvailable(const Model::DescribeSubnetsRequest& request) { using OutcomeT = Model::DescribeSubnetsOutcome; using RequestT = Model::DescribeSubnetsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SubnetAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeSubnetsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -1118,7 +1118,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilVolumeAvailable(const Model::DescribeVolumesRequest& request) { using OutcomeT = Model::DescribeVolumesOutcome; using RequestT = Model::DescribeVolumesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "VolumeAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -1146,7 +1146,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilVolumeDeleted(const Model::DescribeVolumesRequest& request) { using OutcomeT = Model::DescribeVolumesOutcome; using RequestT = Model::DescribeVolumesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "VolumeDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -1167,7 +1167,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilVolumeInUse(const Model::DescribeVolumesRequest& request) { using OutcomeT = Model::DescribeVolumesOutcome; using RequestT = Model::DescribeVolumesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "VolumeInUseWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("in-use"), [](const Model::DescribeVolumesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -1196,7 +1196,7 @@ class EC2Waiter { const Model::DescribeVpcPeeringConnectionsRequest& request) { using OutcomeT = Model::DescribeVpcPeeringConnectionsOutcome; using RequestT = Model::DescribeVpcPeeringConnectionsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "VpcPeeringConnectionDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), [](const Model::DescribeVpcPeeringConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -1220,7 +1220,7 @@ class EC2Waiter { const Model::DescribeVpcPeeringConnectionsRequest& request) { using OutcomeT = Model::DescribeVpcPeeringConnectionsOutcome; using RequestT = Model::DescribeVpcPeeringConnectionsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("VpcPeeringConnectionExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>( @@ -1234,7 +1234,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilVpcAvailable(const Model::DescribeVpcsRequest& request) { using OutcomeT = Model::DescribeVpcsOutcome; using RequestT = Model::DescribeVpcsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "VpcAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeVpcsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -1253,7 +1253,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilVpcExists(const Model::DescribeVpcsRequest& request) { using OutcomeT = Model::DescribeVpcsOutcome; using RequestT = Model::DescribeVpcsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("VpcExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>("VpcExistsWaiter", Aws::Utils::WaiterState::RETRY, @@ -1268,7 +1268,7 @@ class EC2Waiter { const Model::DescribeVpnConnectionsRequest& request) { using OutcomeT = Model::DescribeVpnConnectionsOutcome; using RequestT = Model::DescribeVpnConnectionsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "VpnConnectionAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -1306,7 +1306,7 @@ class EC2Waiter { const Model::DescribeVpnConnectionsRequest& request) { using OutcomeT = Model::DescribeVpnConnectionsOutcome; using RequestT = Model::DescribeVpnConnectionsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "VpnConnectionDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), [](const Model::DescribeVpnConnectionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -1334,7 +1334,7 @@ class EC2Waiter { Aws::Utils::WaiterOutcome WaitUntilPasswordDataAvailable(const Model::GetPasswordDataRequest& request) { using OutcomeT = Model::GetPasswordDataOutcome; using RequestT = Model::GetPasswordDataRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "PasswordDataAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::GetPasswordDataOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h b/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h index 4aa983567fb..e12f41e1323 100644 --- a/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h +++ b/generated/src/aws-cpp-sdk-ecr/include/aws/ecr/ECRWaiter.h @@ -26,7 +26,7 @@ class ECRWaiter { const Model::DescribeImageScanFindingsRequest& request) { using OutcomeT = Model::DescribeImageScanFindingsOutcome; using RequestT = Model::DescribeImageScanFindingsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ImageScanCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETE"), [](const Model::DescribeImageScanFindingsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -51,7 +51,7 @@ class ECRWaiter { const Model::GetLifecyclePolicyPreviewRequest& request) { using OutcomeT = Model::GetLifecyclePolicyPreviewOutcome; using RequestT = Model::GetLifecyclePolicyPreviewRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "LifecyclePolicyPreviewCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETE"), [](const Model::GetLifecyclePolicyPreviewOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h b/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h index 724287bc881..abcdc31125f 100644 --- a/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h +++ b/generated/src/aws-cpp-sdk-ecs/include/aws/ecs/ECSWaiter.h @@ -23,7 +23,7 @@ class ECSWaiter { Aws::Utils::WaiterOutcome WaitUntilServicesInactive(const Model::DescribeServicesRequest& request) { using OutcomeT = Model::DescribeServicesOutcome; using RequestT = Model::DescribeServicesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ServicesInactiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("MISSING"), [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -49,7 +49,7 @@ class ECSWaiter { Aws::Utils::WaiterOutcome WaitUntilServicesStable(const Model::DescribeServicesRequest& request) { using OutcomeT = Model::DescribeServicesOutcome; using RequestT = Model::DescribeServicesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ServicesStableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("MISSING"), [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -92,7 +92,7 @@ class ECSWaiter { Aws::Utils::WaiterOutcome WaitUntilTasksRunning(const Model::DescribeTasksRequest& request) { using OutcomeT = Model::DescribeTasksOutcome; using RequestT = Model::DescribeTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TasksRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("STOPPED"), [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -126,7 +126,7 @@ class ECSWaiter { Aws::Utils::WaiterOutcome WaitUntilTasksStopped(const Model::DescribeTasksRequest& request) { using OutcomeT = Model::DescribeTasksOutcome; using RequestT = Model::DescribeTasksRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TasksStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"), [](const Model::DescribeTasksOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h b/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h index 91817e7dead..4200a8de50e 100644 --- a/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h +++ b/generated/src/aws-cpp-sdk-eks/include/aws/eks/EKSWaiter.h @@ -31,7 +31,7 @@ class EKSWaiter { Aws::Utils::WaiterOutcome WaitUntilAddonActive(const Model::DescribeAddonRequest& request) { using OutcomeT = Model::DescribeAddonOutcome; using RequestT = Model::DescribeAddonRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AddonActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -62,7 +62,7 @@ class EKSWaiter { Aws::Utils::WaiterOutcome WaitUntilAddonDeleted(const Model::DescribeAddonRequest& request) { using OutcomeT = Model::DescribeAddonOutcome; using RequestT = Model::DescribeAddonRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AddonDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), [](const Model::DescribeAddonOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -81,7 +81,7 @@ class EKSWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterActive(const Model::DescribeClusterRequest& request) { using OutcomeT = Model::DescribeClusterOutcome; using RequestT = Model::DescribeClusterRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ClusterActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETING"), [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -112,7 +112,7 @@ class EKSWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClusterRequest& request) { using OutcomeT = Model::DescribeClusterOutcome; using RequestT = Model::DescribeClusterRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ClusterDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("ACTIVE"), [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -146,7 +146,7 @@ class EKSWaiter { const Model::DescribeFargateProfileRequest& request) { using OutcomeT = Model::DescribeFargateProfileOutcome; using RequestT = Model::DescribeFargateProfileRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FargateProfileActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), [](const Model::DescribeFargateProfileOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -173,7 +173,7 @@ class EKSWaiter { const Model::DescribeFargateProfileRequest& request) { using OutcomeT = Model::DescribeFargateProfileOutcome; using RequestT = Model::DescribeFargateProfileRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FargateProfileDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), [](const Model::DescribeFargateProfileOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -193,7 +193,7 @@ class EKSWaiter { Aws::Utils::WaiterOutcome WaitUntilNodegroupActive(const Model::DescribeNodegroupRequest& request) { using OutcomeT = Model::DescribeNodegroupOutcome; using RequestT = Model::DescribeNodegroupRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "NodegroupActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), [](const Model::DescribeNodegroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -217,7 +217,7 @@ class EKSWaiter { Aws::Utils::WaiterOutcome WaitUntilNodegroupDeleted(const Model::DescribeNodegroupRequest& request) { using OutcomeT = Model::DescribeNodegroupOutcome; using RequestT = Model::DescribeNodegroupRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "NodegroupDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"), [](const Model::DescribeNodegroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h b/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h index 9895a82ef24..33d12908c5c 100644 --- a/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h +++ b/generated/src/aws-cpp-sdk-elasticache/include/aws/elasticache/ElastiCacheWaiter.h @@ -24,7 +24,7 @@ class ElastiCacheWaiter { const Model::DescribeCacheClustersRequest& request) { using OutcomeT = Model::DescribeCacheClustersOutcome; using RequestT = Model::DescribeCacheClustersRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "CacheClusterAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -75,7 +75,7 @@ class ElastiCacheWaiter { const Model::DescribeCacheClustersRequest& request) { using OutcomeT = Model::DescribeCacheClustersOutcome; using RequestT = Model::DescribeCacheClustersRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "CacheClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), [](const Model::DescribeCacheClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -144,7 +144,7 @@ class ElastiCacheWaiter { const Model::DescribeReplicationGroupsRequest& request) { using OutcomeT = Model::DescribeReplicationGroupsOutcome; using RequestT = Model::DescribeReplicationGroupsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReplicationGroupAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -171,7 +171,7 @@ class ElastiCacheWaiter { const Model::DescribeReplicationGroupsRequest& request) { using OutcomeT = Model::DescribeReplicationGroupsOutcome; using RequestT = Model::DescribeReplicationGroupsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReplicationGroupDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), [](const Model::DescribeReplicationGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h b/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h index 3d99aea503a..bade6b60517 100644 --- a/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h +++ b/generated/src/aws-cpp-sdk-elasticbeanstalk/include/aws/elasticbeanstalk/ElasticBeanstalkWaiter.h @@ -23,7 +23,7 @@ class ElasticBeanstalkWaiter { const Model::DescribeEnvironmentsRequest& request) { using OutcomeT = Model::DescribeEnvironmentsOutcome; using RequestT = Model::DescribeEnvironmentsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "EnvironmentExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Ready"), [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -54,7 +54,7 @@ class ElasticBeanstalkWaiter { const Model::DescribeEnvironmentsRequest& request) { using OutcomeT = Model::DescribeEnvironmentsOutcome; using RequestT = Model::DescribeEnvironmentsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "EnvironmentTerminatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Terminated"), [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -85,7 +85,7 @@ class ElasticBeanstalkWaiter { const Model::DescribeEnvironmentsRequest& request) { using OutcomeT = Model::DescribeEnvironmentsOutcome; using RequestT = Model::DescribeEnvironmentsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "EnvironmentUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Ready"), [](const Model::DescribeEnvironmentsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h b/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h index 8ff606a46db..846c1e71b0f 100644 --- a/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h +++ b/generated/src/aws-cpp-sdk-elasticloadbalancing/include/aws/elasticloadbalancing/ElasticLoadBalancingWaiter.h @@ -22,7 +22,7 @@ class ElasticLoadBalancingWaiter { const Model::DescribeInstanceHealthRequest& request) { using OutcomeT = Model::DescribeInstanceHealthOutcome; using RequestT = Model::DescribeInstanceHealthRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AnyInstanceInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InService"), [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -41,7 +41,7 @@ class ElasticLoadBalancingWaiter { const Model::DescribeInstanceHealthRequest& request) { using OutcomeT = Model::DescribeInstanceHealthOutcome; using RequestT = Model::DescribeInstanceHealthRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InstanceDeregisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("OutOfService"), [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -62,7 +62,7 @@ class ElasticLoadBalancingWaiter { const Model::DescribeInstanceHealthRequest& request) { using OutcomeT = Model::DescribeInstanceHealthOutcome; using RequestT = Model::DescribeInstanceHealthRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InstanceInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InService"), [](const Model::DescribeInstanceHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h b/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h index 46dcc1bee15..90763cc189a 100644 --- a/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h +++ b/generated/src/aws-cpp-sdk-elasticloadbalancingv2/include/aws/elasticloadbalancingv2/ElasticLoadBalancingv2Waiter.h @@ -26,7 +26,7 @@ class ElasticLoadBalancingv2Waiter { const Model::DescribeLoadBalancersRequest& request) { using OutcomeT = Model::DescribeLoadBalancersOutcome; using RequestT = Model::DescribeLoadBalancersRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "LoadBalancerAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("active"), [](const Model::DescribeLoadBalancersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -59,7 +59,7 @@ class ElasticLoadBalancingv2Waiter { const Model::DescribeLoadBalancersRequest& request) { using OutcomeT = Model::DescribeLoadBalancersOutcome; using RequestT = Model::DescribeLoadBalancersRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("LoadBalancerExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>("LoadBalancerExistsWaiter", Aws::Utils::WaiterState::RETRY, @@ -74,7 +74,7 @@ class ElasticLoadBalancingv2Waiter { const Model::DescribeLoadBalancersRequest& request) { using OutcomeT = Model::DescribeLoadBalancersOutcome; using RequestT = Model::DescribeLoadBalancersRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "LoadBalancersDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("active"), [](const Model::DescribeLoadBalancersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -97,7 +97,7 @@ class ElasticLoadBalancingv2Waiter { const Model::DescribeTargetHealthRequest& request) { using OutcomeT = Model::DescribeTargetHealthOutcome; using RequestT = Model::DescribeTargetHealthRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TargetDeregisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InvalidTarget"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -121,7 +121,7 @@ class ElasticLoadBalancingv2Waiter { const Model::DescribeTargetHealthRequest& request) { using OutcomeT = Model::DescribeTargetHealthOutcome; using RequestT = Model::DescribeTargetHealthRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TargetInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("healthy"), [](const Model::DescribeTargetHealthOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h b/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h index 6971ac661ac..5e66cf84298 100644 --- a/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h +++ b/generated/src/aws-cpp-sdk-elasticmapreduce/include/aws/elasticmapreduce/EMRWaiter.h @@ -25,7 +25,7 @@ class EMRWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterRunning(const Model::DescribeClusterRequest& request) { using OutcomeT = Model::DescribeClusterOutcome; using RequestT = Model::DescribeClusterRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ClusterRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -75,7 +75,7 @@ class EMRWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterTerminated(const Model::DescribeClusterRequest& request) { using OutcomeT = Model::DescribeClusterOutcome; using RequestT = Model::DescribeClusterRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ClusterTerminatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("TERMINATED"), [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -101,7 +101,7 @@ class EMRWaiter { Aws::Utils::WaiterOutcome WaitUntilStepComplete(const Model::DescribeStepRequest& request) { using OutcomeT = Model::DescribeStepOutcome; using RequestT = Model::DescribeStepRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StepCompleteWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::DescribeStepOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h b/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h index 10d2ebaee22..afca89add33 100644 --- a/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h +++ b/generated/src/aws-cpp-sdk-elementalinference/include/aws/elementalinference/ElementalInferenceWaiter.h @@ -22,7 +22,7 @@ class ElementalInferenceWaiter { Aws::Utils::WaiterOutcome WaitUntilFeedDeleted(const Model::GetFeedRequest& request) { using OutcomeT = Model::GetFeedOutcome; using RequestT = Model::GetFeedRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("FeedDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( diff --git a/generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h b/generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h index a53d4c531f7..d6147d048d2 100644 --- a/generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h +++ b/generated/src/aws-cpp-sdk-email/include/aws/email/SESWaiter.h @@ -23,7 +23,7 @@ class SESWaiter { const Model::GetIdentityVerificationAttributesRequest& request) { using OutcomeT = Model::GetIdentityVerificationAttributesOutcome; using RequestT = Model::GetIdentityVerificationAttributesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "IdentityExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Success"), [](const Model::GetIdentityVerificationAttributesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h b/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h index 2f7eda6d2bb..671ea7e35ca 100644 --- a/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h +++ b/generated/src/aws-cpp-sdk-gameliftstreams/include/aws/gameliftstreams/GameLiftStreamsWaiter.h @@ -28,7 +28,7 @@ class GameLiftStreamsWaiter { Aws::Utils::WaiterOutcome WaitUntilApplicationReady(const Model::GetApplicationRequest& request) { using OutcomeT = Model::GetApplicationOutcome; using RequestT = Model::GetApplicationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ApplicationReadyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("READY"), [](const Model::GetApplicationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -52,7 +52,7 @@ class GameLiftStreamsWaiter { Aws::Utils::WaiterOutcome WaitUntilApplicationDeleted(const Model::GetApplicationRequest& request) { using OutcomeT = Model::GetApplicationOutcome; using RequestT = Model::GetApplicationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ApplicationDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); @@ -64,7 +64,7 @@ class GameLiftStreamsWaiter { Aws::Utils::WaiterOutcome WaitUntilStreamGroupActive(const Model::GetStreamGroupRequest& request) { using OutcomeT = Model::GetStreamGroupOutcome; using RequestT = Model::GetStreamGroupRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StreamGroupActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -102,7 +102,7 @@ class GameLiftStreamsWaiter { Aws::Utils::WaiterOutcome WaitUntilStreamGroupDeleted(const Model::GetStreamGroupRequest& request) { using OutcomeT = Model::GetStreamGroupOutcome; using RequestT = Model::GetStreamGroupRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StreamGroupDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); @@ -114,7 +114,7 @@ class GameLiftStreamsWaiter { Aws::Utils::WaiterOutcome WaitUntilStreamSessionActive(const Model::GetStreamSessionRequest& request) { using OutcomeT = Model::GetStreamSessionOutcome; using RequestT = Model::GetStreamSessionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StreamSessionActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetStreamSessionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h b/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h index 2c06fe19ee5..0bdc0550ca5 100644 --- a/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h +++ b/generated/src/aws-cpp-sdk-glacier/include/aws/glacier/GlacierWaiter.h @@ -21,7 +21,7 @@ class GlacierWaiter { Aws::Utils::WaiterOutcome WaitUntilVaultExists(const Model::DescribeVaultRequest& request) { using OutcomeT = Model::DescribeVaultOutcome; using RequestT = Model::DescribeVaultRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("VaultExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>("VaultExistsWaiter", Aws::Utils::WaiterState::RETRY, @@ -35,7 +35,7 @@ class GlacierWaiter { Aws::Utils::WaiterOutcome WaitUntilVaultNotExists(const Model::DescribeVaultRequest& request) { using OutcomeT = Model::DescribeVaultOutcome; using RequestT = Model::DescribeVaultRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("VaultNotExistsWaiter", Aws::Utils::WaiterState::RETRY, false)); acceptors.emplace_back(Aws::MakeUnique>("VaultNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, diff --git a/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h b/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h index 1d5519dfdad..b1ce12863ba 100644 --- a/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h +++ b/generated/src/aws-cpp-sdk-groundstation/include/aws/groundstation/GroundStationWaiter.h @@ -22,7 +22,7 @@ class GroundStationWaiter { Aws::Utils::WaiterOutcome WaitUntilContactScheduled(const Model::DescribeContactRequest& request) { using OutcomeT = Model::DescribeContactOutcome; using RequestT = Model::DescribeContactRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ContactScheduledWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED_TO_SCHEDULE"), [](const Model::DescribeContactOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h b/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h index 35290566d81..edd80b51665 100644 --- a/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h +++ b/generated/src/aws-cpp-sdk-healthlake/include/aws/healthlake/HealthLakeWaiter.h @@ -28,7 +28,7 @@ class HealthLakeWaiter { const Model::DescribeFHIRDatastoreRequest& request) { using OutcomeT = Model::DescribeFHIRDatastoreOutcome; using RequestT = Model::DescribeFHIRDatastoreRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FHIRDatastoreActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -63,7 +63,7 @@ class HealthLakeWaiter { const Model::DescribeFHIRDatastoreRequest& request) { using OutcomeT = Model::DescribeFHIRDatastoreOutcome; using RequestT = Model::DescribeFHIRDatastoreRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FHIRDatastoreDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), [](const Model::DescribeFHIRDatastoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -82,7 +82,7 @@ class HealthLakeWaiter { const Model::DescribeFHIRExportJobRequest& request) { using OutcomeT = Model::DescribeFHIRExportJobOutcome; using RequestT = Model::DescribeFHIRExportJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FHIRExportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::DescribeFHIRExportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -128,7 +128,7 @@ class HealthLakeWaiter { const Model::DescribeFHIRImportJobRequest& request) { using OutcomeT = Model::DescribeFHIRImportJobOutcome; using RequestT = Model::DescribeFHIRImportJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FHIRImportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::DescribeFHIRImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h b/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h index 3bbaa76ab7b..a3abc56a917 100644 --- a/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h +++ b/generated/src/aws-cpp-sdk-iam/include/aws/iam/IAMWaiter.h @@ -28,7 +28,7 @@ class IAMWaiter { const Model::GetInstanceProfileRequest& request) { using OutcomeT = Model::GetInstanceProfileOutcome; using RequestT = Model::GetInstanceProfileRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("InstanceProfileExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>( @@ -42,7 +42,7 @@ class IAMWaiter { Aws::Utils::WaiterOutcome WaitUntilPolicyExists(const Model::GetPolicyRequest& request) { using OutcomeT = Model::GetPolicyOutcome; using RequestT = Model::GetPolicyRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("PolicyExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>("PolicyExistsWaiter", Aws::Utils::WaiterState::RETRY, @@ -56,7 +56,7 @@ class IAMWaiter { Aws::Utils::WaiterOutcome WaitUntilRoleExists(const Model::GetRoleRequest& request) { using OutcomeT = Model::GetRoleOutcome; using RequestT = Model::GetRoleRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("RoleExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>("RoleExistsWaiter", Aws::Utils::WaiterState::RETRY, @@ -70,7 +70,7 @@ class IAMWaiter { Aws::Utils::WaiterOutcome WaitUntilUserExists(const Model::GetUserRequest& request) { using OutcomeT = Model::GetUserOutcome; using RequestT = Model::GetUserRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("UserExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>("UserExistsWaiter", Aws::Utils::WaiterState::RETRY, diff --git a/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h b/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h index cff7ffee9b9..2bfa36e3c6c 100644 --- a/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h +++ b/generated/src/aws-cpp-sdk-iotsitewise/include/aws/iotsitewise/IoTSiteWiseWaiter.h @@ -28,7 +28,7 @@ class IoTSiteWiseWaiter { Aws::Utils::WaiterOutcome WaitUntilAssetActive(const Model::DescribeAssetRequest& request) { using OutcomeT = Model::DescribeAssetOutcome; using RequestT = Model::DescribeAssetRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AssetActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeAssetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -52,7 +52,7 @@ class IoTSiteWiseWaiter { Aws::Utils::WaiterOutcome WaitUntilAssetNotExists(const Model::DescribeAssetRequest& request) { using OutcomeT = Model::DescribeAssetOutcome; using RequestT = Model::DescribeAssetRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("AssetNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); @@ -64,7 +64,7 @@ class IoTSiteWiseWaiter { Aws::Utils::WaiterOutcome WaitUntilAssetModelActive(const Model::DescribeAssetModelRequest& request) { using OutcomeT = Model::DescribeAssetModelOutcome; using RequestT = Model::DescribeAssetModelRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AssetModelActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeAssetModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -91,7 +91,7 @@ class IoTSiteWiseWaiter { const Model::DescribeAssetModelRequest& request) { using OutcomeT = Model::DescribeAssetModelOutcome; using RequestT = Model::DescribeAssetModelRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AssetModelNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); @@ -103,7 +103,7 @@ class IoTSiteWiseWaiter { Aws::Utils::WaiterOutcome WaitUntilPortalActive(const Model::DescribePortalRequest& request) { using OutcomeT = Model::DescribePortalOutcome; using RequestT = Model::DescribePortalRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "PortalActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribePortalOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -120,7 +120,7 @@ class IoTSiteWiseWaiter { Aws::Utils::WaiterOutcome WaitUntilPortalNotExists(const Model::DescribePortalRequest& request) { using OutcomeT = Model::DescribePortalOutcome; using RequestT = Model::DescribePortalRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("PortalNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); diff --git a/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h b/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h index 3b8ddfc0bf9..dfe6ae48391 100644 --- a/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h +++ b/generated/src/aws-cpp-sdk-kinesis/include/aws/kinesis/KinesisWaiter.h @@ -22,7 +22,7 @@ class KinesisWaiter { Aws::Utils::WaiterOutcome WaitUntilStreamExists(const Model::DescribeStreamRequest& request) { using OutcomeT = Model::DescribeStreamOutcome; using RequestT = Model::DescribeStreamRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "StreamExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeStreamOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -40,7 +40,7 @@ class KinesisWaiter { Aws::Utils::WaiterOutcome WaitUntilStreamNotExists(const Model::DescribeStreamRequest& request) { using OutcomeT = Model::DescribeStreamOutcome; using RequestT = Model::DescribeStreamRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("StreamNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); diff --git a/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h b/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h index f5f33c4b8a4..64c9c9012c4 100644 --- a/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h +++ b/generated/src/aws-cpp-sdk-lambda/include/aws/lambda/LambdaWaiter.h @@ -25,7 +25,7 @@ class LambdaWaiter { Aws::Utils::WaiterOutcome WaitUntilFunctionActiveV2(const Model::GetFunctionRequest& request) { using OutcomeT = Model::GetFunctionOutcome; using RequestT = Model::GetFunctionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FunctionActiveV2Waiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Active"), [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -56,7 +56,7 @@ class LambdaWaiter { Aws::Utils::WaiterOutcome WaitUntilFunctionExists(const Model::GetFunctionRequest& request) { using OutcomeT = Model::GetFunctionOutcome; using RequestT = Model::GetFunctionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("FunctionExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>("FunctionExistsWaiter", Aws::Utils::WaiterState::RETRY, @@ -70,7 +70,7 @@ class LambdaWaiter { Aws::Utils::WaiterOutcome WaitUntilFunctionUpdatedV2(const Model::GetFunctionRequest& request) { using OutcomeT = Model::GetFunctionOutcome; using RequestT = Model::GetFunctionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FunctionUpdatedV2Waiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Successful"), [](const Model::GetFunctionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -105,7 +105,7 @@ class LambdaWaiter { const Model::GetFunctionConfigurationRequest& request) { using OutcomeT = Model::GetFunctionConfigurationOutcome; using RequestT = Model::GetFunctionConfigurationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FunctionActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Active"), [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -137,7 +137,7 @@ class LambdaWaiter { const Model::GetFunctionConfigurationRequest& request) { using OutcomeT = Model::GetFunctionConfigurationOutcome; using RequestT = Model::GetFunctionConfigurationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FunctionUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Successful"), [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -169,7 +169,7 @@ class LambdaWaiter { const Model::GetFunctionConfigurationRequest& request) { using OutcomeT = Model::GetFunctionConfigurationOutcome; using RequestT = Model::GetFunctionConfigurationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "PublishedVersionActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Active"), [](const Model::GetFunctionConfigurationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h b/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h index 97b26074de2..8bc5647e909 100644 --- a/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h +++ b/generated/src/aws-cpp-sdk-lexv2-models/include/aws/lexv2-models/LexModelsV2Waiter.h @@ -36,7 +36,7 @@ class LexModelsV2Waiter { Aws::Utils::WaiterOutcome WaitUntilBotAvailable(const Model::DescribeBotRequest& request) { using OutcomeT = Model::DescribeBotOutcome; using RequestT = Model::DescribeBotRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "BotAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Available"), [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -74,7 +74,7 @@ class LexModelsV2Waiter { Aws::Utils::WaiterOutcome WaitUntilBotAliasAvailable(const Model::DescribeBotAliasRequest& request) { using OutcomeT = Model::DescribeBotAliasOutcome; using RequestT = Model::DescribeBotAliasRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "BotAliasAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Available"), [](const Model::DescribeBotAliasOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -105,7 +105,7 @@ class LexModelsV2Waiter { Aws::Utils::WaiterOutcome WaitUntilBotLocaleBuilt(const Model::DescribeBotLocaleRequest& request) { using OutcomeT = Model::DescribeBotLocaleOutcome; using RequestT = Model::DescribeBotLocaleRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "BotLocaleBuiltWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Built"), [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -143,7 +143,7 @@ class LexModelsV2Waiter { Aws::Utils::WaiterOutcome WaitUntilBotLocaleCreated(const Model::DescribeBotLocaleRequest& request) { using OutcomeT = Model::DescribeBotLocaleOutcome; using RequestT = Model::DescribeBotLocaleRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "BotLocaleCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Built"), [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -189,7 +189,7 @@ class LexModelsV2Waiter { const Model::DescribeBotLocaleRequest& request) { using OutcomeT = Model::DescribeBotLocaleOutcome; using RequestT = Model::DescribeBotLocaleRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "BotLocaleExpressTestingAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Built"), [](const Model::DescribeBotLocaleOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -235,7 +235,7 @@ class LexModelsV2Waiter { const Model::DescribeBotVersionRequest& request) { using OutcomeT = Model::DescribeBotVersionOutcome; using RequestT = Model::DescribeBotVersionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "BotVersionAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Available"), [](const Model::DescribeBotVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -268,7 +268,7 @@ class LexModelsV2Waiter { Aws::Utils::WaiterOutcome WaitUntilBotExportCompleted(const Model::DescribeExportRequest& request) { using OutcomeT = Model::DescribeExportOutcome; using RequestT = Model::DescribeExportRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "BotExportCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), [](const Model::DescribeExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -299,7 +299,7 @@ class LexModelsV2Waiter { Aws::Utils::WaiterOutcome WaitUntilBotImportCompleted(const Model::DescribeImportRequest& request) { using OutcomeT = Model::DescribeImportOutcome; using RequestT = Model::DescribeImportRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "BotImportCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), [](const Model::DescribeImportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h b/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h index 26f6ca992ea..8f6587f396b 100644 --- a/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h +++ b/generated/src/aws-cpp-sdk-machinelearning/include/aws/machinelearning/MachineLearningWaiter.h @@ -29,7 +29,7 @@ class MachineLearningWaiter { const Model::DescribeBatchPredictionsRequest& request) { using OutcomeT = Model::DescribeBatchPredictionsOutcome; using RequestT = Model::DescribeBatchPredictionsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "BatchPredictionAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -58,7 +58,7 @@ class MachineLearningWaiter { const Model::DescribeDataSourcesRequest& request) { using OutcomeT = Model::DescribeDataSourcesOutcome; using RequestT = Model::DescribeDataSourcesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DataSourceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -87,7 +87,7 @@ class MachineLearningWaiter { const Model::DescribeEvaluationsRequest& request) { using OutcomeT = Model::DescribeEvaluationsOutcome; using RequestT = Model::DescribeEvaluationsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "EvaluationAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -115,7 +115,7 @@ class MachineLearningWaiter { Aws::Utils::WaiterOutcome WaitUntilMLModelAvailable(const Model::DescribeMLModelsRequest& request) { using OutcomeT = Model::DescribeMLModelsOutcome; using RequestT = Model::DescribeMLModelsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "MLModelAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::DescribeMLModelsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h b/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h index 4470614cf45..ffa174c291b 100644 --- a/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h +++ b/generated/src/aws-cpp-sdk-macie2/include/aws/macie2/Macie2Waiter.h @@ -23,7 +23,7 @@ class Macie2Waiter { const Model::GetSensitiveDataOccurrencesRequest& request) { using OutcomeT = Model::GetSensitiveDataOccurrencesOutcome; using RequestT = Model::GetSensitiveDataOccurrencesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FindingRevealedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCESS"), [](const Model::GetSensitiveDataOccurrencesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h b/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h index 253a95ced3a..f4482f8cbdb 100644 --- a/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h +++ b/generated/src/aws-cpp-sdk-mediaconnect/include/aws/mediaconnect/MediaConnectWaiter.h @@ -29,7 +29,7 @@ class MediaConnectWaiter { Aws::Utils::WaiterOutcome WaitUntilFlowActive(const Model::DescribeFlowRequest& request) { using OutcomeT = Model::DescribeFlowOutcome; using RequestT = Model::DescribeFlowRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FlowActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -78,7 +78,7 @@ class MediaConnectWaiter { Aws::Utils::WaiterOutcome WaitUntilFlowDeleted(const Model::DescribeFlowRequest& request) { using OutcomeT = Model::DescribeFlowOutcome; using RequestT = Model::DescribeFlowRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("FlowDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("NotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -108,7 +108,7 @@ class MediaConnectWaiter { Aws::Utils::WaiterOutcome WaitUntilFlowStandby(const Model::DescribeFlowRequest& request) { using OutcomeT = Model::DescribeFlowOutcome; using RequestT = Model::DescribeFlowRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "FlowStandbyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STANDBY"), [](const Model::DescribeFlowOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -143,7 +143,7 @@ class MediaConnectWaiter { Aws::Utils::WaiterOutcome WaitUntilInputStandby(const Model::GetRouterInputRequest& request) { using OutcomeT = Model::GetRouterInputOutcome; using RequestT = Model::GetRouterInputRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InputStandbyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STANDBY"), [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -181,7 +181,7 @@ class MediaConnectWaiter { Aws::Utils::WaiterOutcome WaitUntilInputDeleted(const Model::GetRouterInputRequest& request) { using OutcomeT = Model::GetRouterInputOutcome; using RequestT = Model::GetRouterInputRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InputDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -213,7 +213,7 @@ class MediaConnectWaiter { Aws::Utils::WaiterOutcome WaitUntilInputActive(const Model::GetRouterInputRequest& request) { using OutcomeT = Model::GetRouterInputOutcome; using RequestT = Model::GetRouterInputRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InputActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetRouterInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -267,7 +267,7 @@ class MediaConnectWaiter { Aws::Utils::WaiterOutcome WaitUntilOutputUnrouted(const Model::GetRouterOutputRequest& request) { using OutcomeT = Model::GetRouterOutputOutcome; using RequestT = Model::GetRouterOutputRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "OutputUnroutedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UNROUTED"), [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -297,7 +297,7 @@ class MediaConnectWaiter { Aws::Utils::WaiterOutcome WaitUntilOutputDeleted(const Model::GetRouterOutputRequest& request) { using OutcomeT = Model::GetRouterOutputOutcome; using RequestT = Model::GetRouterOutputRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "OutputDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"), [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -329,7 +329,7 @@ class MediaConnectWaiter { Aws::Utils::WaiterOutcome WaitUntilOutputActive(const Model::GetRouterOutputRequest& request) { using OutcomeT = Model::GetRouterOutputOutcome; using RequestT = Model::GetRouterOutputRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "OutputActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -383,7 +383,7 @@ class MediaConnectWaiter { Aws::Utils::WaiterOutcome WaitUntilOutputStandby(const Model::GetRouterOutputRequest& request) { using OutcomeT = Model::GetRouterOutputOutcome; using RequestT = Model::GetRouterOutputRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "OutputStandbyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STANDBY"), [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -421,7 +421,7 @@ class MediaConnectWaiter { Aws::Utils::WaiterOutcome WaitUntilOutputRouted(const Model::GetRouterOutputRequest& request) { using OutcomeT = Model::GetRouterOutputOutcome; using RequestT = Model::GetRouterOutputRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "OutputRoutedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ROUTED"), [](const Model::GetRouterOutputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h index 42b96bd7e81..3fc4a9db7c6 100644 --- a/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h +++ b/generated/src/aws-cpp-sdk-medialive/include/aws/medialive/MediaLiveWaiter.h @@ -41,7 +41,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilChannelCreated(const Model::DescribeChannelRequest& request) { using OutcomeT = Model::DescribeChannelOutcome; using RequestT = Model::DescribeChannelRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ChannelCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"), [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -74,7 +74,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilChannelDeleted(const Model::DescribeChannelRequest& request) { using OutcomeT = Model::DescribeChannelOutcome; using RequestT = Model::DescribeChannelRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ChannelDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -100,7 +100,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilChannelRunning(const Model::DescribeChannelRequest& request) { using OutcomeT = Model::DescribeChannelOutcome; using RequestT = Model::DescribeChannelRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ChannelRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -126,7 +126,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilChannelStopped(const Model::DescribeChannelRequest& request) { using OutcomeT = Model::DescribeChannelOutcome; using RequestT = Model::DescribeChannelRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ChannelStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"), [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -153,7 +153,7 @@ class MediaLiveWaiter { const Model::DescribeChannelPlacementGroupRequest& request) { using OutcomeT = Model::DescribeChannelPlacementGroupOutcome; using RequestT = Model::DescribeChannelPlacementGroupRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ChannelPlacementGroupAssignedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ASSIGNED"), [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -182,7 +182,7 @@ class MediaLiveWaiter { const Model::DescribeChannelPlacementGroupRequest& request) { using OutcomeT = Model::DescribeChannelPlacementGroupOutcome; using RequestT = Model::DescribeChannelPlacementGroupRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ChannelPlacementGroupDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -209,7 +209,7 @@ class MediaLiveWaiter { const Model::DescribeChannelPlacementGroupRequest& request) { using OutcomeT = Model::DescribeChannelPlacementGroupOutcome; using RequestT = Model::DescribeChannelPlacementGroupRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ChannelPlacementGroupUnassignedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UNASSIGNED"), [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -237,7 +237,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterCreated(const Model::DescribeClusterRequest& request) { using OutcomeT = Model::DescribeClusterOutcome; using RequestT = Model::DescribeClusterRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ClusterCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -270,7 +270,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClusterRequest& request) { using OutcomeT = Model::DescribeClusterOutcome; using RequestT = Model::DescribeClusterRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -296,7 +296,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilInputAttached(const Model::DescribeInputRequest& request) { using OutcomeT = Model::DescribeInputOutcome; using RequestT = Model::DescribeInputRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InputAttachedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ATTACHED"), [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -322,7 +322,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilInputDeleted(const Model::DescribeInputRequest& request) { using OutcomeT = Model::DescribeInputOutcome; using RequestT = Model::DescribeInputRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InputDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -348,7 +348,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilInputDetached(const Model::DescribeInputRequest& request) { using OutcomeT = Model::DescribeInputOutcome; using RequestT = Model::DescribeInputRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InputDetachedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DETACHED"), [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -381,7 +381,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilMultiplexCreated(const Model::DescribeMultiplexRequest& request) { using OutcomeT = Model::DescribeMultiplexOutcome; using RequestT = Model::DescribeMultiplexRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "MultiplexCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"), [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -414,7 +414,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilMultiplexDeleted(const Model::DescribeMultiplexRequest& request) { using OutcomeT = Model::DescribeMultiplexOutcome; using RequestT = Model::DescribeMultiplexRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "MultiplexDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -440,7 +440,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilMultiplexRunning(const Model::DescribeMultiplexRequest& request) { using OutcomeT = Model::DescribeMultiplexOutcome; using RequestT = Model::DescribeMultiplexRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "MultiplexRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -466,7 +466,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilMultiplexStopped(const Model::DescribeMultiplexRequest& request) { using OutcomeT = Model::DescribeMultiplexOutcome; using RequestT = Model::DescribeMultiplexRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "MultiplexStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"), [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -492,7 +492,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilNodeDeregistered(const Model::DescribeNodeRequest& request) { using OutcomeT = Model::DescribeNodeOutcome; using RequestT = Model::DescribeNodeRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "NodeDeregisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEREGISTERED"), [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -525,7 +525,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilNodeRegistered(const Model::DescribeNodeRequest& request) { using OutcomeT = Model::DescribeNodeOutcome; using RequestT = Model::DescribeNodeRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "NodeRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -560,7 +560,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilSignalMapCreated(const Model::GetSignalMapRequest& request) { using OutcomeT = Model::GetSignalMapOutcome; using RequestT = Model::GetSignalMapRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SignalMapCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -591,7 +591,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilSignalMapMonitorDeleted(const Model::GetSignalMapRequest& request) { using OutcomeT = Model::GetSignalMapOutcome; using RequestT = Model::GetSignalMapRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SignalMapMonitorDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETE_COMPLETE"), [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -625,7 +625,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilSignalMapMonitorDeployed(const Model::GetSignalMapRequest& request) { using OutcomeT = Model::GetSignalMapOutcome; using RequestT = Model::GetSignalMapRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DRY_RUN_DEPLOYMENT_COMPLETE"), [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -683,7 +683,7 @@ class MediaLiveWaiter { Aws::Utils::WaiterOutcome WaitUntilSignalMapUpdated(const Model::GetSignalMapRequest& request) { using OutcomeT = Model::GetSignalMapOutcome; using RequestT = Model::GetSignalMapRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_COMPLETE"), [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h b/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h index c45278c1195..c54f721679a 100644 --- a/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h +++ b/generated/src/aws-cpp-sdk-mediapackagev2/include/aws/mediapackagev2/Mediapackagev2Waiter.h @@ -22,7 +22,7 @@ class Mediapackagev2Waiter { Aws::Utils::WaiterOutcome WaitUntilHarvestJobFinished(const Model::GetHarvestJobRequest& request) { using OutcomeT = Model::GetHarvestJobOutcome; using RequestT = Model::GetHarvestJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "HarvestJobFinishedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetHarvestJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h b/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h index fef3ea8cd50..f96b5bbff7f 100644 --- a/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h +++ b/generated/src/aws-cpp-sdk-monitoring/include/aws/monitoring/CloudWatchWaiter.h @@ -23,7 +23,7 @@ class CloudWatchWaiter { Aws::Utils::WaiterOutcome WaitUntilAlarmExists(const Model::DescribeAlarmsRequest& request) { using OutcomeT = Model::DescribeAlarmsOutcome; using RequestT = Model::DescribeAlarmsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AlarmExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeAlarmsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -40,7 +40,7 @@ class CloudWatchWaiter { Aws::Utils::WaiterOutcome WaitUntilCompositeAlarmExists(const Model::DescribeAlarmsRequest& request) { using OutcomeT = Model::DescribeAlarmsOutcome; using RequestT = Model::DescribeAlarmsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "CompositeAlarmExistsWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeAlarmsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -57,7 +57,7 @@ class CloudWatchWaiter { Aws::Utils::WaiterOutcome WaitUntilAlarmMuteRuleExists(const Model::GetAlarmMuteRuleRequest& request) { using OutcomeT = Model::GetAlarmMuteRuleOutcome; using RequestT = Model::GetAlarmMuteRuleRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("AlarmMuteRuleExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back(Aws::MakeUnique>("AlarmMuteRuleExistsWaiter", Aws::Utils::WaiterState::RETRY, diff --git a/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h b/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h index a1c8396d78f..f06f989f5d5 100644 --- a/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h +++ b/generated/src/aws-cpp-sdk-neptune-graph/include/aws/neptune-graph/NeptuneGraphWaiter.h @@ -34,7 +34,7 @@ class NeptuneGraphWaiter { Aws::Utils::WaiterOutcome WaitUntilExportTaskSuccessful(const Model::GetExportTaskRequest& request) { using OutcomeT = Model::GetExportTaskOutcome; using RequestT = Model::GetExportTaskRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ExportTaskSuccessfulWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLING"), [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -73,7 +73,7 @@ class NeptuneGraphWaiter { Aws::Utils::WaiterOutcome WaitUntilExportTaskCancelled(const Model::GetExportTaskRequest& request) { using OutcomeT = Model::GetExportTaskOutcome; using RequestT = Model::GetExportTaskRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ExportTaskCancelledWaiter", Aws::Utils::WaiterState::FAILURE, true, [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -97,7 +97,7 @@ class NeptuneGraphWaiter { Aws::Utils::WaiterOutcome WaitUntilGraphAvailable(const Model::GetGraphRequest& request) { using OutcomeT = Model::GetGraphOutcome; using RequestT = Model::GetGraphRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "GraphAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETING"), [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -131,7 +131,7 @@ class NeptuneGraphWaiter { Aws::Utils::WaiterOutcome WaitUntilGraphDeleted(const Model::GetGraphRequest& request) { using OutcomeT = Model::GetGraphOutcome; using RequestT = Model::GetGraphRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "GraphDeletedWaiter", Aws::Utils::WaiterState::FAILURE, true, [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -150,7 +150,7 @@ class NeptuneGraphWaiter { Aws::Utils::WaiterOutcome WaitUntilGraphStopped(const Model::GetGraphRequest& request) { using OutcomeT = Model::GetGraphOutcome; using RequestT = Model::GetGraphRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "GraphStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("STOPPED"), [](const Model::GetGraphOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -174,7 +174,7 @@ class NeptuneGraphWaiter { Aws::Utils::WaiterOutcome WaitUntilGraphSnapshotAvailable(const Model::GetGraphSnapshotRequest& request) { using OutcomeT = Model::GetGraphSnapshotOutcome; using RequestT = Model::GetGraphSnapshotRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "GraphSnapshotAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETING"), [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -208,7 +208,7 @@ class NeptuneGraphWaiter { Aws::Utils::WaiterOutcome WaitUntilGraphSnapshotDeleted(const Model::GetGraphSnapshotRequest& request) { using OutcomeT = Model::GetGraphSnapshotOutcome; using RequestT = Model::GetGraphSnapshotRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "GraphSnapshotDeletedWaiter", Aws::Utils::WaiterState::FAILURE, true, [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -227,7 +227,7 @@ class NeptuneGraphWaiter { Aws::Utils::WaiterOutcome WaitUntilImportTaskSuccessful(const Model::GetImportTaskRequest& request) { using OutcomeT = Model::GetImportTaskOutcome; using RequestT = Model::GetImportTaskRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ImportTaskSuccessfulWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLING"), [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -273,7 +273,7 @@ class NeptuneGraphWaiter { Aws::Utils::WaiterOutcome WaitUntilImportTaskCancelled(const Model::GetImportTaskRequest& request) { using OutcomeT = Model::GetImportTaskOutcome; using RequestT = Model::GetImportTaskRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ImportTaskCancelledWaiter", Aws::Utils::WaiterState::FAILURE, true, [](const Model::GetImportTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -298,7 +298,7 @@ class NeptuneGraphWaiter { const Model::GetPrivateGraphEndpointRequest& request) { using OutcomeT = Model::GetPrivateGraphEndpointOutcome; using RequestT = Model::GetPrivateGraphEndpointRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "PrivateGraphEndpointAvailableWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETING"), [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -333,7 +333,7 @@ class NeptuneGraphWaiter { const Model::GetPrivateGraphEndpointRequest& request) { using OutcomeT = Model::GetPrivateGraphEndpointOutcome; using RequestT = Model::GetPrivateGraphEndpointRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "PrivateGraphEndpointDeletedWaiter", Aws::Utils::WaiterState::FAILURE, true, [](const Model::GetPrivateGraphEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h b/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h index a574268552e..bf9c12be574 100644 --- a/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h +++ b/generated/src/aws-cpp-sdk-neptune/include/aws/neptune/NeptuneWaiter.h @@ -22,7 +22,7 @@ class NeptuneWaiter { const Model::DescribeDBInstancesRequest& request) { using OutcomeT = Model::DescribeDBInstancesOutcome; using RequestT = Model::DescribeDBInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -81,7 +81,7 @@ class NeptuneWaiter { const Model::DescribeDBInstancesRequest& request) { using OutcomeT = Model::DescribeDBInstancesOutcome; using RequestT = Model::DescribeDBInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("deleted"), [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h b/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h index a455e0dcdc4..256145c062c 100644 --- a/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h +++ b/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h @@ -46,7 +46,7 @@ class OmicsWaiter { const Model::GetAnnotationImportJobRequest& request) { using OutcomeT = Model::GetAnnotationImportJobOutcome; using RequestT = Model::GetAnnotationImportJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AnnotationImportJobCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -92,7 +92,7 @@ class OmicsWaiter { const Model::GetAnnotationStoreRequest& request) { using OutcomeT = Model::GetAnnotationStoreOutcome; using RequestT = Model::GetAnnotationStoreRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -131,7 +131,7 @@ class OmicsWaiter { const Model::GetAnnotationStoreRequest& request) { using OutcomeT = Model::GetAnnotationStoreOutcome; using RequestT = Model::GetAnnotationStoreRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -158,7 +158,7 @@ class OmicsWaiter { const Model::GetAnnotationStoreVersionRequest& request) { using OutcomeT = Model::GetAnnotationStoreVersionOutcome; using RequestT = Model::GetAnnotationStoreVersionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreVersionCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -197,7 +197,7 @@ class OmicsWaiter { const Model::GetAnnotationStoreVersionRequest& request) { using OutcomeT = Model::GetAnnotationStoreVersionOutcome; using RequestT = Model::GetAnnotationStoreVersionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreVersionDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -224,7 +224,7 @@ class OmicsWaiter { const Model::GetReadSetActivationJobRequest& request) { using OutcomeT = Model::GetReadSetActivationJobOutcome; using RequestT = Model::GetReadSetActivationJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -284,7 +284,7 @@ class OmicsWaiter { const Model::GetReadSetExportJobRequest& request) { using OutcomeT = Model::GetReadSetExportJobOutcome; using RequestT = Model::GetReadSetExportJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -344,7 +344,7 @@ class OmicsWaiter { const Model::GetReadSetImportJobRequest& request) { using OutcomeT = Model::GetReadSetImportJobOutcome; using RequestT = Model::GetReadSetImportJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -404,7 +404,7 @@ class OmicsWaiter { const Model::GetReferenceImportJobRequest& request) { using OutcomeT = Model::GetReferenceImportJobOutcome; using RequestT = Model::GetReferenceImportJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -463,7 +463,7 @@ class OmicsWaiter { Aws::Utils::WaiterOutcome WaitUntilRunRunning(const Model::GetRunRequest& request) { using OutcomeT = Model::GetRunOutcome; using RequestT = Model::GetRunRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "RunRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -508,7 +508,7 @@ class OmicsWaiter { Aws::Utils::WaiterOutcome WaitUntilRunCompleted(const Model::GetRunRequest& request) { using OutcomeT = Model::GetRunOutcome; using RequestT = Model::GetRunRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "RunCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -560,7 +560,7 @@ class OmicsWaiter { Aws::Utils::WaiterOutcome WaitUntilTaskRunning(const Model::GetRunTaskRequest& request) { using OutcomeT = Model::GetRunTaskOutcome; using RequestT = Model::GetRunTaskRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TaskRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -605,7 +605,7 @@ class OmicsWaiter { Aws::Utils::WaiterOutcome WaitUntilTaskCompleted(const Model::GetRunTaskRequest& request) { using OutcomeT = Model::GetRunTaskOutcome; using RequestT = Model::GetRunTaskRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TaskCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -658,7 +658,7 @@ class OmicsWaiter { const Model::GetVariantImportJobRequest& request) { using OutcomeT = Model::GetVariantImportJobOutcome; using RequestT = Model::GetVariantImportJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "VariantImportJobCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -703,7 +703,7 @@ class OmicsWaiter { Aws::Utils::WaiterOutcome WaitUntilVariantStoreCreated(const Model::GetVariantStoreRequest& request) { using OutcomeT = Model::GetVariantStoreOutcome; using RequestT = Model::GetVariantStoreRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "VariantStoreCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -741,7 +741,7 @@ class OmicsWaiter { Aws::Utils::WaiterOutcome WaitUntilVariantStoreDeleted(const Model::GetVariantStoreRequest& request) { using OutcomeT = Model::GetVariantStoreOutcome; using RequestT = Model::GetVariantStoreRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "VariantStoreDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -767,7 +767,7 @@ class OmicsWaiter { Aws::Utils::WaiterOutcome WaitUntilWorkflowActive(const Model::GetWorkflowRequest& request) { using OutcomeT = Model::GetWorkflowOutcome; using RequestT = Model::GetWorkflowRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "WorkflowActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -806,7 +806,7 @@ class OmicsWaiter { const Model::GetWorkflowVersionRequest& request) { using OutcomeT = Model::GetWorkflowVersionOutcome; using RequestT = Model::GetWorkflowVersionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "WorkflowVersionActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h b/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h index 1d816f747dd..6be9ce7f60e 100644 --- a/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h +++ b/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h @@ -31,7 +31,7 @@ class ProtonWaiter { Aws::Utils::WaiterOutcome WaitUntilComponentDeployed(const Model::GetComponentRequest& request) { using OutcomeT = Model::GetComponentOutcome; using RequestT = Model::GetComponentRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ComponentDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -55,7 +55,7 @@ class ProtonWaiter { Aws::Utils::WaiterOutcome WaitUntilComponentDeleted(const Model::GetComponentRequest& request) { using OutcomeT = Model::GetComponentOutcome; using RequestT = Model::GetComponentRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("ComponentDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -74,7 +74,7 @@ class ProtonWaiter { Aws::Utils::WaiterOutcome WaitUntilEnvironmentDeployed(const Model::GetEnvironmentRequest& request) { using OutcomeT = Model::GetEnvironmentOutcome; using RequestT = Model::GetEnvironmentRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "EnvironmentDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -99,7 +99,7 @@ class ProtonWaiter { const Model::GetEnvironmentTemplateVersionRequest& request) { using OutcomeT = Model::GetEnvironmentTemplateVersionOutcome; using RequestT = Model::GetEnvironmentTemplateVersionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "EnvironmentTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DRAFT"), [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -130,7 +130,7 @@ class ProtonWaiter { Aws::Utils::WaiterOutcome WaitUntilServiceCreated(const Model::GetServiceRequest& request) { using OutcomeT = Model::GetServiceOutcome; using RequestT = Model::GetServiceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ServiceCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -168,7 +168,7 @@ class ProtonWaiter { Aws::Utils::WaiterOutcome WaitUntilServiceUpdated(const Model::GetServiceRequest& request) { using OutcomeT = Model::GetServiceOutcome; using RequestT = Model::GetServiceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ServiceUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -213,7 +213,7 @@ class ProtonWaiter { Aws::Utils::WaiterOutcome WaitUntilServiceDeleted(const Model::GetServiceRequest& request) { using OutcomeT = Model::GetServiceOutcome; using RequestT = Model::GetServiceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("ServiceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -232,7 +232,7 @@ class ProtonWaiter { Aws::Utils::WaiterOutcome WaitUntilServicePipelineDeployed(const Model::GetServiceRequest& request) { using OutcomeT = Model::GetServiceOutcome; using RequestT = Model::GetServiceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ServicePipelineDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -257,7 +257,7 @@ class ProtonWaiter { const Model::GetServiceInstanceRequest& request) { using OutcomeT = Model::GetServiceInstanceOutcome; using RequestT = Model::GetServiceInstanceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ServiceInstanceDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), [](const Model::GetServiceInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -282,7 +282,7 @@ class ProtonWaiter { const Model::GetServiceTemplateVersionRequest& request) { using OutcomeT = Model::GetServiceTemplateVersionOutcome; using RequestT = Model::GetServiceTemplateVersionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ServiceTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DRAFT"), [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h b/generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h index 1303c879c28..9ef3ca5c53f 100644 --- a/generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h +++ b/generated/src/aws-cpp-sdk-rds/include/aws/rds/RDSWaiter.h @@ -29,7 +29,7 @@ class RDSWaiter { Aws::Utils::WaiterOutcome WaitUntilDBClusterAvailable(const Model::DescribeDBClustersRequest& request) { using OutcomeT = Model::DescribeDBClustersOutcome; using RequestT = Model::DescribeDBClustersRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBClusterAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -87,7 +87,7 @@ class RDSWaiter { Aws::Utils::WaiterOutcome WaitUntilDBClusterDeleted(const Model::DescribeDBClustersRequest& request) { using OutcomeT = Model::DescribeDBClustersOutcome; using RequestT = Model::DescribeDBClustersRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeDBClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -139,7 +139,7 @@ class RDSWaiter { const Model::DescribeDBClusterSnapshotsRequest& request) { using OutcomeT = Model::DescribeDBClusterSnapshotsOutcome; using RequestT = Model::DescribeDBClusterSnapshotsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBClusterSnapshotAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -198,7 +198,7 @@ class RDSWaiter { const Model::DescribeDBClusterSnapshotsRequest& request) { using OutcomeT = Model::DescribeDBClusterSnapshotsOutcome; using RequestT = Model::DescribeDBClusterSnapshotsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBClusterSnapshotDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeDBClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -250,7 +250,7 @@ class RDSWaiter { const Model::DescribeDBInstancesRequest& request) { using OutcomeT = Model::DescribeDBInstancesOutcome; using RequestT = Model::DescribeDBInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBInstanceAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -309,7 +309,7 @@ class RDSWaiter { const Model::DescribeDBInstancesRequest& request) { using OutcomeT = Model::DescribeDBInstancesOutcome; using RequestT = Model::DescribeDBInstancesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeDBInstancesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -361,7 +361,7 @@ class RDSWaiter { const Model::DescribeDBSnapshotsRequest& request) { using OutcomeT = Model::DescribeDBSnapshotsOutcome; using RequestT = Model::DescribeDBSnapshotsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBSnapshotAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -420,7 +420,7 @@ class RDSWaiter { const Model::DescribeDBSnapshotsRequest& request) { using OutcomeT = Model::DescribeDBSnapshotsOutcome; using RequestT = Model::DescribeDBSnapshotsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "DBSnapshotDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeDBSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -472,7 +472,7 @@ class RDSWaiter { const Model::DescribeTenantDatabasesRequest& request) { using OutcomeT = Model::DescribeTenantDatabasesOutcome; using RequestT = Model::DescribeTenantDatabasesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TenantDatabaseAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -515,7 +515,7 @@ class RDSWaiter { const Model::DescribeTenantDatabasesRequest& request) { using OutcomeT = Model::DescribeTenantDatabasesOutcome; using RequestT = Model::DescribeTenantDatabasesRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TenantDatabaseDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, true, [](const Model::DescribeTenantDatabasesOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h b/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h index 8343ccc0602..235dc29e795 100644 --- a/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h +++ b/generated/src/aws-cpp-sdk-redshift/include/aws/redshift/RedshiftWaiter.h @@ -23,7 +23,7 @@ class RedshiftWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterAvailable(const Model::DescribeClustersRequest& request) { using OutcomeT = Model::DescribeClustersOutcome; using RequestT = Model::DescribeClustersRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ClusterAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -51,7 +51,7 @@ class RedshiftWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClustersRequest& request) { using OutcomeT = Model::DescribeClustersOutcome; using RequestT = Model::DescribeClustersRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("ClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ClusterNotFound"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -79,7 +79,7 @@ class RedshiftWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterRestored(const Model::DescribeClustersRequest& request) { using OutcomeT = Model::DescribeClustersOutcome; using RequestT = Model::DescribeClustersRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ClusterRestoredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("completed"), [](const Model::DescribeClustersOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -107,7 +107,7 @@ class RedshiftWaiter { const Model::DescribeClusterSnapshotsRequest& request) { using OutcomeT = Model::DescribeClusterSnapshotsOutcome; using RequestT = Model::DescribeClusterSnapshotsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SnapshotAvailableWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("available"), [](const Model::DescribeClusterSnapshotsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h b/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h index 0b799fdcdac..7a5df4e808a 100644 --- a/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h +++ b/generated/src/aws-cpp-sdk-rekognition/include/aws/rekognition/RekognitionWaiter.h @@ -23,7 +23,7 @@ class RekognitionWaiter { const Model::DescribeProjectVersionsRequest& request) { using OutcomeT = Model::DescribeProjectVersionsOutcome; using RequestT = Model::DescribeProjectVersionsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ProjectVersionRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"), [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -56,7 +56,7 @@ class RekognitionWaiter { const Model::DescribeProjectVersionsRequest& request) { using OutcomeT = Model::DescribeProjectVersionsOutcome; using RequestT = Model::DescribeProjectVersionsRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ProjectVersionTrainingCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("TRAINING_COMPLETED"), [](const Model::DescribeProjectVersionsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h b/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h index 2ac39311af4..b05073a2ff2 100644 --- a/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h +++ b/generated/src/aws-cpp-sdk-repostspace/include/aws/repostspace/RepostspaceWaiter.h @@ -24,7 +24,7 @@ class RepostspaceWaiter { Aws::Utils::WaiterOutcome WaitUntilChannelCreated(const Model::GetChannelRequest& request) { using OutcomeT = Model::GetChannelOutcome; using RequestT = Model::GetChannelRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ChannelCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATED"), [](const Model::GetChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -55,7 +55,7 @@ class RepostspaceWaiter { Aws::Utils::WaiterOutcome WaitUntilChannelDeleted(const Model::GetChannelRequest& request) { using OutcomeT = Model::GetChannelOutcome; using RequestT = Model::GetChannelRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("ChannelDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -88,7 +88,7 @@ class RepostspaceWaiter { Aws::Utils::WaiterOutcome WaitUntilSpaceCreated(const Model::GetSpaceRequest& request) { using OutcomeT = Model::GetSpaceOutcome; using RequestT = Model::GetSpaceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SpaceCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATED"), [](const Model::GetSpaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -119,7 +119,7 @@ class RepostspaceWaiter { Aws::Utils::WaiterOutcome WaitUntilSpaceDeleted(const Model::GetSpaceRequest& request) { using OutcomeT = Model::GetSpaceOutcome; using RequestT = Model::GetSpaceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("SpaceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( diff --git a/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h b/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h index 1be1c09b72c..e22ba7a588b 100644 --- a/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h +++ b/generated/src/aws-cpp-sdk-route53-recovery-control-config/include/aws/route53-recovery-control-config/Route53RecoveryControlConfigWaiter.h @@ -26,7 +26,7 @@ class Route53RecoveryControlConfigWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterCreated(const Model::DescribeClusterRequest& request) { using OutcomeT = Model::DescribeClusterOutcome; using RequestT = Model::DescribeClusterRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ClusterCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEPLOYED"), [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -52,7 +52,7 @@ class Route53RecoveryControlConfigWaiter { Aws::Utils::WaiterOutcome WaitUntilClusterDeleted(const Model::DescribeClusterRequest& request) { using OutcomeT = Model::DescribeClusterOutcome; using RequestT = Model::DescribeClusterRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("ClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -74,7 +74,7 @@ class Route53RecoveryControlConfigWaiter { const Model::DescribeControlPanelRequest& request) { using OutcomeT = Model::DescribeControlPanelOutcome; using RequestT = Model::DescribeControlPanelRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ControlPanelCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEPLOYED"), [](const Model::DescribeControlPanelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -101,7 +101,7 @@ class Route53RecoveryControlConfigWaiter { const Model::DescribeControlPanelRequest& request) { using OutcomeT = Model::DescribeControlPanelOutcome; using RequestT = Model::DescribeControlPanelRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ControlPanelDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -123,7 +123,7 @@ class Route53RecoveryControlConfigWaiter { const Model::DescribeRoutingControlRequest& request) { using OutcomeT = Model::DescribeRoutingControlOutcome; using RequestT = Model::DescribeRoutingControlRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "RoutingControlCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEPLOYED"), [](const Model::DescribeRoutingControlOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -150,7 +150,7 @@ class Route53RecoveryControlConfigWaiter { const Model::DescribeRoutingControlRequest& request) { using OutcomeT = Model::DescribeRoutingControlOutcome; using RequestT = Model::DescribeRoutingControlRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "RoutingControlDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( diff --git a/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h b/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h index bbe7360830b..119b1322dda 100644 --- a/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h +++ b/generated/src/aws-cpp-sdk-route53/include/aws/route53/Route53Waiter.h @@ -22,7 +22,7 @@ class Route53Waiter { Aws::Utils::WaiterOutcome WaitUntilResourceRecordSetsChanged(const Model::GetChangeRequest& request) { using OutcomeT = Model::GetChangeOutcome; using RequestT = Model::GetChangeRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ResourceRecordSetsChangedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("INSYNC"), [](const Model::GetChangeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h b/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h index 7c4e0101df4..625dc92137e 100644 --- a/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h +++ b/generated/src/aws-cpp-sdk-rtbfabric/include/aws/rtbfabric/RTBFabricWaiter.h @@ -33,7 +33,7 @@ class RTBFabricWaiter { const Model::GetInboundExternalLinkRequest& request) { using OutcomeT = Model::GetInboundExternalLinkOutcome; using RequestT = Model::GetInboundExternalLinkRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "InboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -78,7 +78,7 @@ class RTBFabricWaiter { Aws::Utils::WaiterOutcome WaitUntilLinkAccepted(const Model::GetLinkRequest& request) { using OutcomeT = Model::GetLinkOutcome; using RequestT = Model::GetLinkRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "LinkAcceptedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACCEPTED"), [](const Model::GetLinkOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -116,7 +116,7 @@ class RTBFabricWaiter { Aws::Utils::WaiterOutcome WaitUntilLinkActive(const Model::GetLinkRequest& request) { using OutcomeT = Model::GetLinkOutcome; using RequestT = Model::GetLinkRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "LinkActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -155,7 +155,7 @@ class RTBFabricWaiter { const Model::GetOutboundExternalLinkRequest& request) { using OutcomeT = Model::GetOutboundExternalLinkOutcome; using RequestT = Model::GetOutboundExternalLinkRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "OutboundExternalLinkActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -201,7 +201,7 @@ class RTBFabricWaiter { const Model::GetRequesterGatewayRequest& request) { using OutcomeT = Model::GetRequesterGatewayOutcome; using RequestT = Model::GetRequesterGatewayRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "RequesterGatewayActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -233,7 +233,7 @@ class RTBFabricWaiter { const Model::GetRequesterGatewayRequest& request) { using OutcomeT = Model::GetRequesterGatewayOutcome; using RequestT = Model::GetRequesterGatewayRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "RequesterGatewayDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -258,7 +258,7 @@ class RTBFabricWaiter { const Model::GetResponderGatewayRequest& request) { using OutcomeT = Model::GetResponderGatewayOutcome; using RequestT = Model::GetResponderGatewayRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ResponderGatewayActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -290,7 +290,7 @@ class RTBFabricWaiter { const Model::GetResponderGatewayRequest& request) { using OutcomeT = Model::GetResponderGatewayOutcome; using RequestT = Model::GetResponderGatewayRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ResponderGatewayDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"), [](const Model::GetResponderGatewayOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h b/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h index 819ea52a25f..bf1723a17ee 100644 --- a/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h +++ b/generated/src/aws-cpp-sdk-s3-crt/include/aws/s3-crt/S3CrtWaiter.h @@ -23,7 +23,7 @@ class S3CrtWaiter { Aws::Utils::WaiterOutcome WaitUntilBucketExists(const Model::HeadBucketRequest& request) { using OutcomeT = Model::HeadBucketOutcome; using RequestT = Model::HeadBucketRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("BucketExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back( @@ -37,7 +37,7 @@ class S3CrtWaiter { Aws::Utils::WaiterOutcome WaitUntilBucketNotExists(const Model::HeadBucketRequest& request) { using OutcomeT = Model::HeadBucketOutcome; using RequestT = Model::HeadBucketRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("BucketNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, 404)); @@ -49,7 +49,7 @@ class S3CrtWaiter { Aws::Utils::WaiterOutcome WaitUntilObjectExists(const Model::HeadObjectRequest& request) { using OutcomeT = Model::HeadObjectOutcome; using RequestT = Model::HeadObjectRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("ObjectExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back( @@ -63,7 +63,7 @@ class S3CrtWaiter { Aws::Utils::WaiterOutcome WaitUntilObjectNotExists(const Model::HeadObjectRequest& request) { using OutcomeT = Model::HeadObjectOutcome; using RequestT = Model::HeadObjectRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("ObjectNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, 404)); diff --git a/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h b/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h index cd4ad9636c7..24144ff6d97 100644 --- a/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h +++ b/generated/src/aws-cpp-sdk-s3/include/aws/s3/S3Waiter.h @@ -23,7 +23,7 @@ class S3Waiter { Aws::Utils::WaiterOutcome WaitUntilBucketExists(const Model::HeadBucketRequest& request) { using OutcomeT = Model::HeadBucketOutcome; using RequestT = Model::HeadBucketRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("BucketExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back( @@ -37,7 +37,7 @@ class S3Waiter { Aws::Utils::WaiterOutcome WaitUntilBucketNotExists(const Model::HeadBucketRequest& request) { using OutcomeT = Model::HeadBucketOutcome; using RequestT = Model::HeadBucketRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("BucketNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, 404)); @@ -49,7 +49,7 @@ class S3Waiter { Aws::Utils::WaiterOutcome WaitUntilObjectExists(const Model::HeadObjectRequest& request) { using OutcomeT = Model::HeadObjectOutcome; using RequestT = Model::HeadObjectRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("ObjectExistsWaiter", Aws::Utils::WaiterState::SUCCESS, false)); acceptors.emplace_back( @@ -63,7 +63,7 @@ class S3Waiter { Aws::Utils::WaiterOutcome WaitUntilObjectNotExists(const Model::HeadObjectRequest& request) { using OutcomeT = Model::HeadObjectOutcome; using RequestT = Model::HeadObjectRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back( Aws::MakeUnique>("ObjectNotExistsWaiter", Aws::Utils::WaiterState::SUCCESS, 404)); diff --git a/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h b/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h index 322371992a7..39432ec6a3e 100644 --- a/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h +++ b/generated/src/aws-cpp-sdk-sagemaker/include/aws/sagemaker/SageMakerWaiter.h @@ -40,7 +40,7 @@ class SageMakerWaiter { Aws::Utils::WaiterOutcome WaitUntilEndpointDeleted(const Model::DescribeEndpointRequest& request) { using OutcomeT = Model::DescribeEndpointOutcome; using RequestT = Model::DescribeEndpointRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("EndpointDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ValidationException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -59,7 +59,7 @@ class SageMakerWaiter { Aws::Utils::WaiterOutcome WaitUntilEndpointInService(const Model::DescribeEndpointRequest& request) { using OutcomeT = Model::DescribeEndpointOutcome; using RequestT = Model::DescribeEndpointRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "EndpointInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InService"), [](const Model::DescribeEndpointOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -85,7 +85,7 @@ class SageMakerWaiter { Aws::Utils::WaiterOutcome WaitUntilImageCreated(const Model::DescribeImageRequest& request) { using OutcomeT = Model::DescribeImageOutcome; using RequestT = Model::DescribeImageRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ImageCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATED"), [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -111,7 +111,7 @@ class SageMakerWaiter { Aws::Utils::WaiterOutcome WaitUntilImageDeleted(const Model::DescribeImageRequest& request) { using OutcomeT = Model::DescribeImageOutcome; using RequestT = Model::DescribeImageRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>("ImageDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -132,7 +132,7 @@ class SageMakerWaiter { Aws::Utils::WaiterOutcome WaitUntilImageUpdated(const Model::DescribeImageRequest& request) { using OutcomeT = Model::DescribeImageOutcome; using RequestT = Model::DescribeImageRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ImageUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATED"), [](const Model::DescribeImageOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -159,7 +159,7 @@ class SageMakerWaiter { const Model::DescribeImageVersionRequest& request) { using OutcomeT = Model::DescribeImageVersionOutcome; using RequestT = Model::DescribeImageVersionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ImageVersionCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATED"), [](const Model::DescribeImageVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -188,7 +188,7 @@ class SageMakerWaiter { const Model::DescribeImageVersionRequest& request) { using OutcomeT = Model::DescribeImageVersionOutcome; using RequestT = Model::DescribeImageVersionRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ImageVersionDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -211,7 +211,7 @@ class SageMakerWaiter { const Model::DescribeNotebookInstanceRequest& request) { using OutcomeT = Model::DescribeNotebookInstanceOutcome; using RequestT = Model::DescribeNotebookInstanceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "NotebookInstanceDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ValidationException"))); acceptors.emplace_back(Aws::MakeUnique>( @@ -232,7 +232,7 @@ class SageMakerWaiter { const Model::DescribeNotebookInstanceRequest& request) { using OutcomeT = Model::DescribeNotebookInstanceOutcome; using RequestT = Model::DescribeNotebookInstanceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "NotebookInstanceInServiceWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("InService"), [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -259,7 +259,7 @@ class SageMakerWaiter { const Model::DescribeNotebookInstanceRequest& request) { using OutcomeT = Model::DescribeNotebookInstanceOutcome; using RequestT = Model::DescribeNotebookInstanceRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "NotebookInstanceStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Stopped"), [](const Model::DescribeNotebookInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -286,7 +286,7 @@ class SageMakerWaiter { const Model::DescribeProcessingJobRequest& request) { using OutcomeT = Model::DescribeProcessingJobOutcome; using RequestT = Model::DescribeProcessingJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ProcessingJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), [](const Model::DescribeProcessingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -323,7 +323,7 @@ class SageMakerWaiter { const Model::DescribeTrainingJobRequest& request) { using OutcomeT = Model::DescribeTrainingJobOutcome; using RequestT = Model::DescribeTrainingJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TrainingJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), [](const Model::DescribeTrainingJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -357,7 +357,7 @@ class SageMakerWaiter { const Model::DescribeTransformJobRequest& request) { using OutcomeT = Model::DescribeTransformJobOutcome; using RequestT = Model::DescribeTransformJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TransformJobCompletedOrStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Completed"), [](const Model::DescribeTransformJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h b/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h index a7f41a914c6..17bf90acef7 100644 --- a/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h +++ b/generated/src/aws-cpp-sdk-schemas/include/aws/schemas/SchemasWaiter.h @@ -23,7 +23,7 @@ class SchemasWaiter { const Model::DescribeCodeBindingRequest& request) { using OutcomeT = Model::DescribeCodeBindingOutcome; using RequestT = Model::DescribeCodeBindingRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "CodeBindingExistsWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"), [](const Model::DescribeCodeBindingOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h b/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h index 39d2c6f5d27..5da88acf1e3 100644 --- a/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h +++ b/generated/src/aws-cpp-sdk-signer/include/aws/signer/SignerWaiter.h @@ -23,7 +23,7 @@ class SignerWaiter { const Model::DescribeSigningJobRequest& request) { using OutcomeT = Model::DescribeSigningJobOutcome; using RequestT = Model::DescribeSigningJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "SuccessfulSigningJobWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("Succeeded"), [](const Model::DescribeSigningJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h b/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h index 338ff2fc528..345e529527b 100644 --- a/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h +++ b/generated/src/aws-cpp-sdk-simpledbv2/include/aws/simpledbv2/SimpleDBv2Waiter.h @@ -22,7 +22,7 @@ class SimpleDBv2Waiter { Aws::Utils::WaiterOutcome WaitUntilExportSucceeded(const Model::GetExportRequest& request) { using OutcomeT = Model::GetExportOutcome; using RequestT = Model::GetExportRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "ExportSucceededWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("SUCCEEDED"), [](const Model::GetExportOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h b/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h index f68026a2c01..74b5359600d 100644 --- a/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h +++ b/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h @@ -22,7 +22,7 @@ class SSMIncidentsWaiter { const Model::GetReplicationSetRequest& request) { using OutcomeT = Model::GetReplicationSetOutcome; using RequestT = Model::GetReplicationSetRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "WaitForReplicationSetActiveWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"), [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -61,7 +61,7 @@ class SSMIncidentsWaiter { const Model::GetReplicationSetRequest& request) { using OutcomeT = Model::GetReplicationSetOutcome; using RequestT = Model::GetReplicationSetRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "WaitForReplicationSetDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); acceptors.emplace_back(Aws::MakeUnique>( diff --git a/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h b/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h index 1e06eef930e..daa183a4701 100644 --- a/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h +++ b/generated/src/aws-cpp-sdk-ssm/include/aws/ssm/SSMWaiter.h @@ -23,7 +23,7 @@ class SSMWaiter { const Model::GetCommandInvocationRequest& request) { using OutcomeT = Model::GetCommandInvocationOutcome; using RequestT = Model::GetCommandInvocationRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "CommandExecutedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("Pending"), [](const Model::GetCommandInvocationOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { diff --git a/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h b/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h index 2af7f090e77..e22dc1277b5 100644 --- a/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h +++ b/generated/src/aws-cpp-sdk-transcribe/include/aws/transcribe/TranscribeServiceWaiter.h @@ -39,7 +39,7 @@ class TranscribeServiceWaiter { const Model::DescribeLanguageModelRequest& request) { using OutcomeT = Model::DescribeLanguageModelOutcome; using RequestT = Model::DescribeLanguageModelRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "LanguageModelCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::DescribeLanguageModelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -64,7 +64,7 @@ class TranscribeServiceWaiter { const Model::GetCallAnalyticsJobRequest& request) { using OutcomeT = Model::GetCallAnalyticsJobOutcome; using RequestT = Model::GetCallAnalyticsJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "CallAnalyticsJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetCallAnalyticsJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -91,7 +91,7 @@ class TranscribeServiceWaiter { const Model::GetMedicalScribeJobRequest& request) { using OutcomeT = Model::GetMedicalScribeJobOutcome; using RequestT = Model::GetMedicalScribeJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "MedicalScribeJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetMedicalScribeJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -118,7 +118,7 @@ class TranscribeServiceWaiter { const Model::GetMedicalTranscriptionJobRequest& request) { using OutcomeT = Model::GetMedicalTranscriptionJobOutcome; using RequestT = Model::GetMedicalTranscriptionJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "MedicalTranscriptionJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetMedicalTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -145,7 +145,7 @@ class TranscribeServiceWaiter { const Model::GetMedicalVocabularyRequest& request) { using OutcomeT = Model::GetMedicalVocabularyOutcome; using RequestT = Model::GetMedicalVocabularyRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "MedicalVocabularyReadyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("READY"), [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -170,7 +170,7 @@ class TranscribeServiceWaiter { const Model::GetTranscriptionJobRequest& request) { using OutcomeT = Model::GetTranscriptionJobOutcome; using RequestT = Model::GetTranscriptionJobRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "TranscriptionJobCompletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetTranscriptionJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { @@ -196,7 +196,7 @@ class TranscribeServiceWaiter { Aws::Utils::WaiterOutcome WaitUntilVocabularyReady(const Model::GetVocabularyRequest& request) { using OutcomeT = Model::GetVocabularyOutcome; using RequestT = Model::GetVocabularyRequest; - std::vector>> acceptors; + Aws::Vector>> acceptors; acceptors.emplace_back(Aws::MakeUnique>( "VocabularyReadyWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("READY"), [](const Model::GetVocabularyOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { From 059a254891e00d242aced7e0a6655b9c7438701f Mon Sep 17 00:00:00 2001 From: sbaluja Date: Wed, 18 Mar 2026 15:36:36 -0400 Subject: [PATCH 18/21] Include handling for smithy 1.0 enum modeling (string shape with enum trait) --- .../include/aws/amp/PrometheusServiceWaiter.h | 23 ++- .../aws/cloudcontrol/CloudControlApiWaiter.h | 10 +- .../include/aws/omics/OmicsWaiter.h | 190 ++++++++++-------- .../include/aws/proton/ProtonWaiter.h | 68 ++++--- .../aws/ssm-incidents/SSMIncidentsWaiter.h | 19 +- .../waiters/jmespath/EnumResolver.java | 10 +- 6 files changed, 191 insertions(+), 129 deletions(-) diff --git a/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h b/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h index 1da690fff10..8b233a71452 100644 --- a/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h +++ b/generated/src/aws-cpp-sdk-amp/include/aws/amp/PrometheusServiceWaiter.h @@ -12,6 +12,8 @@ #include #include #include +#include +#include #include #include @@ -88,14 +90,16 @@ class PrometheusServiceWaiter { [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); + return Model::ScraperStatusCodeMapper::GetNameForScraperStatusCode(result.GetScraper().GetStatus().GetStatusCode()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ScraperActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATION_FAILED"), [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); + return Model::ScraperStatusCodeMapper::GetNameForScraperStatusCode(result.GetScraper().GetStatus().GetStatusCode()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeScraper(req); }; @@ -114,7 +118,8 @@ class PrometheusServiceWaiter { [](const Model::DescribeScraperOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetScraper().GetStatus().GetStatusCode() == expected.get(); + return Model::ScraperStatusCodeMapper::GetNameForScraperStatusCode(result.GetScraper().GetStatus().GetStatusCode()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeScraper(req); }; @@ -131,21 +136,24 @@ class PrometheusServiceWaiter { [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + return Model::WorkspaceStatusCodeMapper::GetNameForWorkspaceStatusCode(result.GetWorkspace().GetStatus().GetStatusCode()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WorkspaceActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + return Model::WorkspaceStatusCodeMapper::GetNameForWorkspaceStatusCode(result.GetWorkspace().GetStatus().GetStatusCode()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WorkspaceActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + return Model::WorkspaceStatusCodeMapper::GetNameForWorkspaceStatusCode(result.GetWorkspace().GetStatus().GetStatusCode()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeWorkspace(req); }; @@ -164,7 +172,8 @@ class PrometheusServiceWaiter { [](const Model::DescribeWorkspaceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetWorkspace().GetStatus().GetStatusCode() == expected.get(); + return Model::WorkspaceStatusCodeMapper::GetNameForWorkspaceStatusCode(result.GetWorkspace().GetStatus().GetStatusCode()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeWorkspace(req); }; diff --git a/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h b/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h index e1bf71f6c4b..44f862771b2 100644 --- a/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h +++ b/generated/src/aws-cpp-sdk-cloudcontrol/include/aws/cloudcontrol/CloudControlApiWaiter.h @@ -7,6 +7,7 @@ #include #include #include +#include #include #include @@ -28,21 +29,24 @@ class CloudControlApiWaiter { [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetProgressEvent().GetOperationStatus() == expected.get(); + return Model::OperationStatusMapper::GetNameForOperationStatus(result.GetProgressEvent().GetOperationStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ResourceRequestSuccessWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetProgressEvent().GetOperationStatus() == expected.get(); + return Model::OperationStatusMapper::GetNameForOperationStatus(result.GetProgressEvent().GetOperationStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ResourceRequestSuccessWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCEL_COMPLETE"), [](const Model::GetResourceRequestStatusOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetProgressEvent().GetOperationStatus() == expected.get(); + return Model::OperationStatusMapper::GetNameForOperationStatus(result.GetProgressEvent().GetOperationStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetResourceRequestStatus(req); }; diff --git a/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h b/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h index 256145c062c..c99bb5e77f6 100644 --- a/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h +++ b/generated/src/aws-cpp-sdk-omics/include/aws/omics/OmicsWaiter.h @@ -33,6 +33,16 @@ #include #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include @@ -52,35 +62,35 @@ class OmicsWaiter { [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationImportJobCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationImportJobCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationImportJobCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CANCELLED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationImportJobCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetAnnotationImportJob(req); }; @@ -98,28 +108,28 @@ class OmicsWaiter { [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetAnnotationStore(req); }; @@ -137,7 +147,7 @@ class OmicsWaiter { [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::StoreStatusMapper::GetNameForStoreStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); @@ -146,7 +156,7 @@ class OmicsWaiter { [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::StoreStatusMapper::GetNameForStoreStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetAnnotationStore(req); }; @@ -164,28 +174,28 @@ class OmicsWaiter { [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreVersionCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreVersionCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreVersionCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetAnnotationStoreVersion(req); }; @@ -203,7 +213,7 @@ class OmicsWaiter { [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::StoreStatusMapper::GetNameForStoreStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "AnnotationStoreVersionDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); @@ -212,7 +222,7 @@ class OmicsWaiter { [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::StoreStatusMapper::GetNameForStoreStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetAnnotationStoreVersion(req); }; @@ -230,49 +240,51 @@ class OmicsWaiter { [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CANCELLING"), [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::ReferenceImportJobStatusMapper::GetNameForReferenceImportJobStatus(result.GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetActivationJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("COMPLETED_WITH_FAILURES"), [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::ReferenceImportJobStatusMapper::GetNameForReferenceImportJobStatus(result.GetStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetReadSetActivationJob(req); }; @@ -290,49 +302,51 @@ class OmicsWaiter { [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CANCELLING"), [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::ReferenceImportJobStatusMapper::GetNameForReferenceImportJobStatus(result.GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetExportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("COMPLETED_WITH_FAILURES"), [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::ReferenceImportJobStatusMapper::GetNameForReferenceImportJobStatus(result.GetStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetReadSetExportJob(req); }; @@ -350,49 +364,51 @@ class OmicsWaiter { [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CANCELLING"), [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::ReferenceImportJobStatusMapper::GetNameForReferenceImportJobStatus(result.GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReadSetImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("COMPLETED_WITH_FAILURES"), [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::ReferenceImportJobStatusMapper::GetNameForReferenceImportJobStatus(result.GetStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetReadSetImportJob(req); }; @@ -410,49 +426,51 @@ class OmicsWaiter { [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("SUBMITTED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CANCELLING"), [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::ReferenceImportJobStatusMapper::GetNameForReferenceImportJobStatus(result.GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ReferenceImportJobCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("COMPLETED_WITH_FAILURES"), [](const Model::GetReferenceImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::ReferenceImportJobStatusMapper::GetNameForReferenceImportJobStatus(result.GetStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetReferenceImportJob(req); }; @@ -469,35 +487,35 @@ class OmicsWaiter { [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "RunRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "RunRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "RunRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "RunRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetRun(req); }; @@ -514,42 +532,42 @@ class OmicsWaiter { [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "RunCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "RunCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "RunCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("RUNNING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "RunCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "RunCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetRun(req); }; @@ -566,35 +584,35 @@ class OmicsWaiter { [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "TaskRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "TaskRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "TaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "TaskRunningWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CANCELLED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetRunTask(req); }; @@ -611,42 +629,42 @@ class OmicsWaiter { [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "TaskCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "TaskCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "TaskCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("RUNNING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "TaskCompletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"), [](const Model::GetRunTaskOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::TaskStatusMapper::GetNameForTaskStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "TaskCompletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetRunTask(req); }; @@ -664,35 +682,35 @@ class OmicsWaiter { [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "VariantImportJobCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("IN_PROGRESS"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "VariantImportJobCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "VariantImportJobCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CANCELLED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "VariantImportJobCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("COMPLETED"), [](const Model::GetVariantImportJobOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::JobStatusMapper::GetNameForJobStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetVariantImportJob(req); }; @@ -709,28 +727,28 @@ class OmicsWaiter { [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "VariantStoreCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "VariantStoreCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "VariantStoreCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetVariantStore(req); }; @@ -747,7 +765,7 @@ class OmicsWaiter { [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::StoreStatusMapper::GetNameForStoreStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "VariantStoreDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ResourceNotFoundException"))); @@ -756,7 +774,7 @@ class OmicsWaiter { [](const Model::GetVariantStoreOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::StoreStatusMapper::GetNameForStoreStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetVariantStore(req); }; @@ -773,28 +791,28 @@ class OmicsWaiter { [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WorkflowActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WorkflowActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WorkflowActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetWorkflow(req); }; @@ -812,28 +830,28 @@ class OmicsWaiter { [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WorkflowVersionActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WorkflowVersionActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WorkflowVersionActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetWorkflowVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetStatus() == expected.get(); + return Model::WorkflowStatusMapper::GetNameForWorkflowStatus(result.GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetWorkflowVersion(req); }; diff --git a/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h b/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h index 6be9ce7f60e..13001aff9e7 100644 --- a/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h +++ b/generated/src/aws-cpp-sdk-proton/include/aws/proton/ProtonWaiter.h @@ -7,6 +7,7 @@ #include #include #include +#include #include #include #include @@ -19,6 +20,8 @@ #include #include #include +#include +#include #include @@ -37,14 +40,16 @@ class ProtonWaiter { [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetComponent().GetDeploymentStatus() == expected.get(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetComponent().GetDeploymentStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ComponentDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetComponent().GetDeploymentStatus() == expected.get(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetComponent().GetDeploymentStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetComponent(req); }; @@ -63,7 +68,8 @@ class ProtonWaiter { [](const Model::GetComponentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetComponent().GetDeploymentStatus() == expected.get(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetComponent().GetDeploymentStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetComponent(req); }; @@ -80,14 +86,16 @@ class ProtonWaiter { [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetEnvironment().GetDeploymentStatus() == expected.get(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetEnvironment().GetDeploymentStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "EnvironmentDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetEnvironmentOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetEnvironment().GetDeploymentStatus() == expected.get(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetEnvironment().GetDeploymentStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetEnvironment(req); }; @@ -105,21 +113,24 @@ class ProtonWaiter { [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); + return Model::TemplateVersionStatusMapper::GetNameForTemplateVersionStatus(result.GetEnvironmentTemplateVersion().GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "EnvironmentTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("PUBLISHED"), [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); + return Model::TemplateVersionStatusMapper::GetNameForTemplateVersionStatus(result.GetEnvironmentTemplateVersion().GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "EnvironmentTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REGISTRATION_FAILED"), [](const Model::GetEnvironmentTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetEnvironmentTemplateVersion().GetStatus() == expected.get(); + return Model::TemplateVersionStatusMapper::GetNameForTemplateVersionStatus(result.GetEnvironmentTemplateVersion().GetStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetEnvironmentTemplateVersion(req); }; @@ -136,28 +147,28 @@ class ProtonWaiter { [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); + return Model::ServiceStatusMapper::GetNameForServiceStatus(result.GetService().GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ServiceCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED_CLEANUP_COMPLETE"), [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); + return Model::ServiceStatusMapper::GetNameForServiceStatus(result.GetService().GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ServiceCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED_CLEANUP_FAILED"), [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); + return Model::ServiceStatusMapper::GetNameForServiceStatus(result.GetService().GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ServiceCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"), [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); + return Model::ServiceStatusMapper::GetNameForServiceStatus(result.GetService().GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetService(req); }; @@ -174,35 +185,35 @@ class ProtonWaiter { [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); + return Model::ServiceStatusMapper::GetNameForServiceStatus(result.GetService().GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ServiceUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED_CLEANUP_COMPLETE"), [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); + return Model::ServiceStatusMapper::GetNameForServiceStatus(result.GetService().GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ServiceUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED_CLEANUP_FAILED"), [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); + return Model::ServiceStatusMapper::GetNameForServiceStatus(result.GetService().GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ServiceUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"), [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); + return Model::ServiceStatusMapper::GetNameForServiceStatus(result.GetService().GetStatus()) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ServiceUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_COMPLETE_CLEANUP_FAILED"), [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); + return Model::ServiceStatusMapper::GetNameForServiceStatus(result.GetService().GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetService(req); }; @@ -221,7 +232,7 @@ class ProtonWaiter { [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetStatus() == expected.get(); + return Model::ServiceStatusMapper::GetNameForServiceStatus(result.GetService().GetStatus()) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetService(req); }; @@ -238,14 +249,16 @@ class ProtonWaiter { [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetPipeline().GetDeploymentStatus() == expected.get(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetService().GetPipeline().GetDeploymentStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ServicePipelineDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetServiceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetService().GetPipeline().GetDeploymentStatus() == expected.get(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetService().GetPipeline().GetDeploymentStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetService(req); }; @@ -263,14 +276,16 @@ class ProtonWaiter { [](const Model::GetServiceInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetServiceInstance().GetDeploymentStatus() == expected.get(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetServiceInstance().GetDeploymentStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ServiceInstanceDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetServiceInstanceOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetServiceInstance().GetDeploymentStatus() == expected.get(); + return Model::DeploymentStatusMapper::GetNameForDeploymentStatus(result.GetServiceInstance().GetDeploymentStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetServiceInstance(req); }; @@ -288,21 +303,24 @@ class ProtonWaiter { [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetServiceTemplateVersion().GetStatus() == expected.get(); + return Model::TemplateVersionStatusMapper::GetNameForTemplateVersionStatus(result.GetServiceTemplateVersion().GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ServiceTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("PUBLISHED"), [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetServiceTemplateVersion().GetStatus() == expected.get(); + return Model::TemplateVersionStatusMapper::GetNameForTemplateVersionStatus(result.GetServiceTemplateVersion().GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "ServiceTemplateVersionRegisteredWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REGISTRATION_FAILED"), [](const Model::GetServiceTemplateVersionOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetServiceTemplateVersion().GetStatus() == expected.get(); + return Model::TemplateVersionStatusMapper::GetNameForTemplateVersionStatus(result.GetServiceTemplateVersion().GetStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetServiceTemplateVersion(req); }; diff --git a/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h b/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h index 74b5359600d..499448fc866 100644 --- a/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h +++ b/generated/src/aws-cpp-sdk-ssm-incidents/include/aws/ssm-incidents/SSMIncidentsWaiter.h @@ -9,6 +9,7 @@ #include #include #include +#include #include @@ -28,28 +29,32 @@ class SSMIncidentsWaiter { [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); + return Model::ReplicationSetStatusMapper::GetNameForReplicationSetStatus(result.GetReplicationSet().GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WaitForReplicationSetActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"), [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); + return Model::ReplicationSetStatusMapper::GetNameForReplicationSetStatus(result.GetReplicationSet().GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WaitForReplicationSetActiveWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATING"), [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); + return Model::ReplicationSetStatusMapper::GetNameForReplicationSetStatus(result.GetReplicationSet().GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WaitForReplicationSetActiveWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); + return Model::ReplicationSetStatusMapper::GetNameForReplicationSetStatus(result.GetReplicationSet().GetStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetReplicationSet(req); }; @@ -69,14 +74,16 @@ class SSMIncidentsWaiter { [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); + return Model::ReplicationSetStatusMapper::GetNameForReplicationSetStatus(result.GetReplicationSet().GetStatus()) == + expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "WaitForReplicationSetDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), [](const Model::GetReplicationSetOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return result.GetReplicationSet().GetStatus() == expected.get(); + return Model::ReplicationSetStatusMapper::GetNameForReplicationSetStatus(result.GetReplicationSet().GetStatus()) == + expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->GetReplicationSet(req); }; diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java index d6cfce69762..48831ad8daf 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java @@ -14,6 +14,7 @@ import software.amazon.smithy.model.Model; import software.amazon.smithy.model.shapes.OperationShape; import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.traits.EnumTrait; /** * Walks the Smithy model along the JmesPath field path to determine if the leaf @@ -30,8 +31,13 @@ public static EnumInfo resolveEnumInfo(JmespathExpression expr, Model model, Ope if (model == null || operation == null) return null; Shape current = model.expectShape(operation.getOutputShape()); current = walkExpression(expr, current, model); - if (current != null && current.isEnumShape()) { - return new EnumInfo(current.getId().getName()); + if (current != null) { + if (current.isEnumShape()) { + return new EnumInfo(current.getId().getName()); + } + if (current.isStringShape() && current.hasTrait(EnumTrait.class)) { + return new EnumInfo(current.getId().getName()); + } } return null; } From 62eddc4b7b7190d5346edfa0b8e54cbe14dfaa38 Mon Sep 17 00:00:00 2001 From: sbaluja Date: Wed, 18 Mar 2026 22:07:49 -0400 Subject: [PATCH 19/21] Resolve cpp type from FilterPredicateEmitter for inner types instead of auto --- .../CollectionElementTypeResolver.java | 26 +++++++++++----- .../waiters/jmespath/EnumResolver.java | 3 ++ .../jmespath/FilterOperandEmitter.java | 27 +++++++++++++--- .../jmespath/FilterPredicateEmitter.java | 18 ++++++++--- .../waiters/jmespath/TopLevelVisitor.java | 31 +++++++++++++------ 5 files changed, 79 insertions(+), 26 deletions(-) diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java index d2bce09f20b..4300e5412b9 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/CollectionElementTypeResolver.java @@ -40,18 +40,28 @@ public static String resolve(JmespathExpression expr, Model model, OperationShap public static String resolveFromShape(JmespathExpression expr, Shape current, Model model, String smithyServiceName) { if (model == null || current == null) return "auto"; - return findFirstListElement(expr, current, model) + return resolveElementShape(expr, current, model) .filter(Shape::isStructureShape) - .map(element -> { - String shapeName = element.getId().getName(); - if ("ec2".equals(smithyServiceName) && shapeName.endsWith("Result")) { - shapeName = shapeName.substring(0, shapeName.length() - 6) + "Response"; - } - return "Model::" + shapeName; - }) + .map(element -> shapeToTypeName(element, smithyServiceName)) .orElse("auto"); } + /** + * Resolve the element Shape of the first list encountered in the expression. + */ + public static Optional resolveElementShape(JmespathExpression expr, Shape current, Model model) { + if (model == null || current == null) return Optional.empty(); + return findFirstListElement(expr, current, model); + } + + static String shapeToTypeName(Shape element, String smithyServiceName) { + String shapeName = element.getId().getName(); + if ("ec2".equals(smithyServiceName) && shapeName.endsWith("Result")) { + shapeName = shapeName.substring(0, shapeName.length() - 6) + "Response"; + } + return "Model::" + shapeName; + } + /** * Finds the element shape of the first list encountered when walking the projection's * collection path (the left side of the projection). diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java index 48831ad8daf..161eea41bc5 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java @@ -79,6 +79,9 @@ private static Shape walkProjectionLeft(JmespathExpression expr, Shape current, if (current == null) return null; if (expr instanceof FieldExpression) { return resolveMemberTarget(current, ((FieldExpression) expr).getName(), model); + } else if (expr instanceof Subexpression) { + Shape left = walkExpression(((Subexpression) expr).getLeft(), current, model); + return walkProjectionLeft(((Subexpression) expr).getRight(), left, model); } else if (expr instanceof FlattenExpression) { JmespathExpression inner = ((FlattenExpression) expr).getExpression(); if (inner instanceof ProjectionExpression) { diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java index d6fbad9e382..e9f7a19f5fc 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java @@ -6,13 +6,17 @@ import com.amazonaws.util.awsclientsmithygenerator.generators.ServiceNameUtil; import software.amazon.smithy.jmespath.JmespathExpression; +import software.amazon.smithy.jmespath.ast.CurrentExpression; import software.amazon.smithy.jmespath.ast.FieldExpression; import software.amazon.smithy.jmespath.ast.FilterProjectionExpression; +import software.amazon.smithy.jmespath.ast.FlattenExpression; import software.amazon.smithy.jmespath.ast.FunctionExpression; import software.amazon.smithy.jmespath.ast.LiteralExpression; +import software.amazon.smithy.jmespath.ast.ProjectionExpression; import software.amazon.smithy.jmespath.ast.Subexpression; import software.amazon.smithy.model.Model; import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.Shape; /** * Emits operands within a filter predicate — fields resolve relative to the item, @@ -22,15 +26,20 @@ public class FilterOperandEmitter extends UnsupportedExpressionVisitor { private final String itemVar; private final Model model; private final OperationShape operation; + private final Shape itemShape; + private final String smithyServiceName; FilterOperandEmitter(String itemVar) { - this(itemVar, null, null); + this(itemVar, null, null, null, null); } - FilterOperandEmitter(String itemVar, Model model, OperationShape operation) { + FilterOperandEmitter(String itemVar, Model model, OperationShape operation, + Shape itemShape, String smithyServiceName) { this.itemVar = itemVar; this.model = model; this.operation = operation; + this.itemShape = itemShape; + this.smithyServiceName = smithyServiceName; } @Override @@ -66,10 +75,18 @@ public String visitFunction(FunctionExpression expression) { private String emitItemCountIf(FilterProjectionExpression filterExpr) { String collection = itemVar + filterExpr.getLeft().accept(new CollectionGetterEmitter()); + String innerElementType = resolveInnerElementType(filterExpr.getLeft()); String predicate = filterExpr.getComparison().accept(new FilterPredicateEmitter("inner")); - // For nested count_if inside a filter, the collection is relative to the item, - // so type resolution would need the item's shape context. Fall back to auto for now. return "std::count_if(" + collection + ".begin(), " + collection + ".end(), " - + "[](const auto& inner) { return " + predicate + "; })"; + + "[](const " + innerElementType + "& inner) { return " + predicate + "; })"; + } + + private String resolveInnerElementType(JmespathExpression collectionExpr) { + if (model == null || itemShape == null) return "auto"; + // Wrap the field as a projection to use CollectionElementTypeResolver + JmespathExpression syntheticProj = new ProjectionExpression( + new FlattenExpression(collectionExpr), new CurrentExpression()); + return CollectionElementTypeResolver.resolveFromShape( + syntheticProj, itemShape, model, smithyServiceName); } } diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterPredicateEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterPredicateEmitter.java index 9ee7b82ddf9..24b496baf00 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterPredicateEmitter.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterPredicateEmitter.java @@ -4,12 +4,12 @@ */ package com.amazonaws.util.awsclientsmithygenerator.generators.waiters.jmespath; -import com.amazonaws.util.awsclientsmithygenerator.generators.ServiceNameUtil; -import software.amazon.smithy.jmespath.JmespathExpression; import software.amazon.smithy.jmespath.ast.AndExpression; import software.amazon.smithy.jmespath.ast.ComparatorExpression; import software.amazon.smithy.jmespath.ast.NotExpression; import software.amazon.smithy.jmespath.ast.OrExpression; +import software.amazon.smithy.model.Model; +import software.amazon.smithy.model.shapes.Shape; /** * Emits a boolean predicate for use inside a filter projection lambda. @@ -17,9 +17,19 @@ */ public class FilterPredicateEmitter extends UnsupportedExpressionVisitor { private final String itemVar; + private final Model model; + private final Shape itemShape; + private final String smithyServiceName; FilterPredicateEmitter(String itemVar) { + this(itemVar, null, null, null); + } + + FilterPredicateEmitter(String itemVar, Model model, Shape itemShape, String smithyServiceName) { this.itemVar = itemVar; + this.model = model; + this.itemShape = itemShape; + this.smithyServiceName = smithyServiceName; } @Override @@ -44,8 +54,8 @@ public String visitAnd(AndExpression expression) { @Override public String visitComparator(ComparatorExpression expression) { - String left = expression.getLeft().accept(new FilterOperandEmitter(itemVar)); - String right = expression.getRight().accept(new FilterOperandEmitter(itemVar)); + String left = expression.getLeft().accept(new FilterOperandEmitter(itemVar, model, null, itemShape, smithyServiceName)); + String right = expression.getRight().accept(new FilterOperandEmitter(itemVar, model, null, itemShape, smithyServiceName)); String op; switch (expression.getComparator()) { diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/TopLevelVisitor.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/TopLevelVisitor.java index 1858ad4fc6a..0a4695e633f 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/TopLevelVisitor.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/TopLevelVisitor.java @@ -17,6 +17,7 @@ import software.amazon.smithy.jmespath.ast.Subexpression; import software.amazon.smithy.model.Model; import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.Shape; import software.amazon.smithy.waiters.PathComparator; import java.util.Set; @@ -115,7 +116,11 @@ private String emitContains(FunctionExpression expression) { } String collection = "result" + info.collectionGetter; - String condition = info.comparator.accept(new FilterPredicateEmitter("item")); + + // Resolve the item shape for the outer collection so inner lambdas get concrete types + Shape itemShape = resolveContainsItemShape(collectionArg); + String condition = info.comparator.accept( + new FilterPredicateEmitter("item", model, itemShape, smithyServiceName)); if (searchForFalse) { condition = "!" + condition; } @@ -166,16 +171,24 @@ private ContainsProjectionInfo extractContainsProjection(JmespathExpression expr * Resolves the element type for the collection in a contains() expression. */ private String resolveContainsElementType(JmespathExpression collectionArg) { - if (model == null || operation == null) return "auto"; - // collectionArg is: Projection(Flatten(Projection(Flatten(Field), MultiSelectList)), Current) - // The actual collection is accessed via the inner projection's left side. - if (!(collectionArg instanceof ProjectionExpression)) return "auto"; + Shape itemShape = resolveContainsItemShape(collectionArg); + if (itemShape == null || !itemShape.isStructureShape()) return "auto"; + return CollectionElementTypeResolver.shapeToTypeName(itemShape, smithyServiceName); + } + + /** + * Resolves the element Shape for the outer collection in a contains() expression. + */ + private Shape resolveContainsItemShape(JmespathExpression collectionArg) { + if (model == null || operation == null) return null; + if (!(collectionArg instanceof ProjectionExpression)) return null; JmespathExpression outerLeft = ((ProjectionExpression) collectionArg).getLeft(); - if (!(outerLeft instanceof FlattenExpression)) return "auto"; + if (!(outerLeft instanceof FlattenExpression)) return null; JmespathExpression innerExpr = ((FlattenExpression) outerLeft).getExpression(); - if (!(innerExpr instanceof ProjectionExpression)) return "auto"; - // Resolve element type of the inner projection - return CollectionElementTypeResolver.resolve(innerExpr, model, operation, smithyServiceName); + if (!(innerExpr instanceof ProjectionExpression)) return null; + Shape outputShape = model.expectShape(operation.getOutputShape()); + return CollectionElementTypeResolver.resolveElementShape( + innerExpr, outputShape, model).orElse(null); } private String emitPathCode(JmespathExpression expr) { From 7de1e7907dd06453e56159cc097484ab3e97f14b Mon Sep 17 00:00:00 2001 From: sbaluja Date: Wed, 18 Mar 2026 22:07:57 -0400 Subject: [PATCH 20/21] Updated waiters --- .../include/aws/acm/ACMWaiter.h | 17 ++++++++----- .../aws/autoscaling/AutoScalingWaiter.h | 24 +++++++++---------- .../include/aws/ds/DirectoryServiceWaiter.h | 11 +++++---- 3 files changed, 30 insertions(+), 22 deletions(-) diff --git a/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h b/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h index 301611ea5e8..f3d69cc8577 100644 --- a/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h +++ b/generated/src/aws-cpp-sdk-acm/include/aws/acm/ACMWaiter.h @@ -8,6 +8,7 @@ #include #include #include +#include #include #include @@ -29,18 +30,22 @@ class ACMWaiter { [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return std::all_of( - result.GetCertificate().GetDomainValidationOptions().begin(), result.GetCertificate().GetDomainValidationOptions().end(), - [&](const Model::DomainValidation& item) { return item.GetValidationStatus() == expected.get(); }); + return std::all_of(result.GetCertificate().GetDomainValidationOptions().begin(), + result.GetCertificate().GetDomainValidationOptions().end(), [&](const Model::DomainValidation& item) { + return Model::DomainStatusMapper::GetNameForDomainStatus(item.GetValidationStatus()) == + expected.get(); + }); })); acceptors.emplace_back(Aws::MakeUnique>( "CertificateValidatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("PENDING_VALIDATION"), [](const Model::DescribeCertificateOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return std::any_of( - result.GetCertificate().GetDomainValidationOptions().begin(), result.GetCertificate().GetDomainValidationOptions().end(), - [&](const Model::DomainValidation& item) { return item.GetValidationStatus() == expected.get(); }); + return std::any_of(result.GetCertificate().GetDomainValidationOptions().begin(), + result.GetCertificate().GetDomainValidationOptions().end(), [&](const Model::DomainValidation& item) { + return Model::DomainStatusMapper::GetNameForDomainStatus(item.GetValidationStatus()) == + expected.get(); + }); })); acceptors.emplace_back(Aws::MakeUnique>( "CertificateValidatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("FAILED"), diff --git a/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h index 77bd512cd48..6ffb4e90e82 100644 --- a/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h +++ b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h @@ -53,24 +53,24 @@ class AutoScalingWaiter { [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return std::any_of(result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), - [](const Model::AutoScalingGroup& item) { - return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const auto& inner) { - return (inner.GetLifecycleState() == "InService"); - }) >= item.GetMinSize()); - }) == expected.get(); + return std::any_of( + result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), [](const Model::AutoScalingGroup& item) { + return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const Model::Instance& inner) { + return (inner.GetLifecycleState() == "InService"); + }) >= item.GetMinSize()); + }) == expected.get(); })); acceptors.emplace_back(Aws::MakeUnique>( "GroupInServiceWaiter", Aws::Utils::WaiterState::RETRY, true, [](const Model::DescribeAutoScalingGroupsOutcome& outcome, const Aws::Utils::ExpectedValue& expected) { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); - return std::any_of(result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), - [](const Model::AutoScalingGroup& item) { - return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const auto& inner) { - return (inner.GetLifecycleState() == "InService"); - }) >= item.GetMinSize()); - }) == expected.get(); + return std::any_of( + result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), [](const Model::AutoScalingGroup& item) { + return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const Model::Instance& inner) { + return (inner.GetLifecycleState() == "InService"); + }) >= item.GetMinSize()); + }) == expected.get(); })); auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeAutoScalingGroups(req); }; diff --git a/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h b/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h index 9cc087e4676..6be9c4f9c6e 100644 --- a/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h +++ b/generated/src/aws-cpp-sdk-ds/include/aws/ds/DirectoryServiceWaiter.h @@ -9,6 +9,7 @@ #include #include #include +#include #include @@ -29,8 +30,9 @@ class DirectoryServiceWaiter { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); return std::all_of(result.GetUpdateActivities().GetSelfManagedInstances().begin(), - result.GetUpdateActivities().GetSelfManagedInstances().end(), - [&](const Model::HybridUpdateInfoEntry& item) { return item.GetStatus() == expected.get(); }); + result.GetUpdateActivities().GetSelfManagedInstances().end(), [&](const Model::HybridUpdateInfoEntry& item) { + return Model::UpdateStatusMapper::GetNameForUpdateStatus(item.GetStatus()) == expected.get(); + }); })); acceptors.emplace_back(Aws::MakeUnique>( "HybridADUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UpdateFailed"), @@ -38,8 +40,9 @@ class DirectoryServiceWaiter { if (!outcome.IsSuccess()) return false; const auto& result = outcome.GetResult(); return std::any_of(result.GetUpdateActivities().GetSelfManagedInstances().begin(), - result.GetUpdateActivities().GetSelfManagedInstances().end(), - [&](const Model::HybridUpdateInfoEntry& item) { return item.GetStatus() == expected.get(); }); + result.GetUpdateActivities().GetSelfManagedInstances().end(), [&](const Model::HybridUpdateInfoEntry& item) { + return Model::UpdateStatusMapper::GetNameForUpdateStatus(item.GetStatus()) == expected.get(); + }); })); auto operation = [this](const RequestT& req) { return static_cast(this)->DescribeHybridADUpdate(req); }; From add6ebca44a43055484b8e9d8ff98cbf9762ce1e Mon Sep 17 00:00:00 2001 From: sbaluja Date: Thu, 19 Mar 2026 00:44:36 -0400 Subject: [PATCH 21/21] Resolve enum for filterOperandEmitter paths --- .../aws/autoscaling/AutoScalingWaiter.h | 4 +-- .../include/aws/dynamodb/DynamoDBWaiter.h | 5 +++- .../waiters/jmespath/EnumResolver.java | 13 ++++++++-- .../jmespath/FilterOperandEmitter.java | 25 +++++++++++++++++-- .../waiters/jmespath/ScalarEmitter.java | 13 +++++++++- 5 files changed, 52 insertions(+), 8 deletions(-) diff --git a/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h index 6ffb4e90e82..0ad13d3108b 100644 --- a/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h +++ b/generated/src/aws-cpp-sdk-autoscaling/include/aws/autoscaling/AutoScalingWaiter.h @@ -56,7 +56,7 @@ class AutoScalingWaiter { return std::any_of( result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), [](const Model::AutoScalingGroup& item) { return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const Model::Instance& inner) { - return (inner.GetLifecycleState() == "InService"); + return (Model::LifecycleStateMapper::GetNameForLifecycleState(inner.GetLifecycleState()) == "InService"); }) >= item.GetMinSize()); }) == expected.get(); })); @@ -68,7 +68,7 @@ class AutoScalingWaiter { return std::any_of( result.GetAutoScalingGroups().begin(), result.GetAutoScalingGroups().end(), [](const Model::AutoScalingGroup& item) { return !(std::count_if(item.GetInstances().begin(), item.GetInstances().end(), [](const Model::Instance& inner) { - return (inner.GetLifecycleState() == "InService"); + return (Model::LifecycleStateMapper::GetNameForLifecycleState(inner.GetLifecycleState()) == "InService"); }) >= item.GetMinSize()); }) == expected.get(); })); diff --git a/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h b/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h index 88a79cbecdf..ded4d005463 100644 --- a/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h +++ b/generated/src/aws-cpp-sdk-dynamodb/include/aws/dynamodb/DynamoDBWaiter.h @@ -142,7 +142,10 @@ class DynamoDBWaiter { return ((result.GetKinesisDataStreamDestinations().size() > 0) && (std::count_if(result.GetKinesisDataStreamDestinations().begin(), result.GetKinesisDataStreamDestinations().end(), [](const Model::KinesisDataStreamDestination& item) { - return ((item.GetDestinationStatus() == "DISABLED") || (item.GetDestinationStatus() == "ENABLE_FAILED")); + return ((Model::DestinationStatusMapper::GetNameForDestinationStatus(item.GetDestinationStatus()) == + "DISABLED") || + (Model::DestinationStatusMapper::GetNameForDestinationStatus(item.GetDestinationStatus()) == + "ENABLE_FAILED")); }) == result.GetKinesisDataStreamDestinations().size())) == expected.get(); })); diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java index 161eea41bc5..70b712d0e3d 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/EnumResolver.java @@ -24,13 +24,22 @@ */ public class EnumResolver { /** - * Walk the model from the output shape along the expression's field path. + * Walk the model from the outputx shape along the expression's field path. * Returns EnumInfo if the leaf is an enum, null otherwise. */ public static EnumInfo resolveEnumInfo(JmespathExpression expr, Model model, OperationShape operation) { if (model == null || operation == null) return null; Shape current = model.expectShape(operation.getOutputShape()); - current = walkExpression(expr, current, model); + return resolveEnumInfo(expr, model, current); + } + + /** + * Resolve enum info from a field expression starting from a specific shape. + * Used for filter predicates where we know the item shape. + */ + public static EnumInfo resolveEnumInfo(JmespathExpression expr, Model model, Shape itemShape) { + if (model == null || itemShape == null) return null; + Shape current = walkExpression(expr, itemShape, model); if (current != null) { if (current.isEnumShape()) { return new EnumInfo(current.getId().getName()); diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java index e9f7a19f5fc..cc9abd09294 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/FilterOperandEmitter.java @@ -17,6 +17,7 @@ import software.amazon.smithy.model.Model; import software.amazon.smithy.model.shapes.OperationShape; import software.amazon.smithy.model.shapes.Shape; +import software.amazon.smithy.model.shapes.StructureShape; /** * Emits operands within a filter predicate — fields resolve relative to the item, @@ -44,7 +45,17 @@ public class FilterOperandEmitter extends UnsupportedExpressionVisitor { @Override public String visitField(FieldExpression expression) { - return itemVar + ".Get" + ServiceNameUtil.capitalize(expression.getName()) + "()"; + String fieldAccess = itemVar + ".Get" + ServiceNameUtil.capitalize(expression.getName()) + "()"; + + // Check if this field is an enum and wrap with enum mapper if needed + if (model != null && itemShape != null) { + EnumInfo enumInfo = EnumResolver.resolveEnumInfo(expression, model, itemShape); + if (enumInfo != null) { + return enumInfo.wrapAccess(fieldAccess); + } + } + + return fieldAccess; } @Override @@ -76,7 +87,17 @@ public String visitFunction(FunctionExpression expression) { private String emitItemCountIf(FilterProjectionExpression filterExpr) { String collection = itemVar + filterExpr.getLeft().accept(new CollectionGetterEmitter()); String innerElementType = resolveInnerElementType(filterExpr.getLeft()); - String predicate = filterExpr.getComparison().accept(new FilterPredicateEmitter("inner")); + + // Resolve the inner element shape for enum handling + Shape innerElementShape = null; + if (model != null && itemShape != null) { + innerElementShape = CollectionElementTypeResolver.resolveElementShape( + new ProjectionExpression(new FlattenExpression(filterExpr.getLeft()), new CurrentExpression()), + itemShape, model).orElse(null); + } + + String predicate = filterExpr.getComparison().accept( + new FilterPredicateEmitter("inner", model, innerElementShape, smithyServiceName)); return "std::count_if(" + collection + ".begin(), " + collection + ".end(), " + "[](const " + innerElementType + "& inner) { return " + predicate + "; })"; } diff --git a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ScalarEmitter.java b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ScalarEmitter.java index 68a1f566696..32c382e9bb9 100644 --- a/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ScalarEmitter.java +++ b/tools/code-generation/smithy/cpp-codegen/smithy-cpp-codegen/src/main/java/com/amazonaws/util/awsclientsmithygenerator/generators/waiters/jmespath/ScalarEmitter.java @@ -14,6 +14,7 @@ import software.amazon.smithy.jmespath.ast.ProjectionExpression; import software.amazon.smithy.model.Model; import software.amazon.smithy.model.shapes.OperationShape; +import software.amazon.smithy.model.shapes.Shape; /** * Emits scalar operands in comparisons: length(), literals, and field access. @@ -48,8 +49,18 @@ public String visitFunction(FunctionExpression expression) { private String emitCountIf(FilterProjectionExpression filterExpr) { String collection = "result" + filterExpr.getLeft().accept(new CollectionGetterEmitter()); - String predicate = filterExpr.getComparison().accept(new FilterPredicateEmitter("item")); String elementType = resolveFilterElementType(filterExpr); + + // Resolve the element shape for enum handling + Shape elementShape = null; + if (model != null && operation != null) { + elementShape = CollectionElementTypeResolver.resolveElementShape( + new ProjectionExpression(filterExpr.getLeft(), new CurrentExpression()), + model.expectShape(operation.getOutputShape()), model).orElse(null); + } + + String predicate = filterExpr.getComparison().accept( + new FilterPredicateEmitter("item", model, elementShape, smithyServiceName)); return "std::count_if(" + collection + ".begin(), " + collection + ".end(), " + "[](const " + elementType + "& item) { return " + predicate + "; })"; }