AWS SDK for C++

AWS SDK for C++ Version 1.11.788
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
147 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeChannel(req); };
148 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelStopped");
149 return waiter.Wait(request);
150 }
151
152 Aws::Utils::WaiterOutcome<Model::DescribeChannelPlacementGroupOutcome> WaitUntilChannelPlacementGroupAssigned(
153 const Model::DescribeChannelPlacementGroupRequest& request) {
154 using OutcomeT = Model::DescribeChannelPlacementGroupOutcome;
155 using RequestT = Model::DescribeChannelPlacementGroupRequest;
156 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
157 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
158 "ChannelPlacementGroupAssignedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ASSIGNED"),
159 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
160 if (!outcome.IsSuccess()) return false;
161 const auto& result = outcome.GetResult();
162 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
163 expected.get<Aws::String>();
164 }));
165 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
166 "ChannelPlacementGroupAssignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("ASSIGNING"),
167 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
168 if (!outcome.IsSuccess()) return false;
169 const auto& result = outcome.GetResult();
170 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
171 expected.get<Aws::String>();
172 }));
173 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
174 "ChannelPlacementGroupAssignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InternalServerErrorException")));
175
176 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeChannelPlacementGroup(req); };
177 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(3, 40, std::move(acceptors), operation, "WaitUntilChannelPlacementGroupAssigned");
178 return waiter.Wait(request);
179 }
180
181 Aws::Utils::WaiterOutcome<Model::DescribeChannelPlacementGroupOutcome> WaitUntilChannelPlacementGroupDeleted(
182 const Model::DescribeChannelPlacementGroupRequest& request) {
183 using OutcomeT = Model::DescribeChannelPlacementGroupOutcome;
184 using RequestT = Model::DescribeChannelPlacementGroupRequest;
185 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
186 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
187 "ChannelPlacementGroupDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"),
188 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
189 if (!outcome.IsSuccess()) return false;
190 const auto& result = outcome.GetResult();
191 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
192 expected.get<Aws::String>();
193 }));
194 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
195 "ChannelPlacementGroupDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"),
196 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
197 if (!outcome.IsSuccess()) return false;
198 const auto& result = outcome.GetResult();
199 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
200 expected.get<Aws::String>();
201 }));
202 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
203 "ChannelPlacementGroupDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InternalServerErrorException")));
204
205 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeChannelPlacementGroup(req); };
206 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelPlacementGroupDeleted");
207 return waiter.Wait(request);
208 }
209
210 Aws::Utils::WaiterOutcome<Model::DescribeChannelPlacementGroupOutcome> WaitUntilChannelPlacementGroupUnassigned(
211 const Model::DescribeChannelPlacementGroupRequest& request) {
212 using OutcomeT = Model::DescribeChannelPlacementGroupOutcome;
213 using RequestT = Model::DescribeChannelPlacementGroupRequest;
214 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
215 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
216 "ChannelPlacementGroupUnassignedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UNASSIGNED"),
217 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
218 if (!outcome.IsSuccess()) return false;
219 const auto& result = outcome.GetResult();
220 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
221 expected.get<Aws::String>();
222 }));
223 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
224 "ChannelPlacementGroupUnassignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UNASSIGNING"),
225 [](const Model::DescribeChannelPlacementGroupOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
226 if (!outcome.IsSuccess()) return false;
227 const auto& result = outcome.GetResult();
228 return Model::ChannelPlacementGroupStateMapper::GetNameForChannelPlacementGroupState(result.GetState()) ==
229 expected.get<Aws::String>();
230 }));
231 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>(
232 "ChannelPlacementGroupUnassignedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("InternalServerErrorException")));
233
234 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeChannelPlacementGroup(req); };
235 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilChannelPlacementGroupUnassigned");
236 return waiter.Wait(request);
237 }
238
239 Aws::Utils::WaiterOutcome<Model::DescribeClusterOutcome> WaitUntilClusterCreated(const Model::DescribeClusterRequest& request) {
240 using OutcomeT = Model::DescribeClusterOutcome;
241 using RequestT = Model::DescribeClusterRequest;
242 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
243 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
244 "ClusterCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"),
245 [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
246 if (!outcome.IsSuccess()) return false;
247 const auto& result = outcome.GetResult();
248 return Model::ClusterStateMapper::GetNameForClusterState(result.GetState()) == expected.get<Aws::String>();
249 }));
250 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
251 "ClusterCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"),
252 [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
253 if (!outcome.IsSuccess()) return false;
254 const auto& result = outcome.GetResult();
255 return Model::ClusterStateMapper::GetNameForClusterState(result.GetState()) == expected.get<Aws::String>();
256 }));
257 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("ClusterCreatedWaiter", Aws::Utils::WaiterState::RETRY,
258 Aws::String("InternalServerErrorException")));
259 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
260 "ClusterCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"),
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
267 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeCluster(req); };
268 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(3, 40, std::move(acceptors), operation, "WaitUntilClusterCreated");
269 return waiter.Wait(request);
270 }
271
272 Aws::Utils::WaiterOutcome<Model::DescribeClusterOutcome> WaitUntilClusterDeleted(const Model::DescribeClusterRequest& request) {
273 using OutcomeT = Model::DescribeClusterOutcome;
274 using RequestT = Model::DescribeClusterRequest;
275 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
276 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
277 "ClusterDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"),
278 [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
279 if (!outcome.IsSuccess()) return false;
280 const auto& result = outcome.GetResult();
281 return Model::ClusterStateMapper::GetNameForClusterState(result.GetState()) == expected.get<Aws::String>();
282 }));
283 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
284 "ClusterDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"),
285 [](const Model::DescribeClusterOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
286 if (!outcome.IsSuccess()) return false;
287 const auto& result = outcome.GetResult();
288 return Model::ClusterStateMapper::GetNameForClusterState(result.GetState()) == expected.get<Aws::String>();
289 }));
290 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("ClusterDeletedWaiter", Aws::Utils::WaiterState::RETRY,
291 Aws::String("InternalServerErrorException")));
292
293 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeCluster(req); };
294 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilClusterDeleted");
295 return waiter.Wait(request);
296 }
297
298 Aws::Utils::WaiterOutcome<Model::DescribeInputOutcome> WaitUntilInputAttached(const Model::DescribeInputRequest& request) {
299 using OutcomeT = Model::DescribeInputOutcome;
300 using RequestT = Model::DescribeInputRequest;
301 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
302 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
303 "InputAttachedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ATTACHED"),
304 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
305 if (!outcome.IsSuccess()) return false;
306 const auto& result = outcome.GetResult();
307 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
308 }));
309 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
310 "InputAttachedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DETACHED"),
311 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
312 if (!outcome.IsSuccess()) return false;
313 const auto& result = outcome.GetResult();
314 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
315 }));
316 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("InputAttachedWaiter", Aws::Utils::WaiterState::RETRY,
317 Aws::String("InternalServerErrorException")));
318
319 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeInput(req); };
320 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilInputAttached");
321 return waiter.Wait(request);
322 }
323
324 Aws::Utils::WaiterOutcome<Model::DescribeInputOutcome> WaitUntilInputDeleted(const Model::DescribeInputRequest& request) {
325 using OutcomeT = Model::DescribeInputOutcome;
326 using RequestT = Model::DescribeInputRequest;
327 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
328 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
329 "InputDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"),
330 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
331 if (!outcome.IsSuccess()) return false;
332 const auto& result = outcome.GetResult();
333 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
334 }));
335 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
336 "InputDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"),
337 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
338 if (!outcome.IsSuccess()) return false;
339 const auto& result = outcome.GetResult();
340 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
341 }));
342 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("InputDeletedWaiter", Aws::Utils::WaiterState::RETRY,
343 Aws::String("InternalServerErrorException")));
344
345 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeInput(req); };
346 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilInputDeleted");
347 return waiter.Wait(request);
348 }
349
350 Aws::Utils::WaiterOutcome<Model::DescribeInputOutcome> WaitUntilInputDetached(const Model::DescribeInputRequest& request) {
351 using OutcomeT = Model::DescribeInputOutcome;
352 using RequestT = Model::DescribeInputRequest;
353 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
354 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
355 "InputDetachedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DETACHED"),
356 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
357 if (!outcome.IsSuccess()) return false;
358 const auto& result = outcome.GetResult();
359 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
360 }));
361 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
362 "InputDetachedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"),
363 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
364 if (!outcome.IsSuccess()) return false;
365 const auto& result = outcome.GetResult();
366 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
367 }));
368 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
369 "InputDetachedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("ATTACHED"),
370 [](const Model::DescribeInputOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
371 if (!outcome.IsSuccess()) return false;
372 const auto& result = outcome.GetResult();
373 return Model::InputStateMapper::GetNameForInputState(result.GetState()) == expected.get<Aws::String>();
374 }));
375 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("InputDetachedWaiter", Aws::Utils::WaiterState::RETRY,
376 Aws::String("InternalServerErrorException")));
377
378 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeInput(req); };
379 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilInputDetached");
380 return waiter.Wait(request);
381 }
382
383 Aws::Utils::WaiterOutcome<Model::DescribeMultiplexOutcome> WaitUntilMultiplexCreated(const Model::DescribeMultiplexRequest& request) {
384 using OutcomeT = Model::DescribeMultiplexOutcome;
385 using RequestT = Model::DescribeMultiplexRequest;
386 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
387 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
388 "MultiplexCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"),
389 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
390 if (!outcome.IsSuccess()) return false;
391 const auto& result = outcome.GetResult();
392 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
393 }));
394 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
395 "MultiplexCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATING"),
396 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
397 if (!outcome.IsSuccess()) return false;
398 const auto& result = outcome.GetResult();
399 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
400 }));
401 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("MultiplexCreatedWaiter", Aws::Utils::WaiterState::RETRY,
402 Aws::String("InternalServerErrorException")));
403 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
404 "MultiplexCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"),
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
411 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMultiplex(req); };
412 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(3, 40, std::move(acceptors), operation, "WaitUntilMultiplexCreated");
413 return waiter.Wait(request);
414 }
415
416 Aws::Utils::WaiterOutcome<Model::DescribeMultiplexOutcome> WaitUntilMultiplexDeleted(const Model::DescribeMultiplexRequest& request) {
417 using OutcomeT = Model::DescribeMultiplexOutcome;
418 using RequestT = Model::DescribeMultiplexRequest;
419 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
420 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
421 "MultiplexDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETED"),
422 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
423 if (!outcome.IsSuccess()) return false;
424 const auto& result = outcome.GetResult();
425 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
426 }));
427 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
428 "MultiplexDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETING"),
429 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
430 if (!outcome.IsSuccess()) return false;
431 const auto& result = outcome.GetResult();
432 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
433 }));
434 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("MultiplexDeletedWaiter", Aws::Utils::WaiterState::RETRY,
435 Aws::String("InternalServerErrorException")));
436
437 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMultiplex(req); };
438 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilMultiplexDeleted");
439 return waiter.Wait(request);
440 }
441
442 Aws::Utils::WaiterOutcome<Model::DescribeMultiplexOutcome> WaitUntilMultiplexRunning(const Model::DescribeMultiplexRequest& request) {
443 using OutcomeT = Model::DescribeMultiplexOutcome;
444 using RequestT = Model::DescribeMultiplexRequest;
445 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
446 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
447 "MultiplexRunningWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("RUNNING"),
448 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
449 if (!outcome.IsSuccess()) return false;
450 const auto& result = outcome.GetResult();
451 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
452 }));
453 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
454 "MultiplexRunningWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STARTING"),
455 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
456 if (!outcome.IsSuccess()) return false;
457 const auto& result = outcome.GetResult();
458 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
459 }));
460 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("MultiplexRunningWaiter", Aws::Utils::WaiterState::RETRY,
461 Aws::String("InternalServerErrorException")));
462
463 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMultiplex(req); };
464 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilMultiplexRunning");
465 return waiter.Wait(request);
466 }
467
468 Aws::Utils::WaiterOutcome<Model::DescribeMultiplexOutcome> WaitUntilMultiplexStopped(const Model::DescribeMultiplexRequest& request) {
469 using OutcomeT = Model::DescribeMultiplexOutcome;
470 using RequestT = Model::DescribeMultiplexRequest;
471 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
472 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
473 "MultiplexStoppedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("IDLE"),
474 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
475 if (!outcome.IsSuccess()) return false;
476 const auto& result = outcome.GetResult();
477 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
478 }));
479 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
480 "MultiplexStoppedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("STOPPING"),
481 [](const Model::DescribeMultiplexOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
482 if (!outcome.IsSuccess()) return false;
483 const auto& result = outcome.GetResult();
484 return Model::MultiplexStateMapper::GetNameForMultiplexState(result.GetState()) == expected.get<Aws::String>();
485 }));
486 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("MultiplexStoppedWaiter", Aws::Utils::WaiterState::RETRY,
487 Aws::String("InternalServerErrorException")));
488
489 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeMultiplex(req); };
490 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilMultiplexStopped");
491 return waiter.Wait(request);
492 }
493
494 Aws::Utils::WaiterOutcome<Model::DescribeNodeOutcome> WaitUntilNodeDeregistered(const Model::DescribeNodeRequest& request) {
495 using OutcomeT = Model::DescribeNodeOutcome;
496 using RequestT = Model::DescribeNodeRequest;
497 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
498 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
499 "NodeDeregisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEREGISTERED"),
500 [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
501 if (!outcome.IsSuccess()) return false;
502 const auto& result = outcome.GetResult();
503 return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get<Aws::String>();
504 }));
505 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
506 "NodeDeregisteredWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DEREGISTERING"),
507 [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
508 if (!outcome.IsSuccess()) return false;
509 const auto& result = outcome.GetResult();
510 return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get<Aws::String>();
511 }));
512 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
513 "NodeDeregisteredWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DRAINING"),
514 [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
515 if (!outcome.IsSuccess()) return false;
516 const auto& result = outcome.GetResult();
517 return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get<Aws::String>();
518 }));
519 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("NodeDeregisteredWaiter", Aws::Utils::WaiterState::RETRY,
520 Aws::String("InternalServerErrorException")));
521
522 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeNode(req); };
523 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilNodeDeregistered");
524 return waiter.Wait(request);
525 }
526
527 Aws::Utils::WaiterOutcome<Model::DescribeNodeOutcome> WaitUntilNodeRegistered(const Model::DescribeNodeRequest& request) {
528 using OutcomeT = Model::DescribeNodeOutcome;
529 using RequestT = Model::DescribeNodeRequest;
530 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
531 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
532 "NodeRegisteredWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("ACTIVE"),
533 [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
534 if (!outcome.IsSuccess()) return false;
535 const auto& result = outcome.GetResult();
536 return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get<Aws::String>();
537 }));
538 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
539 "NodeRegisteredWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("REGISTERING"),
540 [](const Model::DescribeNodeOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
541 if (!outcome.IsSuccess()) return false;
542 const auto& result = outcome.GetResult();
543 return Model::NodeStateMapper::GetNameForNodeState(result.GetState()) == expected.get<Aws::String>();
544 }));
545 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::ErrorAcceptor<OutcomeT>>("NodeRegisteredWaiter", Aws::Utils::WaiterState::RETRY,
546 Aws::String("NotFoundException")));
547 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
548 "NodeRegisteredWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("REGISTRATION_FAILED"),
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::ErrorAcceptor<OutcomeT>>("NodeRegisteredWaiter", Aws::Utils::WaiterState::RETRY,
555 Aws::String("InternalServerErrorException")));
556
557 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->DescribeNode(req); };
558 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(3, 40, std::move(acceptors), operation, "WaitUntilNodeRegistered");
559 return waiter.Wait(request);
560 }
561
562 Aws::Utils::WaiterOutcome<Model::GetSignalMapOutcome> WaitUntilSignalMapCreated(const Model::GetSignalMapRequest& request) {
563 using OutcomeT = Model::GetSignalMapOutcome;
564 using RequestT = Model::GetSignalMapRequest;
565 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
566 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
567 "SignalMapCreatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("CREATE_COMPLETE"),
568 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
569 if (!outcome.IsSuccess()) return false;
570 const auto& result = outcome.GetResult();
571 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
572 }));
573 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
574 "SignalMapCreatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("CREATE_IN_PROGRESS"),
575 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
576 if (!outcome.IsSuccess()) return false;
577 const auto& result = outcome.GetResult();
578 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
579 }));
580 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
581 "SignalMapCreatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("CREATE_FAILED"),
582 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
583 if (!outcome.IsSuccess()) return false;
584 const auto& result = outcome.GetResult();
585 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
586 }));
587
588 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetSignalMap(req); };
589 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapCreated");
590 return waiter.Wait(request);
591 }
592
593 Aws::Utils::WaiterOutcome<Model::GetSignalMapOutcome> WaitUntilSignalMapMonitorDeleted(const Model::GetSignalMapRequest& request) {
594 using OutcomeT = Model::GetSignalMapOutcome;
595 using RequestT = Model::GetSignalMapRequest;
596 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
597 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
598 "SignalMapMonitorDeletedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DELETE_COMPLETE"),
599 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
600 if (!outcome.IsSuccess()) return false;
601 const auto& result = outcome.GetResult();
602 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
603 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
604 }));
605 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
606 "SignalMapMonitorDeletedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DELETE_IN_PROGRESS"),
607 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
608 if (!outcome.IsSuccess()) return false;
609 const auto& result = outcome.GetResult();
610 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
611 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
612 }));
613 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
614 "SignalMapMonitorDeletedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("DELETE_FAILED"),
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
622 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetSignalMap(req); };
623 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapMonitorDeleted");
624 return waiter.Wait(request);
625 }
626
627 Aws::Utils::WaiterOutcome<Model::GetSignalMapOutcome> WaitUntilSignalMapMonitorDeployed(const Model::GetSignalMapRequest& request) {
628 using OutcomeT = Model::GetSignalMapOutcome;
629 using RequestT = Model::GetSignalMapRequest;
630 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
631 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
632 "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DRY_RUN_DEPLOYMENT_COMPLETE"),
633 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
634 if (!outcome.IsSuccess()) return false;
635 const auto& result = outcome.GetResult();
636 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
637 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
638 }));
639 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
640 "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("DEPLOYMENT_COMPLETE"),
641 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
642 if (!outcome.IsSuccess()) return false;
643 const auto& result = outcome.GetResult();
644 return Model::SignalMapMonitorDeploymentStatusMapper::GetNameForSignalMapMonitorDeploymentStatus(
645 result.GetMonitorDeployment().GetStatus()) == expected.get<Aws::String>();
646 }));
647 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
648 "SignalMapMonitorDeployedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("DRY_RUN_DEPLOYMENT_IN_PROGRESS"),
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::RETRY, Aws::String("DEPLOYMENT_IN_PROGRESS"),
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::FAILURE, Aws::String("DRY_RUN_DEPLOYMENT_FAILED"),
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::FAILURE, Aws::String("DEPLOYMENT_FAILED"),
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
680 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetSignalMap(req); };
681 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapMonitorDeployed");
682 return waiter.Wait(request);
683 }
684
685 Aws::Utils::WaiterOutcome<Model::GetSignalMapOutcome> WaitUntilSignalMapUpdated(const Model::GetSignalMapRequest& request) {
686 using OutcomeT = Model::GetSignalMapOutcome;
687 using RequestT = Model::GetSignalMapRequest;
688 Aws::Vector<Aws::UniquePtr<Aws::Utils::Acceptor<OutcomeT>>> acceptors;
689 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
690 "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::SUCCESS, Aws::String("UPDATE_COMPLETE"),
691 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
692 if (!outcome.IsSuccess()) return false;
693 const auto& result = outcome.GetResult();
694 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
695 }));
696 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
697 "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::RETRY, Aws::String("UPDATE_IN_PROGRESS"),
698 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
699 if (!outcome.IsSuccess()) return false;
700 const auto& result = outcome.GetResult();
701 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
702 }));
703 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
704 "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_FAILED"),
705 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
706 if (!outcome.IsSuccess()) return false;
707 const auto& result = outcome.GetResult();
708 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
709 }));
710 acceptors.emplace_back(Aws::MakeUnique<Aws::Utils::PathAcceptor<OutcomeT>>(
711 "SignalMapUpdatedWaiter", Aws::Utils::WaiterState::FAILURE, Aws::String("UPDATE_REVERTED"),
712 [](const Model::GetSignalMapOutcome& outcome, const Aws::Utils::ExpectedValue& expected) -> bool {
713 if (!outcome.IsSuccess()) return false;
714 const auto& result = outcome.GetResult();
715 return Model::SignalMapStatusMapper::GetNameForSignalMapStatus(result.GetStatus()) == expected.get<Aws::String>();
716 }));
717
718 auto operation = [this](const RequestT& req) { return static_cast<DerivedClient*>(this)->GetSignalMap(req); };
719 Aws::Utils::Waiter<RequestT, OutcomeT> waiter(5, 24, std::move(acceptors), operation, "WaitUntilSignalMapUpdated");
720 return waiter.Wait(request);
721 }
722};
723} // namespace MediaLive
724} // namespace Aws
Aws::MediaLive::MediaLiveWaiter::WaitUntilChannelPlacementGroupAssigned
Aws::Utils::WaiterOutcome< Model::DescribeChannelPlacementGroupOutcome > WaitUntilChannelPlacementGroupAssigned(const Model::DescribeChannelPlacementGroupRequest &request)
Definition MediaLiveWaiter.h:152
Aws::MediaLive::MediaLiveWaiter::WaitUntilInputAttached
Aws::Utils::WaiterOutcome< Model::DescribeInputOutcome > WaitUntilInputAttached(const Model::DescribeInputRequest &request)
Definition MediaLiveWaiter.h:298
Aws::MediaLive::MediaLiveWaiter::WaitUntilClusterCreated
Aws::Utils::WaiterOutcome< Model::DescribeClusterOutcome > WaitUntilClusterCreated(const Model::DescribeClusterRequest &request)
Definition MediaLiveWaiter.h:239
Aws::MediaLive::MediaLiveWaiter::WaitUntilClusterDeleted
Aws::Utils::WaiterOutcome< Model::DescribeClusterOutcome > WaitUntilClusterDeleted(const Model::DescribeClusterRequest &request)
Definition MediaLiveWaiter.h:272
Aws::MediaLive::MediaLiveWaiter::WaitUntilNodeDeregistered
Aws::Utils::WaiterOutcome< Model::DescribeNodeOutcome > WaitUntilNodeDeregistered(const Model::DescribeNodeRequest &request)
Definition MediaLiveWaiter.h:494
Aws::MediaLive::MediaLiveWaiter::WaitUntilMultiplexCreated
Aws::Utils::WaiterOutcome< Model::DescribeMultiplexOutcome > WaitUntilMultiplexCreated(const Model::DescribeMultiplexRequest &request)
Definition MediaLiveWaiter.h:383
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:350
Aws::MediaLive::MediaLiveWaiter::WaitUntilChannelPlacementGroupDeleted
Aws::Utils::WaiterOutcome< Model::DescribeChannelPlacementGroupOutcome > WaitUntilChannelPlacementGroupDeleted(const Model::DescribeChannelPlacementGroupRequest &request)
Definition MediaLiveWaiter.h:181
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:527
Aws::MediaLive::MediaLiveWaiter::WaitUntilSignalMapUpdated
Aws::Utils::WaiterOutcome< Model::GetSignalMapOutcome > WaitUntilSignalMapUpdated(const Model::GetSignalMapRequest &request)
Definition MediaLiveWaiter.h:685
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:324
Aws::MediaLive::MediaLiveWaiter::WaitUntilSignalMapMonitorDeleted
Aws::Utils::WaiterOutcome< Model::GetSignalMapOutcome > WaitUntilSignalMapMonitorDeleted(const Model::GetSignalMapRequest &request)
Definition MediaLiveWaiter.h:593
Aws::MediaLive::MediaLiveWaiter::WaitUntilMultiplexDeleted
Aws::Utils::WaiterOutcome< Model::DescribeMultiplexOutcome > WaitUntilMultiplexDeleted(const Model::DescribeMultiplexRequest &request)
Definition MediaLiveWaiter.h:416
Aws::MediaLive::MediaLiveWaiter::WaitUntilMultiplexRunning
Aws::Utils::WaiterOutcome< Model::DescribeMultiplexOutcome > WaitUntilMultiplexRunning(const Model::DescribeMultiplexRequest &request)
Definition MediaLiveWaiter.h:442
Aws::MediaLive::MediaLiveWaiter::WaitUntilChannelPlacementGroupUnassigned
Aws::Utils::WaiterOutcome< Model::DescribeChannelPlacementGroupOutcome > WaitUntilChannelPlacementGroupUnassigned(const Model::DescribeChannelPlacementGroupRequest &request)
Definition MediaLiveWaiter.h:210
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:627
Aws::MediaLive::MediaLiveWaiter::WaitUntilSignalMapCreated
Aws::Utils::WaiterOutcome< Model::GetSignalMapOutcome > WaitUntilSignalMapCreated(const Model::GetSignalMapRequest &request)
Definition MediaLiveWaiter.h:562
Aws::MediaLive::MediaLiveWaiter::WaitUntilMultiplexStopped
Aws::Utils::WaiterOutcome< Model::DescribeMultiplexOutcome > WaitUntilMultiplexStopped(const Model::DescribeMultiplexRequest &request)
Definition MediaLiveWaiter.h:468
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