AWS SDK for C++

AWS SDK for C++ Version 1.11.891
Loading...
Searching...
No Matches
MediaLiveWaiter.h
1
6#pragma once
7#include <aws/core/utils/Waiter.h>
8#include <aws/core/utils/memory/AWSMemory.h>
9#include <aws/medialive/MediaLiveClient.h>
10#include <aws/medialive/model/ChannelPlacementGroupState.h>
11#include <aws/medialive/model/ChannelState.h>
12#include <aws/medialive/model/ClusterState.h>
13#include <aws/medialive/model/DescribeChannelPlacementGroupRequest.h>
14#include <aws/medialive/model/DescribeChannelPlacementGroupSdkResult.h>
15#include <aws/medialive/model/DescribeChannelRequest.h>
16#include <aws/medialive/model/DescribeChannelResult.h>
17#include <aws/medialive/model/DescribeClusterRequest.h>
18#include <aws/medialive/model/DescribeClusterSdkResult.h>
19#include <aws/medialive/model/DescribeInputRequest.h>
20#include <aws/medialive/model/DescribeInputResult.h>
21#include <aws/medialive/model/DescribeMultiplexRequest.h>
22#include <aws/medialive/model/DescribeMultiplexResult.h>
23#include <aws/medialive/model/DescribeNodeRequest.h>
24#include <aws/medialive/model/DescribeNodeSdkResult.h>
25#include <aws/medialive/model/GetSignalMapRequest.h>
26#include <aws/medialive/model/GetSignalMapResult.h>
27#include <aws/medialive/model/InputState.h>
28#include <aws/medialive/model/MultiplexState.h>
29#include <aws/medialive/model/NodeState.h>
30#include <aws/medialive/model/SignalMapMonitorDeploymentStatus.h>
31#include <aws/medialive/model/SignalMapStatus.h>
32
33#include <algorithm>
34
35namespace Aws {
36namespace MediaLive {
37
38template <typename DerivedClient = MediaLiveClient>
39class MediaLiveWaiter {
40 public:
41 Aws::Utils::WaiterOutcome<Model::DescribeChannelOutcome> WaitUntilChannelCreated(const Model::DescribeChannelRequest& request) {
42 using OutcomeT = Model::DescribeChannelOutcome;
43 using RequestT = Model::DescribeChannelRequest;
44 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
45 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
46 "ChannelCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"),
47 [](const Model::DescribeChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
48 if (!outcome.IsSuccess()) return false;
49 const auto& result = outcome.GetResult();
50 return Model::ChannelStateMapper::GetNameForChannelState(result.GetState()) == expected.get<Aws::String>();
51 }));
52 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
53 "ChannelCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"),
54 [](const Model::DescribeChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
55 if (!outcome.IsSuccess()) return false;
56 const auto& result = outcome.GetResult();
57 return Model::ChannelStateMapper::GetNameForChannelState(result.GetState()) == expected.get<Aws::String>();
58 }));
59 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("ChannelCreatedWaiter", Aws::Utils::WaiterState::RETRY,
60 Aws::String("InternalServerErrorException")));
61 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
62 "ChannelCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"),
63 [](const Model::DescribeChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
64 if (!outcome.IsSuccess()) return false;
65 const auto& result = outcome.GetResult();
66 return Model::ChannelStateMapper::GetNameForChannelState(result.GetState()) == expected.get<Aws::String>();
67 }));
68
69 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeChannel(req); };
70 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(3, 40, std::move(acceptors), operation, "WaitUntilChannelCreated");
71 return waiter.Wait(request);
72 }
73
74 Aws::Utils::WaiterOutcome<Model::DescribeChannelOutcome> WaitUntilChannelDeleted(const Model::DescribeChannelRequest& request) {
75 using OutcomeT = Model::DescribeChannelOutcome;
76 using RequestT = Model::DescribeChannelRequest;
77 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
78 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
79 "ChannelDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"),
80 [](const Model::DescribeChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
81 if (!outcome.IsSuccess()) return false;
82 const auto& result = outcome.GetResult();
83 return Model::ChannelStateMapper::GetNameForChannelState(result.GetState()) == expected.get<Aws::String>();
84 }));
85 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
86 "ChannelDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"),
87 [](const Model::DescribeChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
88 if (!outcome.IsSuccess()) return false;
89 const auto& result = outcome.GetResult();
90 return Model::ChannelStateMapper::GetNameForChannelState(result.GetState()) == expected.get<Aws::String>();
91 }));
92 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("ChannelDeletedWaiter", Aws::Utils::WaiterState::RETRY,
93 Aws::String("InternalServerErrorException")));
94
95 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeChannel(req); };
96 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelDeleted");
97 return waiter.Wait(request);
98 }
99
100 Aws::Utils::WaiterOutcome<Model::DescribeChannelOutcome> WaitUntilChannelRunning(const Model::DescribeChannelRequest& request) {
101 using OutcomeT = Model::DescribeChannelOutcome;
102 using RequestT = Model::DescribeChannelRequest;
103 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
104 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
105 "ChannelRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"),
106 [](const Model::DescribeChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
107 if (!outcome.IsSuccess()) return false;
108 const auto& result = outcome.GetResult();
109 return Model::ChannelStateMapper::GetNameForChannelState(result.GetState()) == expected.get<Aws::String>();
110 }));
111 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
112 "ChannelRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"),
113 [](const Model::DescribeChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
114 if (!outcome.IsSuccess()) return false;
115 const auto& result = outcome.GetResult();
116 return Model::ChannelStateMapper::GetNameForChannelState(result.GetState()) == expected.get<Aws::String>();
117 }));
118 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("ChannelRunningWaiter", Aws::Utils::WaiterState::RETRY,
119 Aws::String("InternalServerErrorException")));
120
121 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeChannel(req); };
122 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelRunning");
123 return waiter.Wait(request);
124 }
125
126 Aws::Utils::WaiterOutcome<Model::DescribeChannelOutcome> WaitUntilChannelStopped(const Model::DescribeChannelRequest& request) {
127 using OutcomeT = Model::DescribeChannelOutcome;
128 using RequestT = Model::DescribeChannelRequest;
129 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
130 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
131 "ChannelStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"),
132 [](const Model::DescribeChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
133 if (!outcome.IsSuccess()) return false;
134 const auto& result = outcome.GetResult();
135 return Model::ChannelStateMapper::GetNameForChannelState(result.GetState()) == expected.get<Aws::String>();
136 }));
137 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
138 "ChannelStoppedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"),
139 [](const Model::DescribeChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
140 if (!outcome.IsSuccess()) return false;
141 const auto& result = outcome.GetResult();
142 return Model::ChannelStateMapper::GetNameForChannelState(result.GetState()) == expected.get<Aws::String>();
143 }));
144 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("ChannelStoppedWaiter", Aws::Utils::WaiterState::RETRY,
145 Aws::String("InternalServerErrorException")));
146 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
147 "ChannelStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETING"),
148 [](const Model::DescribeChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
149 if (!outcome.IsSuccess()) return false;
150 const auto& result = outcome.GetResult();
151 return Model::ChannelStateMapper::GetNameForChannelState(result.GetState()) == expected.get<Aws::String>();
152 }));
153 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
154 "ChannelStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"),
155 [](const Model::DescribeChannelOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
156 if (!outcome.IsSuccess()) return false;
157 const auto& result = outcome.GetResult();
158 return Model::ChannelStateMapper::GetNameForChannelState(result.GetState()) == expected.get<Aws::String>();
159 }));
160 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("ChannelStoppedWaiter", Aws::Utils::WaiterState::FAILURE,
161 Aws::String("NotFoundException")));
162
163 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeChannel(req); };
164 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelStopped");
165 return waiter.Wait(request);
166 }
167
168 Aws::Utils::WaiterOutcome<Model::DescribeChannelPlacementGroupOutcome> WaitUntilChannelPlacementGroupAssigned(
169 const Model::DescribeChannelPlacementGroupRequest& request) {
170 using OutcomeT = Model::DescribeChannelPlacementGroupOutcome;
171 using RequestT = Model::DescribeChannelPlacementGroupRequest;
172 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
173 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
174 "ChannelPlacementGroupAssignedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ASSIGNED"),
175 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
176 if (!outcome.IsSuccess()) return false;
177 const auto& result = outcome.GetResult();
178 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
179 expected.get<Aws::String>();
180 }));
181 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
182 "ChannelPlacementGroupAssignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("ASSIGNING"),
183 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
184 if (!outcome.IsSuccess()) return false;
185 const auto& result = outcome.GetResult();
186 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
187 expected.get<Aws::String>();
188 }));
189 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
190 "ChannelPlacementGroupAssignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InternalServerErrorException")));
191
192 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeChannelPlacementGroup(req); };
193 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(3, 40, std::move(acceptors), operation, "WaitUntilChannelPlacementGroupAssigned");
194 return waiter.Wait(request);
195 }
196
197 Aws::Utils::WaiterOutcome<Model::DescribeChannelPlacementGroupOutcome> WaitUntilChannelPlacementGroupDeleted(
198 const Model::DescribeChannelPlacementGroupRequest& request) {
199 using OutcomeT = Model::DescribeChannelPlacementGroupOutcome;
200 using RequestT = Model::DescribeChannelPlacementGroupRequest;
201 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
202 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
203 "ChannelPlacementGroupDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"),
204 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
205 if (!outcome.IsSuccess()) return false;
206 const auto& result = outcome.GetResult();
207 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
208 expected.get<Aws::String>();
209 }));
210 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
211 "ChannelPlacementGroupDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"),
212 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
213 if (!outcome.IsSuccess()) return false;
214 const auto& result = outcome.GetResult();
215 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
216 expected.get<Aws::String>();
217 }));
218 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
219 "ChannelPlacementGroupDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InternalServerErrorException")));
220
221 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeChannelPlacementGroup(req); };
222 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelPlacementGroupDeleted");
223 return waiter.Wait(request);
224 }
225
226 Aws::Utils::WaiterOutcome<Model::DescribeChannelPlacementGroupOutcome> WaitUntilChannelPlacementGroupUnassigned(
227 const Model::DescribeChannelPlacementGroupRequest& request) {
228 using OutcomeT = Model::DescribeChannelPlacementGroupOutcome;
229 using RequestT = Model::DescribeChannelPlacementGroupRequest;
230 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
231 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
232 "ChannelPlacementGroupUnassignedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UNASSIGNED"),
233 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
234 if (!outcome.IsSuccess()) return false;
235 const auto& result = outcome.GetResult();
236 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
237 expected.get<Aws::String>();
238 }));
239 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
240 "ChannelPlacementGroupUnassignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UNASSIGNING"),
241 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
242 if (!outcome.IsSuccess()) return false;
243 const auto& result = outcome.GetResult();
244 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
245 expected.get<Aws::String>();
246 }));
247 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
248 "ChannelPlacementGroupUnassignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InternalServerErrorException")));
249
250 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeChannelPlacementGroup(req); };
251 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelPlacementGroupUnassigned");
252 return waiter.Wait(request);
253 }
254
255 Aws::Utils::WaiterOutcome<Model::DescribeClusterOutcome> WaitUntilClusterCreated(const Model::DescribeClusterRequest& request) {
256 using OutcomeT = Model::DescribeClusterOutcome;
257 using RequestT = Model::DescribeClusterRequest;
258 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
259 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
260 "ClusterCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"),
261 [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
262 if (!outcome.IsSuccess()) return false;
263 const auto& result = outcome.GetResult();
264 return Model::ClusterStateMapper::GetNameForClusterState(result.GetState()) == expected.get<Aws::String>();
265 }));
266 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
267 "ClusterCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"),
268 [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
269 if (!outcome.IsSuccess()) return false;
270 const auto& result = outcome.GetResult();
271 return Model::ClusterStateMapper::GetNameForClusterState(result.GetState()) == expected.get<Aws::String>();
272 }));
273 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("ClusterCreatedWaiter", Aws::Utils::WaiterState::RETRY,
274 Aws::String("InternalServerErrorException")));
275 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
276 "ClusterCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"),
277 [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
278 if (!outcome.IsSuccess()) return false;
279 const auto& result = outcome.GetResult();
280 return Model::ClusterStateMapper::GetNameForClusterState(result.GetState()) == expected.get<Aws::String>();
281 }));
282
283 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeCluster(req); };
284 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(3, 40, std::move(acceptors), operation, "WaitUntilClusterCreated");
285 return waiter.Wait(request);
286 }
287
288 Aws::Utils::WaiterOutcome<Model::DescribeClusterOutcome> WaitUntilClusterDeleted(const Model::DescribeClusterRequest& request) {
289 using OutcomeT = Model::DescribeClusterOutcome;
290 using RequestT = Model::DescribeClusterRequest;
291 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
292 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
293 "ClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"),
294 [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
295 if (!outcome.IsSuccess()) return false;
296 const auto& result = outcome.GetResult();
297 return Model::ClusterStateMapper::GetNameForClusterState(result.GetState()) == expected.get<Aws::String>();
298 }));
299 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
300 "ClusterDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"),
301 [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
302 if (!outcome.IsSuccess()) return false;
303 const auto& result = outcome.GetResult();
304 return Model::ClusterStateMapper::GetNameForClusterState(result.GetState()) == expected.get<Aws::String>();
305 }));
306 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("ClusterDeletedWaiter", Aws::Utils::WaiterState::RETRY,
307 Aws::String("InternalServerErrorException")));
308
309 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeCluster(req); };
310 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilClusterDeleted");
311 return waiter.Wait(request);
312 }
313
314 Aws::Utils::WaiterOutcome<Model::DescribeInputOutcome> WaitUntilInputAttached(const Model::DescribeInputRequest& request) {
315 using OutcomeT = Model::DescribeInputOutcome;
316 using RequestT = Model::DescribeInputRequest;
317 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
318 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
319 "InputAttachedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ATTACHED"),
320 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
321 if (!outcome.IsSuccess()) return false;
322 const auto& result = outcome.GetResult();
323 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
324 }));
325 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
326 "InputAttachedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DETACHED"),
327 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
328 if (!outcome.IsSuccess()) return false;
329 const auto& result = outcome.GetResult();
330 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
331 }));
332 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("InputAttachedWaiter", Aws::Utils::WaiterState::RETRY,
333 Aws::String("InternalServerErrorException")));
334
335 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeInput(req); };
336 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilInputAttached");
337 return waiter.Wait(request);
338 }
339
340 Aws::Utils::WaiterOutcome<Model::DescribeInputOutcome> WaitUntilInputDeleted(const Model::DescribeInputRequest& request) {
341 using OutcomeT = Model::DescribeInputOutcome;
342 using RequestT = Model::DescribeInputRequest;
343 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
344 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
345 "InputDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"),
346 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
347 if (!outcome.IsSuccess()) return false;
348 const auto& result = outcome.GetResult();
349 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
350 }));
351 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
352 "InputDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"),
353 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
354 if (!outcome.IsSuccess()) return false;
355 const auto& result = outcome.GetResult();
356 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
357 }));
358 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("InputDeletedWaiter", Aws::Utils::WaiterState::RETRY,
359 Aws::String("InternalServerErrorException")));
360
361 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeInput(req); };
362 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilInputDeleted");
363 return waiter.Wait(request);
364 }
365
366 Aws::Utils::WaiterOutcome<Model::DescribeInputOutcome> WaitUntilInputDetached(const Model::DescribeInputRequest& request) {
367 using OutcomeT = Model::DescribeInputOutcome;
368 using RequestT = Model::DescribeInputRequest;
369 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
370 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
371 "InputDetachedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DETACHED"),
372 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
373 if (!outcome.IsSuccess()) return false;
374 const auto& result = outcome.GetResult();
375 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
376 }));
377 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
378 "InputDetachedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"),
379 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
380 if (!outcome.IsSuccess()) return false;
381 const auto& result = outcome.GetResult();
382 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
383 }));
384 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
385 "InputDetachedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("ATTACHED"),
386 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
387 if (!outcome.IsSuccess()) return false;
388 const auto& result = outcome.GetResult();
389 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
390 }));
391 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("InputDetachedWaiter", Aws::Utils::WaiterState::RETRY,
392 Aws::String("InternalServerErrorException")));
393
394 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeInput(req); };
395 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilInputDetached");
396 return waiter.Wait(request);
397 }
398
399 Aws::Utils::WaiterOutcome<Model::DescribeMultiplexOutcome> WaitUntilMultiplexCreated(const Model::DescribeMultiplexRequest& request) {
400 using OutcomeT = Model::DescribeMultiplexOutcome;
401 using RequestT = Model::DescribeMultiplexRequest;
402 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
403 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
404 "MultiplexCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"),
405 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
406 if (!outcome.IsSuccess()) return false;
407 const auto& result = outcome.GetResult();
408 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
409 }));
410 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
411 "MultiplexCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"),
412 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
413 if (!outcome.IsSuccess()) return false;
414 const auto& result = outcome.GetResult();
415 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
416 }));
417 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("MultiplexCreatedWaiter", Aws::Utils::WaiterState::RETRY,
418 Aws::String("InternalServerErrorException")));
419 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
420 "MultiplexCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"),
421 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
422 if (!outcome.IsSuccess()) return false;
423 const auto& result = outcome.GetResult();
424 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
425 }));
426
427 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMultiplex(req); };
428 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(3, 40, std::move(acceptors), operation, "WaitUntilMultiplexCreated");
429 return waiter.Wait(request);
430 }
431
432 Aws::Utils::WaiterOutcome<Model::DescribeMultiplexOutcome> WaitUntilMultiplexDeleted(const Model::DescribeMultiplexRequest& request) {
433 using OutcomeT = Model::DescribeMultiplexOutcome;
434 using RequestT = Model::DescribeMultiplexRequest;
435 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
436 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
437 "MultiplexDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"),
438 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
439 if (!outcome.IsSuccess()) return false;
440 const auto& result = outcome.GetResult();
441 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
442 }));
443 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
444 "MultiplexDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"),
445 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
446 if (!outcome.IsSuccess()) return false;
447 const auto& result = outcome.GetResult();
448 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
449 }));
450 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("MultiplexDeletedWaiter", Aws::Utils::WaiterState::RETRY,
451 Aws::String("InternalServerErrorException")));
452
453 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMultiplex(req); };
454 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilMultiplexDeleted");
455 return waiter.Wait(request);
456 }
457
458 Aws::Utils::WaiterOutcome<Model::DescribeMultiplexOutcome> WaitUntilMultiplexRunning(const Model::DescribeMultiplexRequest& request) {
459 using OutcomeT = Model::DescribeMultiplexOutcome;
460 using RequestT = Model::DescribeMultiplexRequest;
461 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
462 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
463 "MultiplexRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"),
464 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
465 if (!outcome.IsSuccess()) return false;
466 const auto& result = outcome.GetResult();
467 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
468 }));
469 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
470 "MultiplexRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"),
471 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
472 if (!outcome.IsSuccess()) return false;
473 const auto& result = outcome.GetResult();
474 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
475 }));
476 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("MultiplexRunningWaiter", Aws::Utils::WaiterState::RETRY,
477 Aws::String("InternalServerErrorException")));
478
479 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMultiplex(req); };
480 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilMultiplexRunning");
481 return waiter.Wait(request);
482 }
483
484 Aws::Utils::WaiterOutcome<Model::DescribeMultiplexOutcome> WaitUntilMultiplexStopped(const Model::DescribeMultiplexRequest& request) {
485 using OutcomeT = Model::DescribeMultiplexOutcome;
486 using RequestT = Model::DescribeMultiplexRequest;
487 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
488 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
489 "MultiplexStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"),
490 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
491 if (!outcome.IsSuccess()) return false;
492 const auto& result = outcome.GetResult();
493 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
494 }));
495 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
496 "MultiplexStoppedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"),
497 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
498 if (!outcome.IsSuccess()) return false;
499 const auto& result = outcome.GetResult();
500 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
501 }));
502 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("MultiplexStoppedWaiter", Aws::Utils::WaiterState::RETRY,
503 Aws::String("InternalServerErrorException")));
504
505 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMultiplex(req); };
506 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilMultiplexStopped");
507 return waiter.Wait(request);
508 }
509
510 Aws::Utils::WaiterOutcome<Model::DescribeNodeOutcome> WaitUntilNodeDeregistered(const Model::DescribeNodeRequest& request) {
511 using OutcomeT = Model::DescribeNodeOutcome;
512 using RequestT = Model::DescribeNodeRequest;
513 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
514 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
515 "NodeDeregisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEREGISTERED"),
516 [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
517 if (!outcome.IsSuccess()) return false;
518 const auto& result = outcome.GetResult();
519 return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get<Aws::String>();
520 }));
521 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
522 "NodeDeregisteredWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DEREGISTERING"),
523 [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
524 if (!outcome.IsSuccess()) return false;
525 const auto& result = outcome.GetResult();
526 return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get<Aws::String>();
527 }));
528 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
529 "NodeDeregisteredWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DRAINING"),
530 [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
531 if (!outcome.IsSuccess()) return false;
532 const auto& result = outcome.GetResult();
533 return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get<Aws::String>();
534 }));
535 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("NodeDeregisteredWaiter", Aws::Utils::WaiterState::RETRY,
536 Aws::String("InternalServerErrorException")));
537
538 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeNode(req); };
539 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilNodeDeregistered");
540 return waiter.Wait(request);
541 }
542
543 Aws::Utils::WaiterOutcome<Model::DescribeNodeOutcome> WaitUntilNodeRegistered(const Model::DescribeNodeRequest& request) {
544 using OutcomeT = Model::DescribeNodeOutcome;
545 using RequestT = Model::DescribeNodeRequest;
546 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
547 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
548 "NodeRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"),
549 [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
550 if (!outcome.IsSuccess()) return false;
551 const auto& result = outcome.GetResult();
552 return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get<Aws::String>();
553 }));
554 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
555 "NodeRegisteredWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("REGISTERING"),
556 [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
557 if (!outcome.IsSuccess()) return false;
558 const auto& result = outcome.GetResult();
559 return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get<Aws::String>();
560 }));
561 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("NodeRegisteredWaiter", Aws::Utils::WaiterState::RETRY,
562 Aws::String("NotFoundException")));
563 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
564 "NodeRegisteredWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REGISTRATION_FAILED"),
565 [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
566 if (!outcome.IsSuccess()) return false;
567 const auto& result = outcome.GetResult();
568 return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get<Aws::String>();
569 }));
570 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("NodeRegisteredWaiter", Aws::Utils::WaiterState::RETRY,
571 Aws::String("InternalServerErrorException")));
572
573 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeNode(req); };
574 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(3, 40, std::move(acceptors), operation, "WaitUntilNodeRegistered");
575 return waiter.Wait(request);
576 }
577
578 Aws::Utils::WaiterOutcome<Model::GetSignalMapOutcome> WaitUntilSignalMapCreated(const Model::GetSignalMapRequest& request) {
579 using OutcomeT = Model::GetSignalMapOutcome;
580 using RequestT = Model::GetSignalMapRequest;
581 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
582 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
583 "SignalMapCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"),
584 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
585 if (!outcome.IsSuccess()) return false;
586 const auto& result = outcome.GetResult();
587 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
588 }));
589 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
590 "SignalMapCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATE_IN_PROGRESS"),
591 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
592 if (!outcome.IsSuccess()) return false;
593 const auto& result = outcome.GetResult();
594 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
595 }));
596 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
597 "SignalMapCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"),
598 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
599 if (!outcome.IsSuccess()) return false;
600 const auto& result = outcome.GetResult();
601 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
602 }));
603
604 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetSignalMap(req); };
605 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapCreated");
606 return waiter.Wait(request);
607 }
608
609 Aws::Utils::WaiterOutcome<Model::GetSignalMapOutcome> WaitUntilSignalMapMonitorDeleted(const Model::GetSignalMapRequest& request) {
610 using OutcomeT = Model::GetSignalMapOutcome;
611 using RequestT = Model::GetSignalMapRequest;
612 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
613 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
614 "SignalMapMonitorDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETE_COMPLETE"),
615 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
616 if (!outcome.IsSuccess()) return false;
617 const auto& result = outcome.GetResult();
618 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
619 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
620 }));
621 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
622 "SignalMapMonitorDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETE_IN_PROGRESS"),
623 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
624 if (!outcome.IsSuccess()) return false;
625 const auto& result = outcome.GetResult();
626 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
627 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
628 }));
629 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
630 "SignalMapMonitorDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"),
631 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
632 if (!outcome.IsSuccess()) return false;
633 const auto& result = outcome.GetResult();
634 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
635 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
636 }));
637
638 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetSignalMap(req); };
639 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapMonitorDeleted");
640 return waiter.Wait(request);
641 }
642
643 Aws::Utils::WaiterOutcome<Model::GetSignalMapOutcome> WaitUntilSignalMapMonitorDeployed(const Model::GetSignalMapRequest& request) {
644 using OutcomeT = Model::GetSignalMapOutcome;
645 using RequestT = Model::GetSignalMapRequest;
646 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
647 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
648 "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DRY_RUN_DEPLOYMENT_COMPLETE"),
649 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
650 if (!outcome.IsSuccess()) return false;
651 const auto& result = outcome.GetResult();
652 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
653 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
654 }));
655 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
656 "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEPLOYMENT_COMPLETE"),
657 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
658 if (!outcome.IsSuccess()) return false;
659 const auto& result = outcome.GetResult();
660 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
661 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
662 }));
663 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
664 "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DRY_RUN_DEPLOYMENT_IN_PROGRESS"),
665 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
666 if (!outcome.IsSuccess()) return false;
667 const auto& result = outcome.GetResult();
668 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
669 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
670 }));
671 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
672 "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DEPLOYMENT_IN_PROGRESS"),
673 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
674 if (!outcome.IsSuccess()) return false;
675 const auto& result = outcome.GetResult();
676 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
677 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
678 }));
679 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
680 "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DRY_RUN_DEPLOYMENT_FAILED"),
681 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
682 if (!outcome.IsSuccess()) return false;
683 const auto& result = outcome.GetResult();
684 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
685 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
686 }));
687 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
688 "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DEPLOYMENT_FAILED"),
689 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
690 if (!outcome.IsSuccess()) return false;
691 const auto& result = outcome.GetResult();
692 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
693 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
694 }));
695
696 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetSignalMap(req); };
697 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapMonitorDeployed");
698 return waiter.Wait(request);
699 }
700
701 Aws::Utils::WaiterOutcome<Model::GetSignalMapOutcome> WaitUntilSignalMapUpdated(const Model::GetSignalMapRequest& request) {
702 using OutcomeT = Model::GetSignalMapOutcome;
703 using RequestT = Model::GetSignalMapRequest;
704 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
705 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
706 "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_COMPLETE"),
707 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
708 if (!outcome.IsSuccess()) return false;
709 const auto& result = outcome.GetResult();
710 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
711 }));
712 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
713 "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATE_IN_PROGRESS"),
714 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
715 if (!outcome.IsSuccess()) return false;
716 const auto& result = outcome.GetResult();
717 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
718 }));
719 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
720 "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"),
721 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
722 if (!outcome.IsSuccess()) return false;
723 const auto& result = outcome.GetResult();
724 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
725 }));
726 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
727 "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_REVERTED"),
728 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
729 if (!outcome.IsSuccess()) return false;
730 const auto& result = outcome.GetResult();
731 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
732 }));
733
734 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetSignalMap(req); };
735 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapUpdated");
736 return waiter.Wait(request);
737 }
738};
739} // namespace MediaLive
740} // namespace Aws
Aws::MediaLive::MediaLiveWaiter::WaitUntilChannelPlacementGroupAssigned
Aws::Utils::WaiterOutcome< Model::DescribeChannelPlacementGroupOutcome > WaitUntilChannelPlacementGroupAssigned(const Model::DescribeChannelPlacementGroupRequest &request)
Definition MediaLiveWaiter.h:168
Aws::MediaLive::MediaLiveWaiter::WaitUntilInputAttached
Aws::Utils::WaiterOutcome< Model::DescribeInputOutcome > WaitUntilInputAttached(const Model::DescribeInputRequest &request)
Definition MediaLiveWaiter.h:314
Aws::MediaLive::MediaLiveWaiter::WaitUntilClusterCreated
Aws::Utils::WaiterOutcome< Model::DescribeClusterOutcome > WaitUntilClusterCreated(const Model::DescribeClusterRequest &request)
Definition MediaLiveWaiter.h:255
Aws::MediaLive::MediaLiveWaiter::WaitUntilClusterDeleted
Aws::Utils::WaiterOutcome< Model::DescribeClusterOutcome > WaitUntilClusterDeleted(const Model::DescribeClusterRequest &request)
Definition MediaLiveWaiter.h:288
Aws::MediaLive::MediaLiveWaiter::WaitUntilNodeDeregistered
Aws::Utils::WaiterOutcome< Model::DescribeNodeOutcome > WaitUntilNodeDeregistered(const Model::DescribeNodeRequest &request)
Definition MediaLiveWaiter.h:510
Aws::MediaLive::MediaLiveWaiter::WaitUntilMultiplexCreated
Aws::Utils::WaiterOutcome< Model::DescribeMultiplexOutcome > WaitUntilMultiplexCreated(const Model::DescribeMultiplexRequest &request)
Definition MediaLiveWaiter.h:399
Aws::MediaLive::MediaLiveWaiter::WaitUntilChannelDeleted
Aws::Utils::WaiterOutcome< Model::DescribeChannelOutcome > WaitUntilChannelDeleted(const Model::DescribeChannelRequest &request)
Definition MediaLiveWaiter.h:74
Aws::MediaLive::MediaLiveWaiter::WaitUntilInputDetached
Aws::Utils::WaiterOutcome< Model::DescribeInputOutcome > WaitUntilInputDetached(const Model::DescribeInputRequest &request)
Definition MediaLiveWaiter.h:366
Aws::MediaLive::MediaLiveWaiter::WaitUntilChannelPlacementGroupDeleted
Aws::Utils::WaiterOutcome< Model::DescribeChannelPlacementGroupOutcome > WaitUntilChannelPlacementGroupDeleted(const Model::DescribeChannelPlacementGroupRequest &request)
Definition MediaLiveWaiter.h:197
Aws::MediaLive::MediaLiveWaiter::WaitUntilChannelRunning
Aws::Utils::WaiterOutcome< Model::DescribeChannelOutcome > WaitUntilChannelRunning(const Model::DescribeChannelRequest &request)
Definition MediaLiveWaiter.h:100
Aws::MediaLive::MediaLiveWaiter::WaitUntilNodeRegistered
Aws::Utils::WaiterOutcome< Model::DescribeNodeOutcome > WaitUntilNodeRegistered(const Model::DescribeNodeRequest &request)
Definition MediaLiveWaiter.h:543
Aws::MediaLive::MediaLiveWaiter::WaitUntilSignalMapUpdated
Aws::Utils::WaiterOutcome< Model::GetSignalMapOutcome > WaitUntilSignalMapUpdated(const Model::GetSignalMapRequest &request)
Definition MediaLiveWaiter.h:701
Aws::MediaLive::MediaLiveWaiter::WaitUntilChannelCreated
Aws::Utils::WaiterOutcome< Model::DescribeChannelOutcome > WaitUntilChannelCreated(const Model::DescribeChannelRequest &request)
Definition MediaLiveWaiter.h:41
Aws::MediaLive::MediaLiveWaiter::WaitUntilInputDeleted
Aws::Utils::WaiterOutcome< Model::DescribeInputOutcome > WaitUntilInputDeleted(const Model::DescribeInputRequest &request)
Definition MediaLiveWaiter.h:340
Aws::MediaLive::MediaLiveWaiter::WaitUntilSignalMapMonitorDeleted
Aws::Utils::WaiterOutcome< Model::GetSignalMapOutcome > WaitUntilSignalMapMonitorDeleted(const Model::GetSignalMapRequest &request)
Definition MediaLiveWaiter.h:609
Aws::MediaLive::MediaLiveWaiter::WaitUntilMultiplexDeleted
Aws::Utils::WaiterOutcome< Model::DescribeMultiplexOutcome > WaitUntilMultiplexDeleted(const Model::DescribeMultiplexRequest &request)
Definition MediaLiveWaiter.h:432
Aws::MediaLive::MediaLiveWaiter::WaitUntilMultiplexRunning
Aws::Utils::WaiterOutcome< Model::DescribeMultiplexOutcome > WaitUntilMultiplexRunning(const Model::DescribeMultiplexRequest &request)
Definition MediaLiveWaiter.h:458
Aws::MediaLive::MediaLiveWaiter::WaitUntilChannelPlacementGroupUnassigned
Aws::Utils::WaiterOutcome< Model::DescribeChannelPlacementGroupOutcome > WaitUntilChannelPlacementGroupUnassigned(const Model::DescribeChannelPlacementGroupRequest &request)
Definition MediaLiveWaiter.h:226
Aws::MediaLive::MediaLiveWaiter::WaitUntilChannelStopped
Aws::Utils::WaiterOutcome< Model::DescribeChannelOutcome > WaitUntilChannelStopped(const Model::DescribeChannelRequest &request)
Definition MediaLiveWaiter.h:126
Aws::MediaLive::MediaLiveWaiter::WaitUntilSignalMapMonitorDeployed
Aws::Utils::WaiterOutcome< Model::GetSignalMapOutcome > WaitUntilSignalMapMonitorDeployed(const Model::GetSignalMapRequest &request)
Definition MediaLiveWaiter.h:643
Aws::MediaLive::MediaLiveWaiter::WaitUntilSignalMapCreated
Aws::Utils::WaiterOutcome< Model::GetSignalMapOutcome > WaitUntilSignalMapCreated(const Model::GetSignalMapRequest &request)
Definition MediaLiveWaiter.h:578
Aws::MediaLive::MediaLiveWaiter::WaitUntilMultiplexStopped
Aws::Utils::WaiterOutcome< Model::DescribeMultiplexOutcome > WaitUntilMultiplexStopped(const Model::DescribeMultiplexRequest &request)
Definition MediaLiveWaiter.h:484
Aws::Utils::Outcome::IsSuccess
bool IsSuccess() const
Aws::Utils::Outcome::GetResult
const R & GetResult() const
Aws::Utils::Waiter::Wait
WaiterOutcome< OutcomeT > Wait(const RequestT &request)
Aws::MediaLive::Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState
AWS_MEDIALIVE_API Aws::String GetNameForChannelPlacementGroupState(ChannelPlacementGroupState value)
Aws::MediaLive::Model::ChannelStateMapper::GetNameForChannelState
AWS_MEDIALIVE_API Aws::String GetNameForChannelState(ChannelState value)
Aws::MediaLive::Model::ClusterStateMapper::GetNameForClusterState
AWS_MEDIALIVE_API Aws::String GetNameForClusterState(ClusterState value)
Aws::MediaLive::Model::InputStateMapper::GetNameForInputState
AWS_MEDIALIVE_API Aws::String GetNameForInputState(InputState value)
Aws::MediaLive::Model::MultiplexStateMapper::GetNameForMultiplexState
AWS_MEDIALIVE_API Aws::String GetNameForMultiplexState(MultiplexState value)
Aws::MediaLive::Model::NodeStateMapper::GetNameForNodeState
AWS_MEDIALIVE_API Aws::String GetNameForNodeState(NodeState value)
Aws::MediaLive::Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus
AWS_MEDIALIVE_API Aws::String GetNameForSignalMapMonitorDeploymentStatus(SignalMapMonitorDeploymentStatus value)
Aws::MediaLive::Model::SignalMapStatusMapper::GetNameForSignalMapStatus
AWS_MEDIALIVE_API Aws::String GetNameForSignalMapStatus(SignalMapStatus value)
Aws::MediaLive::Model::DescribeNodeOutcome
Aws::Utils::Outcome< DescribeNodeSdkResult, MediaLiveError > DescribeNodeOutcome
Definition MediaLiveServiceClientModel.h:380
Aws::MediaLive::Model::DescribeChannelOutcome
Aws::Utils::Outcome< DescribeChannelResult, MediaLiveError > DescribeChannelOutcome
Definition MediaLiveServiceClientModel.h:370
Aws::MediaLive::Model::GetSignalMapOutcome
Aws::Utils::Outcome< GetSignalMapResult, MediaLiveError > GetSignalMapOutcome
Definition MediaLiveServiceClientModel.h:390
Aws::MediaLive::Model::DescribeMultiplexOutcome
Aws::Utils::Outcome< DescribeMultiplexResult, MediaLiveError > DescribeMultiplexOutcome
Definition MediaLiveServiceClientModel.h:377
Aws::MediaLive::Model::DescribeChannelPlacementGroupOutcome
Aws::Utils::Outcome< DescribeChannelPlacementGroupSdkResult, MediaLiveError > DescribeChannelPlacementGroupOutcome
Definition MediaLiveServiceClientModel.h:371
Aws::MediaLive::Model::DescribeClusterOutcome
Aws::Utils::Outcome< DescribeClusterSdkResult, MediaLiveError > DescribeClusterOutcome
Definition MediaLiveServiceClientModel.h:372
Aws::MediaLive::Model::DescribeInputOutcome
Aws::Utils::Outcome< DescribeInputResult, MediaLiveError > DescribeInputOutcome
Definition MediaLiveServiceClientModel.h:373
Aws::Utils::ExpectedValue
Crt::Variant< int, bool, Aws::String > ExpectedValue
Aws::String
std::basic_string< char, std::char_traits< char >, Aws::Allocator< char > > String
Aws::MakeUnique
UniquePtr< T > MakeUnique(const char *allocationTag, ArgTypes &&... args)
Aws::Vector
std::vector< T, Aws::Allocator< T > > Vector
Generated by doxygen 1.9.8
Privacy | Site terms | Cookie preferences