1 // Copyright 2023 gRPC authors. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #ifndef GRPC_SRC_CORE_LIB_PROMISE_DETAIL_SEQ_STATE_H 16 #define GRPC_SRC_CORE_LIB_PROMISE_DETAIL_SEQ_STATE_H 17 18 // This file is generated by tools/codegen/core/gen_seq.py 19 20 #include <grpc/support/port_platform.h> 21 #include <stdint.h> 22 23 #include <utility> 24 25 #include "absl/base/attributes.h" 26 #include "absl/log/check.h" 27 #include "absl/log/log.h" 28 #include "absl/strings/str_cat.h" 29 #include "src/core/lib/debug/trace.h" 30 #include "src/core/lib/promise/detail/promise_factory.h" 31 #include "src/core/lib/promise/detail/promise_like.h" 32 #include "src/core/lib/promise/poll.h" 33 #include "src/core/util/construct_destruct.h" 34 #include "src/core/util/debug_location.h" 35 36 // A sequence under some traits for some set of callables P, Fs. 37 // P should be a promise-like object that yields a value. 38 // Fs... should be promise-factory-like objects that take the value from the 39 // previous step and yield a promise. Note that most of the machinery in 40 // PromiseFactory exists to make it possible for those promise-factory-like 41 // objects to be anything that's convenient. 42 // Traits defines how we move from one step to the next. Traits sets up the 43 // wrapping and escape handling for the sequence. 44 // Promises return wrapped values that the trait can inspect and unwrap before 45 // passing them to the next element of the sequence. The trait can 46 // also interpret a wrapped value as an escape value, which terminates 47 // evaluation of the sequence immediately yielding a result. Traits for type T 48 // have the members: 49 // * type UnwrappedType - the type after removing wrapping from T (i.e. for 50 // TrySeq, T=StatusOr<U> yields UnwrappedType=U). 51 // * type WrappedType - the type after adding wrapping if it doesn't already 52 // exist (i.e. for TrySeq if T is not Status/StatusOr/void, then 53 // WrappedType=StatusOr<T>; if T is Status then WrappedType=Status (it's 54 // already wrapped!)) 55 // * template <typename Next> void CallFactory(Next* next_factory, T&& value) - 56 // call promise factory next_factory with the result of unwrapping value, and 57 // return the resulting promise. 58 // * template <typename Result, typename RunNext> Poll<Result> 59 // CheckResultAndRunNext(T prior, RunNext run_next) - examine the value of 60 // prior, and decide to escape or continue. If escaping, return the final 61 // sequence value of type Poll<Result>. If continuing, return the value of 62 // run_next(std::move(prior)). 63 // 64 // A state contains the current promise, and the promise factory to turn the 65 // result of the current promise into the next state's promise. We play a shell 66 // game such that the prior state and our current promise are kept in a union, 67 // and the next promise factory is kept alongside in the state struct. 68 // Recursively this guarantees that the next functions get initialized once, and 69 // destroyed once, and don't need to be moved around in between, which avoids a 70 // potential O(n**2) loop of next factory moves had we used a variant of states 71 // here. The very first state does not have a prior state, and so that state has 72 // a partial specialization below. The final state does not have a next state; 73 // that state is inlined in BasicSeq since that was simpler to type. 74 75 namespace grpc_core { 76 namespace promise_detail { 77 template <template <typename> class Traits, typename P, typename... Fs> 78 struct SeqState; 79 80 template <template <typename> class Traits, typename P, typename F0> 81 struct SeqState<Traits, P, F0> { 82 using Promise0 = PromiseLike<P>; 83 using PromiseResult0 = typename Promise0::Result; 84 using PromiseResultTraits0 = Traits<PromiseResult0>; 85 using NextFactory0 = 86 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 87 using Promise1 = typename NextFactory0::Promise; 88 using PromiseResult1 = typename Promise1::Result; 89 using PromiseResultTraits1 = Traits<PromiseResult1>; 90 using Result = typename PromiseResultTraits1::WrappedType; 91 struct Running0 { 92 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 93 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 94 }; 95 union { 96 GPR_NO_UNIQUE_ADDRESS Running0 prior; 97 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 98 }; 99 enum class State : uint8_t { kState0, kState1 }; 100 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 101 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 102 103 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, 104 DebugLocation whence) noexcept 105 : whence(whence) { 106 Construct(&prior.current_promise, std::forward<P>(p)); 107 Construct(&prior.next_factory, std::forward<F0>(f0)); 108 } 109 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 110 switch (state) { 111 case State::kState0: 112 Destruct(&prior.current_promise); 113 goto tail0; 114 case State::kState1: 115 Destruct(¤t_promise); 116 return; 117 } 118 tail0: 119 Destruct(&prior.next_factory); 120 } 121 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 122 : state(other.state), whence(other.whence) { 123 DCHECK(state == State::kState0); 124 Construct(&prior.current_promise, other.prior.current_promise); 125 Construct(&prior.next_factory, other.prior.next_factory); 126 } 127 SeqState& operator=(const SeqState& other) = delete; 128 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 129 : state(other.state), whence(other.whence) { 130 DCHECK(state == State::kState0); 131 Construct(&prior.current_promise, std::move(other.prior.current_promise)); 132 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 133 } 134 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 135 delete; 136 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 137 switch (state) { 138 case State::kState0: { 139 GRPC_TRACE_LOG(promise_primitives, INFO) 140 .AtLocation(whence.file(), whence.line()) 141 << "seq[" << this << "]: begin poll step 1/2"; 142 auto result = prior.current_promise(); 143 PromiseResult0* p = result.value_if_ready(); 144 GRPC_TRACE_LOG(promise_primitives, INFO) 145 .AtLocation(whence.file(), whence.line()) 146 << "seq[" << this << "]: poll step 1/2 gets " 147 << (p != nullptr 148 ? (PromiseResultTraits0::IsOk(*p) 149 ? "ready" 150 : absl::StrCat("early-error:", 151 PromiseResultTraits0::ErrorString(*p)) 152 .c_str()) 153 : "pending"); 154 if (p == nullptr) return Pending{}; 155 if (!PromiseResultTraits0::IsOk(*p)) { 156 return PromiseResultTraits0::template ReturnValue<Result>( 157 std::move(*p)); 158 } 159 Destruct(&prior.current_promise); 160 auto next_promise = PromiseResultTraits0::CallFactory( 161 &prior.next_factory, std::move(*p)); 162 Destruct(&prior.next_factory); 163 Construct(¤t_promise, std::move(next_promise)); 164 state = State::kState1; 165 } 166 ABSL_FALLTHROUGH_INTENDED; 167 default: 168 case State::kState1: { 169 GRPC_TRACE_LOG(promise_primitives, INFO) 170 .AtLocation(whence.file(), whence.line()) 171 << "seq[" << this << "]: begin poll step 2/2"; 172 auto result = current_promise(); 173 GRPC_TRACE_LOG(promise_primitives, INFO) 174 .AtLocation(whence.file(), whence.line()) 175 << "seq[" << this << "]: poll step 2/2 gets " 176 << (result.ready() ? "ready" : "pending"); 177 auto* p = result.value_if_ready(); 178 if (p == nullptr) return Pending{}; 179 return Result(std::move(*p)); 180 } 181 } 182 } 183 }; 184 185 template <template <typename> class Traits, typename P, typename F0, 186 typename F1> 187 struct SeqState<Traits, P, F0, F1> { 188 using Promise0 = PromiseLike<P>; 189 using PromiseResult0 = typename Promise0::Result; 190 using PromiseResultTraits0 = Traits<PromiseResult0>; 191 using NextFactory0 = 192 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 193 using Promise1 = typename NextFactory0::Promise; 194 using PromiseResult1 = typename Promise1::Result; 195 using PromiseResultTraits1 = Traits<PromiseResult1>; 196 using NextFactory1 = 197 OncePromiseFactory<typename PromiseResultTraits1::UnwrappedType, F1>; 198 using Promise2 = typename NextFactory1::Promise; 199 using PromiseResult2 = typename Promise2::Result; 200 using PromiseResultTraits2 = Traits<PromiseResult2>; 201 using Result = typename PromiseResultTraits2::WrappedType; 202 struct Running0 { 203 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 204 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 205 }; 206 struct Running1 { 207 union { 208 GPR_NO_UNIQUE_ADDRESS Running0 prior; 209 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 210 }; 211 GPR_NO_UNIQUE_ADDRESS NextFactory1 next_factory; 212 }; 213 union { 214 GPR_NO_UNIQUE_ADDRESS Running1 prior; 215 GPR_NO_UNIQUE_ADDRESS Promise2 current_promise; 216 }; 217 enum class State : uint8_t { kState0, kState1, kState2 }; 218 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 219 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 220 221 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, F1&& f1, 222 DebugLocation whence) noexcept 223 : whence(whence) { 224 Construct(&prior.prior.current_promise, std::forward<P>(p)); 225 Construct(&prior.prior.next_factory, std::forward<F0>(f0)); 226 Construct(&prior.next_factory, std::forward<F1>(f1)); 227 } 228 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 229 switch (state) { 230 case State::kState0: 231 Destruct(&prior.prior.current_promise); 232 goto tail0; 233 case State::kState1: 234 Destruct(&prior.current_promise); 235 goto tail1; 236 case State::kState2: 237 Destruct(¤t_promise); 238 return; 239 } 240 tail0: 241 Destruct(&prior.prior.next_factory); 242 tail1: 243 Destruct(&prior.next_factory); 244 } 245 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 246 : state(other.state), whence(other.whence) { 247 DCHECK(state == State::kState0); 248 Construct(&prior.prior.current_promise, other.prior.prior.current_promise); 249 Construct(&prior.prior.next_factory, other.prior.prior.next_factory); 250 Construct(&prior.next_factory, other.prior.next_factory); 251 } 252 SeqState& operator=(const SeqState& other) = delete; 253 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 254 : state(other.state), whence(other.whence) { 255 DCHECK(state == State::kState0); 256 Construct(&prior.prior.current_promise, 257 std::move(other.prior.prior.current_promise)); 258 Construct(&prior.prior.next_factory, 259 std::move(other.prior.prior.next_factory)); 260 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 261 } 262 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 263 delete; 264 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 265 switch (state) { 266 case State::kState0: { 267 GRPC_TRACE_LOG(promise_primitives, INFO) 268 .AtLocation(whence.file(), whence.line()) 269 << "seq[" << this << "]: begin poll step 1/3"; 270 auto result = prior.prior.current_promise(); 271 PromiseResult0* p = result.value_if_ready(); 272 GRPC_TRACE_LOG(promise_primitives, INFO) 273 .AtLocation(whence.file(), whence.line()) 274 << "seq[" << this << "]: poll step 1/3 gets " 275 << (p != nullptr 276 ? (PromiseResultTraits0::IsOk(*p) 277 ? "ready" 278 : absl::StrCat("early-error:", 279 PromiseResultTraits0::ErrorString(*p)) 280 .c_str()) 281 : "pending"); 282 if (p == nullptr) return Pending{}; 283 if (!PromiseResultTraits0::IsOk(*p)) { 284 return PromiseResultTraits0::template ReturnValue<Result>( 285 std::move(*p)); 286 } 287 Destruct(&prior.prior.current_promise); 288 auto next_promise = PromiseResultTraits0::CallFactory( 289 &prior.prior.next_factory, std::move(*p)); 290 Destruct(&prior.prior.next_factory); 291 Construct(&prior.current_promise, std::move(next_promise)); 292 state = State::kState1; 293 } 294 ABSL_FALLTHROUGH_INTENDED; 295 case State::kState1: { 296 GRPC_TRACE_LOG(promise_primitives, INFO) 297 .AtLocation(whence.file(), whence.line()) 298 << "seq[" << this << "]: begin poll step 2/3"; 299 auto result = prior.current_promise(); 300 PromiseResult1* p = result.value_if_ready(); 301 GRPC_TRACE_LOG(promise_primitives, INFO) 302 .AtLocation(whence.file(), whence.line()) 303 << "seq[" << this << "]: poll step 2/3 gets " 304 << (p != nullptr 305 ? (PromiseResultTraits1::IsOk(*p) 306 ? "ready" 307 : absl::StrCat("early-error:", 308 PromiseResultTraits1::ErrorString(*p)) 309 .c_str()) 310 : "pending"); 311 if (p == nullptr) return Pending{}; 312 if (!PromiseResultTraits1::IsOk(*p)) { 313 return PromiseResultTraits1::template ReturnValue<Result>( 314 std::move(*p)); 315 } 316 Destruct(&prior.current_promise); 317 auto next_promise = PromiseResultTraits1::CallFactory( 318 &prior.next_factory, std::move(*p)); 319 Destruct(&prior.next_factory); 320 Construct(¤t_promise, std::move(next_promise)); 321 state = State::kState2; 322 } 323 ABSL_FALLTHROUGH_INTENDED; 324 default: 325 case State::kState2: { 326 GRPC_TRACE_LOG(promise_primitives, INFO) 327 .AtLocation(whence.file(), whence.line()) 328 << "seq[" << this << "]: begin poll step 3/3"; 329 auto result = current_promise(); 330 GRPC_TRACE_LOG(promise_primitives, INFO) 331 .AtLocation(whence.file(), whence.line()) 332 << "seq[" << this << "]: poll step 3/3 gets " 333 << (result.ready() ? "ready" : "pending"); 334 auto* p = result.value_if_ready(); 335 if (p == nullptr) return Pending{}; 336 return Result(std::move(*p)); 337 } 338 } 339 } 340 }; 341 342 template <template <typename> class Traits, typename P, typename F0, 343 typename F1, typename F2> 344 struct SeqState<Traits, P, F0, F1, F2> { 345 using Promise0 = PromiseLike<P>; 346 using PromiseResult0 = typename Promise0::Result; 347 using PromiseResultTraits0 = Traits<PromiseResult0>; 348 using NextFactory0 = 349 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 350 using Promise1 = typename NextFactory0::Promise; 351 using PromiseResult1 = typename Promise1::Result; 352 using PromiseResultTraits1 = Traits<PromiseResult1>; 353 using NextFactory1 = 354 OncePromiseFactory<typename PromiseResultTraits1::UnwrappedType, F1>; 355 using Promise2 = typename NextFactory1::Promise; 356 using PromiseResult2 = typename Promise2::Result; 357 using PromiseResultTraits2 = Traits<PromiseResult2>; 358 using NextFactory2 = 359 OncePromiseFactory<typename PromiseResultTraits2::UnwrappedType, F2>; 360 using Promise3 = typename NextFactory2::Promise; 361 using PromiseResult3 = typename Promise3::Result; 362 using PromiseResultTraits3 = Traits<PromiseResult3>; 363 using Result = typename PromiseResultTraits3::WrappedType; 364 struct Running0 { 365 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 366 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 367 }; 368 struct Running1 { 369 union { 370 GPR_NO_UNIQUE_ADDRESS Running0 prior; 371 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 372 }; 373 GPR_NO_UNIQUE_ADDRESS NextFactory1 next_factory; 374 }; 375 struct Running2 { 376 union { 377 GPR_NO_UNIQUE_ADDRESS Running1 prior; 378 GPR_NO_UNIQUE_ADDRESS Promise2 current_promise; 379 }; 380 GPR_NO_UNIQUE_ADDRESS NextFactory2 next_factory; 381 }; 382 union { 383 GPR_NO_UNIQUE_ADDRESS Running2 prior; 384 GPR_NO_UNIQUE_ADDRESS Promise3 current_promise; 385 }; 386 enum class State : uint8_t { kState0, kState1, kState2, kState3 }; 387 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 388 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 389 390 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, F1&& f1, 391 F2&& f2, 392 DebugLocation whence) noexcept 393 : whence(whence) { 394 Construct(&prior.prior.prior.current_promise, std::forward<P>(p)); 395 Construct(&prior.prior.prior.next_factory, std::forward<F0>(f0)); 396 Construct(&prior.prior.next_factory, std::forward<F1>(f1)); 397 Construct(&prior.next_factory, std::forward<F2>(f2)); 398 } 399 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 400 switch (state) { 401 case State::kState0: 402 Destruct(&prior.prior.prior.current_promise); 403 goto tail0; 404 case State::kState1: 405 Destruct(&prior.prior.current_promise); 406 goto tail1; 407 case State::kState2: 408 Destruct(&prior.current_promise); 409 goto tail2; 410 case State::kState3: 411 Destruct(¤t_promise); 412 return; 413 } 414 tail0: 415 Destruct(&prior.prior.prior.next_factory); 416 tail1: 417 Destruct(&prior.prior.next_factory); 418 tail2: 419 Destruct(&prior.next_factory); 420 } 421 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 422 : state(other.state), whence(other.whence) { 423 DCHECK(state == State::kState0); 424 Construct(&prior.prior.prior.current_promise, 425 other.prior.prior.prior.current_promise); 426 Construct(&prior.prior.prior.next_factory, 427 other.prior.prior.prior.next_factory); 428 Construct(&prior.prior.next_factory, other.prior.prior.next_factory); 429 Construct(&prior.next_factory, other.prior.next_factory); 430 } 431 SeqState& operator=(const SeqState& other) = delete; 432 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 433 : state(other.state), whence(other.whence) { 434 DCHECK(state == State::kState0); 435 Construct(&prior.prior.prior.current_promise, 436 std::move(other.prior.prior.prior.current_promise)); 437 Construct(&prior.prior.prior.next_factory, 438 std::move(other.prior.prior.prior.next_factory)); 439 Construct(&prior.prior.next_factory, 440 std::move(other.prior.prior.next_factory)); 441 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 442 } 443 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 444 delete; 445 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 446 switch (state) { 447 case State::kState0: { 448 GRPC_TRACE_LOG(promise_primitives, INFO) 449 .AtLocation(whence.file(), whence.line()) 450 << "seq[" << this << "]: begin poll step 1/4"; 451 auto result = prior.prior.prior.current_promise(); 452 PromiseResult0* p = result.value_if_ready(); 453 GRPC_TRACE_LOG(promise_primitives, INFO) 454 .AtLocation(whence.file(), whence.line()) 455 << "seq[" << this << "]: poll step 1/4 gets " 456 << (p != nullptr 457 ? (PromiseResultTraits0::IsOk(*p) 458 ? "ready" 459 : absl::StrCat("early-error:", 460 PromiseResultTraits0::ErrorString(*p)) 461 .c_str()) 462 : "pending"); 463 if (p == nullptr) return Pending{}; 464 if (!PromiseResultTraits0::IsOk(*p)) { 465 return PromiseResultTraits0::template ReturnValue<Result>( 466 std::move(*p)); 467 } 468 Destruct(&prior.prior.prior.current_promise); 469 auto next_promise = PromiseResultTraits0::CallFactory( 470 &prior.prior.prior.next_factory, std::move(*p)); 471 Destruct(&prior.prior.prior.next_factory); 472 Construct(&prior.prior.current_promise, std::move(next_promise)); 473 state = State::kState1; 474 } 475 ABSL_FALLTHROUGH_INTENDED; 476 case State::kState1: { 477 GRPC_TRACE_LOG(promise_primitives, INFO) 478 .AtLocation(whence.file(), whence.line()) 479 << "seq[" << this << "]: begin poll step 2/4"; 480 auto result = prior.prior.current_promise(); 481 PromiseResult1* p = result.value_if_ready(); 482 GRPC_TRACE_LOG(promise_primitives, INFO) 483 .AtLocation(whence.file(), whence.line()) 484 << "seq[" << this << "]: poll step 2/4 gets " 485 << (p != nullptr 486 ? (PromiseResultTraits1::IsOk(*p) 487 ? "ready" 488 : absl::StrCat("early-error:", 489 PromiseResultTraits1::ErrorString(*p)) 490 .c_str()) 491 : "pending"); 492 if (p == nullptr) return Pending{}; 493 if (!PromiseResultTraits1::IsOk(*p)) { 494 return PromiseResultTraits1::template ReturnValue<Result>( 495 std::move(*p)); 496 } 497 Destruct(&prior.prior.current_promise); 498 auto next_promise = PromiseResultTraits1::CallFactory( 499 &prior.prior.next_factory, std::move(*p)); 500 Destruct(&prior.prior.next_factory); 501 Construct(&prior.current_promise, std::move(next_promise)); 502 state = State::kState2; 503 } 504 ABSL_FALLTHROUGH_INTENDED; 505 case State::kState2: { 506 GRPC_TRACE_LOG(promise_primitives, INFO) 507 .AtLocation(whence.file(), whence.line()) 508 << "seq[" << this << "]: begin poll step 3/4"; 509 auto result = prior.current_promise(); 510 PromiseResult2* p = result.value_if_ready(); 511 GRPC_TRACE_LOG(promise_primitives, INFO) 512 .AtLocation(whence.file(), whence.line()) 513 << "seq[" << this << "]: poll step 3/4 gets " 514 << (p != nullptr 515 ? (PromiseResultTraits2::IsOk(*p) 516 ? "ready" 517 : absl::StrCat("early-error:", 518 PromiseResultTraits2::ErrorString(*p)) 519 .c_str()) 520 : "pending"); 521 if (p == nullptr) return Pending{}; 522 if (!PromiseResultTraits2::IsOk(*p)) { 523 return PromiseResultTraits2::template ReturnValue<Result>( 524 std::move(*p)); 525 } 526 Destruct(&prior.current_promise); 527 auto next_promise = PromiseResultTraits2::CallFactory( 528 &prior.next_factory, std::move(*p)); 529 Destruct(&prior.next_factory); 530 Construct(¤t_promise, std::move(next_promise)); 531 state = State::kState3; 532 } 533 ABSL_FALLTHROUGH_INTENDED; 534 default: 535 case State::kState3: { 536 GRPC_TRACE_LOG(promise_primitives, INFO) 537 .AtLocation(whence.file(), whence.line()) 538 << "seq[" << this << "]: begin poll step 4/4"; 539 auto result = current_promise(); 540 GRPC_TRACE_LOG(promise_primitives, INFO) 541 .AtLocation(whence.file(), whence.line()) 542 << "seq[" << this << "]: poll step 4/4 gets " 543 << (result.ready() ? "ready" : "pending"); 544 auto* p = result.value_if_ready(); 545 if (p == nullptr) return Pending{}; 546 return Result(std::move(*p)); 547 } 548 } 549 } 550 }; 551 552 template <template <typename> class Traits, typename P, typename F0, 553 typename F1, typename F2, typename F3> 554 struct SeqState<Traits, P, F0, F1, F2, F3> { 555 using Promise0 = PromiseLike<P>; 556 using PromiseResult0 = typename Promise0::Result; 557 using PromiseResultTraits0 = Traits<PromiseResult0>; 558 using NextFactory0 = 559 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 560 using Promise1 = typename NextFactory0::Promise; 561 using PromiseResult1 = typename Promise1::Result; 562 using PromiseResultTraits1 = Traits<PromiseResult1>; 563 using NextFactory1 = 564 OncePromiseFactory<typename PromiseResultTraits1::UnwrappedType, F1>; 565 using Promise2 = typename NextFactory1::Promise; 566 using PromiseResult2 = typename Promise2::Result; 567 using PromiseResultTraits2 = Traits<PromiseResult2>; 568 using NextFactory2 = 569 OncePromiseFactory<typename PromiseResultTraits2::UnwrappedType, F2>; 570 using Promise3 = typename NextFactory2::Promise; 571 using PromiseResult3 = typename Promise3::Result; 572 using PromiseResultTraits3 = Traits<PromiseResult3>; 573 using NextFactory3 = 574 OncePromiseFactory<typename PromiseResultTraits3::UnwrappedType, F3>; 575 using Promise4 = typename NextFactory3::Promise; 576 using PromiseResult4 = typename Promise4::Result; 577 using PromiseResultTraits4 = Traits<PromiseResult4>; 578 using Result = typename PromiseResultTraits4::WrappedType; 579 struct Running0 { 580 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 581 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 582 }; 583 struct Running1 { 584 union { 585 GPR_NO_UNIQUE_ADDRESS Running0 prior; 586 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 587 }; 588 GPR_NO_UNIQUE_ADDRESS NextFactory1 next_factory; 589 }; 590 struct Running2 { 591 union { 592 GPR_NO_UNIQUE_ADDRESS Running1 prior; 593 GPR_NO_UNIQUE_ADDRESS Promise2 current_promise; 594 }; 595 GPR_NO_UNIQUE_ADDRESS NextFactory2 next_factory; 596 }; 597 struct Running3 { 598 union { 599 GPR_NO_UNIQUE_ADDRESS Running2 prior; 600 GPR_NO_UNIQUE_ADDRESS Promise3 current_promise; 601 }; 602 GPR_NO_UNIQUE_ADDRESS NextFactory3 next_factory; 603 }; 604 union { 605 GPR_NO_UNIQUE_ADDRESS Running3 prior; 606 GPR_NO_UNIQUE_ADDRESS Promise4 current_promise; 607 }; 608 enum class State : uint8_t { kState0, kState1, kState2, kState3, kState4 }; 609 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 610 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 611 612 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, F1&& f1, 613 F2&& f2, F3&& f3, 614 DebugLocation whence) noexcept 615 : whence(whence) { 616 Construct(&prior.prior.prior.prior.current_promise, std::forward<P>(p)); 617 Construct(&prior.prior.prior.prior.next_factory, std::forward<F0>(f0)); 618 Construct(&prior.prior.prior.next_factory, std::forward<F1>(f1)); 619 Construct(&prior.prior.next_factory, std::forward<F2>(f2)); 620 Construct(&prior.next_factory, std::forward<F3>(f3)); 621 } 622 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 623 switch (state) { 624 case State::kState0: 625 Destruct(&prior.prior.prior.prior.current_promise); 626 goto tail0; 627 case State::kState1: 628 Destruct(&prior.prior.prior.current_promise); 629 goto tail1; 630 case State::kState2: 631 Destruct(&prior.prior.current_promise); 632 goto tail2; 633 case State::kState3: 634 Destruct(&prior.current_promise); 635 goto tail3; 636 case State::kState4: 637 Destruct(¤t_promise); 638 return; 639 } 640 tail0: 641 Destruct(&prior.prior.prior.prior.next_factory); 642 tail1: 643 Destruct(&prior.prior.prior.next_factory); 644 tail2: 645 Destruct(&prior.prior.next_factory); 646 tail3: 647 Destruct(&prior.next_factory); 648 } 649 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 650 : state(other.state), whence(other.whence) { 651 DCHECK(state == State::kState0); 652 Construct(&prior.prior.prior.prior.current_promise, 653 other.prior.prior.prior.prior.current_promise); 654 Construct(&prior.prior.prior.prior.next_factory, 655 other.prior.prior.prior.prior.next_factory); 656 Construct(&prior.prior.prior.next_factory, 657 other.prior.prior.prior.next_factory); 658 Construct(&prior.prior.next_factory, other.prior.prior.next_factory); 659 Construct(&prior.next_factory, other.prior.next_factory); 660 } 661 SeqState& operator=(const SeqState& other) = delete; 662 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 663 : state(other.state), whence(other.whence) { 664 DCHECK(state == State::kState0); 665 Construct(&prior.prior.prior.prior.current_promise, 666 std::move(other.prior.prior.prior.prior.current_promise)); 667 Construct(&prior.prior.prior.prior.next_factory, 668 std::move(other.prior.prior.prior.prior.next_factory)); 669 Construct(&prior.prior.prior.next_factory, 670 std::move(other.prior.prior.prior.next_factory)); 671 Construct(&prior.prior.next_factory, 672 std::move(other.prior.prior.next_factory)); 673 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 674 } 675 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 676 delete; 677 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 678 switch (state) { 679 case State::kState0: { 680 GRPC_TRACE_LOG(promise_primitives, INFO) 681 .AtLocation(whence.file(), whence.line()) 682 << "seq[" << this << "]: begin poll step 1/5"; 683 auto result = prior.prior.prior.prior.current_promise(); 684 PromiseResult0* p = result.value_if_ready(); 685 GRPC_TRACE_LOG(promise_primitives, INFO) 686 .AtLocation(whence.file(), whence.line()) 687 << "seq[" << this << "]: poll step 1/5 gets " 688 << (p != nullptr 689 ? (PromiseResultTraits0::IsOk(*p) 690 ? "ready" 691 : absl::StrCat("early-error:", 692 PromiseResultTraits0::ErrorString(*p)) 693 .c_str()) 694 : "pending"); 695 if (p == nullptr) return Pending{}; 696 if (!PromiseResultTraits0::IsOk(*p)) { 697 return PromiseResultTraits0::template ReturnValue<Result>( 698 std::move(*p)); 699 } 700 Destruct(&prior.prior.prior.prior.current_promise); 701 auto next_promise = PromiseResultTraits0::CallFactory( 702 &prior.prior.prior.prior.next_factory, std::move(*p)); 703 Destruct(&prior.prior.prior.prior.next_factory); 704 Construct(&prior.prior.prior.current_promise, std::move(next_promise)); 705 state = State::kState1; 706 } 707 ABSL_FALLTHROUGH_INTENDED; 708 case State::kState1: { 709 GRPC_TRACE_LOG(promise_primitives, INFO) 710 .AtLocation(whence.file(), whence.line()) 711 << "seq[" << this << "]: begin poll step 2/5"; 712 auto result = prior.prior.prior.current_promise(); 713 PromiseResult1* p = result.value_if_ready(); 714 GRPC_TRACE_LOG(promise_primitives, INFO) 715 .AtLocation(whence.file(), whence.line()) 716 << "seq[" << this << "]: poll step 2/5 gets " 717 << (p != nullptr 718 ? (PromiseResultTraits1::IsOk(*p) 719 ? "ready" 720 : absl::StrCat("early-error:", 721 PromiseResultTraits1::ErrorString(*p)) 722 .c_str()) 723 : "pending"); 724 if (p == nullptr) return Pending{}; 725 if (!PromiseResultTraits1::IsOk(*p)) { 726 return PromiseResultTraits1::template ReturnValue<Result>( 727 std::move(*p)); 728 } 729 Destruct(&prior.prior.prior.current_promise); 730 auto next_promise = PromiseResultTraits1::CallFactory( 731 &prior.prior.prior.next_factory, std::move(*p)); 732 Destruct(&prior.prior.prior.next_factory); 733 Construct(&prior.prior.current_promise, std::move(next_promise)); 734 state = State::kState2; 735 } 736 ABSL_FALLTHROUGH_INTENDED; 737 case State::kState2: { 738 GRPC_TRACE_LOG(promise_primitives, INFO) 739 .AtLocation(whence.file(), whence.line()) 740 << "seq[" << this << "]: begin poll step 3/5"; 741 auto result = prior.prior.current_promise(); 742 PromiseResult2* p = result.value_if_ready(); 743 GRPC_TRACE_LOG(promise_primitives, INFO) 744 .AtLocation(whence.file(), whence.line()) 745 << "seq[" << this << "]: poll step 3/5 gets " 746 << (p != nullptr 747 ? (PromiseResultTraits2::IsOk(*p) 748 ? "ready" 749 : absl::StrCat("early-error:", 750 PromiseResultTraits2::ErrorString(*p)) 751 .c_str()) 752 : "pending"); 753 if (p == nullptr) return Pending{}; 754 if (!PromiseResultTraits2::IsOk(*p)) { 755 return PromiseResultTraits2::template ReturnValue<Result>( 756 std::move(*p)); 757 } 758 Destruct(&prior.prior.current_promise); 759 auto next_promise = PromiseResultTraits2::CallFactory( 760 &prior.prior.next_factory, std::move(*p)); 761 Destruct(&prior.prior.next_factory); 762 Construct(&prior.current_promise, std::move(next_promise)); 763 state = State::kState3; 764 } 765 ABSL_FALLTHROUGH_INTENDED; 766 case State::kState3: { 767 GRPC_TRACE_LOG(promise_primitives, INFO) 768 .AtLocation(whence.file(), whence.line()) 769 << "seq[" << this << "]: begin poll step 4/5"; 770 auto result = prior.current_promise(); 771 PromiseResult3* p = result.value_if_ready(); 772 GRPC_TRACE_LOG(promise_primitives, INFO) 773 .AtLocation(whence.file(), whence.line()) 774 << "seq[" << this << "]: poll step 4/5 gets " 775 << (p != nullptr 776 ? (PromiseResultTraits3::IsOk(*p) 777 ? "ready" 778 : absl::StrCat("early-error:", 779 PromiseResultTraits3::ErrorString(*p)) 780 .c_str()) 781 : "pending"); 782 if (p == nullptr) return Pending{}; 783 if (!PromiseResultTraits3::IsOk(*p)) { 784 return PromiseResultTraits3::template ReturnValue<Result>( 785 std::move(*p)); 786 } 787 Destruct(&prior.current_promise); 788 auto next_promise = PromiseResultTraits3::CallFactory( 789 &prior.next_factory, std::move(*p)); 790 Destruct(&prior.next_factory); 791 Construct(¤t_promise, std::move(next_promise)); 792 state = State::kState4; 793 } 794 ABSL_FALLTHROUGH_INTENDED; 795 default: 796 case State::kState4: { 797 GRPC_TRACE_LOG(promise_primitives, INFO) 798 .AtLocation(whence.file(), whence.line()) 799 << "seq[" << this << "]: begin poll step 5/5"; 800 auto result = current_promise(); 801 GRPC_TRACE_LOG(promise_primitives, INFO) 802 .AtLocation(whence.file(), whence.line()) 803 << "seq[" << this << "]: poll step 5/5 gets " 804 << (result.ready() ? "ready" : "pending"); 805 auto* p = result.value_if_ready(); 806 if (p == nullptr) return Pending{}; 807 return Result(std::move(*p)); 808 } 809 } 810 } 811 }; 812 813 template <template <typename> class Traits, typename P, typename F0, 814 typename F1, typename F2, typename F3, typename F4> 815 struct SeqState<Traits, P, F0, F1, F2, F3, F4> { 816 using Promise0 = PromiseLike<P>; 817 using PromiseResult0 = typename Promise0::Result; 818 using PromiseResultTraits0 = Traits<PromiseResult0>; 819 using NextFactory0 = 820 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 821 using Promise1 = typename NextFactory0::Promise; 822 using PromiseResult1 = typename Promise1::Result; 823 using PromiseResultTraits1 = Traits<PromiseResult1>; 824 using NextFactory1 = 825 OncePromiseFactory<typename PromiseResultTraits1::UnwrappedType, F1>; 826 using Promise2 = typename NextFactory1::Promise; 827 using PromiseResult2 = typename Promise2::Result; 828 using PromiseResultTraits2 = Traits<PromiseResult2>; 829 using NextFactory2 = 830 OncePromiseFactory<typename PromiseResultTraits2::UnwrappedType, F2>; 831 using Promise3 = typename NextFactory2::Promise; 832 using PromiseResult3 = typename Promise3::Result; 833 using PromiseResultTraits3 = Traits<PromiseResult3>; 834 using NextFactory3 = 835 OncePromiseFactory<typename PromiseResultTraits3::UnwrappedType, F3>; 836 using Promise4 = typename NextFactory3::Promise; 837 using PromiseResult4 = typename Promise4::Result; 838 using PromiseResultTraits4 = Traits<PromiseResult4>; 839 using NextFactory4 = 840 OncePromiseFactory<typename PromiseResultTraits4::UnwrappedType, F4>; 841 using Promise5 = typename NextFactory4::Promise; 842 using PromiseResult5 = typename Promise5::Result; 843 using PromiseResultTraits5 = Traits<PromiseResult5>; 844 using Result = typename PromiseResultTraits5::WrappedType; 845 struct Running0 { 846 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 847 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 848 }; 849 struct Running1 { 850 union { 851 GPR_NO_UNIQUE_ADDRESS Running0 prior; 852 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 853 }; 854 GPR_NO_UNIQUE_ADDRESS NextFactory1 next_factory; 855 }; 856 struct Running2 { 857 union { 858 GPR_NO_UNIQUE_ADDRESS Running1 prior; 859 GPR_NO_UNIQUE_ADDRESS Promise2 current_promise; 860 }; 861 GPR_NO_UNIQUE_ADDRESS NextFactory2 next_factory; 862 }; 863 struct Running3 { 864 union { 865 GPR_NO_UNIQUE_ADDRESS Running2 prior; 866 GPR_NO_UNIQUE_ADDRESS Promise3 current_promise; 867 }; 868 GPR_NO_UNIQUE_ADDRESS NextFactory3 next_factory; 869 }; 870 struct Running4 { 871 union { 872 GPR_NO_UNIQUE_ADDRESS Running3 prior; 873 GPR_NO_UNIQUE_ADDRESS Promise4 current_promise; 874 }; 875 GPR_NO_UNIQUE_ADDRESS NextFactory4 next_factory; 876 }; 877 union { 878 GPR_NO_UNIQUE_ADDRESS Running4 prior; 879 GPR_NO_UNIQUE_ADDRESS Promise5 current_promise; 880 }; 881 enum class State : uint8_t { 882 kState0, 883 kState1, 884 kState2, 885 kState3, 886 kState4, 887 kState5 888 }; 889 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 890 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 891 892 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, F1&& f1, 893 F2&& f2, F3&& f3, F4&& f4, 894 DebugLocation whence) noexcept 895 : whence(whence) { 896 Construct(&prior.prior.prior.prior.prior.current_promise, 897 std::forward<P>(p)); 898 Construct(&prior.prior.prior.prior.prior.next_factory, 899 std::forward<F0>(f0)); 900 Construct(&prior.prior.prior.prior.next_factory, std::forward<F1>(f1)); 901 Construct(&prior.prior.prior.next_factory, std::forward<F2>(f2)); 902 Construct(&prior.prior.next_factory, std::forward<F3>(f3)); 903 Construct(&prior.next_factory, std::forward<F4>(f4)); 904 } 905 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 906 switch (state) { 907 case State::kState0: 908 Destruct(&prior.prior.prior.prior.prior.current_promise); 909 goto tail0; 910 case State::kState1: 911 Destruct(&prior.prior.prior.prior.current_promise); 912 goto tail1; 913 case State::kState2: 914 Destruct(&prior.prior.prior.current_promise); 915 goto tail2; 916 case State::kState3: 917 Destruct(&prior.prior.current_promise); 918 goto tail3; 919 case State::kState4: 920 Destruct(&prior.current_promise); 921 goto tail4; 922 case State::kState5: 923 Destruct(¤t_promise); 924 return; 925 } 926 tail0: 927 Destruct(&prior.prior.prior.prior.prior.next_factory); 928 tail1: 929 Destruct(&prior.prior.prior.prior.next_factory); 930 tail2: 931 Destruct(&prior.prior.prior.next_factory); 932 tail3: 933 Destruct(&prior.prior.next_factory); 934 tail4: 935 Destruct(&prior.next_factory); 936 } 937 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 938 : state(other.state), whence(other.whence) { 939 DCHECK(state == State::kState0); 940 Construct(&prior.prior.prior.prior.prior.current_promise, 941 other.prior.prior.prior.prior.prior.current_promise); 942 Construct(&prior.prior.prior.prior.prior.next_factory, 943 other.prior.prior.prior.prior.prior.next_factory); 944 Construct(&prior.prior.prior.prior.next_factory, 945 other.prior.prior.prior.prior.next_factory); 946 Construct(&prior.prior.prior.next_factory, 947 other.prior.prior.prior.next_factory); 948 Construct(&prior.prior.next_factory, other.prior.prior.next_factory); 949 Construct(&prior.next_factory, other.prior.next_factory); 950 } 951 SeqState& operator=(const SeqState& other) = delete; 952 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 953 : state(other.state), whence(other.whence) { 954 DCHECK(state == State::kState0); 955 Construct(&prior.prior.prior.prior.prior.current_promise, 956 std::move(other.prior.prior.prior.prior.prior.current_promise)); 957 Construct(&prior.prior.prior.prior.prior.next_factory, 958 std::move(other.prior.prior.prior.prior.prior.next_factory)); 959 Construct(&prior.prior.prior.prior.next_factory, 960 std::move(other.prior.prior.prior.prior.next_factory)); 961 Construct(&prior.prior.prior.next_factory, 962 std::move(other.prior.prior.prior.next_factory)); 963 Construct(&prior.prior.next_factory, 964 std::move(other.prior.prior.next_factory)); 965 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 966 } 967 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 968 delete; 969 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 970 switch (state) { 971 case State::kState0: { 972 GRPC_TRACE_LOG(promise_primitives, INFO) 973 .AtLocation(whence.file(), whence.line()) 974 << "seq[" << this << "]: begin poll step 1/6"; 975 auto result = prior.prior.prior.prior.prior.current_promise(); 976 PromiseResult0* p = result.value_if_ready(); 977 GRPC_TRACE_LOG(promise_primitives, INFO) 978 .AtLocation(whence.file(), whence.line()) 979 << "seq[" << this << "]: poll step 1/6 gets " 980 << (p != nullptr 981 ? (PromiseResultTraits0::IsOk(*p) 982 ? "ready" 983 : absl::StrCat("early-error:", 984 PromiseResultTraits0::ErrorString(*p)) 985 .c_str()) 986 : "pending"); 987 if (p == nullptr) return Pending{}; 988 if (!PromiseResultTraits0::IsOk(*p)) { 989 return PromiseResultTraits0::template ReturnValue<Result>( 990 std::move(*p)); 991 } 992 Destruct(&prior.prior.prior.prior.prior.current_promise); 993 auto next_promise = PromiseResultTraits0::CallFactory( 994 &prior.prior.prior.prior.prior.next_factory, std::move(*p)); 995 Destruct(&prior.prior.prior.prior.prior.next_factory); 996 Construct(&prior.prior.prior.prior.current_promise, 997 std::move(next_promise)); 998 state = State::kState1; 999 } 1000 ABSL_FALLTHROUGH_INTENDED; 1001 case State::kState1: { 1002 GRPC_TRACE_LOG(promise_primitives, INFO) 1003 .AtLocation(whence.file(), whence.line()) 1004 << "seq[" << this << "]: begin poll step 2/6"; 1005 auto result = prior.prior.prior.prior.current_promise(); 1006 PromiseResult1* p = result.value_if_ready(); 1007 GRPC_TRACE_LOG(promise_primitives, INFO) 1008 .AtLocation(whence.file(), whence.line()) 1009 << "seq[" << this << "]: poll step 2/6 gets " 1010 << (p != nullptr 1011 ? (PromiseResultTraits1::IsOk(*p) 1012 ? "ready" 1013 : absl::StrCat("early-error:", 1014 PromiseResultTraits1::ErrorString(*p)) 1015 .c_str()) 1016 : "pending"); 1017 if (p == nullptr) return Pending{}; 1018 if (!PromiseResultTraits1::IsOk(*p)) { 1019 return PromiseResultTraits1::template ReturnValue<Result>( 1020 std::move(*p)); 1021 } 1022 Destruct(&prior.prior.prior.prior.current_promise); 1023 auto next_promise = PromiseResultTraits1::CallFactory( 1024 &prior.prior.prior.prior.next_factory, std::move(*p)); 1025 Destruct(&prior.prior.prior.prior.next_factory); 1026 Construct(&prior.prior.prior.current_promise, std::move(next_promise)); 1027 state = State::kState2; 1028 } 1029 ABSL_FALLTHROUGH_INTENDED; 1030 case State::kState2: { 1031 GRPC_TRACE_LOG(promise_primitives, INFO) 1032 .AtLocation(whence.file(), whence.line()) 1033 << "seq[" << this << "]: begin poll step 3/6"; 1034 auto result = prior.prior.prior.current_promise(); 1035 PromiseResult2* p = result.value_if_ready(); 1036 GRPC_TRACE_LOG(promise_primitives, INFO) 1037 .AtLocation(whence.file(), whence.line()) 1038 << "seq[" << this << "]: poll step 3/6 gets " 1039 << (p != nullptr 1040 ? (PromiseResultTraits2::IsOk(*p) 1041 ? "ready" 1042 : absl::StrCat("early-error:", 1043 PromiseResultTraits2::ErrorString(*p)) 1044 .c_str()) 1045 : "pending"); 1046 if (p == nullptr) return Pending{}; 1047 if (!PromiseResultTraits2::IsOk(*p)) { 1048 return PromiseResultTraits2::template ReturnValue<Result>( 1049 std::move(*p)); 1050 } 1051 Destruct(&prior.prior.prior.current_promise); 1052 auto next_promise = PromiseResultTraits2::CallFactory( 1053 &prior.prior.prior.next_factory, std::move(*p)); 1054 Destruct(&prior.prior.prior.next_factory); 1055 Construct(&prior.prior.current_promise, std::move(next_promise)); 1056 state = State::kState3; 1057 } 1058 ABSL_FALLTHROUGH_INTENDED; 1059 case State::kState3: { 1060 GRPC_TRACE_LOG(promise_primitives, INFO) 1061 .AtLocation(whence.file(), whence.line()) 1062 << "seq[" << this << "]: begin poll step 4/6"; 1063 auto result = prior.prior.current_promise(); 1064 PromiseResult3* p = result.value_if_ready(); 1065 GRPC_TRACE_LOG(promise_primitives, INFO) 1066 .AtLocation(whence.file(), whence.line()) 1067 << "seq[" << this << "]: poll step 4/6 gets " 1068 << (p != nullptr 1069 ? (PromiseResultTraits3::IsOk(*p) 1070 ? "ready" 1071 : absl::StrCat("early-error:", 1072 PromiseResultTraits3::ErrorString(*p)) 1073 .c_str()) 1074 : "pending"); 1075 if (p == nullptr) return Pending{}; 1076 if (!PromiseResultTraits3::IsOk(*p)) { 1077 return PromiseResultTraits3::template ReturnValue<Result>( 1078 std::move(*p)); 1079 } 1080 Destruct(&prior.prior.current_promise); 1081 auto next_promise = PromiseResultTraits3::CallFactory( 1082 &prior.prior.next_factory, std::move(*p)); 1083 Destruct(&prior.prior.next_factory); 1084 Construct(&prior.current_promise, std::move(next_promise)); 1085 state = State::kState4; 1086 } 1087 ABSL_FALLTHROUGH_INTENDED; 1088 case State::kState4: { 1089 GRPC_TRACE_LOG(promise_primitives, INFO) 1090 .AtLocation(whence.file(), whence.line()) 1091 << "seq[" << this << "]: begin poll step 5/6"; 1092 auto result = prior.current_promise(); 1093 PromiseResult4* p = result.value_if_ready(); 1094 GRPC_TRACE_LOG(promise_primitives, INFO) 1095 .AtLocation(whence.file(), whence.line()) 1096 << "seq[" << this << "]: poll step 5/6 gets " 1097 << (p != nullptr 1098 ? (PromiseResultTraits4::IsOk(*p) 1099 ? "ready" 1100 : absl::StrCat("early-error:", 1101 PromiseResultTraits4::ErrorString(*p)) 1102 .c_str()) 1103 : "pending"); 1104 if (p == nullptr) return Pending{}; 1105 if (!PromiseResultTraits4::IsOk(*p)) { 1106 return PromiseResultTraits4::template ReturnValue<Result>( 1107 std::move(*p)); 1108 } 1109 Destruct(&prior.current_promise); 1110 auto next_promise = PromiseResultTraits4::CallFactory( 1111 &prior.next_factory, std::move(*p)); 1112 Destruct(&prior.next_factory); 1113 Construct(¤t_promise, std::move(next_promise)); 1114 state = State::kState5; 1115 } 1116 ABSL_FALLTHROUGH_INTENDED; 1117 default: 1118 case State::kState5: { 1119 GRPC_TRACE_LOG(promise_primitives, INFO) 1120 .AtLocation(whence.file(), whence.line()) 1121 << "seq[" << this << "]: begin poll step 6/6"; 1122 auto result = current_promise(); 1123 GRPC_TRACE_LOG(promise_primitives, INFO) 1124 .AtLocation(whence.file(), whence.line()) 1125 << "seq[" << this << "]: poll step 6/6 gets " 1126 << (result.ready() ? "ready" : "pending"); 1127 auto* p = result.value_if_ready(); 1128 if (p == nullptr) return Pending{}; 1129 return Result(std::move(*p)); 1130 } 1131 } 1132 } 1133 }; 1134 1135 template <template <typename> class Traits, typename P, typename F0, 1136 typename F1, typename F2, typename F3, typename F4, typename F5> 1137 struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5> { 1138 using Promise0 = PromiseLike<P>; 1139 using PromiseResult0 = typename Promise0::Result; 1140 using PromiseResultTraits0 = Traits<PromiseResult0>; 1141 using NextFactory0 = 1142 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 1143 using Promise1 = typename NextFactory0::Promise; 1144 using PromiseResult1 = typename Promise1::Result; 1145 using PromiseResultTraits1 = Traits<PromiseResult1>; 1146 using NextFactory1 = 1147 OncePromiseFactory<typename PromiseResultTraits1::UnwrappedType, F1>; 1148 using Promise2 = typename NextFactory1::Promise; 1149 using PromiseResult2 = typename Promise2::Result; 1150 using PromiseResultTraits2 = Traits<PromiseResult2>; 1151 using NextFactory2 = 1152 OncePromiseFactory<typename PromiseResultTraits2::UnwrappedType, F2>; 1153 using Promise3 = typename NextFactory2::Promise; 1154 using PromiseResult3 = typename Promise3::Result; 1155 using PromiseResultTraits3 = Traits<PromiseResult3>; 1156 using NextFactory3 = 1157 OncePromiseFactory<typename PromiseResultTraits3::UnwrappedType, F3>; 1158 using Promise4 = typename NextFactory3::Promise; 1159 using PromiseResult4 = typename Promise4::Result; 1160 using PromiseResultTraits4 = Traits<PromiseResult4>; 1161 using NextFactory4 = 1162 OncePromiseFactory<typename PromiseResultTraits4::UnwrappedType, F4>; 1163 using Promise5 = typename NextFactory4::Promise; 1164 using PromiseResult5 = typename Promise5::Result; 1165 using PromiseResultTraits5 = Traits<PromiseResult5>; 1166 using NextFactory5 = 1167 OncePromiseFactory<typename PromiseResultTraits5::UnwrappedType, F5>; 1168 using Promise6 = typename NextFactory5::Promise; 1169 using PromiseResult6 = typename Promise6::Result; 1170 using PromiseResultTraits6 = Traits<PromiseResult6>; 1171 using Result = typename PromiseResultTraits6::WrappedType; 1172 struct Running0 { 1173 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 1174 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 1175 }; 1176 struct Running1 { 1177 union { 1178 GPR_NO_UNIQUE_ADDRESS Running0 prior; 1179 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 1180 }; 1181 GPR_NO_UNIQUE_ADDRESS NextFactory1 next_factory; 1182 }; 1183 struct Running2 { 1184 union { 1185 GPR_NO_UNIQUE_ADDRESS Running1 prior; 1186 GPR_NO_UNIQUE_ADDRESS Promise2 current_promise; 1187 }; 1188 GPR_NO_UNIQUE_ADDRESS NextFactory2 next_factory; 1189 }; 1190 struct Running3 { 1191 union { 1192 GPR_NO_UNIQUE_ADDRESS Running2 prior; 1193 GPR_NO_UNIQUE_ADDRESS Promise3 current_promise; 1194 }; 1195 GPR_NO_UNIQUE_ADDRESS NextFactory3 next_factory; 1196 }; 1197 struct Running4 { 1198 union { 1199 GPR_NO_UNIQUE_ADDRESS Running3 prior; 1200 GPR_NO_UNIQUE_ADDRESS Promise4 current_promise; 1201 }; 1202 GPR_NO_UNIQUE_ADDRESS NextFactory4 next_factory; 1203 }; 1204 struct Running5 { 1205 union { 1206 GPR_NO_UNIQUE_ADDRESS Running4 prior; 1207 GPR_NO_UNIQUE_ADDRESS Promise5 current_promise; 1208 }; 1209 GPR_NO_UNIQUE_ADDRESS NextFactory5 next_factory; 1210 }; 1211 union { 1212 GPR_NO_UNIQUE_ADDRESS Running5 prior; 1213 GPR_NO_UNIQUE_ADDRESS Promise6 current_promise; 1214 }; 1215 enum class State : uint8_t { 1216 kState0, 1217 kState1, 1218 kState2, 1219 kState3, 1220 kState4, 1221 kState5, 1222 kState6 1223 }; 1224 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 1225 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 1226 1227 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, F1&& f1, 1228 F2&& f2, F3&& f3, F4&& f4, 1229 F5&& f5, 1230 DebugLocation whence) noexcept 1231 : whence(whence) { 1232 Construct(&prior.prior.prior.prior.prior.prior.current_promise, 1233 std::forward<P>(p)); 1234 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 1235 std::forward<F0>(f0)); 1236 Construct(&prior.prior.prior.prior.prior.next_factory, 1237 std::forward<F1>(f1)); 1238 Construct(&prior.prior.prior.prior.next_factory, std::forward<F2>(f2)); 1239 Construct(&prior.prior.prior.next_factory, std::forward<F3>(f3)); 1240 Construct(&prior.prior.next_factory, std::forward<F4>(f4)); 1241 Construct(&prior.next_factory, std::forward<F5>(f5)); 1242 } 1243 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 1244 switch (state) { 1245 case State::kState0: 1246 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 1247 goto tail0; 1248 case State::kState1: 1249 Destruct(&prior.prior.prior.prior.prior.current_promise); 1250 goto tail1; 1251 case State::kState2: 1252 Destruct(&prior.prior.prior.prior.current_promise); 1253 goto tail2; 1254 case State::kState3: 1255 Destruct(&prior.prior.prior.current_promise); 1256 goto tail3; 1257 case State::kState4: 1258 Destruct(&prior.prior.current_promise); 1259 goto tail4; 1260 case State::kState5: 1261 Destruct(&prior.current_promise); 1262 goto tail5; 1263 case State::kState6: 1264 Destruct(¤t_promise); 1265 return; 1266 } 1267 tail0: 1268 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 1269 tail1: 1270 Destruct(&prior.prior.prior.prior.prior.next_factory); 1271 tail2: 1272 Destruct(&prior.prior.prior.prior.next_factory); 1273 tail3: 1274 Destruct(&prior.prior.prior.next_factory); 1275 tail4: 1276 Destruct(&prior.prior.next_factory); 1277 tail5: 1278 Destruct(&prior.next_factory); 1279 } 1280 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 1281 : state(other.state), whence(other.whence) { 1282 DCHECK(state == State::kState0); 1283 Construct(&prior.prior.prior.prior.prior.prior.current_promise, 1284 other.prior.prior.prior.prior.prior.prior.current_promise); 1285 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 1286 other.prior.prior.prior.prior.prior.prior.next_factory); 1287 Construct(&prior.prior.prior.prior.prior.next_factory, 1288 other.prior.prior.prior.prior.prior.next_factory); 1289 Construct(&prior.prior.prior.prior.next_factory, 1290 other.prior.prior.prior.prior.next_factory); 1291 Construct(&prior.prior.prior.next_factory, 1292 other.prior.prior.prior.next_factory); 1293 Construct(&prior.prior.next_factory, other.prior.prior.next_factory); 1294 Construct(&prior.next_factory, other.prior.next_factory); 1295 } 1296 SeqState& operator=(const SeqState& other) = delete; 1297 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 1298 : state(other.state), whence(other.whence) { 1299 DCHECK(state == State::kState0); 1300 Construct( 1301 &prior.prior.prior.prior.prior.prior.current_promise, 1302 std::move(other.prior.prior.prior.prior.prior.prior.current_promise)); 1303 Construct( 1304 &prior.prior.prior.prior.prior.prior.next_factory, 1305 std::move(other.prior.prior.prior.prior.prior.prior.next_factory)); 1306 Construct(&prior.prior.prior.prior.prior.next_factory, 1307 std::move(other.prior.prior.prior.prior.prior.next_factory)); 1308 Construct(&prior.prior.prior.prior.next_factory, 1309 std::move(other.prior.prior.prior.prior.next_factory)); 1310 Construct(&prior.prior.prior.next_factory, 1311 std::move(other.prior.prior.prior.next_factory)); 1312 Construct(&prior.prior.next_factory, 1313 std::move(other.prior.prior.next_factory)); 1314 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 1315 } 1316 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 1317 delete; 1318 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 1319 switch (state) { 1320 case State::kState0: { 1321 GRPC_TRACE_LOG(promise_primitives, INFO) 1322 .AtLocation(whence.file(), whence.line()) 1323 << "seq[" << this << "]: begin poll step 1/7"; 1324 auto result = prior.prior.prior.prior.prior.prior.current_promise(); 1325 PromiseResult0* p = result.value_if_ready(); 1326 GRPC_TRACE_LOG(promise_primitives, INFO) 1327 .AtLocation(whence.file(), whence.line()) 1328 << "seq[" << this << "]: poll step 1/7 gets " 1329 << (p != nullptr 1330 ? (PromiseResultTraits0::IsOk(*p) 1331 ? "ready" 1332 : absl::StrCat("early-error:", 1333 PromiseResultTraits0::ErrorString(*p)) 1334 .c_str()) 1335 : "pending"); 1336 if (p == nullptr) return Pending{}; 1337 if (!PromiseResultTraits0::IsOk(*p)) { 1338 return PromiseResultTraits0::template ReturnValue<Result>( 1339 std::move(*p)); 1340 } 1341 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 1342 auto next_promise = PromiseResultTraits0::CallFactory( 1343 &prior.prior.prior.prior.prior.prior.next_factory, std::move(*p)); 1344 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 1345 Construct(&prior.prior.prior.prior.prior.current_promise, 1346 std::move(next_promise)); 1347 state = State::kState1; 1348 } 1349 ABSL_FALLTHROUGH_INTENDED; 1350 case State::kState1: { 1351 GRPC_TRACE_LOG(promise_primitives, INFO) 1352 .AtLocation(whence.file(), whence.line()) 1353 << "seq[" << this << "]: begin poll step 2/7"; 1354 auto result = prior.prior.prior.prior.prior.current_promise(); 1355 PromiseResult1* p = result.value_if_ready(); 1356 GRPC_TRACE_LOG(promise_primitives, INFO) 1357 .AtLocation(whence.file(), whence.line()) 1358 << "seq[" << this << "]: poll step 2/7 gets " 1359 << (p != nullptr 1360 ? (PromiseResultTraits1::IsOk(*p) 1361 ? "ready" 1362 : absl::StrCat("early-error:", 1363 PromiseResultTraits1::ErrorString(*p)) 1364 .c_str()) 1365 : "pending"); 1366 if (p == nullptr) return Pending{}; 1367 if (!PromiseResultTraits1::IsOk(*p)) { 1368 return PromiseResultTraits1::template ReturnValue<Result>( 1369 std::move(*p)); 1370 } 1371 Destruct(&prior.prior.prior.prior.prior.current_promise); 1372 auto next_promise = PromiseResultTraits1::CallFactory( 1373 &prior.prior.prior.prior.prior.next_factory, std::move(*p)); 1374 Destruct(&prior.prior.prior.prior.prior.next_factory); 1375 Construct(&prior.prior.prior.prior.current_promise, 1376 std::move(next_promise)); 1377 state = State::kState2; 1378 } 1379 ABSL_FALLTHROUGH_INTENDED; 1380 case State::kState2: { 1381 GRPC_TRACE_LOG(promise_primitives, INFO) 1382 .AtLocation(whence.file(), whence.line()) 1383 << "seq[" << this << "]: begin poll step 3/7"; 1384 auto result = prior.prior.prior.prior.current_promise(); 1385 PromiseResult2* p = result.value_if_ready(); 1386 GRPC_TRACE_LOG(promise_primitives, INFO) 1387 .AtLocation(whence.file(), whence.line()) 1388 << "seq[" << this << "]: poll step 3/7 gets " 1389 << (p != nullptr 1390 ? (PromiseResultTraits2::IsOk(*p) 1391 ? "ready" 1392 : absl::StrCat("early-error:", 1393 PromiseResultTraits2::ErrorString(*p)) 1394 .c_str()) 1395 : "pending"); 1396 if (p == nullptr) return Pending{}; 1397 if (!PromiseResultTraits2::IsOk(*p)) { 1398 return PromiseResultTraits2::template ReturnValue<Result>( 1399 std::move(*p)); 1400 } 1401 Destruct(&prior.prior.prior.prior.current_promise); 1402 auto next_promise = PromiseResultTraits2::CallFactory( 1403 &prior.prior.prior.prior.next_factory, std::move(*p)); 1404 Destruct(&prior.prior.prior.prior.next_factory); 1405 Construct(&prior.prior.prior.current_promise, std::move(next_promise)); 1406 state = State::kState3; 1407 } 1408 ABSL_FALLTHROUGH_INTENDED; 1409 case State::kState3: { 1410 GRPC_TRACE_LOG(promise_primitives, INFO) 1411 .AtLocation(whence.file(), whence.line()) 1412 << "seq[" << this << "]: begin poll step 4/7"; 1413 auto result = prior.prior.prior.current_promise(); 1414 PromiseResult3* p = result.value_if_ready(); 1415 GRPC_TRACE_LOG(promise_primitives, INFO) 1416 .AtLocation(whence.file(), whence.line()) 1417 << "seq[" << this << "]: poll step 4/7 gets " 1418 << (p != nullptr 1419 ? (PromiseResultTraits3::IsOk(*p) 1420 ? "ready" 1421 : absl::StrCat("early-error:", 1422 PromiseResultTraits3::ErrorString(*p)) 1423 .c_str()) 1424 : "pending"); 1425 if (p == nullptr) return Pending{}; 1426 if (!PromiseResultTraits3::IsOk(*p)) { 1427 return PromiseResultTraits3::template ReturnValue<Result>( 1428 std::move(*p)); 1429 } 1430 Destruct(&prior.prior.prior.current_promise); 1431 auto next_promise = PromiseResultTraits3::CallFactory( 1432 &prior.prior.prior.next_factory, std::move(*p)); 1433 Destruct(&prior.prior.prior.next_factory); 1434 Construct(&prior.prior.current_promise, std::move(next_promise)); 1435 state = State::kState4; 1436 } 1437 ABSL_FALLTHROUGH_INTENDED; 1438 case State::kState4: { 1439 GRPC_TRACE_LOG(promise_primitives, INFO) 1440 .AtLocation(whence.file(), whence.line()) 1441 << "seq[" << this << "]: begin poll step 5/7"; 1442 auto result = prior.prior.current_promise(); 1443 PromiseResult4* p = result.value_if_ready(); 1444 GRPC_TRACE_LOG(promise_primitives, INFO) 1445 .AtLocation(whence.file(), whence.line()) 1446 << "seq[" << this << "]: poll step 5/7 gets " 1447 << (p != nullptr 1448 ? (PromiseResultTraits4::IsOk(*p) 1449 ? "ready" 1450 : absl::StrCat("early-error:", 1451 PromiseResultTraits4::ErrorString(*p)) 1452 .c_str()) 1453 : "pending"); 1454 if (p == nullptr) return Pending{}; 1455 if (!PromiseResultTraits4::IsOk(*p)) { 1456 return PromiseResultTraits4::template ReturnValue<Result>( 1457 std::move(*p)); 1458 } 1459 Destruct(&prior.prior.current_promise); 1460 auto next_promise = PromiseResultTraits4::CallFactory( 1461 &prior.prior.next_factory, std::move(*p)); 1462 Destruct(&prior.prior.next_factory); 1463 Construct(&prior.current_promise, std::move(next_promise)); 1464 state = State::kState5; 1465 } 1466 ABSL_FALLTHROUGH_INTENDED; 1467 case State::kState5: { 1468 GRPC_TRACE_LOG(promise_primitives, INFO) 1469 .AtLocation(whence.file(), whence.line()) 1470 << "seq[" << this << "]: begin poll step 6/7"; 1471 auto result = prior.current_promise(); 1472 PromiseResult5* p = result.value_if_ready(); 1473 GRPC_TRACE_LOG(promise_primitives, INFO) 1474 .AtLocation(whence.file(), whence.line()) 1475 << "seq[" << this << "]: poll step 6/7 gets " 1476 << (p != nullptr 1477 ? (PromiseResultTraits5::IsOk(*p) 1478 ? "ready" 1479 : absl::StrCat("early-error:", 1480 PromiseResultTraits5::ErrorString(*p)) 1481 .c_str()) 1482 : "pending"); 1483 if (p == nullptr) return Pending{}; 1484 if (!PromiseResultTraits5::IsOk(*p)) { 1485 return PromiseResultTraits5::template ReturnValue<Result>( 1486 std::move(*p)); 1487 } 1488 Destruct(&prior.current_promise); 1489 auto next_promise = PromiseResultTraits5::CallFactory( 1490 &prior.next_factory, std::move(*p)); 1491 Destruct(&prior.next_factory); 1492 Construct(¤t_promise, std::move(next_promise)); 1493 state = State::kState6; 1494 } 1495 ABSL_FALLTHROUGH_INTENDED; 1496 default: 1497 case State::kState6: { 1498 GRPC_TRACE_LOG(promise_primitives, INFO) 1499 .AtLocation(whence.file(), whence.line()) 1500 << "seq[" << this << "]: begin poll step 7/7"; 1501 auto result = current_promise(); 1502 GRPC_TRACE_LOG(promise_primitives, INFO) 1503 .AtLocation(whence.file(), whence.line()) 1504 << "seq[" << this << "]: poll step 7/7 gets " 1505 << (result.ready() ? "ready" : "pending"); 1506 auto* p = result.value_if_ready(); 1507 if (p == nullptr) return Pending{}; 1508 return Result(std::move(*p)); 1509 } 1510 } 1511 } 1512 }; 1513 1514 template <template <typename> class Traits, typename P, typename F0, 1515 typename F1, typename F2, typename F3, typename F4, typename F5, 1516 typename F6> 1517 struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6> { 1518 using Promise0 = PromiseLike<P>; 1519 using PromiseResult0 = typename Promise0::Result; 1520 using PromiseResultTraits0 = Traits<PromiseResult0>; 1521 using NextFactory0 = 1522 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 1523 using Promise1 = typename NextFactory0::Promise; 1524 using PromiseResult1 = typename Promise1::Result; 1525 using PromiseResultTraits1 = Traits<PromiseResult1>; 1526 using NextFactory1 = 1527 OncePromiseFactory<typename PromiseResultTraits1::UnwrappedType, F1>; 1528 using Promise2 = typename NextFactory1::Promise; 1529 using PromiseResult2 = typename Promise2::Result; 1530 using PromiseResultTraits2 = Traits<PromiseResult2>; 1531 using NextFactory2 = 1532 OncePromiseFactory<typename PromiseResultTraits2::UnwrappedType, F2>; 1533 using Promise3 = typename NextFactory2::Promise; 1534 using PromiseResult3 = typename Promise3::Result; 1535 using PromiseResultTraits3 = Traits<PromiseResult3>; 1536 using NextFactory3 = 1537 OncePromiseFactory<typename PromiseResultTraits3::UnwrappedType, F3>; 1538 using Promise4 = typename NextFactory3::Promise; 1539 using PromiseResult4 = typename Promise4::Result; 1540 using PromiseResultTraits4 = Traits<PromiseResult4>; 1541 using NextFactory4 = 1542 OncePromiseFactory<typename PromiseResultTraits4::UnwrappedType, F4>; 1543 using Promise5 = typename NextFactory4::Promise; 1544 using PromiseResult5 = typename Promise5::Result; 1545 using PromiseResultTraits5 = Traits<PromiseResult5>; 1546 using NextFactory5 = 1547 OncePromiseFactory<typename PromiseResultTraits5::UnwrappedType, F5>; 1548 using Promise6 = typename NextFactory5::Promise; 1549 using PromiseResult6 = typename Promise6::Result; 1550 using PromiseResultTraits6 = Traits<PromiseResult6>; 1551 using NextFactory6 = 1552 OncePromiseFactory<typename PromiseResultTraits6::UnwrappedType, F6>; 1553 using Promise7 = typename NextFactory6::Promise; 1554 using PromiseResult7 = typename Promise7::Result; 1555 using PromiseResultTraits7 = Traits<PromiseResult7>; 1556 using Result = typename PromiseResultTraits7::WrappedType; 1557 struct Running0 { 1558 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 1559 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 1560 }; 1561 struct Running1 { 1562 union { 1563 GPR_NO_UNIQUE_ADDRESS Running0 prior; 1564 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 1565 }; 1566 GPR_NO_UNIQUE_ADDRESS NextFactory1 next_factory; 1567 }; 1568 struct Running2 { 1569 union { 1570 GPR_NO_UNIQUE_ADDRESS Running1 prior; 1571 GPR_NO_UNIQUE_ADDRESS Promise2 current_promise; 1572 }; 1573 GPR_NO_UNIQUE_ADDRESS NextFactory2 next_factory; 1574 }; 1575 struct Running3 { 1576 union { 1577 GPR_NO_UNIQUE_ADDRESS Running2 prior; 1578 GPR_NO_UNIQUE_ADDRESS Promise3 current_promise; 1579 }; 1580 GPR_NO_UNIQUE_ADDRESS NextFactory3 next_factory; 1581 }; 1582 struct Running4 { 1583 union { 1584 GPR_NO_UNIQUE_ADDRESS Running3 prior; 1585 GPR_NO_UNIQUE_ADDRESS Promise4 current_promise; 1586 }; 1587 GPR_NO_UNIQUE_ADDRESS NextFactory4 next_factory; 1588 }; 1589 struct Running5 { 1590 union { 1591 GPR_NO_UNIQUE_ADDRESS Running4 prior; 1592 GPR_NO_UNIQUE_ADDRESS Promise5 current_promise; 1593 }; 1594 GPR_NO_UNIQUE_ADDRESS NextFactory5 next_factory; 1595 }; 1596 struct Running6 { 1597 union { 1598 GPR_NO_UNIQUE_ADDRESS Running5 prior; 1599 GPR_NO_UNIQUE_ADDRESS Promise6 current_promise; 1600 }; 1601 GPR_NO_UNIQUE_ADDRESS NextFactory6 next_factory; 1602 }; 1603 union { 1604 GPR_NO_UNIQUE_ADDRESS Running6 prior; 1605 GPR_NO_UNIQUE_ADDRESS Promise7 current_promise; 1606 }; 1607 enum class State : uint8_t { 1608 kState0, 1609 kState1, 1610 kState2, 1611 kState3, 1612 kState4, 1613 kState5, 1614 kState6, 1615 kState7 1616 }; 1617 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 1618 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 1619 1620 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, F1&& f1, 1621 F2&& f2, F3&& f3, F4&& f4, 1622 F5&& f5, F6&& f6, 1623 DebugLocation whence) noexcept 1624 : whence(whence) { 1625 Construct(&prior.prior.prior.prior.prior.prior.prior.current_promise, 1626 std::forward<P>(p)); 1627 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 1628 std::forward<F0>(f0)); 1629 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 1630 std::forward<F1>(f1)); 1631 Construct(&prior.prior.prior.prior.prior.next_factory, 1632 std::forward<F2>(f2)); 1633 Construct(&prior.prior.prior.prior.next_factory, std::forward<F3>(f3)); 1634 Construct(&prior.prior.prior.next_factory, std::forward<F4>(f4)); 1635 Construct(&prior.prior.next_factory, std::forward<F5>(f5)); 1636 Construct(&prior.next_factory, std::forward<F6>(f6)); 1637 } 1638 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 1639 switch (state) { 1640 case State::kState0: 1641 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 1642 goto tail0; 1643 case State::kState1: 1644 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 1645 goto tail1; 1646 case State::kState2: 1647 Destruct(&prior.prior.prior.prior.prior.current_promise); 1648 goto tail2; 1649 case State::kState3: 1650 Destruct(&prior.prior.prior.prior.current_promise); 1651 goto tail3; 1652 case State::kState4: 1653 Destruct(&prior.prior.prior.current_promise); 1654 goto tail4; 1655 case State::kState5: 1656 Destruct(&prior.prior.current_promise); 1657 goto tail5; 1658 case State::kState6: 1659 Destruct(&prior.current_promise); 1660 goto tail6; 1661 case State::kState7: 1662 Destruct(¤t_promise); 1663 return; 1664 } 1665 tail0: 1666 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 1667 tail1: 1668 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 1669 tail2: 1670 Destruct(&prior.prior.prior.prior.prior.next_factory); 1671 tail3: 1672 Destruct(&prior.prior.prior.prior.next_factory); 1673 tail4: 1674 Destruct(&prior.prior.prior.next_factory); 1675 tail5: 1676 Destruct(&prior.prior.next_factory); 1677 tail6: 1678 Destruct(&prior.next_factory); 1679 } 1680 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 1681 : state(other.state), whence(other.whence) { 1682 DCHECK(state == State::kState0); 1683 Construct(&prior.prior.prior.prior.prior.prior.prior.current_promise, 1684 other.prior.prior.prior.prior.prior.prior.prior.current_promise); 1685 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 1686 other.prior.prior.prior.prior.prior.prior.prior.next_factory); 1687 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 1688 other.prior.prior.prior.prior.prior.prior.next_factory); 1689 Construct(&prior.prior.prior.prior.prior.next_factory, 1690 other.prior.prior.prior.prior.prior.next_factory); 1691 Construct(&prior.prior.prior.prior.next_factory, 1692 other.prior.prior.prior.prior.next_factory); 1693 Construct(&prior.prior.prior.next_factory, 1694 other.prior.prior.prior.next_factory); 1695 Construct(&prior.prior.next_factory, other.prior.prior.next_factory); 1696 Construct(&prior.next_factory, other.prior.next_factory); 1697 } 1698 SeqState& operator=(const SeqState& other) = delete; 1699 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 1700 : state(other.state), whence(other.whence) { 1701 DCHECK(state == State::kState0); 1702 Construct( 1703 &prior.prior.prior.prior.prior.prior.prior.current_promise, 1704 std::move( 1705 other.prior.prior.prior.prior.prior.prior.prior.current_promise)); 1706 Construct( 1707 &prior.prior.prior.prior.prior.prior.prior.next_factory, 1708 std::move( 1709 other.prior.prior.prior.prior.prior.prior.prior.next_factory)); 1710 Construct( 1711 &prior.prior.prior.prior.prior.prior.next_factory, 1712 std::move(other.prior.prior.prior.prior.prior.prior.next_factory)); 1713 Construct(&prior.prior.prior.prior.prior.next_factory, 1714 std::move(other.prior.prior.prior.prior.prior.next_factory)); 1715 Construct(&prior.prior.prior.prior.next_factory, 1716 std::move(other.prior.prior.prior.prior.next_factory)); 1717 Construct(&prior.prior.prior.next_factory, 1718 std::move(other.prior.prior.prior.next_factory)); 1719 Construct(&prior.prior.next_factory, 1720 std::move(other.prior.prior.next_factory)); 1721 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 1722 } 1723 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 1724 delete; 1725 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 1726 switch (state) { 1727 case State::kState0: { 1728 GRPC_TRACE_LOG(promise_primitives, INFO) 1729 .AtLocation(whence.file(), whence.line()) 1730 << "seq[" << this << "]: begin poll step 1/8"; 1731 auto result = 1732 prior.prior.prior.prior.prior.prior.prior.current_promise(); 1733 PromiseResult0* p = result.value_if_ready(); 1734 GRPC_TRACE_LOG(promise_primitives, INFO) 1735 .AtLocation(whence.file(), whence.line()) 1736 << "seq[" << this << "]: poll step 1/8 gets " 1737 << (p != nullptr 1738 ? (PromiseResultTraits0::IsOk(*p) 1739 ? "ready" 1740 : absl::StrCat("early-error:", 1741 PromiseResultTraits0::ErrorString(*p)) 1742 .c_str()) 1743 : "pending"); 1744 if (p == nullptr) return Pending{}; 1745 if (!PromiseResultTraits0::IsOk(*p)) { 1746 return PromiseResultTraits0::template ReturnValue<Result>( 1747 std::move(*p)); 1748 } 1749 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 1750 auto next_promise = PromiseResultTraits0::CallFactory( 1751 &prior.prior.prior.prior.prior.prior.prior.next_factory, 1752 std::move(*p)); 1753 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 1754 Construct(&prior.prior.prior.prior.prior.prior.current_promise, 1755 std::move(next_promise)); 1756 state = State::kState1; 1757 } 1758 ABSL_FALLTHROUGH_INTENDED; 1759 case State::kState1: { 1760 GRPC_TRACE_LOG(promise_primitives, INFO) 1761 .AtLocation(whence.file(), whence.line()) 1762 << "seq[" << this << "]: begin poll step 2/8"; 1763 auto result = prior.prior.prior.prior.prior.prior.current_promise(); 1764 PromiseResult1* p = result.value_if_ready(); 1765 GRPC_TRACE_LOG(promise_primitives, INFO) 1766 .AtLocation(whence.file(), whence.line()) 1767 << "seq[" << this << "]: poll step 2/8 gets " 1768 << (p != nullptr 1769 ? (PromiseResultTraits1::IsOk(*p) 1770 ? "ready" 1771 : absl::StrCat("early-error:", 1772 PromiseResultTraits1::ErrorString(*p)) 1773 .c_str()) 1774 : "pending"); 1775 if (p == nullptr) return Pending{}; 1776 if (!PromiseResultTraits1::IsOk(*p)) { 1777 return PromiseResultTraits1::template ReturnValue<Result>( 1778 std::move(*p)); 1779 } 1780 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 1781 auto next_promise = PromiseResultTraits1::CallFactory( 1782 &prior.prior.prior.prior.prior.prior.next_factory, std::move(*p)); 1783 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 1784 Construct(&prior.prior.prior.prior.prior.current_promise, 1785 std::move(next_promise)); 1786 state = State::kState2; 1787 } 1788 ABSL_FALLTHROUGH_INTENDED; 1789 case State::kState2: { 1790 GRPC_TRACE_LOG(promise_primitives, INFO) 1791 .AtLocation(whence.file(), whence.line()) 1792 << "seq[" << this << "]: begin poll step 3/8"; 1793 auto result = prior.prior.prior.prior.prior.current_promise(); 1794 PromiseResult2* p = result.value_if_ready(); 1795 GRPC_TRACE_LOG(promise_primitives, INFO) 1796 .AtLocation(whence.file(), whence.line()) 1797 << "seq[" << this << "]: poll step 3/8 gets " 1798 << (p != nullptr 1799 ? (PromiseResultTraits2::IsOk(*p) 1800 ? "ready" 1801 : absl::StrCat("early-error:", 1802 PromiseResultTraits2::ErrorString(*p)) 1803 .c_str()) 1804 : "pending"); 1805 if (p == nullptr) return Pending{}; 1806 if (!PromiseResultTraits2::IsOk(*p)) { 1807 return PromiseResultTraits2::template ReturnValue<Result>( 1808 std::move(*p)); 1809 } 1810 Destruct(&prior.prior.prior.prior.prior.current_promise); 1811 auto next_promise = PromiseResultTraits2::CallFactory( 1812 &prior.prior.prior.prior.prior.next_factory, std::move(*p)); 1813 Destruct(&prior.prior.prior.prior.prior.next_factory); 1814 Construct(&prior.prior.prior.prior.current_promise, 1815 std::move(next_promise)); 1816 state = State::kState3; 1817 } 1818 ABSL_FALLTHROUGH_INTENDED; 1819 case State::kState3: { 1820 GRPC_TRACE_LOG(promise_primitives, INFO) 1821 .AtLocation(whence.file(), whence.line()) 1822 << "seq[" << this << "]: begin poll step 4/8"; 1823 auto result = prior.prior.prior.prior.current_promise(); 1824 PromiseResult3* p = result.value_if_ready(); 1825 GRPC_TRACE_LOG(promise_primitives, INFO) 1826 .AtLocation(whence.file(), whence.line()) 1827 << "seq[" << this << "]: poll step 4/8 gets " 1828 << (p != nullptr 1829 ? (PromiseResultTraits3::IsOk(*p) 1830 ? "ready" 1831 : absl::StrCat("early-error:", 1832 PromiseResultTraits3::ErrorString(*p)) 1833 .c_str()) 1834 : "pending"); 1835 if (p == nullptr) return Pending{}; 1836 if (!PromiseResultTraits3::IsOk(*p)) { 1837 return PromiseResultTraits3::template ReturnValue<Result>( 1838 std::move(*p)); 1839 } 1840 Destruct(&prior.prior.prior.prior.current_promise); 1841 auto next_promise = PromiseResultTraits3::CallFactory( 1842 &prior.prior.prior.prior.next_factory, std::move(*p)); 1843 Destruct(&prior.prior.prior.prior.next_factory); 1844 Construct(&prior.prior.prior.current_promise, std::move(next_promise)); 1845 state = State::kState4; 1846 } 1847 ABSL_FALLTHROUGH_INTENDED; 1848 case State::kState4: { 1849 GRPC_TRACE_LOG(promise_primitives, INFO) 1850 .AtLocation(whence.file(), whence.line()) 1851 << "seq[" << this << "]: begin poll step 5/8"; 1852 auto result = prior.prior.prior.current_promise(); 1853 PromiseResult4* p = result.value_if_ready(); 1854 GRPC_TRACE_LOG(promise_primitives, INFO) 1855 .AtLocation(whence.file(), whence.line()) 1856 << "seq[" << this << "]: poll step 5/8 gets " 1857 << (p != nullptr 1858 ? (PromiseResultTraits4::IsOk(*p) 1859 ? "ready" 1860 : absl::StrCat("early-error:", 1861 PromiseResultTraits4::ErrorString(*p)) 1862 .c_str()) 1863 : "pending"); 1864 if (p == nullptr) return Pending{}; 1865 if (!PromiseResultTraits4::IsOk(*p)) { 1866 return PromiseResultTraits4::template ReturnValue<Result>( 1867 std::move(*p)); 1868 } 1869 Destruct(&prior.prior.prior.current_promise); 1870 auto next_promise = PromiseResultTraits4::CallFactory( 1871 &prior.prior.prior.next_factory, std::move(*p)); 1872 Destruct(&prior.prior.prior.next_factory); 1873 Construct(&prior.prior.current_promise, std::move(next_promise)); 1874 state = State::kState5; 1875 } 1876 ABSL_FALLTHROUGH_INTENDED; 1877 case State::kState5: { 1878 GRPC_TRACE_LOG(promise_primitives, INFO) 1879 .AtLocation(whence.file(), whence.line()) 1880 << "seq[" << this << "]: begin poll step 6/8"; 1881 auto result = prior.prior.current_promise(); 1882 PromiseResult5* p = result.value_if_ready(); 1883 GRPC_TRACE_LOG(promise_primitives, INFO) 1884 .AtLocation(whence.file(), whence.line()) 1885 << "seq[" << this << "]: poll step 6/8 gets " 1886 << (p != nullptr 1887 ? (PromiseResultTraits5::IsOk(*p) 1888 ? "ready" 1889 : absl::StrCat("early-error:", 1890 PromiseResultTraits5::ErrorString(*p)) 1891 .c_str()) 1892 : "pending"); 1893 if (p == nullptr) return Pending{}; 1894 if (!PromiseResultTraits5::IsOk(*p)) { 1895 return PromiseResultTraits5::template ReturnValue<Result>( 1896 std::move(*p)); 1897 } 1898 Destruct(&prior.prior.current_promise); 1899 auto next_promise = PromiseResultTraits5::CallFactory( 1900 &prior.prior.next_factory, std::move(*p)); 1901 Destruct(&prior.prior.next_factory); 1902 Construct(&prior.current_promise, std::move(next_promise)); 1903 state = State::kState6; 1904 } 1905 ABSL_FALLTHROUGH_INTENDED; 1906 case State::kState6: { 1907 GRPC_TRACE_LOG(promise_primitives, INFO) 1908 .AtLocation(whence.file(), whence.line()) 1909 << "seq[" << this << "]: begin poll step 7/8"; 1910 auto result = prior.current_promise(); 1911 PromiseResult6* p = result.value_if_ready(); 1912 GRPC_TRACE_LOG(promise_primitives, INFO) 1913 .AtLocation(whence.file(), whence.line()) 1914 << "seq[" << this << "]: poll step 7/8 gets " 1915 << (p != nullptr 1916 ? (PromiseResultTraits6::IsOk(*p) 1917 ? "ready" 1918 : absl::StrCat("early-error:", 1919 PromiseResultTraits6::ErrorString(*p)) 1920 .c_str()) 1921 : "pending"); 1922 if (p == nullptr) return Pending{}; 1923 if (!PromiseResultTraits6::IsOk(*p)) { 1924 return PromiseResultTraits6::template ReturnValue<Result>( 1925 std::move(*p)); 1926 } 1927 Destruct(&prior.current_promise); 1928 auto next_promise = PromiseResultTraits6::CallFactory( 1929 &prior.next_factory, std::move(*p)); 1930 Destruct(&prior.next_factory); 1931 Construct(¤t_promise, std::move(next_promise)); 1932 state = State::kState7; 1933 } 1934 ABSL_FALLTHROUGH_INTENDED; 1935 default: 1936 case State::kState7: { 1937 GRPC_TRACE_LOG(promise_primitives, INFO) 1938 .AtLocation(whence.file(), whence.line()) 1939 << "seq[" << this << "]: begin poll step 8/8"; 1940 auto result = current_promise(); 1941 GRPC_TRACE_LOG(promise_primitives, INFO) 1942 .AtLocation(whence.file(), whence.line()) 1943 << "seq[" << this << "]: poll step 8/8 gets " 1944 << (result.ready() ? "ready" : "pending"); 1945 auto* p = result.value_if_ready(); 1946 if (p == nullptr) return Pending{}; 1947 return Result(std::move(*p)); 1948 } 1949 } 1950 } 1951 }; 1952 1953 template <template <typename> class Traits, typename P, typename F0, 1954 typename F1, typename F2, typename F3, typename F4, typename F5, 1955 typename F6, typename F7> 1956 struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7> { 1957 using Promise0 = PromiseLike<P>; 1958 using PromiseResult0 = typename Promise0::Result; 1959 using PromiseResultTraits0 = Traits<PromiseResult0>; 1960 using NextFactory0 = 1961 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 1962 using Promise1 = typename NextFactory0::Promise; 1963 using PromiseResult1 = typename Promise1::Result; 1964 using PromiseResultTraits1 = Traits<PromiseResult1>; 1965 using NextFactory1 = 1966 OncePromiseFactory<typename PromiseResultTraits1::UnwrappedType, F1>; 1967 using Promise2 = typename NextFactory1::Promise; 1968 using PromiseResult2 = typename Promise2::Result; 1969 using PromiseResultTraits2 = Traits<PromiseResult2>; 1970 using NextFactory2 = 1971 OncePromiseFactory<typename PromiseResultTraits2::UnwrappedType, F2>; 1972 using Promise3 = typename NextFactory2::Promise; 1973 using PromiseResult3 = typename Promise3::Result; 1974 using PromiseResultTraits3 = Traits<PromiseResult3>; 1975 using NextFactory3 = 1976 OncePromiseFactory<typename PromiseResultTraits3::UnwrappedType, F3>; 1977 using Promise4 = typename NextFactory3::Promise; 1978 using PromiseResult4 = typename Promise4::Result; 1979 using PromiseResultTraits4 = Traits<PromiseResult4>; 1980 using NextFactory4 = 1981 OncePromiseFactory<typename PromiseResultTraits4::UnwrappedType, F4>; 1982 using Promise5 = typename NextFactory4::Promise; 1983 using PromiseResult5 = typename Promise5::Result; 1984 using PromiseResultTraits5 = Traits<PromiseResult5>; 1985 using NextFactory5 = 1986 OncePromiseFactory<typename PromiseResultTraits5::UnwrappedType, F5>; 1987 using Promise6 = typename NextFactory5::Promise; 1988 using PromiseResult6 = typename Promise6::Result; 1989 using PromiseResultTraits6 = Traits<PromiseResult6>; 1990 using NextFactory6 = 1991 OncePromiseFactory<typename PromiseResultTraits6::UnwrappedType, F6>; 1992 using Promise7 = typename NextFactory6::Promise; 1993 using PromiseResult7 = typename Promise7::Result; 1994 using PromiseResultTraits7 = Traits<PromiseResult7>; 1995 using NextFactory7 = 1996 OncePromiseFactory<typename PromiseResultTraits7::UnwrappedType, F7>; 1997 using Promise8 = typename NextFactory7::Promise; 1998 using PromiseResult8 = typename Promise8::Result; 1999 using PromiseResultTraits8 = Traits<PromiseResult8>; 2000 using Result = typename PromiseResultTraits8::WrappedType; 2001 struct Running0 { 2002 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 2003 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 2004 }; 2005 struct Running1 { 2006 union { 2007 GPR_NO_UNIQUE_ADDRESS Running0 prior; 2008 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 2009 }; 2010 GPR_NO_UNIQUE_ADDRESS NextFactory1 next_factory; 2011 }; 2012 struct Running2 { 2013 union { 2014 GPR_NO_UNIQUE_ADDRESS Running1 prior; 2015 GPR_NO_UNIQUE_ADDRESS Promise2 current_promise; 2016 }; 2017 GPR_NO_UNIQUE_ADDRESS NextFactory2 next_factory; 2018 }; 2019 struct Running3 { 2020 union { 2021 GPR_NO_UNIQUE_ADDRESS Running2 prior; 2022 GPR_NO_UNIQUE_ADDRESS Promise3 current_promise; 2023 }; 2024 GPR_NO_UNIQUE_ADDRESS NextFactory3 next_factory; 2025 }; 2026 struct Running4 { 2027 union { 2028 GPR_NO_UNIQUE_ADDRESS Running3 prior; 2029 GPR_NO_UNIQUE_ADDRESS Promise4 current_promise; 2030 }; 2031 GPR_NO_UNIQUE_ADDRESS NextFactory4 next_factory; 2032 }; 2033 struct Running5 { 2034 union { 2035 GPR_NO_UNIQUE_ADDRESS Running4 prior; 2036 GPR_NO_UNIQUE_ADDRESS Promise5 current_promise; 2037 }; 2038 GPR_NO_UNIQUE_ADDRESS NextFactory5 next_factory; 2039 }; 2040 struct Running6 { 2041 union { 2042 GPR_NO_UNIQUE_ADDRESS Running5 prior; 2043 GPR_NO_UNIQUE_ADDRESS Promise6 current_promise; 2044 }; 2045 GPR_NO_UNIQUE_ADDRESS NextFactory6 next_factory; 2046 }; 2047 struct Running7 { 2048 union { 2049 GPR_NO_UNIQUE_ADDRESS Running6 prior; 2050 GPR_NO_UNIQUE_ADDRESS Promise7 current_promise; 2051 }; 2052 GPR_NO_UNIQUE_ADDRESS NextFactory7 next_factory; 2053 }; 2054 union { 2055 GPR_NO_UNIQUE_ADDRESS Running7 prior; 2056 GPR_NO_UNIQUE_ADDRESS Promise8 current_promise; 2057 }; 2058 enum class State : uint8_t { 2059 kState0, 2060 kState1, 2061 kState2, 2062 kState3, 2063 kState4, 2064 kState5, 2065 kState6, 2066 kState7, 2067 kState8 2068 }; 2069 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 2070 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 2071 2072 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, F1&& f1, 2073 F2&& f2, F3&& f3, F4&& f4, 2074 F5&& f5, F6&& f6, F7&& f7, 2075 DebugLocation whence) noexcept 2076 : whence(whence) { 2077 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.current_promise, 2078 std::forward<P>(p)); 2079 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2080 std::forward<F0>(f0)); 2081 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 2082 std::forward<F1>(f1)); 2083 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 2084 std::forward<F2>(f2)); 2085 Construct(&prior.prior.prior.prior.prior.next_factory, 2086 std::forward<F3>(f3)); 2087 Construct(&prior.prior.prior.prior.next_factory, std::forward<F4>(f4)); 2088 Construct(&prior.prior.prior.next_factory, std::forward<F5>(f5)); 2089 Construct(&prior.prior.next_factory, std::forward<F6>(f6)); 2090 Construct(&prior.next_factory, std::forward<F7>(f7)); 2091 } 2092 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 2093 switch (state) { 2094 case State::kState0: 2095 Destruct( 2096 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise); 2097 goto tail0; 2098 case State::kState1: 2099 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 2100 goto tail1; 2101 case State::kState2: 2102 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 2103 goto tail2; 2104 case State::kState3: 2105 Destruct(&prior.prior.prior.prior.prior.current_promise); 2106 goto tail3; 2107 case State::kState4: 2108 Destruct(&prior.prior.prior.prior.current_promise); 2109 goto tail4; 2110 case State::kState5: 2111 Destruct(&prior.prior.prior.current_promise); 2112 goto tail5; 2113 case State::kState6: 2114 Destruct(&prior.prior.current_promise); 2115 goto tail6; 2116 case State::kState7: 2117 Destruct(&prior.current_promise); 2118 goto tail7; 2119 case State::kState8: 2120 Destruct(¤t_promise); 2121 return; 2122 } 2123 tail0: 2124 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 2125 tail1: 2126 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 2127 tail2: 2128 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 2129 tail3: 2130 Destruct(&prior.prior.prior.prior.prior.next_factory); 2131 tail4: 2132 Destruct(&prior.prior.prior.prior.next_factory); 2133 tail5: 2134 Destruct(&prior.prior.prior.next_factory); 2135 tail6: 2136 Destruct(&prior.prior.next_factory); 2137 tail7: 2138 Destruct(&prior.next_factory); 2139 } 2140 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 2141 : state(other.state), whence(other.whence) { 2142 DCHECK(state == State::kState0); 2143 Construct( 2144 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise, 2145 other.prior.prior.prior.prior.prior.prior.prior.prior.current_promise); 2146 Construct( 2147 &prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2148 other.prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 2149 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 2150 other.prior.prior.prior.prior.prior.prior.prior.next_factory); 2151 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 2152 other.prior.prior.prior.prior.prior.prior.next_factory); 2153 Construct(&prior.prior.prior.prior.prior.next_factory, 2154 other.prior.prior.prior.prior.prior.next_factory); 2155 Construct(&prior.prior.prior.prior.next_factory, 2156 other.prior.prior.prior.prior.next_factory); 2157 Construct(&prior.prior.prior.next_factory, 2158 other.prior.prior.prior.next_factory); 2159 Construct(&prior.prior.next_factory, other.prior.prior.next_factory); 2160 Construct(&prior.next_factory, other.prior.next_factory); 2161 } 2162 SeqState& operator=(const SeqState& other) = delete; 2163 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 2164 : state(other.state), whence(other.whence) { 2165 DCHECK(state == State::kState0); 2166 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.current_promise, 2167 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 2168 .current_promise)); 2169 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2170 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 2171 .next_factory)); 2172 Construct( 2173 &prior.prior.prior.prior.prior.prior.prior.next_factory, 2174 std::move( 2175 other.prior.prior.prior.prior.prior.prior.prior.next_factory)); 2176 Construct( 2177 &prior.prior.prior.prior.prior.prior.next_factory, 2178 std::move(other.prior.prior.prior.prior.prior.prior.next_factory)); 2179 Construct(&prior.prior.prior.prior.prior.next_factory, 2180 std::move(other.prior.prior.prior.prior.prior.next_factory)); 2181 Construct(&prior.prior.prior.prior.next_factory, 2182 std::move(other.prior.prior.prior.prior.next_factory)); 2183 Construct(&prior.prior.prior.next_factory, 2184 std::move(other.prior.prior.prior.next_factory)); 2185 Construct(&prior.prior.next_factory, 2186 std::move(other.prior.prior.next_factory)); 2187 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 2188 } 2189 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 2190 delete; 2191 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 2192 switch (state) { 2193 case State::kState0: { 2194 GRPC_TRACE_LOG(promise_primitives, INFO) 2195 .AtLocation(whence.file(), whence.line()) 2196 << "seq[" << this << "]: begin poll step 1/9"; 2197 auto result = 2198 prior.prior.prior.prior.prior.prior.prior.prior.current_promise(); 2199 PromiseResult0* p = result.value_if_ready(); 2200 GRPC_TRACE_LOG(promise_primitives, INFO) 2201 .AtLocation(whence.file(), whence.line()) 2202 << "seq[" << this << "]: poll step 1/9 gets " 2203 << (p != nullptr 2204 ? (PromiseResultTraits0::IsOk(*p) 2205 ? "ready" 2206 : absl::StrCat("early-error:", 2207 PromiseResultTraits0::ErrorString(*p)) 2208 .c_str()) 2209 : "pending"); 2210 if (p == nullptr) return Pending{}; 2211 if (!PromiseResultTraits0::IsOk(*p)) { 2212 return PromiseResultTraits0::template ReturnValue<Result>( 2213 std::move(*p)); 2214 } 2215 Destruct( 2216 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise); 2217 auto next_promise = PromiseResultTraits0::CallFactory( 2218 &prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2219 std::move(*p)); 2220 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 2221 Construct(&prior.prior.prior.prior.prior.prior.prior.current_promise, 2222 std::move(next_promise)); 2223 state = State::kState1; 2224 } 2225 ABSL_FALLTHROUGH_INTENDED; 2226 case State::kState1: { 2227 GRPC_TRACE_LOG(promise_primitives, INFO) 2228 .AtLocation(whence.file(), whence.line()) 2229 << "seq[" << this << "]: begin poll step 2/9"; 2230 auto result = 2231 prior.prior.prior.prior.prior.prior.prior.current_promise(); 2232 PromiseResult1* p = result.value_if_ready(); 2233 GRPC_TRACE_LOG(promise_primitives, INFO) 2234 .AtLocation(whence.file(), whence.line()) 2235 << "seq[" << this << "]: poll step 2/9 gets " 2236 << (p != nullptr 2237 ? (PromiseResultTraits1::IsOk(*p) 2238 ? "ready" 2239 : absl::StrCat("early-error:", 2240 PromiseResultTraits1::ErrorString(*p)) 2241 .c_str()) 2242 : "pending"); 2243 if (p == nullptr) return Pending{}; 2244 if (!PromiseResultTraits1::IsOk(*p)) { 2245 return PromiseResultTraits1::template ReturnValue<Result>( 2246 std::move(*p)); 2247 } 2248 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 2249 auto next_promise = PromiseResultTraits1::CallFactory( 2250 &prior.prior.prior.prior.prior.prior.prior.next_factory, 2251 std::move(*p)); 2252 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 2253 Construct(&prior.prior.prior.prior.prior.prior.current_promise, 2254 std::move(next_promise)); 2255 state = State::kState2; 2256 } 2257 ABSL_FALLTHROUGH_INTENDED; 2258 case State::kState2: { 2259 GRPC_TRACE_LOG(promise_primitives, INFO) 2260 .AtLocation(whence.file(), whence.line()) 2261 << "seq[" << this << "]: begin poll step 3/9"; 2262 auto result = prior.prior.prior.prior.prior.prior.current_promise(); 2263 PromiseResult2* p = result.value_if_ready(); 2264 GRPC_TRACE_LOG(promise_primitives, INFO) 2265 .AtLocation(whence.file(), whence.line()) 2266 << "seq[" << this << "]: poll step 3/9 gets " 2267 << (p != nullptr 2268 ? (PromiseResultTraits2::IsOk(*p) 2269 ? "ready" 2270 : absl::StrCat("early-error:", 2271 PromiseResultTraits2::ErrorString(*p)) 2272 .c_str()) 2273 : "pending"); 2274 if (p == nullptr) return Pending{}; 2275 if (!PromiseResultTraits2::IsOk(*p)) { 2276 return PromiseResultTraits2::template ReturnValue<Result>( 2277 std::move(*p)); 2278 } 2279 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 2280 auto next_promise = PromiseResultTraits2::CallFactory( 2281 &prior.prior.prior.prior.prior.prior.next_factory, std::move(*p)); 2282 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 2283 Construct(&prior.prior.prior.prior.prior.current_promise, 2284 std::move(next_promise)); 2285 state = State::kState3; 2286 } 2287 ABSL_FALLTHROUGH_INTENDED; 2288 case State::kState3: { 2289 GRPC_TRACE_LOG(promise_primitives, INFO) 2290 .AtLocation(whence.file(), whence.line()) 2291 << "seq[" << this << "]: begin poll step 4/9"; 2292 auto result = prior.prior.prior.prior.prior.current_promise(); 2293 PromiseResult3* p = result.value_if_ready(); 2294 GRPC_TRACE_LOG(promise_primitives, INFO) 2295 .AtLocation(whence.file(), whence.line()) 2296 << "seq[" << this << "]: poll step 4/9 gets " 2297 << (p != nullptr 2298 ? (PromiseResultTraits3::IsOk(*p) 2299 ? "ready" 2300 : absl::StrCat("early-error:", 2301 PromiseResultTraits3::ErrorString(*p)) 2302 .c_str()) 2303 : "pending"); 2304 if (p == nullptr) return Pending{}; 2305 if (!PromiseResultTraits3::IsOk(*p)) { 2306 return PromiseResultTraits3::template ReturnValue<Result>( 2307 std::move(*p)); 2308 } 2309 Destruct(&prior.prior.prior.prior.prior.current_promise); 2310 auto next_promise = PromiseResultTraits3::CallFactory( 2311 &prior.prior.prior.prior.prior.next_factory, std::move(*p)); 2312 Destruct(&prior.prior.prior.prior.prior.next_factory); 2313 Construct(&prior.prior.prior.prior.current_promise, 2314 std::move(next_promise)); 2315 state = State::kState4; 2316 } 2317 ABSL_FALLTHROUGH_INTENDED; 2318 case State::kState4: { 2319 GRPC_TRACE_LOG(promise_primitives, INFO) 2320 .AtLocation(whence.file(), whence.line()) 2321 << "seq[" << this << "]: begin poll step 5/9"; 2322 auto result = prior.prior.prior.prior.current_promise(); 2323 PromiseResult4* p = result.value_if_ready(); 2324 GRPC_TRACE_LOG(promise_primitives, INFO) 2325 .AtLocation(whence.file(), whence.line()) 2326 << "seq[" << this << "]: poll step 5/9 gets " 2327 << (p != nullptr 2328 ? (PromiseResultTraits4::IsOk(*p) 2329 ? "ready" 2330 : absl::StrCat("early-error:", 2331 PromiseResultTraits4::ErrorString(*p)) 2332 .c_str()) 2333 : "pending"); 2334 if (p == nullptr) return Pending{}; 2335 if (!PromiseResultTraits4::IsOk(*p)) { 2336 return PromiseResultTraits4::template ReturnValue<Result>( 2337 std::move(*p)); 2338 } 2339 Destruct(&prior.prior.prior.prior.current_promise); 2340 auto next_promise = PromiseResultTraits4::CallFactory( 2341 &prior.prior.prior.prior.next_factory, std::move(*p)); 2342 Destruct(&prior.prior.prior.prior.next_factory); 2343 Construct(&prior.prior.prior.current_promise, std::move(next_promise)); 2344 state = State::kState5; 2345 } 2346 ABSL_FALLTHROUGH_INTENDED; 2347 case State::kState5: { 2348 GRPC_TRACE_LOG(promise_primitives, INFO) 2349 .AtLocation(whence.file(), whence.line()) 2350 << "seq[" << this << "]: begin poll step 6/9"; 2351 auto result = prior.prior.prior.current_promise(); 2352 PromiseResult5* p = result.value_if_ready(); 2353 GRPC_TRACE_LOG(promise_primitives, INFO) 2354 .AtLocation(whence.file(), whence.line()) 2355 << "seq[" << this << "]: poll step 6/9 gets " 2356 << (p != nullptr 2357 ? (PromiseResultTraits5::IsOk(*p) 2358 ? "ready" 2359 : absl::StrCat("early-error:", 2360 PromiseResultTraits5::ErrorString(*p)) 2361 .c_str()) 2362 : "pending"); 2363 if (p == nullptr) return Pending{}; 2364 if (!PromiseResultTraits5::IsOk(*p)) { 2365 return PromiseResultTraits5::template ReturnValue<Result>( 2366 std::move(*p)); 2367 } 2368 Destruct(&prior.prior.prior.current_promise); 2369 auto next_promise = PromiseResultTraits5::CallFactory( 2370 &prior.prior.prior.next_factory, std::move(*p)); 2371 Destruct(&prior.prior.prior.next_factory); 2372 Construct(&prior.prior.current_promise, std::move(next_promise)); 2373 state = State::kState6; 2374 } 2375 ABSL_FALLTHROUGH_INTENDED; 2376 case State::kState6: { 2377 GRPC_TRACE_LOG(promise_primitives, INFO) 2378 .AtLocation(whence.file(), whence.line()) 2379 << "seq[" << this << "]: begin poll step 7/9"; 2380 auto result = prior.prior.current_promise(); 2381 PromiseResult6* p = result.value_if_ready(); 2382 GRPC_TRACE_LOG(promise_primitives, INFO) 2383 .AtLocation(whence.file(), whence.line()) 2384 << "seq[" << this << "]: poll step 7/9 gets " 2385 << (p != nullptr 2386 ? (PromiseResultTraits6::IsOk(*p) 2387 ? "ready" 2388 : absl::StrCat("early-error:", 2389 PromiseResultTraits6::ErrorString(*p)) 2390 .c_str()) 2391 : "pending"); 2392 if (p == nullptr) return Pending{}; 2393 if (!PromiseResultTraits6::IsOk(*p)) { 2394 return PromiseResultTraits6::template ReturnValue<Result>( 2395 std::move(*p)); 2396 } 2397 Destruct(&prior.prior.current_promise); 2398 auto next_promise = PromiseResultTraits6::CallFactory( 2399 &prior.prior.next_factory, std::move(*p)); 2400 Destruct(&prior.prior.next_factory); 2401 Construct(&prior.current_promise, std::move(next_promise)); 2402 state = State::kState7; 2403 } 2404 ABSL_FALLTHROUGH_INTENDED; 2405 case State::kState7: { 2406 GRPC_TRACE_LOG(promise_primitives, INFO) 2407 .AtLocation(whence.file(), whence.line()) 2408 << "seq[" << this << "]: begin poll step 8/9"; 2409 auto result = prior.current_promise(); 2410 PromiseResult7* p = result.value_if_ready(); 2411 GRPC_TRACE_LOG(promise_primitives, INFO) 2412 .AtLocation(whence.file(), whence.line()) 2413 << "seq[" << this << "]: poll step 8/9 gets " 2414 << (p != nullptr 2415 ? (PromiseResultTraits7::IsOk(*p) 2416 ? "ready" 2417 : absl::StrCat("early-error:", 2418 PromiseResultTraits7::ErrorString(*p)) 2419 .c_str()) 2420 : "pending"); 2421 if (p == nullptr) return Pending{}; 2422 if (!PromiseResultTraits7::IsOk(*p)) { 2423 return PromiseResultTraits7::template ReturnValue<Result>( 2424 std::move(*p)); 2425 } 2426 Destruct(&prior.current_promise); 2427 auto next_promise = PromiseResultTraits7::CallFactory( 2428 &prior.next_factory, std::move(*p)); 2429 Destruct(&prior.next_factory); 2430 Construct(¤t_promise, std::move(next_promise)); 2431 state = State::kState8; 2432 } 2433 ABSL_FALLTHROUGH_INTENDED; 2434 default: 2435 case State::kState8: { 2436 GRPC_TRACE_LOG(promise_primitives, INFO) 2437 .AtLocation(whence.file(), whence.line()) 2438 << "seq[" << this << "]: begin poll step 9/9"; 2439 auto result = current_promise(); 2440 GRPC_TRACE_LOG(promise_primitives, INFO) 2441 .AtLocation(whence.file(), whence.line()) 2442 << "seq[" << this << "]: poll step 9/9 gets " 2443 << (result.ready() ? "ready" : "pending"); 2444 auto* p = result.value_if_ready(); 2445 if (p == nullptr) return Pending{}; 2446 return Result(std::move(*p)); 2447 } 2448 } 2449 } 2450 }; 2451 2452 template <template <typename> class Traits, typename P, typename F0, 2453 typename F1, typename F2, typename F3, typename F4, typename F5, 2454 typename F6, typename F7, typename F8> 2455 struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8> { 2456 using Promise0 = PromiseLike<P>; 2457 using PromiseResult0 = typename Promise0::Result; 2458 using PromiseResultTraits0 = Traits<PromiseResult0>; 2459 using NextFactory0 = 2460 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 2461 using Promise1 = typename NextFactory0::Promise; 2462 using PromiseResult1 = typename Promise1::Result; 2463 using PromiseResultTraits1 = Traits<PromiseResult1>; 2464 using NextFactory1 = 2465 OncePromiseFactory<typename PromiseResultTraits1::UnwrappedType, F1>; 2466 using Promise2 = typename NextFactory1::Promise; 2467 using PromiseResult2 = typename Promise2::Result; 2468 using PromiseResultTraits2 = Traits<PromiseResult2>; 2469 using NextFactory2 = 2470 OncePromiseFactory<typename PromiseResultTraits2::UnwrappedType, F2>; 2471 using Promise3 = typename NextFactory2::Promise; 2472 using PromiseResult3 = typename Promise3::Result; 2473 using PromiseResultTraits3 = Traits<PromiseResult3>; 2474 using NextFactory3 = 2475 OncePromiseFactory<typename PromiseResultTraits3::UnwrappedType, F3>; 2476 using Promise4 = typename NextFactory3::Promise; 2477 using PromiseResult4 = typename Promise4::Result; 2478 using PromiseResultTraits4 = Traits<PromiseResult4>; 2479 using NextFactory4 = 2480 OncePromiseFactory<typename PromiseResultTraits4::UnwrappedType, F4>; 2481 using Promise5 = typename NextFactory4::Promise; 2482 using PromiseResult5 = typename Promise5::Result; 2483 using PromiseResultTraits5 = Traits<PromiseResult5>; 2484 using NextFactory5 = 2485 OncePromiseFactory<typename PromiseResultTraits5::UnwrappedType, F5>; 2486 using Promise6 = typename NextFactory5::Promise; 2487 using PromiseResult6 = typename Promise6::Result; 2488 using PromiseResultTraits6 = Traits<PromiseResult6>; 2489 using NextFactory6 = 2490 OncePromiseFactory<typename PromiseResultTraits6::UnwrappedType, F6>; 2491 using Promise7 = typename NextFactory6::Promise; 2492 using PromiseResult7 = typename Promise7::Result; 2493 using PromiseResultTraits7 = Traits<PromiseResult7>; 2494 using NextFactory7 = 2495 OncePromiseFactory<typename PromiseResultTraits7::UnwrappedType, F7>; 2496 using Promise8 = typename NextFactory7::Promise; 2497 using PromiseResult8 = typename Promise8::Result; 2498 using PromiseResultTraits8 = Traits<PromiseResult8>; 2499 using NextFactory8 = 2500 OncePromiseFactory<typename PromiseResultTraits8::UnwrappedType, F8>; 2501 using Promise9 = typename NextFactory8::Promise; 2502 using PromiseResult9 = typename Promise9::Result; 2503 using PromiseResultTraits9 = Traits<PromiseResult9>; 2504 using Result = typename PromiseResultTraits9::WrappedType; 2505 struct Running0 { 2506 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 2507 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 2508 }; 2509 struct Running1 { 2510 union { 2511 GPR_NO_UNIQUE_ADDRESS Running0 prior; 2512 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 2513 }; 2514 GPR_NO_UNIQUE_ADDRESS NextFactory1 next_factory; 2515 }; 2516 struct Running2 { 2517 union { 2518 GPR_NO_UNIQUE_ADDRESS Running1 prior; 2519 GPR_NO_UNIQUE_ADDRESS Promise2 current_promise; 2520 }; 2521 GPR_NO_UNIQUE_ADDRESS NextFactory2 next_factory; 2522 }; 2523 struct Running3 { 2524 union { 2525 GPR_NO_UNIQUE_ADDRESS Running2 prior; 2526 GPR_NO_UNIQUE_ADDRESS Promise3 current_promise; 2527 }; 2528 GPR_NO_UNIQUE_ADDRESS NextFactory3 next_factory; 2529 }; 2530 struct Running4 { 2531 union { 2532 GPR_NO_UNIQUE_ADDRESS Running3 prior; 2533 GPR_NO_UNIQUE_ADDRESS Promise4 current_promise; 2534 }; 2535 GPR_NO_UNIQUE_ADDRESS NextFactory4 next_factory; 2536 }; 2537 struct Running5 { 2538 union { 2539 GPR_NO_UNIQUE_ADDRESS Running4 prior; 2540 GPR_NO_UNIQUE_ADDRESS Promise5 current_promise; 2541 }; 2542 GPR_NO_UNIQUE_ADDRESS NextFactory5 next_factory; 2543 }; 2544 struct Running6 { 2545 union { 2546 GPR_NO_UNIQUE_ADDRESS Running5 prior; 2547 GPR_NO_UNIQUE_ADDRESS Promise6 current_promise; 2548 }; 2549 GPR_NO_UNIQUE_ADDRESS NextFactory6 next_factory; 2550 }; 2551 struct Running7 { 2552 union { 2553 GPR_NO_UNIQUE_ADDRESS Running6 prior; 2554 GPR_NO_UNIQUE_ADDRESS Promise7 current_promise; 2555 }; 2556 GPR_NO_UNIQUE_ADDRESS NextFactory7 next_factory; 2557 }; 2558 struct Running8 { 2559 union { 2560 GPR_NO_UNIQUE_ADDRESS Running7 prior; 2561 GPR_NO_UNIQUE_ADDRESS Promise8 current_promise; 2562 }; 2563 GPR_NO_UNIQUE_ADDRESS NextFactory8 next_factory; 2564 }; 2565 union { 2566 GPR_NO_UNIQUE_ADDRESS Running8 prior; 2567 GPR_NO_UNIQUE_ADDRESS Promise9 current_promise; 2568 }; 2569 enum class State : uint8_t { 2570 kState0, 2571 kState1, 2572 kState2, 2573 kState3, 2574 kState4, 2575 kState5, 2576 kState6, 2577 kState7, 2578 kState8, 2579 kState9 2580 }; 2581 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 2582 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 2583 2584 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, F1&& f1, 2585 F2&& f2, F3&& f3, F4&& f4, 2586 F5&& f5, F6&& f6, F7&& f7, 2587 F8&& f8, 2588 DebugLocation whence) noexcept 2589 : whence(whence) { 2590 Construct( 2591 &prior.prior.prior.prior.prior.prior.prior.prior.prior.current_promise, 2592 std::forward<P>(p)); 2593 Construct( 2594 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2595 std::forward<F0>(f0)); 2596 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2597 std::forward<F1>(f1)); 2598 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 2599 std::forward<F2>(f2)); 2600 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 2601 std::forward<F3>(f3)); 2602 Construct(&prior.prior.prior.prior.prior.next_factory, 2603 std::forward<F4>(f4)); 2604 Construct(&prior.prior.prior.prior.next_factory, std::forward<F5>(f5)); 2605 Construct(&prior.prior.prior.next_factory, std::forward<F6>(f6)); 2606 Construct(&prior.prior.next_factory, std::forward<F7>(f7)); 2607 Construct(&prior.next_factory, std::forward<F8>(f8)); 2608 } 2609 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 2610 switch (state) { 2611 case State::kState0: 2612 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 2613 .current_promise); 2614 goto tail0; 2615 case State::kState1: 2616 Destruct( 2617 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise); 2618 goto tail1; 2619 case State::kState2: 2620 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 2621 goto tail2; 2622 case State::kState3: 2623 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 2624 goto tail3; 2625 case State::kState4: 2626 Destruct(&prior.prior.prior.prior.prior.current_promise); 2627 goto tail4; 2628 case State::kState5: 2629 Destruct(&prior.prior.prior.prior.current_promise); 2630 goto tail5; 2631 case State::kState6: 2632 Destruct(&prior.prior.prior.current_promise); 2633 goto tail6; 2634 case State::kState7: 2635 Destruct(&prior.prior.current_promise); 2636 goto tail7; 2637 case State::kState8: 2638 Destruct(&prior.current_promise); 2639 goto tail8; 2640 case State::kState9: 2641 Destruct(¤t_promise); 2642 return; 2643 } 2644 tail0: 2645 Destruct( 2646 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 2647 tail1: 2648 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 2649 tail2: 2650 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 2651 tail3: 2652 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 2653 tail4: 2654 Destruct(&prior.prior.prior.prior.prior.next_factory); 2655 tail5: 2656 Destruct(&prior.prior.prior.prior.next_factory); 2657 tail6: 2658 Destruct(&prior.prior.prior.next_factory); 2659 tail7: 2660 Destruct(&prior.prior.next_factory); 2661 tail8: 2662 Destruct(&prior.next_factory); 2663 } 2664 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 2665 : state(other.state), whence(other.whence) { 2666 DCHECK(state == State::kState0); 2667 Construct( 2668 &prior.prior.prior.prior.prior.prior.prior.prior.prior.current_promise, 2669 other.prior.prior.prior.prior.prior.prior.prior.prior.prior 2670 .current_promise); 2671 Construct( 2672 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2673 other.prior.prior.prior.prior.prior.prior.prior.prior.prior 2674 .next_factory); 2675 Construct( 2676 &prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2677 other.prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 2678 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 2679 other.prior.prior.prior.prior.prior.prior.prior.next_factory); 2680 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 2681 other.prior.prior.prior.prior.prior.prior.next_factory); 2682 Construct(&prior.prior.prior.prior.prior.next_factory, 2683 other.prior.prior.prior.prior.prior.next_factory); 2684 Construct(&prior.prior.prior.prior.next_factory, 2685 other.prior.prior.prior.prior.next_factory); 2686 Construct(&prior.prior.prior.next_factory, 2687 other.prior.prior.prior.next_factory); 2688 Construct(&prior.prior.next_factory, other.prior.prior.next_factory); 2689 Construct(&prior.next_factory, other.prior.next_factory); 2690 } 2691 SeqState& operator=(const SeqState& other) = delete; 2692 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 2693 : state(other.state), whence(other.whence) { 2694 DCHECK(state == State::kState0); 2695 Construct( 2696 &prior.prior.prior.prior.prior.prior.prior.prior.prior.current_promise, 2697 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior.prior 2698 .current_promise)); 2699 Construct( 2700 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2701 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior.prior 2702 .next_factory)); 2703 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2704 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 2705 .next_factory)); 2706 Construct( 2707 &prior.prior.prior.prior.prior.prior.prior.next_factory, 2708 std::move( 2709 other.prior.prior.prior.prior.prior.prior.prior.next_factory)); 2710 Construct( 2711 &prior.prior.prior.prior.prior.prior.next_factory, 2712 std::move(other.prior.prior.prior.prior.prior.prior.next_factory)); 2713 Construct(&prior.prior.prior.prior.prior.next_factory, 2714 std::move(other.prior.prior.prior.prior.prior.next_factory)); 2715 Construct(&prior.prior.prior.prior.next_factory, 2716 std::move(other.prior.prior.prior.prior.next_factory)); 2717 Construct(&prior.prior.prior.next_factory, 2718 std::move(other.prior.prior.prior.next_factory)); 2719 Construct(&prior.prior.next_factory, 2720 std::move(other.prior.prior.next_factory)); 2721 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 2722 } 2723 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 2724 delete; 2725 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 2726 switch (state) { 2727 case State::kState0: { 2728 GRPC_TRACE_LOG(promise_primitives, INFO) 2729 .AtLocation(whence.file(), whence.line()) 2730 << "seq[" << this << "]: begin poll step 1/10"; 2731 auto result = prior.prior.prior.prior.prior.prior.prior.prior.prior 2732 .current_promise(); 2733 PromiseResult0* p = result.value_if_ready(); 2734 GRPC_TRACE_LOG(promise_primitives, INFO) 2735 .AtLocation(whence.file(), whence.line()) 2736 << "seq[" << this << "]: poll step 1/10 gets " 2737 << (p != nullptr 2738 ? (PromiseResultTraits0::IsOk(*p) 2739 ? "ready" 2740 : absl::StrCat("early-error:", 2741 PromiseResultTraits0::ErrorString(*p)) 2742 .c_str()) 2743 : "pending"); 2744 if (p == nullptr) return Pending{}; 2745 if (!PromiseResultTraits0::IsOk(*p)) { 2746 return PromiseResultTraits0::template ReturnValue<Result>( 2747 std::move(*p)); 2748 } 2749 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 2750 .current_promise); 2751 auto next_promise = PromiseResultTraits0::CallFactory( 2752 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2753 std::move(*p)); 2754 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 2755 .next_factory); 2756 Construct( 2757 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise, 2758 std::move(next_promise)); 2759 state = State::kState1; 2760 } 2761 ABSL_FALLTHROUGH_INTENDED; 2762 case State::kState1: { 2763 GRPC_TRACE_LOG(promise_primitives, INFO) 2764 .AtLocation(whence.file(), whence.line()) 2765 << "seq[" << this << "]: begin poll step 2/10"; 2766 auto result = 2767 prior.prior.prior.prior.prior.prior.prior.prior.current_promise(); 2768 PromiseResult1* p = result.value_if_ready(); 2769 GRPC_TRACE_LOG(promise_primitives, INFO) 2770 .AtLocation(whence.file(), whence.line()) 2771 << "seq[" << this << "]: poll step 2/10 gets " 2772 << (p != nullptr 2773 ? (PromiseResultTraits1::IsOk(*p) 2774 ? "ready" 2775 : absl::StrCat("early-error:", 2776 PromiseResultTraits1::ErrorString(*p)) 2777 .c_str()) 2778 : "pending"); 2779 if (p == nullptr) return Pending{}; 2780 if (!PromiseResultTraits1::IsOk(*p)) { 2781 return PromiseResultTraits1::template ReturnValue<Result>( 2782 std::move(*p)); 2783 } 2784 Destruct( 2785 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise); 2786 auto next_promise = PromiseResultTraits1::CallFactory( 2787 &prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 2788 std::move(*p)); 2789 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 2790 Construct(&prior.prior.prior.prior.prior.prior.prior.current_promise, 2791 std::move(next_promise)); 2792 state = State::kState2; 2793 } 2794 ABSL_FALLTHROUGH_INTENDED; 2795 case State::kState2: { 2796 GRPC_TRACE_LOG(promise_primitives, INFO) 2797 .AtLocation(whence.file(), whence.line()) 2798 << "seq[" << this << "]: begin poll step 3/10"; 2799 auto result = 2800 prior.prior.prior.prior.prior.prior.prior.current_promise(); 2801 PromiseResult2* p = result.value_if_ready(); 2802 GRPC_TRACE_LOG(promise_primitives, INFO) 2803 .AtLocation(whence.file(), whence.line()) 2804 << "seq[" << this << "]: poll step 3/10 gets " 2805 << (p != nullptr 2806 ? (PromiseResultTraits2::IsOk(*p) 2807 ? "ready" 2808 : absl::StrCat("early-error:", 2809 PromiseResultTraits2::ErrorString(*p)) 2810 .c_str()) 2811 : "pending"); 2812 if (p == nullptr) return Pending{}; 2813 if (!PromiseResultTraits2::IsOk(*p)) { 2814 return PromiseResultTraits2::template ReturnValue<Result>( 2815 std::move(*p)); 2816 } 2817 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 2818 auto next_promise = PromiseResultTraits2::CallFactory( 2819 &prior.prior.prior.prior.prior.prior.prior.next_factory, 2820 std::move(*p)); 2821 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 2822 Construct(&prior.prior.prior.prior.prior.prior.current_promise, 2823 std::move(next_promise)); 2824 state = State::kState3; 2825 } 2826 ABSL_FALLTHROUGH_INTENDED; 2827 case State::kState3: { 2828 GRPC_TRACE_LOG(promise_primitives, INFO) 2829 .AtLocation(whence.file(), whence.line()) 2830 << "seq[" << this << "]: begin poll step 4/10"; 2831 auto result = prior.prior.prior.prior.prior.prior.current_promise(); 2832 PromiseResult3* p = result.value_if_ready(); 2833 GRPC_TRACE_LOG(promise_primitives, INFO) 2834 .AtLocation(whence.file(), whence.line()) 2835 << "seq[" << this << "]: poll step 4/10 gets " 2836 << (p != nullptr 2837 ? (PromiseResultTraits3::IsOk(*p) 2838 ? "ready" 2839 : absl::StrCat("early-error:", 2840 PromiseResultTraits3::ErrorString(*p)) 2841 .c_str()) 2842 : "pending"); 2843 if (p == nullptr) return Pending{}; 2844 if (!PromiseResultTraits3::IsOk(*p)) { 2845 return PromiseResultTraits3::template ReturnValue<Result>( 2846 std::move(*p)); 2847 } 2848 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 2849 auto next_promise = PromiseResultTraits3::CallFactory( 2850 &prior.prior.prior.prior.prior.prior.next_factory, std::move(*p)); 2851 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 2852 Construct(&prior.prior.prior.prior.prior.current_promise, 2853 std::move(next_promise)); 2854 state = State::kState4; 2855 } 2856 ABSL_FALLTHROUGH_INTENDED; 2857 case State::kState4: { 2858 GRPC_TRACE_LOG(promise_primitives, INFO) 2859 .AtLocation(whence.file(), whence.line()) 2860 << "seq[" << this << "]: begin poll step 5/10"; 2861 auto result = prior.prior.prior.prior.prior.current_promise(); 2862 PromiseResult4* p = result.value_if_ready(); 2863 GRPC_TRACE_LOG(promise_primitives, INFO) 2864 .AtLocation(whence.file(), whence.line()) 2865 << "seq[" << this << "]: poll step 5/10 gets " 2866 << (p != nullptr 2867 ? (PromiseResultTraits4::IsOk(*p) 2868 ? "ready" 2869 : absl::StrCat("early-error:", 2870 PromiseResultTraits4::ErrorString(*p)) 2871 .c_str()) 2872 : "pending"); 2873 if (p == nullptr) return Pending{}; 2874 if (!PromiseResultTraits4::IsOk(*p)) { 2875 return PromiseResultTraits4::template ReturnValue<Result>( 2876 std::move(*p)); 2877 } 2878 Destruct(&prior.prior.prior.prior.prior.current_promise); 2879 auto next_promise = PromiseResultTraits4::CallFactory( 2880 &prior.prior.prior.prior.prior.next_factory, std::move(*p)); 2881 Destruct(&prior.prior.prior.prior.prior.next_factory); 2882 Construct(&prior.prior.prior.prior.current_promise, 2883 std::move(next_promise)); 2884 state = State::kState5; 2885 } 2886 ABSL_FALLTHROUGH_INTENDED; 2887 case State::kState5: { 2888 GRPC_TRACE_LOG(promise_primitives, INFO) 2889 .AtLocation(whence.file(), whence.line()) 2890 << "seq[" << this << "]: begin poll step 6/10"; 2891 auto result = prior.prior.prior.prior.current_promise(); 2892 PromiseResult5* p = result.value_if_ready(); 2893 GRPC_TRACE_LOG(promise_primitives, INFO) 2894 .AtLocation(whence.file(), whence.line()) 2895 << "seq[" << this << "]: poll step 6/10 gets " 2896 << (p != nullptr 2897 ? (PromiseResultTraits5::IsOk(*p) 2898 ? "ready" 2899 : absl::StrCat("early-error:", 2900 PromiseResultTraits5::ErrorString(*p)) 2901 .c_str()) 2902 : "pending"); 2903 if (p == nullptr) return Pending{}; 2904 if (!PromiseResultTraits5::IsOk(*p)) { 2905 return PromiseResultTraits5::template ReturnValue<Result>( 2906 std::move(*p)); 2907 } 2908 Destruct(&prior.prior.prior.prior.current_promise); 2909 auto next_promise = PromiseResultTraits5::CallFactory( 2910 &prior.prior.prior.prior.next_factory, std::move(*p)); 2911 Destruct(&prior.prior.prior.prior.next_factory); 2912 Construct(&prior.prior.prior.current_promise, std::move(next_promise)); 2913 state = State::kState6; 2914 } 2915 ABSL_FALLTHROUGH_INTENDED; 2916 case State::kState6: { 2917 GRPC_TRACE_LOG(promise_primitives, INFO) 2918 .AtLocation(whence.file(), whence.line()) 2919 << "seq[" << this << "]: begin poll step 7/10"; 2920 auto result = prior.prior.prior.current_promise(); 2921 PromiseResult6* p = result.value_if_ready(); 2922 GRPC_TRACE_LOG(promise_primitives, INFO) 2923 .AtLocation(whence.file(), whence.line()) 2924 << "seq[" << this << "]: poll step 7/10 gets " 2925 << (p != nullptr 2926 ? (PromiseResultTraits6::IsOk(*p) 2927 ? "ready" 2928 : absl::StrCat("early-error:", 2929 PromiseResultTraits6::ErrorString(*p)) 2930 .c_str()) 2931 : "pending"); 2932 if (p == nullptr) return Pending{}; 2933 if (!PromiseResultTraits6::IsOk(*p)) { 2934 return PromiseResultTraits6::template ReturnValue<Result>( 2935 std::move(*p)); 2936 } 2937 Destruct(&prior.prior.prior.current_promise); 2938 auto next_promise = PromiseResultTraits6::CallFactory( 2939 &prior.prior.prior.next_factory, std::move(*p)); 2940 Destruct(&prior.prior.prior.next_factory); 2941 Construct(&prior.prior.current_promise, std::move(next_promise)); 2942 state = State::kState7; 2943 } 2944 ABSL_FALLTHROUGH_INTENDED; 2945 case State::kState7: { 2946 GRPC_TRACE_LOG(promise_primitives, INFO) 2947 .AtLocation(whence.file(), whence.line()) 2948 << "seq[" << this << "]: begin poll step 8/10"; 2949 auto result = prior.prior.current_promise(); 2950 PromiseResult7* p = result.value_if_ready(); 2951 GRPC_TRACE_LOG(promise_primitives, INFO) 2952 .AtLocation(whence.file(), whence.line()) 2953 << "seq[" << this << "]: poll step 8/10 gets " 2954 << (p != nullptr 2955 ? (PromiseResultTraits7::IsOk(*p) 2956 ? "ready" 2957 : absl::StrCat("early-error:", 2958 PromiseResultTraits7::ErrorString(*p)) 2959 .c_str()) 2960 : "pending"); 2961 if (p == nullptr) return Pending{}; 2962 if (!PromiseResultTraits7::IsOk(*p)) { 2963 return PromiseResultTraits7::template ReturnValue<Result>( 2964 std::move(*p)); 2965 } 2966 Destruct(&prior.prior.current_promise); 2967 auto next_promise = PromiseResultTraits7::CallFactory( 2968 &prior.prior.next_factory, std::move(*p)); 2969 Destruct(&prior.prior.next_factory); 2970 Construct(&prior.current_promise, std::move(next_promise)); 2971 state = State::kState8; 2972 } 2973 ABSL_FALLTHROUGH_INTENDED; 2974 case State::kState8: { 2975 GRPC_TRACE_LOG(promise_primitives, INFO) 2976 .AtLocation(whence.file(), whence.line()) 2977 << "seq[" << this << "]: begin poll step 9/10"; 2978 auto result = prior.current_promise(); 2979 PromiseResult8* p = result.value_if_ready(); 2980 GRPC_TRACE_LOG(promise_primitives, INFO) 2981 .AtLocation(whence.file(), whence.line()) 2982 << "seq[" << this << "]: poll step 9/10 gets " 2983 << (p != nullptr 2984 ? (PromiseResultTraits8::IsOk(*p) 2985 ? "ready" 2986 : absl::StrCat("early-error:", 2987 PromiseResultTraits8::ErrorString(*p)) 2988 .c_str()) 2989 : "pending"); 2990 if (p == nullptr) return Pending{}; 2991 if (!PromiseResultTraits8::IsOk(*p)) { 2992 return PromiseResultTraits8::template ReturnValue<Result>( 2993 std::move(*p)); 2994 } 2995 Destruct(&prior.current_promise); 2996 auto next_promise = PromiseResultTraits8::CallFactory( 2997 &prior.next_factory, std::move(*p)); 2998 Destruct(&prior.next_factory); 2999 Construct(¤t_promise, std::move(next_promise)); 3000 state = State::kState9; 3001 } 3002 ABSL_FALLTHROUGH_INTENDED; 3003 default: 3004 case State::kState9: { 3005 GRPC_TRACE_LOG(promise_primitives, INFO) 3006 .AtLocation(whence.file(), whence.line()) 3007 << "seq[" << this << "]: begin poll step 10/10"; 3008 auto result = current_promise(); 3009 GRPC_TRACE_LOG(promise_primitives, INFO) 3010 .AtLocation(whence.file(), whence.line()) 3011 << "seq[" << this << "]: poll step 10/10 gets " 3012 << (result.ready() ? "ready" : "pending"); 3013 auto* p = result.value_if_ready(); 3014 if (p == nullptr) return Pending{}; 3015 return Result(std::move(*p)); 3016 } 3017 } 3018 } 3019 }; 3020 3021 template <template <typename> class Traits, typename P, typename F0, 3022 typename F1, typename F2, typename F3, typename F4, typename F5, 3023 typename F6, typename F7, typename F8, typename F9> 3024 struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9> { 3025 using Promise0 = PromiseLike<P>; 3026 using PromiseResult0 = typename Promise0::Result; 3027 using PromiseResultTraits0 = Traits<PromiseResult0>; 3028 using NextFactory0 = 3029 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 3030 using Promise1 = typename NextFactory0::Promise; 3031 using PromiseResult1 = typename Promise1::Result; 3032 using PromiseResultTraits1 = Traits<PromiseResult1>; 3033 using NextFactory1 = 3034 OncePromiseFactory<typename PromiseResultTraits1::UnwrappedType, F1>; 3035 using Promise2 = typename NextFactory1::Promise; 3036 using PromiseResult2 = typename Promise2::Result; 3037 using PromiseResultTraits2 = Traits<PromiseResult2>; 3038 using NextFactory2 = 3039 OncePromiseFactory<typename PromiseResultTraits2::UnwrappedType, F2>; 3040 using Promise3 = typename NextFactory2::Promise; 3041 using PromiseResult3 = typename Promise3::Result; 3042 using PromiseResultTraits3 = Traits<PromiseResult3>; 3043 using NextFactory3 = 3044 OncePromiseFactory<typename PromiseResultTraits3::UnwrappedType, F3>; 3045 using Promise4 = typename NextFactory3::Promise; 3046 using PromiseResult4 = typename Promise4::Result; 3047 using PromiseResultTraits4 = Traits<PromiseResult4>; 3048 using NextFactory4 = 3049 OncePromiseFactory<typename PromiseResultTraits4::UnwrappedType, F4>; 3050 using Promise5 = typename NextFactory4::Promise; 3051 using PromiseResult5 = typename Promise5::Result; 3052 using PromiseResultTraits5 = Traits<PromiseResult5>; 3053 using NextFactory5 = 3054 OncePromiseFactory<typename PromiseResultTraits5::UnwrappedType, F5>; 3055 using Promise6 = typename NextFactory5::Promise; 3056 using PromiseResult6 = typename Promise6::Result; 3057 using PromiseResultTraits6 = Traits<PromiseResult6>; 3058 using NextFactory6 = 3059 OncePromiseFactory<typename PromiseResultTraits6::UnwrappedType, F6>; 3060 using Promise7 = typename NextFactory6::Promise; 3061 using PromiseResult7 = typename Promise7::Result; 3062 using PromiseResultTraits7 = Traits<PromiseResult7>; 3063 using NextFactory7 = 3064 OncePromiseFactory<typename PromiseResultTraits7::UnwrappedType, F7>; 3065 using Promise8 = typename NextFactory7::Promise; 3066 using PromiseResult8 = typename Promise8::Result; 3067 using PromiseResultTraits8 = Traits<PromiseResult8>; 3068 using NextFactory8 = 3069 OncePromiseFactory<typename PromiseResultTraits8::UnwrappedType, F8>; 3070 using Promise9 = typename NextFactory8::Promise; 3071 using PromiseResult9 = typename Promise9::Result; 3072 using PromiseResultTraits9 = Traits<PromiseResult9>; 3073 using NextFactory9 = 3074 OncePromiseFactory<typename PromiseResultTraits9::UnwrappedType, F9>; 3075 using Promise10 = typename NextFactory9::Promise; 3076 using PromiseResult10 = typename Promise10::Result; 3077 using PromiseResultTraits10 = Traits<PromiseResult10>; 3078 using Result = typename PromiseResultTraits10::WrappedType; 3079 struct Running0 { 3080 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 3081 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 3082 }; 3083 struct Running1 { 3084 union { 3085 GPR_NO_UNIQUE_ADDRESS Running0 prior; 3086 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 3087 }; 3088 GPR_NO_UNIQUE_ADDRESS NextFactory1 next_factory; 3089 }; 3090 struct Running2 { 3091 union { 3092 GPR_NO_UNIQUE_ADDRESS Running1 prior; 3093 GPR_NO_UNIQUE_ADDRESS Promise2 current_promise; 3094 }; 3095 GPR_NO_UNIQUE_ADDRESS NextFactory2 next_factory; 3096 }; 3097 struct Running3 { 3098 union { 3099 GPR_NO_UNIQUE_ADDRESS Running2 prior; 3100 GPR_NO_UNIQUE_ADDRESS Promise3 current_promise; 3101 }; 3102 GPR_NO_UNIQUE_ADDRESS NextFactory3 next_factory; 3103 }; 3104 struct Running4 { 3105 union { 3106 GPR_NO_UNIQUE_ADDRESS Running3 prior; 3107 GPR_NO_UNIQUE_ADDRESS Promise4 current_promise; 3108 }; 3109 GPR_NO_UNIQUE_ADDRESS NextFactory4 next_factory; 3110 }; 3111 struct Running5 { 3112 union { 3113 GPR_NO_UNIQUE_ADDRESS Running4 prior; 3114 GPR_NO_UNIQUE_ADDRESS Promise5 current_promise; 3115 }; 3116 GPR_NO_UNIQUE_ADDRESS NextFactory5 next_factory; 3117 }; 3118 struct Running6 { 3119 union { 3120 GPR_NO_UNIQUE_ADDRESS Running5 prior; 3121 GPR_NO_UNIQUE_ADDRESS Promise6 current_promise; 3122 }; 3123 GPR_NO_UNIQUE_ADDRESS NextFactory6 next_factory; 3124 }; 3125 struct Running7 { 3126 union { 3127 GPR_NO_UNIQUE_ADDRESS Running6 prior; 3128 GPR_NO_UNIQUE_ADDRESS Promise7 current_promise; 3129 }; 3130 GPR_NO_UNIQUE_ADDRESS NextFactory7 next_factory; 3131 }; 3132 struct Running8 { 3133 union { 3134 GPR_NO_UNIQUE_ADDRESS Running7 prior; 3135 GPR_NO_UNIQUE_ADDRESS Promise8 current_promise; 3136 }; 3137 GPR_NO_UNIQUE_ADDRESS NextFactory8 next_factory; 3138 }; 3139 struct Running9 { 3140 union { 3141 GPR_NO_UNIQUE_ADDRESS Running8 prior; 3142 GPR_NO_UNIQUE_ADDRESS Promise9 current_promise; 3143 }; 3144 GPR_NO_UNIQUE_ADDRESS NextFactory9 next_factory; 3145 }; 3146 union { 3147 GPR_NO_UNIQUE_ADDRESS Running9 prior; 3148 GPR_NO_UNIQUE_ADDRESS Promise10 current_promise; 3149 }; 3150 enum class State : uint8_t { 3151 kState0, 3152 kState1, 3153 kState2, 3154 kState3, 3155 kState4, 3156 kState5, 3157 kState6, 3158 kState7, 3159 kState8, 3160 kState9, 3161 kState10 3162 }; 3163 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 3164 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 3165 3166 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, F1&& f1, 3167 F2&& f2, F3&& f3, F4&& f4, 3168 F5&& f5, F6&& f6, F7&& f7, 3169 F8&& f8, F9&& f9, 3170 DebugLocation whence) noexcept 3171 : whence(whence) { 3172 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3173 .current_promise, 3174 std::forward<P>(p)); 3175 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3176 .next_factory, 3177 std::forward<F0>(f0)); 3178 Construct( 3179 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3180 std::forward<F1>(f1)); 3181 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3182 std::forward<F2>(f2)); 3183 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 3184 std::forward<F3>(f3)); 3185 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 3186 std::forward<F4>(f4)); 3187 Construct(&prior.prior.prior.prior.prior.next_factory, 3188 std::forward<F5>(f5)); 3189 Construct(&prior.prior.prior.prior.next_factory, std::forward<F6>(f6)); 3190 Construct(&prior.prior.prior.next_factory, std::forward<F7>(f7)); 3191 Construct(&prior.prior.next_factory, std::forward<F8>(f8)); 3192 Construct(&prior.next_factory, std::forward<F9>(f9)); 3193 } 3194 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 3195 switch (state) { 3196 case State::kState0: 3197 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3198 .current_promise); 3199 goto tail0; 3200 case State::kState1: 3201 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 3202 .current_promise); 3203 goto tail1; 3204 case State::kState2: 3205 Destruct( 3206 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise); 3207 goto tail2; 3208 case State::kState3: 3209 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 3210 goto tail3; 3211 case State::kState4: 3212 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 3213 goto tail4; 3214 case State::kState5: 3215 Destruct(&prior.prior.prior.prior.prior.current_promise); 3216 goto tail5; 3217 case State::kState6: 3218 Destruct(&prior.prior.prior.prior.current_promise); 3219 goto tail6; 3220 case State::kState7: 3221 Destruct(&prior.prior.prior.current_promise); 3222 goto tail7; 3223 case State::kState8: 3224 Destruct(&prior.prior.current_promise); 3225 goto tail8; 3226 case State::kState9: 3227 Destruct(&prior.current_promise); 3228 goto tail9; 3229 case State::kState10: 3230 Destruct(¤t_promise); 3231 return; 3232 } 3233 tail0: 3234 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3235 .next_factory); 3236 tail1: 3237 Destruct( 3238 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 3239 tail2: 3240 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 3241 tail3: 3242 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 3243 tail4: 3244 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 3245 tail5: 3246 Destruct(&prior.prior.prior.prior.prior.next_factory); 3247 tail6: 3248 Destruct(&prior.prior.prior.prior.next_factory); 3249 tail7: 3250 Destruct(&prior.prior.prior.next_factory); 3251 tail8: 3252 Destruct(&prior.prior.next_factory); 3253 tail9: 3254 Destruct(&prior.next_factory); 3255 } 3256 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 3257 : state(other.state), whence(other.whence) { 3258 DCHECK(state == State::kState0); 3259 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3260 .current_promise, 3261 other.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3262 .current_promise); 3263 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3264 .next_factory, 3265 other.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3266 .next_factory); 3267 Construct( 3268 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3269 other.prior.prior.prior.prior.prior.prior.prior.prior.prior 3270 .next_factory); 3271 Construct( 3272 &prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3273 other.prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 3274 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 3275 other.prior.prior.prior.prior.prior.prior.prior.next_factory); 3276 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 3277 other.prior.prior.prior.prior.prior.prior.next_factory); 3278 Construct(&prior.prior.prior.prior.prior.next_factory, 3279 other.prior.prior.prior.prior.prior.next_factory); 3280 Construct(&prior.prior.prior.prior.next_factory, 3281 other.prior.prior.prior.prior.next_factory); 3282 Construct(&prior.prior.prior.next_factory, 3283 other.prior.prior.prior.next_factory); 3284 Construct(&prior.prior.next_factory, other.prior.prior.next_factory); 3285 Construct(&prior.next_factory, other.prior.next_factory); 3286 } 3287 SeqState& operator=(const SeqState& other) = delete; 3288 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 3289 : state(other.state), whence(other.whence) { 3290 DCHECK(state == State::kState0); 3291 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3292 .current_promise, 3293 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 3294 .prior.prior.current_promise)); 3295 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3296 .next_factory, 3297 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 3298 .prior.prior.next_factory)); 3299 Construct( 3300 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3301 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior.prior 3302 .next_factory)); 3303 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3304 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 3305 .next_factory)); 3306 Construct( 3307 &prior.prior.prior.prior.prior.prior.prior.next_factory, 3308 std::move( 3309 other.prior.prior.prior.prior.prior.prior.prior.next_factory)); 3310 Construct( 3311 &prior.prior.prior.prior.prior.prior.next_factory, 3312 std::move(other.prior.prior.prior.prior.prior.prior.next_factory)); 3313 Construct(&prior.prior.prior.prior.prior.next_factory, 3314 std::move(other.prior.prior.prior.prior.prior.next_factory)); 3315 Construct(&prior.prior.prior.prior.next_factory, 3316 std::move(other.prior.prior.prior.prior.next_factory)); 3317 Construct(&prior.prior.prior.next_factory, 3318 std::move(other.prior.prior.prior.next_factory)); 3319 Construct(&prior.prior.next_factory, 3320 std::move(other.prior.prior.next_factory)); 3321 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 3322 } 3323 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 3324 delete; 3325 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 3326 switch (state) { 3327 case State::kState0: { 3328 GRPC_TRACE_LOG(promise_primitives, INFO) 3329 .AtLocation(whence.file(), whence.line()) 3330 << "seq[" << this << "]: begin poll step 1/11"; 3331 auto result = prior.prior.prior.prior.prior.prior.prior.prior.prior 3332 .prior.current_promise(); 3333 PromiseResult0* p = result.value_if_ready(); 3334 GRPC_TRACE_LOG(promise_primitives, INFO) 3335 .AtLocation(whence.file(), whence.line()) 3336 << "seq[" << this << "]: poll step 1/11 gets " 3337 << (p != nullptr 3338 ? (PromiseResultTraits0::IsOk(*p) 3339 ? "ready" 3340 : absl::StrCat("early-error:", 3341 PromiseResultTraits0::ErrorString(*p)) 3342 .c_str()) 3343 : "pending"); 3344 if (p == nullptr) return Pending{}; 3345 if (!PromiseResultTraits0::IsOk(*p)) { 3346 return PromiseResultTraits0::template ReturnValue<Result>( 3347 std::move(*p)); 3348 } 3349 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3350 .current_promise); 3351 auto next_promise = PromiseResultTraits0::CallFactory( 3352 &prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3353 .next_factory, 3354 std::move(*p)); 3355 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3356 .next_factory); 3357 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 3358 .current_promise, 3359 std::move(next_promise)); 3360 state = State::kState1; 3361 } 3362 ABSL_FALLTHROUGH_INTENDED; 3363 case State::kState1: { 3364 GRPC_TRACE_LOG(promise_primitives, INFO) 3365 .AtLocation(whence.file(), whence.line()) 3366 << "seq[" << this << "]: begin poll step 2/11"; 3367 auto result = prior.prior.prior.prior.prior.prior.prior.prior.prior 3368 .current_promise(); 3369 PromiseResult1* p = result.value_if_ready(); 3370 GRPC_TRACE_LOG(promise_primitives, INFO) 3371 .AtLocation(whence.file(), whence.line()) 3372 << "seq[" << this << "]: poll step 2/11 gets " 3373 << (p != nullptr 3374 ? (PromiseResultTraits1::IsOk(*p) 3375 ? "ready" 3376 : absl::StrCat("early-error:", 3377 PromiseResultTraits1::ErrorString(*p)) 3378 .c_str()) 3379 : "pending"); 3380 if (p == nullptr) return Pending{}; 3381 if (!PromiseResultTraits1::IsOk(*p)) { 3382 return PromiseResultTraits1::template ReturnValue<Result>( 3383 std::move(*p)); 3384 } 3385 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 3386 .current_promise); 3387 auto next_promise = PromiseResultTraits1::CallFactory( 3388 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3389 std::move(*p)); 3390 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 3391 .next_factory); 3392 Construct( 3393 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise, 3394 std::move(next_promise)); 3395 state = State::kState2; 3396 } 3397 ABSL_FALLTHROUGH_INTENDED; 3398 case State::kState2: { 3399 GRPC_TRACE_LOG(promise_primitives, INFO) 3400 .AtLocation(whence.file(), whence.line()) 3401 << "seq[" << this << "]: begin poll step 3/11"; 3402 auto result = 3403 prior.prior.prior.prior.prior.prior.prior.prior.current_promise(); 3404 PromiseResult2* p = result.value_if_ready(); 3405 GRPC_TRACE_LOG(promise_primitives, INFO) 3406 .AtLocation(whence.file(), whence.line()) 3407 << "seq[" << this << "]: poll step 3/11 gets " 3408 << (p != nullptr 3409 ? (PromiseResultTraits2::IsOk(*p) 3410 ? "ready" 3411 : absl::StrCat("early-error:", 3412 PromiseResultTraits2::ErrorString(*p)) 3413 .c_str()) 3414 : "pending"); 3415 if (p == nullptr) return Pending{}; 3416 if (!PromiseResultTraits2::IsOk(*p)) { 3417 return PromiseResultTraits2::template ReturnValue<Result>( 3418 std::move(*p)); 3419 } 3420 Destruct( 3421 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise); 3422 auto next_promise = PromiseResultTraits2::CallFactory( 3423 &prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3424 std::move(*p)); 3425 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 3426 Construct(&prior.prior.prior.prior.prior.prior.prior.current_promise, 3427 std::move(next_promise)); 3428 state = State::kState3; 3429 } 3430 ABSL_FALLTHROUGH_INTENDED; 3431 case State::kState3: { 3432 GRPC_TRACE_LOG(promise_primitives, INFO) 3433 .AtLocation(whence.file(), whence.line()) 3434 << "seq[" << this << "]: begin poll step 4/11"; 3435 auto result = 3436 prior.prior.prior.prior.prior.prior.prior.current_promise(); 3437 PromiseResult3* p = result.value_if_ready(); 3438 GRPC_TRACE_LOG(promise_primitives, INFO) 3439 .AtLocation(whence.file(), whence.line()) 3440 << "seq[" << this << "]: poll step 4/11 gets " 3441 << (p != nullptr 3442 ? (PromiseResultTraits3::IsOk(*p) 3443 ? "ready" 3444 : absl::StrCat("early-error:", 3445 PromiseResultTraits3::ErrorString(*p)) 3446 .c_str()) 3447 : "pending"); 3448 if (p == nullptr) return Pending{}; 3449 if (!PromiseResultTraits3::IsOk(*p)) { 3450 return PromiseResultTraits3::template ReturnValue<Result>( 3451 std::move(*p)); 3452 } 3453 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 3454 auto next_promise = PromiseResultTraits3::CallFactory( 3455 &prior.prior.prior.prior.prior.prior.prior.next_factory, 3456 std::move(*p)); 3457 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 3458 Construct(&prior.prior.prior.prior.prior.prior.current_promise, 3459 std::move(next_promise)); 3460 state = State::kState4; 3461 } 3462 ABSL_FALLTHROUGH_INTENDED; 3463 case State::kState4: { 3464 GRPC_TRACE_LOG(promise_primitives, INFO) 3465 .AtLocation(whence.file(), whence.line()) 3466 << "seq[" << this << "]: begin poll step 5/11"; 3467 auto result = prior.prior.prior.prior.prior.prior.current_promise(); 3468 PromiseResult4* p = result.value_if_ready(); 3469 GRPC_TRACE_LOG(promise_primitives, INFO) 3470 .AtLocation(whence.file(), whence.line()) 3471 << "seq[" << this << "]: poll step 5/11 gets " 3472 << (p != nullptr 3473 ? (PromiseResultTraits4::IsOk(*p) 3474 ? "ready" 3475 : absl::StrCat("early-error:", 3476 PromiseResultTraits4::ErrorString(*p)) 3477 .c_str()) 3478 : "pending"); 3479 if (p == nullptr) return Pending{}; 3480 if (!PromiseResultTraits4::IsOk(*p)) { 3481 return PromiseResultTraits4::template ReturnValue<Result>( 3482 std::move(*p)); 3483 } 3484 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 3485 auto next_promise = PromiseResultTraits4::CallFactory( 3486 &prior.prior.prior.prior.prior.prior.next_factory, std::move(*p)); 3487 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 3488 Construct(&prior.prior.prior.prior.prior.current_promise, 3489 std::move(next_promise)); 3490 state = State::kState5; 3491 } 3492 ABSL_FALLTHROUGH_INTENDED; 3493 case State::kState5: { 3494 GRPC_TRACE_LOG(promise_primitives, INFO) 3495 .AtLocation(whence.file(), whence.line()) 3496 << "seq[" << this << "]: begin poll step 6/11"; 3497 auto result = prior.prior.prior.prior.prior.current_promise(); 3498 PromiseResult5* p = result.value_if_ready(); 3499 GRPC_TRACE_LOG(promise_primitives, INFO) 3500 .AtLocation(whence.file(), whence.line()) 3501 << "seq[" << this << "]: poll step 6/11 gets " 3502 << (p != nullptr 3503 ? (PromiseResultTraits5::IsOk(*p) 3504 ? "ready" 3505 : absl::StrCat("early-error:", 3506 PromiseResultTraits5::ErrorString(*p)) 3507 .c_str()) 3508 : "pending"); 3509 if (p == nullptr) return Pending{}; 3510 if (!PromiseResultTraits5::IsOk(*p)) { 3511 return PromiseResultTraits5::template ReturnValue<Result>( 3512 std::move(*p)); 3513 } 3514 Destruct(&prior.prior.prior.prior.prior.current_promise); 3515 auto next_promise = PromiseResultTraits5::CallFactory( 3516 &prior.prior.prior.prior.prior.next_factory, std::move(*p)); 3517 Destruct(&prior.prior.prior.prior.prior.next_factory); 3518 Construct(&prior.prior.prior.prior.current_promise, 3519 std::move(next_promise)); 3520 state = State::kState6; 3521 } 3522 ABSL_FALLTHROUGH_INTENDED; 3523 case State::kState6: { 3524 GRPC_TRACE_LOG(promise_primitives, INFO) 3525 .AtLocation(whence.file(), whence.line()) 3526 << "seq[" << this << "]: begin poll step 7/11"; 3527 auto result = prior.prior.prior.prior.current_promise(); 3528 PromiseResult6* p = result.value_if_ready(); 3529 GRPC_TRACE_LOG(promise_primitives, INFO) 3530 .AtLocation(whence.file(), whence.line()) 3531 << "seq[" << this << "]: poll step 7/11 gets " 3532 << (p != nullptr 3533 ? (PromiseResultTraits6::IsOk(*p) 3534 ? "ready" 3535 : absl::StrCat("early-error:", 3536 PromiseResultTraits6::ErrorString(*p)) 3537 .c_str()) 3538 : "pending"); 3539 if (p == nullptr) return Pending{}; 3540 if (!PromiseResultTraits6::IsOk(*p)) { 3541 return PromiseResultTraits6::template ReturnValue<Result>( 3542 std::move(*p)); 3543 } 3544 Destruct(&prior.prior.prior.prior.current_promise); 3545 auto next_promise = PromiseResultTraits6::CallFactory( 3546 &prior.prior.prior.prior.next_factory, std::move(*p)); 3547 Destruct(&prior.prior.prior.prior.next_factory); 3548 Construct(&prior.prior.prior.current_promise, std::move(next_promise)); 3549 state = State::kState7; 3550 } 3551 ABSL_FALLTHROUGH_INTENDED; 3552 case State::kState7: { 3553 GRPC_TRACE_LOG(promise_primitives, INFO) 3554 .AtLocation(whence.file(), whence.line()) 3555 << "seq[" << this << "]: begin poll step 8/11"; 3556 auto result = prior.prior.prior.current_promise(); 3557 PromiseResult7* p = result.value_if_ready(); 3558 GRPC_TRACE_LOG(promise_primitives, INFO) 3559 .AtLocation(whence.file(), whence.line()) 3560 << "seq[" << this << "]: poll step 8/11 gets " 3561 << (p != nullptr 3562 ? (PromiseResultTraits7::IsOk(*p) 3563 ? "ready" 3564 : absl::StrCat("early-error:", 3565 PromiseResultTraits7::ErrorString(*p)) 3566 .c_str()) 3567 : "pending"); 3568 if (p == nullptr) return Pending{}; 3569 if (!PromiseResultTraits7::IsOk(*p)) { 3570 return PromiseResultTraits7::template ReturnValue<Result>( 3571 std::move(*p)); 3572 } 3573 Destruct(&prior.prior.prior.current_promise); 3574 auto next_promise = PromiseResultTraits7::CallFactory( 3575 &prior.prior.prior.next_factory, std::move(*p)); 3576 Destruct(&prior.prior.prior.next_factory); 3577 Construct(&prior.prior.current_promise, std::move(next_promise)); 3578 state = State::kState8; 3579 } 3580 ABSL_FALLTHROUGH_INTENDED; 3581 case State::kState8: { 3582 GRPC_TRACE_LOG(promise_primitives, INFO) 3583 .AtLocation(whence.file(), whence.line()) 3584 << "seq[" << this << "]: begin poll step 9/11"; 3585 auto result = prior.prior.current_promise(); 3586 PromiseResult8* p = result.value_if_ready(); 3587 GRPC_TRACE_LOG(promise_primitives, INFO) 3588 .AtLocation(whence.file(), whence.line()) 3589 << "seq[" << this << "]: poll step 9/11 gets " 3590 << (p != nullptr 3591 ? (PromiseResultTraits8::IsOk(*p) 3592 ? "ready" 3593 : absl::StrCat("early-error:", 3594 PromiseResultTraits8::ErrorString(*p)) 3595 .c_str()) 3596 : "pending"); 3597 if (p == nullptr) return Pending{}; 3598 if (!PromiseResultTraits8::IsOk(*p)) { 3599 return PromiseResultTraits8::template ReturnValue<Result>( 3600 std::move(*p)); 3601 } 3602 Destruct(&prior.prior.current_promise); 3603 auto next_promise = PromiseResultTraits8::CallFactory( 3604 &prior.prior.next_factory, std::move(*p)); 3605 Destruct(&prior.prior.next_factory); 3606 Construct(&prior.current_promise, std::move(next_promise)); 3607 state = State::kState9; 3608 } 3609 ABSL_FALLTHROUGH_INTENDED; 3610 case State::kState9: { 3611 GRPC_TRACE_LOG(promise_primitives, INFO) 3612 .AtLocation(whence.file(), whence.line()) 3613 << "seq[" << this << "]: begin poll step 10/11"; 3614 auto result = prior.current_promise(); 3615 PromiseResult9* p = result.value_if_ready(); 3616 GRPC_TRACE_LOG(promise_primitives, INFO) 3617 .AtLocation(whence.file(), whence.line()) 3618 << "seq[" << this << "]: poll step 10/11 gets " 3619 << (p != nullptr 3620 ? (PromiseResultTraits9::IsOk(*p) 3621 ? "ready" 3622 : absl::StrCat("early-error:", 3623 PromiseResultTraits9::ErrorString(*p)) 3624 .c_str()) 3625 : "pending"); 3626 if (p == nullptr) return Pending{}; 3627 if (!PromiseResultTraits9::IsOk(*p)) { 3628 return PromiseResultTraits9::template ReturnValue<Result>( 3629 std::move(*p)); 3630 } 3631 Destruct(&prior.current_promise); 3632 auto next_promise = PromiseResultTraits9::CallFactory( 3633 &prior.next_factory, std::move(*p)); 3634 Destruct(&prior.next_factory); 3635 Construct(¤t_promise, std::move(next_promise)); 3636 state = State::kState10; 3637 } 3638 ABSL_FALLTHROUGH_INTENDED; 3639 default: 3640 case State::kState10: { 3641 GRPC_TRACE_LOG(promise_primitives, INFO) 3642 .AtLocation(whence.file(), whence.line()) 3643 << "seq[" << this << "]: begin poll step 11/11"; 3644 auto result = current_promise(); 3645 GRPC_TRACE_LOG(promise_primitives, INFO) 3646 .AtLocation(whence.file(), whence.line()) 3647 << "seq[" << this << "]: poll step 11/11 gets " 3648 << (result.ready() ? "ready" : "pending"); 3649 auto* p = result.value_if_ready(); 3650 if (p == nullptr) return Pending{}; 3651 return Result(std::move(*p)); 3652 } 3653 } 3654 } 3655 }; 3656 3657 template <template <typename> class Traits, typename P, typename F0, 3658 typename F1, typename F2, typename F3, typename F4, typename F5, 3659 typename F6, typename F7, typename F8, typename F9, typename F10> 3660 struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10> { 3661 using Promise0 = PromiseLike<P>; 3662 using PromiseResult0 = typename Promise0::Result; 3663 using PromiseResultTraits0 = Traits<PromiseResult0>; 3664 using NextFactory0 = 3665 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 3666 using Promise1 = typename NextFactory0::Promise; 3667 using PromiseResult1 = typename Promise1::Result; 3668 using PromiseResultTraits1 = Traits<PromiseResult1>; 3669 using NextFactory1 = 3670 OncePromiseFactory<typename PromiseResultTraits1::UnwrappedType, F1>; 3671 using Promise2 = typename NextFactory1::Promise; 3672 using PromiseResult2 = typename Promise2::Result; 3673 using PromiseResultTraits2 = Traits<PromiseResult2>; 3674 using NextFactory2 = 3675 OncePromiseFactory<typename PromiseResultTraits2::UnwrappedType, F2>; 3676 using Promise3 = typename NextFactory2::Promise; 3677 using PromiseResult3 = typename Promise3::Result; 3678 using PromiseResultTraits3 = Traits<PromiseResult3>; 3679 using NextFactory3 = 3680 OncePromiseFactory<typename PromiseResultTraits3::UnwrappedType, F3>; 3681 using Promise4 = typename NextFactory3::Promise; 3682 using PromiseResult4 = typename Promise4::Result; 3683 using PromiseResultTraits4 = Traits<PromiseResult4>; 3684 using NextFactory4 = 3685 OncePromiseFactory<typename PromiseResultTraits4::UnwrappedType, F4>; 3686 using Promise5 = typename NextFactory4::Promise; 3687 using PromiseResult5 = typename Promise5::Result; 3688 using PromiseResultTraits5 = Traits<PromiseResult5>; 3689 using NextFactory5 = 3690 OncePromiseFactory<typename PromiseResultTraits5::UnwrappedType, F5>; 3691 using Promise6 = typename NextFactory5::Promise; 3692 using PromiseResult6 = typename Promise6::Result; 3693 using PromiseResultTraits6 = Traits<PromiseResult6>; 3694 using NextFactory6 = 3695 OncePromiseFactory<typename PromiseResultTraits6::UnwrappedType, F6>; 3696 using Promise7 = typename NextFactory6::Promise; 3697 using PromiseResult7 = typename Promise7::Result; 3698 using PromiseResultTraits7 = Traits<PromiseResult7>; 3699 using NextFactory7 = 3700 OncePromiseFactory<typename PromiseResultTraits7::UnwrappedType, F7>; 3701 using Promise8 = typename NextFactory7::Promise; 3702 using PromiseResult8 = typename Promise8::Result; 3703 using PromiseResultTraits8 = Traits<PromiseResult8>; 3704 using NextFactory8 = 3705 OncePromiseFactory<typename PromiseResultTraits8::UnwrappedType, F8>; 3706 using Promise9 = typename NextFactory8::Promise; 3707 using PromiseResult9 = typename Promise9::Result; 3708 using PromiseResultTraits9 = Traits<PromiseResult9>; 3709 using NextFactory9 = 3710 OncePromiseFactory<typename PromiseResultTraits9::UnwrappedType, F9>; 3711 using Promise10 = typename NextFactory9::Promise; 3712 using PromiseResult10 = typename Promise10::Result; 3713 using PromiseResultTraits10 = Traits<PromiseResult10>; 3714 using NextFactory10 = 3715 OncePromiseFactory<typename PromiseResultTraits10::UnwrappedType, F10>; 3716 using Promise11 = typename NextFactory10::Promise; 3717 using PromiseResult11 = typename Promise11::Result; 3718 using PromiseResultTraits11 = Traits<PromiseResult11>; 3719 using Result = typename PromiseResultTraits11::WrappedType; 3720 struct Running0 { 3721 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 3722 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 3723 }; 3724 struct Running1 { 3725 union { 3726 GPR_NO_UNIQUE_ADDRESS Running0 prior; 3727 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 3728 }; 3729 GPR_NO_UNIQUE_ADDRESS NextFactory1 next_factory; 3730 }; 3731 struct Running2 { 3732 union { 3733 GPR_NO_UNIQUE_ADDRESS Running1 prior; 3734 GPR_NO_UNIQUE_ADDRESS Promise2 current_promise; 3735 }; 3736 GPR_NO_UNIQUE_ADDRESS NextFactory2 next_factory; 3737 }; 3738 struct Running3 { 3739 union { 3740 GPR_NO_UNIQUE_ADDRESS Running2 prior; 3741 GPR_NO_UNIQUE_ADDRESS Promise3 current_promise; 3742 }; 3743 GPR_NO_UNIQUE_ADDRESS NextFactory3 next_factory; 3744 }; 3745 struct Running4 { 3746 union { 3747 GPR_NO_UNIQUE_ADDRESS Running3 prior; 3748 GPR_NO_UNIQUE_ADDRESS Promise4 current_promise; 3749 }; 3750 GPR_NO_UNIQUE_ADDRESS NextFactory4 next_factory; 3751 }; 3752 struct Running5 { 3753 union { 3754 GPR_NO_UNIQUE_ADDRESS Running4 prior; 3755 GPR_NO_UNIQUE_ADDRESS Promise5 current_promise; 3756 }; 3757 GPR_NO_UNIQUE_ADDRESS NextFactory5 next_factory; 3758 }; 3759 struct Running6 { 3760 union { 3761 GPR_NO_UNIQUE_ADDRESS Running5 prior; 3762 GPR_NO_UNIQUE_ADDRESS Promise6 current_promise; 3763 }; 3764 GPR_NO_UNIQUE_ADDRESS NextFactory6 next_factory; 3765 }; 3766 struct Running7 { 3767 union { 3768 GPR_NO_UNIQUE_ADDRESS Running6 prior; 3769 GPR_NO_UNIQUE_ADDRESS Promise7 current_promise; 3770 }; 3771 GPR_NO_UNIQUE_ADDRESS NextFactory7 next_factory; 3772 }; 3773 struct Running8 { 3774 union { 3775 GPR_NO_UNIQUE_ADDRESS Running7 prior; 3776 GPR_NO_UNIQUE_ADDRESS Promise8 current_promise; 3777 }; 3778 GPR_NO_UNIQUE_ADDRESS NextFactory8 next_factory; 3779 }; 3780 struct Running9 { 3781 union { 3782 GPR_NO_UNIQUE_ADDRESS Running8 prior; 3783 GPR_NO_UNIQUE_ADDRESS Promise9 current_promise; 3784 }; 3785 GPR_NO_UNIQUE_ADDRESS NextFactory9 next_factory; 3786 }; 3787 struct Running10 { 3788 union { 3789 GPR_NO_UNIQUE_ADDRESS Running9 prior; 3790 GPR_NO_UNIQUE_ADDRESS Promise10 current_promise; 3791 }; 3792 GPR_NO_UNIQUE_ADDRESS NextFactory10 next_factory; 3793 }; 3794 union { 3795 GPR_NO_UNIQUE_ADDRESS Running10 prior; 3796 GPR_NO_UNIQUE_ADDRESS Promise11 current_promise; 3797 }; 3798 enum class State : uint8_t { 3799 kState0, 3800 kState1, 3801 kState2, 3802 kState3, 3803 kState4, 3804 kState5, 3805 kState6, 3806 kState7, 3807 kState8, 3808 kState9, 3809 kState10, 3810 kState11 3811 }; 3812 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 3813 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 3814 3815 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, F1&& f1, 3816 F2&& f2, F3&& f3, F4&& f4, 3817 F5&& f5, F6&& f6, F7&& f7, 3818 F8&& f8, F9&& f9, F10&& f10, 3819 DebugLocation whence) noexcept 3820 : whence(whence) { 3821 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3822 .current_promise, 3823 std::forward<P>(p)); 3824 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3825 .next_factory, 3826 std::forward<F0>(f0)); 3827 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3828 .next_factory, 3829 std::forward<F1>(f1)); 3830 Construct( 3831 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3832 std::forward<F2>(f2)); 3833 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3834 std::forward<F3>(f3)); 3835 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 3836 std::forward<F4>(f4)); 3837 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 3838 std::forward<F5>(f5)); 3839 Construct(&prior.prior.prior.prior.prior.next_factory, 3840 std::forward<F6>(f6)); 3841 Construct(&prior.prior.prior.prior.next_factory, std::forward<F7>(f7)); 3842 Construct(&prior.prior.prior.next_factory, std::forward<F8>(f8)); 3843 Construct(&prior.prior.next_factory, std::forward<F9>(f9)); 3844 Construct(&prior.next_factory, std::forward<F10>(f10)); 3845 } 3846 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 3847 switch (state) { 3848 case State::kState0: 3849 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3850 .prior.current_promise); 3851 goto tail0; 3852 case State::kState1: 3853 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3854 .current_promise); 3855 goto tail1; 3856 case State::kState2: 3857 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 3858 .current_promise); 3859 goto tail2; 3860 case State::kState3: 3861 Destruct( 3862 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise); 3863 goto tail3; 3864 case State::kState4: 3865 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 3866 goto tail4; 3867 case State::kState5: 3868 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 3869 goto tail5; 3870 case State::kState6: 3871 Destruct(&prior.prior.prior.prior.prior.current_promise); 3872 goto tail6; 3873 case State::kState7: 3874 Destruct(&prior.prior.prior.prior.current_promise); 3875 goto tail7; 3876 case State::kState8: 3877 Destruct(&prior.prior.prior.current_promise); 3878 goto tail8; 3879 case State::kState9: 3880 Destruct(&prior.prior.current_promise); 3881 goto tail9; 3882 case State::kState10: 3883 Destruct(&prior.current_promise); 3884 goto tail10; 3885 case State::kState11: 3886 Destruct(¤t_promise); 3887 return; 3888 } 3889 tail0: 3890 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3891 .next_factory); 3892 tail1: 3893 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3894 .next_factory); 3895 tail2: 3896 Destruct( 3897 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 3898 tail3: 3899 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 3900 tail4: 3901 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 3902 tail5: 3903 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 3904 tail6: 3905 Destruct(&prior.prior.prior.prior.prior.next_factory); 3906 tail7: 3907 Destruct(&prior.prior.prior.prior.next_factory); 3908 tail8: 3909 Destruct(&prior.prior.prior.next_factory); 3910 tail9: 3911 Destruct(&prior.prior.next_factory); 3912 tail10: 3913 Destruct(&prior.next_factory); 3914 } 3915 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 3916 : state(other.state), whence(other.whence) { 3917 DCHECK(state == State::kState0); 3918 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3919 .current_promise, 3920 other.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3921 .prior.current_promise); 3922 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3923 .next_factory, 3924 other.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3925 .prior.next_factory); 3926 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3927 .next_factory, 3928 other.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3929 .next_factory); 3930 Construct( 3931 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3932 other.prior.prior.prior.prior.prior.prior.prior.prior.prior 3933 .next_factory); 3934 Construct( 3935 &prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3936 other.prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 3937 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 3938 other.prior.prior.prior.prior.prior.prior.prior.next_factory); 3939 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 3940 other.prior.prior.prior.prior.prior.prior.next_factory); 3941 Construct(&prior.prior.prior.prior.prior.next_factory, 3942 other.prior.prior.prior.prior.prior.next_factory); 3943 Construct(&prior.prior.prior.prior.next_factory, 3944 other.prior.prior.prior.prior.next_factory); 3945 Construct(&prior.prior.prior.next_factory, 3946 other.prior.prior.prior.next_factory); 3947 Construct(&prior.prior.next_factory, other.prior.prior.next_factory); 3948 Construct(&prior.next_factory, other.prior.next_factory); 3949 } 3950 SeqState& operator=(const SeqState& other) = delete; 3951 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 3952 : state(other.state), whence(other.whence) { 3953 DCHECK(state == State::kState0); 3954 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3955 .current_promise, 3956 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 3957 .prior.prior.prior.current_promise)); 3958 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3959 .next_factory, 3960 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 3961 .prior.prior.prior.next_factory)); 3962 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 3963 .next_factory, 3964 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 3965 .prior.prior.next_factory)); 3966 Construct( 3967 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3968 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior.prior 3969 .next_factory)); 3970 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 3971 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 3972 .next_factory)); 3973 Construct( 3974 &prior.prior.prior.prior.prior.prior.prior.next_factory, 3975 std::move( 3976 other.prior.prior.prior.prior.prior.prior.prior.next_factory)); 3977 Construct( 3978 &prior.prior.prior.prior.prior.prior.next_factory, 3979 std::move(other.prior.prior.prior.prior.prior.prior.next_factory)); 3980 Construct(&prior.prior.prior.prior.prior.next_factory, 3981 std::move(other.prior.prior.prior.prior.prior.next_factory)); 3982 Construct(&prior.prior.prior.prior.next_factory, 3983 std::move(other.prior.prior.prior.prior.next_factory)); 3984 Construct(&prior.prior.prior.next_factory, 3985 std::move(other.prior.prior.prior.next_factory)); 3986 Construct(&prior.prior.next_factory, 3987 std::move(other.prior.prior.next_factory)); 3988 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 3989 } 3990 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 3991 delete; 3992 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 3993 switch (state) { 3994 case State::kState0: { 3995 GRPC_TRACE_LOG(promise_primitives, INFO) 3996 .AtLocation(whence.file(), whence.line()) 3997 << "seq[" << this << "]: begin poll step 1/12"; 3998 auto result = prior.prior.prior.prior.prior.prior.prior.prior.prior 3999 .prior.prior.current_promise(); 4000 PromiseResult0* p = result.value_if_ready(); 4001 GRPC_TRACE_LOG(promise_primitives, INFO) 4002 .AtLocation(whence.file(), whence.line()) 4003 << "seq[" << this << "]: poll step 1/12 gets " 4004 << (p != nullptr 4005 ? (PromiseResultTraits0::IsOk(*p) 4006 ? "ready" 4007 : absl::StrCat("early-error:", 4008 PromiseResultTraits0::ErrorString(*p)) 4009 .c_str()) 4010 : "pending"); 4011 if (p == nullptr) return Pending{}; 4012 if (!PromiseResultTraits0::IsOk(*p)) { 4013 return PromiseResultTraits0::template ReturnValue<Result>( 4014 std::move(*p)); 4015 } 4016 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4017 .prior.current_promise); 4018 auto next_promise = PromiseResultTraits0::CallFactory( 4019 &prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4020 .next_factory, 4021 std::move(*p)); 4022 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4023 .prior.next_factory); 4024 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4025 .current_promise, 4026 std::move(next_promise)); 4027 state = State::kState1; 4028 } 4029 ABSL_FALLTHROUGH_INTENDED; 4030 case State::kState1: { 4031 GRPC_TRACE_LOG(promise_primitives, INFO) 4032 .AtLocation(whence.file(), whence.line()) 4033 << "seq[" << this << "]: begin poll step 2/12"; 4034 auto result = prior.prior.prior.prior.prior.prior.prior.prior.prior 4035 .prior.current_promise(); 4036 PromiseResult1* p = result.value_if_ready(); 4037 GRPC_TRACE_LOG(promise_primitives, INFO) 4038 .AtLocation(whence.file(), whence.line()) 4039 << "seq[" << this << "]: poll step 2/12 gets " 4040 << (p != nullptr 4041 ? (PromiseResultTraits1::IsOk(*p) 4042 ? "ready" 4043 : absl::StrCat("early-error:", 4044 PromiseResultTraits1::ErrorString(*p)) 4045 .c_str()) 4046 : "pending"); 4047 if (p == nullptr) return Pending{}; 4048 if (!PromiseResultTraits1::IsOk(*p)) { 4049 return PromiseResultTraits1::template ReturnValue<Result>( 4050 std::move(*p)); 4051 } 4052 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4053 .current_promise); 4054 auto next_promise = PromiseResultTraits1::CallFactory( 4055 &prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4056 .next_factory, 4057 std::move(*p)); 4058 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4059 .next_factory); 4060 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 4061 .current_promise, 4062 std::move(next_promise)); 4063 state = State::kState2; 4064 } 4065 ABSL_FALLTHROUGH_INTENDED; 4066 case State::kState2: { 4067 GRPC_TRACE_LOG(promise_primitives, INFO) 4068 .AtLocation(whence.file(), whence.line()) 4069 << "seq[" << this << "]: begin poll step 3/12"; 4070 auto result = prior.prior.prior.prior.prior.prior.prior.prior.prior 4071 .current_promise(); 4072 PromiseResult2* p = result.value_if_ready(); 4073 GRPC_TRACE_LOG(promise_primitives, INFO) 4074 .AtLocation(whence.file(), whence.line()) 4075 << "seq[" << this << "]: poll step 3/12 gets " 4076 << (p != nullptr 4077 ? (PromiseResultTraits2::IsOk(*p) 4078 ? "ready" 4079 : absl::StrCat("early-error:", 4080 PromiseResultTraits2::ErrorString(*p)) 4081 .c_str()) 4082 : "pending"); 4083 if (p == nullptr) return Pending{}; 4084 if (!PromiseResultTraits2::IsOk(*p)) { 4085 return PromiseResultTraits2::template ReturnValue<Result>( 4086 std::move(*p)); 4087 } 4088 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 4089 .current_promise); 4090 auto next_promise = PromiseResultTraits2::CallFactory( 4091 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 4092 std::move(*p)); 4093 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 4094 .next_factory); 4095 Construct( 4096 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise, 4097 std::move(next_promise)); 4098 state = State::kState3; 4099 } 4100 ABSL_FALLTHROUGH_INTENDED; 4101 case State::kState3: { 4102 GRPC_TRACE_LOG(promise_primitives, INFO) 4103 .AtLocation(whence.file(), whence.line()) 4104 << "seq[" << this << "]: begin poll step 4/12"; 4105 auto result = 4106 prior.prior.prior.prior.prior.prior.prior.prior.current_promise(); 4107 PromiseResult3* p = result.value_if_ready(); 4108 GRPC_TRACE_LOG(promise_primitives, INFO) 4109 .AtLocation(whence.file(), whence.line()) 4110 << "seq[" << this << "]: poll step 4/12 gets " 4111 << (p != nullptr 4112 ? (PromiseResultTraits3::IsOk(*p) 4113 ? "ready" 4114 : absl::StrCat("early-error:", 4115 PromiseResultTraits3::ErrorString(*p)) 4116 .c_str()) 4117 : "pending"); 4118 if (p == nullptr) return Pending{}; 4119 if (!PromiseResultTraits3::IsOk(*p)) { 4120 return PromiseResultTraits3::template ReturnValue<Result>( 4121 std::move(*p)); 4122 } 4123 Destruct( 4124 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise); 4125 auto next_promise = PromiseResultTraits3::CallFactory( 4126 &prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 4127 std::move(*p)); 4128 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 4129 Construct(&prior.prior.prior.prior.prior.prior.prior.current_promise, 4130 std::move(next_promise)); 4131 state = State::kState4; 4132 } 4133 ABSL_FALLTHROUGH_INTENDED; 4134 case State::kState4: { 4135 GRPC_TRACE_LOG(promise_primitives, INFO) 4136 .AtLocation(whence.file(), whence.line()) 4137 << "seq[" << this << "]: begin poll step 5/12"; 4138 auto result = 4139 prior.prior.prior.prior.prior.prior.prior.current_promise(); 4140 PromiseResult4* p = result.value_if_ready(); 4141 GRPC_TRACE_LOG(promise_primitives, INFO) 4142 .AtLocation(whence.file(), whence.line()) 4143 << "seq[" << this << "]: poll step 5/12 gets " 4144 << (p != nullptr 4145 ? (PromiseResultTraits4::IsOk(*p) 4146 ? "ready" 4147 : absl::StrCat("early-error:", 4148 PromiseResultTraits4::ErrorString(*p)) 4149 .c_str()) 4150 : "pending"); 4151 if (p == nullptr) return Pending{}; 4152 if (!PromiseResultTraits4::IsOk(*p)) { 4153 return PromiseResultTraits4::template ReturnValue<Result>( 4154 std::move(*p)); 4155 } 4156 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 4157 auto next_promise = PromiseResultTraits4::CallFactory( 4158 &prior.prior.prior.prior.prior.prior.prior.next_factory, 4159 std::move(*p)); 4160 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 4161 Construct(&prior.prior.prior.prior.prior.prior.current_promise, 4162 std::move(next_promise)); 4163 state = State::kState5; 4164 } 4165 ABSL_FALLTHROUGH_INTENDED; 4166 case State::kState5: { 4167 GRPC_TRACE_LOG(promise_primitives, INFO) 4168 .AtLocation(whence.file(), whence.line()) 4169 << "seq[" << this << "]: begin poll step 6/12"; 4170 auto result = prior.prior.prior.prior.prior.prior.current_promise(); 4171 PromiseResult5* p = result.value_if_ready(); 4172 GRPC_TRACE_LOG(promise_primitives, INFO) 4173 .AtLocation(whence.file(), whence.line()) 4174 << "seq[" << this << "]: poll step 6/12 gets " 4175 << (p != nullptr 4176 ? (PromiseResultTraits5::IsOk(*p) 4177 ? "ready" 4178 : absl::StrCat("early-error:", 4179 PromiseResultTraits5::ErrorString(*p)) 4180 .c_str()) 4181 : "pending"); 4182 if (p == nullptr) return Pending{}; 4183 if (!PromiseResultTraits5::IsOk(*p)) { 4184 return PromiseResultTraits5::template ReturnValue<Result>( 4185 std::move(*p)); 4186 } 4187 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 4188 auto next_promise = PromiseResultTraits5::CallFactory( 4189 &prior.prior.prior.prior.prior.prior.next_factory, std::move(*p)); 4190 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 4191 Construct(&prior.prior.prior.prior.prior.current_promise, 4192 std::move(next_promise)); 4193 state = State::kState6; 4194 } 4195 ABSL_FALLTHROUGH_INTENDED; 4196 case State::kState6: { 4197 GRPC_TRACE_LOG(promise_primitives, INFO) 4198 .AtLocation(whence.file(), whence.line()) 4199 << "seq[" << this << "]: begin poll step 7/12"; 4200 auto result = prior.prior.prior.prior.prior.current_promise(); 4201 PromiseResult6* p = result.value_if_ready(); 4202 GRPC_TRACE_LOG(promise_primitives, INFO) 4203 .AtLocation(whence.file(), whence.line()) 4204 << "seq[" << this << "]: poll step 7/12 gets " 4205 << (p != nullptr 4206 ? (PromiseResultTraits6::IsOk(*p) 4207 ? "ready" 4208 : absl::StrCat("early-error:", 4209 PromiseResultTraits6::ErrorString(*p)) 4210 .c_str()) 4211 : "pending"); 4212 if (p == nullptr) return Pending{}; 4213 if (!PromiseResultTraits6::IsOk(*p)) { 4214 return PromiseResultTraits6::template ReturnValue<Result>( 4215 std::move(*p)); 4216 } 4217 Destruct(&prior.prior.prior.prior.prior.current_promise); 4218 auto next_promise = PromiseResultTraits6::CallFactory( 4219 &prior.prior.prior.prior.prior.next_factory, std::move(*p)); 4220 Destruct(&prior.prior.prior.prior.prior.next_factory); 4221 Construct(&prior.prior.prior.prior.current_promise, 4222 std::move(next_promise)); 4223 state = State::kState7; 4224 } 4225 ABSL_FALLTHROUGH_INTENDED; 4226 case State::kState7: { 4227 GRPC_TRACE_LOG(promise_primitives, INFO) 4228 .AtLocation(whence.file(), whence.line()) 4229 << "seq[" << this << "]: begin poll step 8/12"; 4230 auto result = prior.prior.prior.prior.current_promise(); 4231 PromiseResult7* p = result.value_if_ready(); 4232 GRPC_TRACE_LOG(promise_primitives, INFO) 4233 .AtLocation(whence.file(), whence.line()) 4234 << "seq[" << this << "]: poll step 8/12 gets " 4235 << (p != nullptr 4236 ? (PromiseResultTraits7::IsOk(*p) 4237 ? "ready" 4238 : absl::StrCat("early-error:", 4239 PromiseResultTraits7::ErrorString(*p)) 4240 .c_str()) 4241 : "pending"); 4242 if (p == nullptr) return Pending{}; 4243 if (!PromiseResultTraits7::IsOk(*p)) { 4244 return PromiseResultTraits7::template ReturnValue<Result>( 4245 std::move(*p)); 4246 } 4247 Destruct(&prior.prior.prior.prior.current_promise); 4248 auto next_promise = PromiseResultTraits7::CallFactory( 4249 &prior.prior.prior.prior.next_factory, std::move(*p)); 4250 Destruct(&prior.prior.prior.prior.next_factory); 4251 Construct(&prior.prior.prior.current_promise, std::move(next_promise)); 4252 state = State::kState8; 4253 } 4254 ABSL_FALLTHROUGH_INTENDED; 4255 case State::kState8: { 4256 GRPC_TRACE_LOG(promise_primitives, INFO) 4257 .AtLocation(whence.file(), whence.line()) 4258 << "seq[" << this << "]: begin poll step 9/12"; 4259 auto result = prior.prior.prior.current_promise(); 4260 PromiseResult8* p = result.value_if_ready(); 4261 GRPC_TRACE_LOG(promise_primitives, INFO) 4262 .AtLocation(whence.file(), whence.line()) 4263 << "seq[" << this << "]: poll step 9/12 gets " 4264 << (p != nullptr 4265 ? (PromiseResultTraits8::IsOk(*p) 4266 ? "ready" 4267 : absl::StrCat("early-error:", 4268 PromiseResultTraits8::ErrorString(*p)) 4269 .c_str()) 4270 : "pending"); 4271 if (p == nullptr) return Pending{}; 4272 if (!PromiseResultTraits8::IsOk(*p)) { 4273 return PromiseResultTraits8::template ReturnValue<Result>( 4274 std::move(*p)); 4275 } 4276 Destruct(&prior.prior.prior.current_promise); 4277 auto next_promise = PromiseResultTraits8::CallFactory( 4278 &prior.prior.prior.next_factory, std::move(*p)); 4279 Destruct(&prior.prior.prior.next_factory); 4280 Construct(&prior.prior.current_promise, std::move(next_promise)); 4281 state = State::kState9; 4282 } 4283 ABSL_FALLTHROUGH_INTENDED; 4284 case State::kState9: { 4285 GRPC_TRACE_LOG(promise_primitives, INFO) 4286 .AtLocation(whence.file(), whence.line()) 4287 << "seq[" << this << "]: begin poll step 10/12"; 4288 auto result = prior.prior.current_promise(); 4289 PromiseResult9* p = result.value_if_ready(); 4290 GRPC_TRACE_LOG(promise_primitives, INFO) 4291 .AtLocation(whence.file(), whence.line()) 4292 << "seq[" << this << "]: poll step 10/12 gets " 4293 << (p != nullptr 4294 ? (PromiseResultTraits9::IsOk(*p) 4295 ? "ready" 4296 : absl::StrCat("early-error:", 4297 PromiseResultTraits9::ErrorString(*p)) 4298 .c_str()) 4299 : "pending"); 4300 if (p == nullptr) return Pending{}; 4301 if (!PromiseResultTraits9::IsOk(*p)) { 4302 return PromiseResultTraits9::template ReturnValue<Result>( 4303 std::move(*p)); 4304 } 4305 Destruct(&prior.prior.current_promise); 4306 auto next_promise = PromiseResultTraits9::CallFactory( 4307 &prior.prior.next_factory, std::move(*p)); 4308 Destruct(&prior.prior.next_factory); 4309 Construct(&prior.current_promise, std::move(next_promise)); 4310 state = State::kState10; 4311 } 4312 ABSL_FALLTHROUGH_INTENDED; 4313 case State::kState10: { 4314 GRPC_TRACE_LOG(promise_primitives, INFO) 4315 .AtLocation(whence.file(), whence.line()) 4316 << "seq[" << this << "]: begin poll step 11/12"; 4317 auto result = prior.current_promise(); 4318 PromiseResult10* p = result.value_if_ready(); 4319 GRPC_TRACE_LOG(promise_primitives, INFO) 4320 .AtLocation(whence.file(), whence.line()) 4321 << "seq[" << this << "]: poll step 11/12 gets " 4322 << (p != nullptr 4323 ? (PromiseResultTraits10::IsOk(*p) 4324 ? "ready" 4325 : absl::StrCat( 4326 "early-error:", 4327 PromiseResultTraits10::ErrorString(*p)) 4328 .c_str()) 4329 : "pending"); 4330 if (p == nullptr) return Pending{}; 4331 if (!PromiseResultTraits10::IsOk(*p)) { 4332 return PromiseResultTraits10::template ReturnValue<Result>( 4333 std::move(*p)); 4334 } 4335 Destruct(&prior.current_promise); 4336 auto next_promise = PromiseResultTraits10::CallFactory( 4337 &prior.next_factory, std::move(*p)); 4338 Destruct(&prior.next_factory); 4339 Construct(¤t_promise, std::move(next_promise)); 4340 state = State::kState11; 4341 } 4342 ABSL_FALLTHROUGH_INTENDED; 4343 default: 4344 case State::kState11: { 4345 GRPC_TRACE_LOG(promise_primitives, INFO) 4346 .AtLocation(whence.file(), whence.line()) 4347 << "seq[" << this << "]: begin poll step 12/12"; 4348 auto result = current_promise(); 4349 GRPC_TRACE_LOG(promise_primitives, INFO) 4350 .AtLocation(whence.file(), whence.line()) 4351 << "seq[" << this << "]: poll step 12/12 gets " 4352 << (result.ready() ? "ready" : "pending"); 4353 auto* p = result.value_if_ready(); 4354 if (p == nullptr) return Pending{}; 4355 return Result(std::move(*p)); 4356 } 4357 } 4358 } 4359 }; 4360 4361 template <template <typename> class Traits, typename P, typename F0, 4362 typename F1, typename F2, typename F3, typename F4, typename F5, 4363 typename F6, typename F7, typename F8, typename F9, typename F10, 4364 typename F11> 4365 struct SeqState<Traits, P, F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11> { 4366 using Promise0 = PromiseLike<P>; 4367 using PromiseResult0 = typename Promise0::Result; 4368 using PromiseResultTraits0 = Traits<PromiseResult0>; 4369 using NextFactory0 = 4370 OncePromiseFactory<typename PromiseResultTraits0::UnwrappedType, F0>; 4371 using Promise1 = typename NextFactory0::Promise; 4372 using PromiseResult1 = typename Promise1::Result; 4373 using PromiseResultTraits1 = Traits<PromiseResult1>; 4374 using NextFactory1 = 4375 OncePromiseFactory<typename PromiseResultTraits1::UnwrappedType, F1>; 4376 using Promise2 = typename NextFactory1::Promise; 4377 using PromiseResult2 = typename Promise2::Result; 4378 using PromiseResultTraits2 = Traits<PromiseResult2>; 4379 using NextFactory2 = 4380 OncePromiseFactory<typename PromiseResultTraits2::UnwrappedType, F2>; 4381 using Promise3 = typename NextFactory2::Promise; 4382 using PromiseResult3 = typename Promise3::Result; 4383 using PromiseResultTraits3 = Traits<PromiseResult3>; 4384 using NextFactory3 = 4385 OncePromiseFactory<typename PromiseResultTraits3::UnwrappedType, F3>; 4386 using Promise4 = typename NextFactory3::Promise; 4387 using PromiseResult4 = typename Promise4::Result; 4388 using PromiseResultTraits4 = Traits<PromiseResult4>; 4389 using NextFactory4 = 4390 OncePromiseFactory<typename PromiseResultTraits4::UnwrappedType, F4>; 4391 using Promise5 = typename NextFactory4::Promise; 4392 using PromiseResult5 = typename Promise5::Result; 4393 using PromiseResultTraits5 = Traits<PromiseResult5>; 4394 using NextFactory5 = 4395 OncePromiseFactory<typename PromiseResultTraits5::UnwrappedType, F5>; 4396 using Promise6 = typename NextFactory5::Promise; 4397 using PromiseResult6 = typename Promise6::Result; 4398 using PromiseResultTraits6 = Traits<PromiseResult6>; 4399 using NextFactory6 = 4400 OncePromiseFactory<typename PromiseResultTraits6::UnwrappedType, F6>; 4401 using Promise7 = typename NextFactory6::Promise; 4402 using PromiseResult7 = typename Promise7::Result; 4403 using PromiseResultTraits7 = Traits<PromiseResult7>; 4404 using NextFactory7 = 4405 OncePromiseFactory<typename PromiseResultTraits7::UnwrappedType, F7>; 4406 using Promise8 = typename NextFactory7::Promise; 4407 using PromiseResult8 = typename Promise8::Result; 4408 using PromiseResultTraits8 = Traits<PromiseResult8>; 4409 using NextFactory8 = 4410 OncePromiseFactory<typename PromiseResultTraits8::UnwrappedType, F8>; 4411 using Promise9 = typename NextFactory8::Promise; 4412 using PromiseResult9 = typename Promise9::Result; 4413 using PromiseResultTraits9 = Traits<PromiseResult9>; 4414 using NextFactory9 = 4415 OncePromiseFactory<typename PromiseResultTraits9::UnwrappedType, F9>; 4416 using Promise10 = typename NextFactory9::Promise; 4417 using PromiseResult10 = typename Promise10::Result; 4418 using PromiseResultTraits10 = Traits<PromiseResult10>; 4419 using NextFactory10 = 4420 OncePromiseFactory<typename PromiseResultTraits10::UnwrappedType, F10>; 4421 using Promise11 = typename NextFactory10::Promise; 4422 using PromiseResult11 = typename Promise11::Result; 4423 using PromiseResultTraits11 = Traits<PromiseResult11>; 4424 using NextFactory11 = 4425 OncePromiseFactory<typename PromiseResultTraits11::UnwrappedType, F11>; 4426 using Promise12 = typename NextFactory11::Promise; 4427 using PromiseResult12 = typename Promise12::Result; 4428 using PromiseResultTraits12 = Traits<PromiseResult12>; 4429 using Result = typename PromiseResultTraits12::WrappedType; 4430 struct Running0 { 4431 GPR_NO_UNIQUE_ADDRESS Promise0 current_promise; 4432 GPR_NO_UNIQUE_ADDRESS NextFactory0 next_factory; 4433 }; 4434 struct Running1 { 4435 union { 4436 GPR_NO_UNIQUE_ADDRESS Running0 prior; 4437 GPR_NO_UNIQUE_ADDRESS Promise1 current_promise; 4438 }; 4439 GPR_NO_UNIQUE_ADDRESS NextFactory1 next_factory; 4440 }; 4441 struct Running2 { 4442 union { 4443 GPR_NO_UNIQUE_ADDRESS Running1 prior; 4444 GPR_NO_UNIQUE_ADDRESS Promise2 current_promise; 4445 }; 4446 GPR_NO_UNIQUE_ADDRESS NextFactory2 next_factory; 4447 }; 4448 struct Running3 { 4449 union { 4450 GPR_NO_UNIQUE_ADDRESS Running2 prior; 4451 GPR_NO_UNIQUE_ADDRESS Promise3 current_promise; 4452 }; 4453 GPR_NO_UNIQUE_ADDRESS NextFactory3 next_factory; 4454 }; 4455 struct Running4 { 4456 union { 4457 GPR_NO_UNIQUE_ADDRESS Running3 prior; 4458 GPR_NO_UNIQUE_ADDRESS Promise4 current_promise; 4459 }; 4460 GPR_NO_UNIQUE_ADDRESS NextFactory4 next_factory; 4461 }; 4462 struct Running5 { 4463 union { 4464 GPR_NO_UNIQUE_ADDRESS Running4 prior; 4465 GPR_NO_UNIQUE_ADDRESS Promise5 current_promise; 4466 }; 4467 GPR_NO_UNIQUE_ADDRESS NextFactory5 next_factory; 4468 }; 4469 struct Running6 { 4470 union { 4471 GPR_NO_UNIQUE_ADDRESS Running5 prior; 4472 GPR_NO_UNIQUE_ADDRESS Promise6 current_promise; 4473 }; 4474 GPR_NO_UNIQUE_ADDRESS NextFactory6 next_factory; 4475 }; 4476 struct Running7 { 4477 union { 4478 GPR_NO_UNIQUE_ADDRESS Running6 prior; 4479 GPR_NO_UNIQUE_ADDRESS Promise7 current_promise; 4480 }; 4481 GPR_NO_UNIQUE_ADDRESS NextFactory7 next_factory; 4482 }; 4483 struct Running8 { 4484 union { 4485 GPR_NO_UNIQUE_ADDRESS Running7 prior; 4486 GPR_NO_UNIQUE_ADDRESS Promise8 current_promise; 4487 }; 4488 GPR_NO_UNIQUE_ADDRESS NextFactory8 next_factory; 4489 }; 4490 struct Running9 { 4491 union { 4492 GPR_NO_UNIQUE_ADDRESS Running8 prior; 4493 GPR_NO_UNIQUE_ADDRESS Promise9 current_promise; 4494 }; 4495 GPR_NO_UNIQUE_ADDRESS NextFactory9 next_factory; 4496 }; 4497 struct Running10 { 4498 union { 4499 GPR_NO_UNIQUE_ADDRESS Running9 prior; 4500 GPR_NO_UNIQUE_ADDRESS Promise10 current_promise; 4501 }; 4502 GPR_NO_UNIQUE_ADDRESS NextFactory10 next_factory; 4503 }; 4504 struct Running11 { 4505 union { 4506 GPR_NO_UNIQUE_ADDRESS Running10 prior; 4507 GPR_NO_UNIQUE_ADDRESS Promise11 current_promise; 4508 }; 4509 GPR_NO_UNIQUE_ADDRESS NextFactory11 next_factory; 4510 }; 4511 union { 4512 GPR_NO_UNIQUE_ADDRESS Running11 prior; 4513 GPR_NO_UNIQUE_ADDRESS Promise12 current_promise; 4514 }; 4515 enum class State : uint8_t { 4516 kState0, 4517 kState1, 4518 kState2, 4519 kState3, 4520 kState4, 4521 kState5, 4522 kState6, 4523 kState7, 4524 kState8, 4525 kState9, 4526 kState10, 4527 kState11, 4528 kState12 4529 }; 4530 GPR_NO_UNIQUE_ADDRESS State state = State::kState0; 4531 GPR_NO_UNIQUE_ADDRESS DebugLocation whence; 4532 4533 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(P&& p, F0&& f0, F1&& f1, 4534 F2&& f2, F3&& f3, F4&& f4, 4535 F5&& f5, F6&& f6, F7&& f7, 4536 F8&& f8, F9&& f9, F10&& f10, 4537 F11&& f11, 4538 DebugLocation whence) noexcept 4539 : whence(whence) { 4540 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4541 .prior.current_promise, 4542 std::forward<P>(p)); 4543 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4544 .prior.next_factory, 4545 std::forward<F0>(f0)); 4546 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4547 .next_factory, 4548 std::forward<F1>(f1)); 4549 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4550 .next_factory, 4551 std::forward<F2>(f2)); 4552 Construct( 4553 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 4554 std::forward<F3>(f3)); 4555 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 4556 std::forward<F4>(f4)); 4557 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 4558 std::forward<F5>(f5)); 4559 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 4560 std::forward<F6>(f6)); 4561 Construct(&prior.prior.prior.prior.prior.next_factory, 4562 std::forward<F7>(f7)); 4563 Construct(&prior.prior.prior.prior.next_factory, std::forward<F8>(f8)); 4564 Construct(&prior.prior.prior.next_factory, std::forward<F9>(f9)); 4565 Construct(&prior.prior.next_factory, std::forward<F10>(f10)); 4566 Construct(&prior.next_factory, std::forward<F11>(f11)); 4567 } 4568 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION ~SeqState() { 4569 switch (state) { 4570 case State::kState0: 4571 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4572 .prior.prior.current_promise); 4573 goto tail0; 4574 case State::kState1: 4575 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4576 .prior.current_promise); 4577 goto tail1; 4578 case State::kState2: 4579 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4580 .current_promise); 4581 goto tail2; 4582 case State::kState3: 4583 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 4584 .current_promise); 4585 goto tail3; 4586 case State::kState4: 4587 Destruct( 4588 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise); 4589 goto tail4; 4590 case State::kState5: 4591 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 4592 goto tail5; 4593 case State::kState6: 4594 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 4595 goto tail6; 4596 case State::kState7: 4597 Destruct(&prior.prior.prior.prior.prior.current_promise); 4598 goto tail7; 4599 case State::kState8: 4600 Destruct(&prior.prior.prior.prior.current_promise); 4601 goto tail8; 4602 case State::kState9: 4603 Destruct(&prior.prior.prior.current_promise); 4604 goto tail9; 4605 case State::kState10: 4606 Destruct(&prior.prior.current_promise); 4607 goto tail10; 4608 case State::kState11: 4609 Destruct(&prior.current_promise); 4610 goto tail11; 4611 case State::kState12: 4612 Destruct(¤t_promise); 4613 return; 4614 } 4615 tail0: 4616 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4617 .prior.next_factory); 4618 tail1: 4619 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4620 .next_factory); 4621 tail2: 4622 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4623 .next_factory); 4624 tail3: 4625 Destruct( 4626 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 4627 tail4: 4628 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 4629 tail5: 4630 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 4631 tail6: 4632 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 4633 tail7: 4634 Destruct(&prior.prior.prior.prior.prior.next_factory); 4635 tail8: 4636 Destruct(&prior.prior.prior.prior.next_factory); 4637 tail9: 4638 Destruct(&prior.prior.prior.next_factory); 4639 tail10: 4640 Destruct(&prior.prior.next_factory); 4641 tail11: 4642 Destruct(&prior.next_factory); 4643 } 4644 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(const SeqState& other) noexcept 4645 : state(other.state), whence(other.whence) { 4646 DCHECK(state == State::kState0); 4647 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4648 .prior.current_promise, 4649 other.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4650 .prior.prior.current_promise); 4651 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4652 .prior.next_factory, 4653 other.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4654 .prior.prior.next_factory); 4655 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4656 .next_factory, 4657 other.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4658 .prior.next_factory); 4659 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4660 .next_factory, 4661 other.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4662 .next_factory); 4663 Construct( 4664 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 4665 other.prior.prior.prior.prior.prior.prior.prior.prior.prior 4666 .next_factory); 4667 Construct( 4668 &prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 4669 other.prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 4670 Construct(&prior.prior.prior.prior.prior.prior.prior.next_factory, 4671 other.prior.prior.prior.prior.prior.prior.prior.next_factory); 4672 Construct(&prior.prior.prior.prior.prior.prior.next_factory, 4673 other.prior.prior.prior.prior.prior.prior.next_factory); 4674 Construct(&prior.prior.prior.prior.prior.next_factory, 4675 other.prior.prior.prior.prior.prior.next_factory); 4676 Construct(&prior.prior.prior.prior.next_factory, 4677 other.prior.prior.prior.prior.next_factory); 4678 Construct(&prior.prior.prior.next_factory, 4679 other.prior.prior.prior.next_factory); 4680 Construct(&prior.prior.next_factory, other.prior.prior.next_factory); 4681 Construct(&prior.next_factory, other.prior.next_factory); 4682 } 4683 SeqState& operator=(const SeqState& other) = delete; 4684 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState(SeqState&& other) noexcept 4685 : state(other.state), whence(other.whence) { 4686 DCHECK(state == State::kState0); 4687 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4688 .prior.current_promise, 4689 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 4690 .prior.prior.prior.prior.current_promise)); 4691 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4692 .prior.next_factory, 4693 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 4694 .prior.prior.prior.prior.next_factory)); 4695 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4696 .next_factory, 4697 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 4698 .prior.prior.prior.next_factory)); 4699 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4700 .next_factory, 4701 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 4702 .prior.prior.next_factory)); 4703 Construct( 4704 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 4705 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior.prior 4706 .next_factory)); 4707 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 4708 std::move(other.prior.prior.prior.prior.prior.prior.prior.prior 4709 .next_factory)); 4710 Construct( 4711 &prior.prior.prior.prior.prior.prior.prior.next_factory, 4712 std::move( 4713 other.prior.prior.prior.prior.prior.prior.prior.next_factory)); 4714 Construct( 4715 &prior.prior.prior.prior.prior.prior.next_factory, 4716 std::move(other.prior.prior.prior.prior.prior.prior.next_factory)); 4717 Construct(&prior.prior.prior.prior.prior.next_factory, 4718 std::move(other.prior.prior.prior.prior.prior.next_factory)); 4719 Construct(&prior.prior.prior.prior.next_factory, 4720 std::move(other.prior.prior.prior.prior.next_factory)); 4721 Construct(&prior.prior.prior.next_factory, 4722 std::move(other.prior.prior.prior.next_factory)); 4723 Construct(&prior.prior.next_factory, 4724 std::move(other.prior.prior.next_factory)); 4725 Construct(&prior.next_factory, std::move(other.prior.next_factory)); 4726 } 4727 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION SeqState& operator=(SeqState&& other) = 4728 delete; 4729 GPR_ATTRIBUTE_ALWAYS_INLINE_FUNCTION Poll<Result> PollOnce() { 4730 switch (state) { 4731 case State::kState0: { 4732 GRPC_TRACE_LOG(promise_primitives, INFO) 4733 .AtLocation(whence.file(), whence.line()) 4734 << "seq[" << this << "]: begin poll step 1/13"; 4735 auto result = prior.prior.prior.prior.prior.prior.prior.prior.prior 4736 .prior.prior.prior.current_promise(); 4737 PromiseResult0* p = result.value_if_ready(); 4738 GRPC_TRACE_LOG(promise_primitives, INFO) 4739 .AtLocation(whence.file(), whence.line()) 4740 << "seq[" << this << "]: poll step 1/13 gets " 4741 << (p != nullptr 4742 ? (PromiseResultTraits0::IsOk(*p) 4743 ? "ready" 4744 : absl::StrCat("early-error:", 4745 PromiseResultTraits0::ErrorString(*p)) 4746 .c_str()) 4747 : "pending"); 4748 if (p == nullptr) return Pending{}; 4749 if (!PromiseResultTraits0::IsOk(*p)) { 4750 return PromiseResultTraits0::template ReturnValue<Result>( 4751 std::move(*p)); 4752 } 4753 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4754 .prior.prior.current_promise); 4755 auto next_promise = PromiseResultTraits0::CallFactory( 4756 &prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4757 .prior.next_factory, 4758 std::move(*p)); 4759 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4760 .prior.prior.next_factory); 4761 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4762 .prior.current_promise, 4763 std::move(next_promise)); 4764 state = State::kState1; 4765 } 4766 ABSL_FALLTHROUGH_INTENDED; 4767 case State::kState1: { 4768 GRPC_TRACE_LOG(promise_primitives, INFO) 4769 .AtLocation(whence.file(), whence.line()) 4770 << "seq[" << this << "]: begin poll step 2/13"; 4771 auto result = prior.prior.prior.prior.prior.prior.prior.prior.prior 4772 .prior.prior.current_promise(); 4773 PromiseResult1* p = result.value_if_ready(); 4774 GRPC_TRACE_LOG(promise_primitives, INFO) 4775 .AtLocation(whence.file(), whence.line()) 4776 << "seq[" << this << "]: poll step 2/13 gets " 4777 << (p != nullptr 4778 ? (PromiseResultTraits1::IsOk(*p) 4779 ? "ready" 4780 : absl::StrCat("early-error:", 4781 PromiseResultTraits1::ErrorString(*p)) 4782 .c_str()) 4783 : "pending"); 4784 if (p == nullptr) return Pending{}; 4785 if (!PromiseResultTraits1::IsOk(*p)) { 4786 return PromiseResultTraits1::template ReturnValue<Result>( 4787 std::move(*p)); 4788 } 4789 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4790 .prior.current_promise); 4791 auto next_promise = PromiseResultTraits1::CallFactory( 4792 &prior.prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4793 .next_factory, 4794 std::move(*p)); 4795 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4796 .prior.next_factory); 4797 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4798 .current_promise, 4799 std::move(next_promise)); 4800 state = State::kState2; 4801 } 4802 ABSL_FALLTHROUGH_INTENDED; 4803 case State::kState2: { 4804 GRPC_TRACE_LOG(promise_primitives, INFO) 4805 .AtLocation(whence.file(), whence.line()) 4806 << "seq[" << this << "]: begin poll step 3/13"; 4807 auto result = prior.prior.prior.prior.prior.prior.prior.prior.prior 4808 .prior.current_promise(); 4809 PromiseResult2* p = result.value_if_ready(); 4810 GRPC_TRACE_LOG(promise_primitives, INFO) 4811 .AtLocation(whence.file(), whence.line()) 4812 << "seq[" << this << "]: poll step 3/13 gets " 4813 << (p != nullptr 4814 ? (PromiseResultTraits2::IsOk(*p) 4815 ? "ready" 4816 : absl::StrCat("early-error:", 4817 PromiseResultTraits2::ErrorString(*p)) 4818 .c_str()) 4819 : "pending"); 4820 if (p == nullptr) return Pending{}; 4821 if (!PromiseResultTraits2::IsOk(*p)) { 4822 return PromiseResultTraits2::template ReturnValue<Result>( 4823 std::move(*p)); 4824 } 4825 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4826 .current_promise); 4827 auto next_promise = PromiseResultTraits2::CallFactory( 4828 &prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4829 .next_factory, 4830 std::move(*p)); 4831 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior.prior 4832 .next_factory); 4833 Construct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 4834 .current_promise, 4835 std::move(next_promise)); 4836 state = State::kState3; 4837 } 4838 ABSL_FALLTHROUGH_INTENDED; 4839 case State::kState3: { 4840 GRPC_TRACE_LOG(promise_primitives, INFO) 4841 .AtLocation(whence.file(), whence.line()) 4842 << "seq[" << this << "]: begin poll step 4/13"; 4843 auto result = prior.prior.prior.prior.prior.prior.prior.prior.prior 4844 .current_promise(); 4845 PromiseResult3* p = result.value_if_ready(); 4846 GRPC_TRACE_LOG(promise_primitives, INFO) 4847 .AtLocation(whence.file(), whence.line()) 4848 << "seq[" << this << "]: poll step 4/13 gets " 4849 << (p != nullptr 4850 ? (PromiseResultTraits3::IsOk(*p) 4851 ? "ready" 4852 : absl::StrCat("early-error:", 4853 PromiseResultTraits3::ErrorString(*p)) 4854 .c_str()) 4855 : "pending"); 4856 if (p == nullptr) return Pending{}; 4857 if (!PromiseResultTraits3::IsOk(*p)) { 4858 return PromiseResultTraits3::template ReturnValue<Result>( 4859 std::move(*p)); 4860 } 4861 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 4862 .current_promise); 4863 auto next_promise = PromiseResultTraits3::CallFactory( 4864 &prior.prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 4865 std::move(*p)); 4866 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.prior 4867 .next_factory); 4868 Construct( 4869 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise, 4870 std::move(next_promise)); 4871 state = State::kState4; 4872 } 4873 ABSL_FALLTHROUGH_INTENDED; 4874 case State::kState4: { 4875 GRPC_TRACE_LOG(promise_primitives, INFO) 4876 .AtLocation(whence.file(), whence.line()) 4877 << "seq[" << this << "]: begin poll step 5/13"; 4878 auto result = 4879 prior.prior.prior.prior.prior.prior.prior.prior.current_promise(); 4880 PromiseResult4* p = result.value_if_ready(); 4881 GRPC_TRACE_LOG(promise_primitives, INFO) 4882 .AtLocation(whence.file(), whence.line()) 4883 << "seq[" << this << "]: poll step 5/13 gets " 4884 << (p != nullptr 4885 ? (PromiseResultTraits4::IsOk(*p) 4886 ? "ready" 4887 : absl::StrCat("early-error:", 4888 PromiseResultTraits4::ErrorString(*p)) 4889 .c_str()) 4890 : "pending"); 4891 if (p == nullptr) return Pending{}; 4892 if (!PromiseResultTraits4::IsOk(*p)) { 4893 return PromiseResultTraits4::template ReturnValue<Result>( 4894 std::move(*p)); 4895 } 4896 Destruct( 4897 &prior.prior.prior.prior.prior.prior.prior.prior.current_promise); 4898 auto next_promise = PromiseResultTraits4::CallFactory( 4899 &prior.prior.prior.prior.prior.prior.prior.prior.next_factory, 4900 std::move(*p)); 4901 Destruct(&prior.prior.prior.prior.prior.prior.prior.prior.next_factory); 4902 Construct(&prior.prior.prior.prior.prior.prior.prior.current_promise, 4903 std::move(next_promise)); 4904 state = State::kState5; 4905 } 4906 ABSL_FALLTHROUGH_INTENDED; 4907 case State::kState5: { 4908 GRPC_TRACE_LOG(promise_primitives, INFO) 4909 .AtLocation(whence.file(), whence.line()) 4910 << "seq[" << this << "]: begin poll step 6/13"; 4911 auto result = 4912 prior.prior.prior.prior.prior.prior.prior.current_promise(); 4913 PromiseResult5* p = result.value_if_ready(); 4914 GRPC_TRACE_LOG(promise_primitives, INFO) 4915 .AtLocation(whence.file(), whence.line()) 4916 << "seq[" << this << "]: poll step 6/13 gets " 4917 << (p != nullptr 4918 ? (PromiseResultTraits5::IsOk(*p) 4919 ? "ready" 4920 : absl::StrCat("early-error:", 4921 PromiseResultTraits5::ErrorString(*p)) 4922 .c_str()) 4923 : "pending"); 4924 if (p == nullptr) return Pending{}; 4925 if (!PromiseResultTraits5::IsOk(*p)) { 4926 return PromiseResultTraits5::template ReturnValue<Result>( 4927 std::move(*p)); 4928 } 4929 Destruct(&prior.prior.prior.prior.prior.prior.prior.current_promise); 4930 auto next_promise = PromiseResultTraits5::CallFactory( 4931 &prior.prior.prior.prior.prior.prior.prior.next_factory, 4932 std::move(*p)); 4933 Destruct(&prior.prior.prior.prior.prior.prior.prior.next_factory); 4934 Construct(&prior.prior.prior.prior.prior.prior.current_promise, 4935 std::move(next_promise)); 4936 state = State::kState6; 4937 } 4938 ABSL_FALLTHROUGH_INTENDED; 4939 case State::kState6: { 4940 GRPC_TRACE_LOG(promise_primitives, INFO) 4941 .AtLocation(whence.file(), whence.line()) 4942 << "seq[" << this << "]: begin poll step 7/13"; 4943 auto result = prior.prior.prior.prior.prior.prior.current_promise(); 4944 PromiseResult6* p = result.value_if_ready(); 4945 GRPC_TRACE_LOG(promise_primitives, INFO) 4946 .AtLocation(whence.file(), whence.line()) 4947 << "seq[" << this << "]: poll step 7/13 gets " 4948 << (p != nullptr 4949 ? (PromiseResultTraits6::IsOk(*p) 4950 ? "ready" 4951 : absl::StrCat("early-error:", 4952 PromiseResultTraits6::ErrorString(*p)) 4953 .c_str()) 4954 : "pending"); 4955 if (p == nullptr) return Pending{}; 4956 if (!PromiseResultTraits6::IsOk(*p)) { 4957 return PromiseResultTraits6::template ReturnValue<Result>( 4958 std::move(*p)); 4959 } 4960 Destruct(&prior.prior.prior.prior.prior.prior.current_promise); 4961 auto next_promise = PromiseResultTraits6::CallFactory( 4962 &prior.prior.prior.prior.prior.prior.next_factory, std::move(*p)); 4963 Destruct(&prior.prior.prior.prior.prior.prior.next_factory); 4964 Construct(&prior.prior.prior.prior.prior.current_promise, 4965 std::move(next_promise)); 4966 state = State::kState7; 4967 } 4968 ABSL_FALLTHROUGH_INTENDED; 4969 case State::kState7: { 4970 GRPC_TRACE_LOG(promise_primitives, INFO) 4971 .AtLocation(whence.file(), whence.line()) 4972 << "seq[" << this << "]: begin poll step 8/13"; 4973 auto result = prior.prior.prior.prior.prior.current_promise(); 4974 PromiseResult7* p = result.value_if_ready(); 4975 GRPC_TRACE_LOG(promise_primitives, INFO) 4976 .AtLocation(whence.file(), whence.line()) 4977 << "seq[" << this << "]: poll step 8/13 gets " 4978 << (p != nullptr 4979 ? (PromiseResultTraits7::IsOk(*p) 4980 ? "ready" 4981 : absl::StrCat("early-error:", 4982 PromiseResultTraits7::ErrorString(*p)) 4983 .c_str()) 4984 : "pending"); 4985 if (p == nullptr) return Pending{}; 4986 if (!PromiseResultTraits7::IsOk(*p)) { 4987 return PromiseResultTraits7::template ReturnValue<Result>( 4988 std::move(*p)); 4989 } 4990 Destruct(&prior.prior.prior.prior.prior.current_promise); 4991 auto next_promise = PromiseResultTraits7::CallFactory( 4992 &prior.prior.prior.prior.prior.next_factory, std::move(*p)); 4993 Destruct(&prior.prior.prior.prior.prior.next_factory); 4994 Construct(&prior.prior.prior.prior.current_promise, 4995 std::move(next_promise)); 4996 state = State::kState8; 4997 } 4998 ABSL_FALLTHROUGH_INTENDED; 4999 case State::kState8: { 5000 GRPC_TRACE_LOG(promise_primitives, INFO) 5001 .AtLocation(whence.file(), whence.line()) 5002 << "seq[" << this << "]: begin poll step 9/13"; 5003 auto result = prior.prior.prior.prior.current_promise(); 5004 PromiseResult8* p = result.value_if_ready(); 5005 GRPC_TRACE_LOG(promise_primitives, INFO) 5006 .AtLocation(whence.file(), whence.line()) 5007 << "seq[" << this << "]: poll step 9/13 gets " 5008 << (p != nullptr 5009 ? (PromiseResultTraits8::IsOk(*p) 5010 ? "ready" 5011 : absl::StrCat("early-error:", 5012 PromiseResultTraits8::ErrorString(*p)) 5013 .c_str()) 5014 : "pending"); 5015 if (p == nullptr) return Pending{}; 5016 if (!PromiseResultTraits8::IsOk(*p)) { 5017 return PromiseResultTraits8::template ReturnValue<Result>( 5018 std::move(*p)); 5019 } 5020 Destruct(&prior.prior.prior.prior.current_promise); 5021 auto next_promise = PromiseResultTraits8::CallFactory( 5022 &prior.prior.prior.prior.next_factory, std::move(*p)); 5023 Destruct(&prior.prior.prior.prior.next_factory); 5024 Construct(&prior.prior.prior.current_promise, std::move(next_promise)); 5025 state = State::kState9; 5026 } 5027 ABSL_FALLTHROUGH_INTENDED; 5028 case State::kState9: { 5029 GRPC_TRACE_LOG(promise_primitives, INFO) 5030 .AtLocation(whence.file(), whence.line()) 5031 << "seq[" << this << "]: begin poll step 10/13"; 5032 auto result = prior.prior.prior.current_promise(); 5033 PromiseResult9* p = result.value_if_ready(); 5034 GRPC_TRACE_LOG(promise_primitives, INFO) 5035 .AtLocation(whence.file(), whence.line()) 5036 << "seq[" << this << "]: poll step 10/13 gets " 5037 << (p != nullptr 5038 ? (PromiseResultTraits9::IsOk(*p) 5039 ? "ready" 5040 : absl::StrCat("early-error:", 5041 PromiseResultTraits9::ErrorString(*p)) 5042 .c_str()) 5043 : "pending"); 5044 if (p == nullptr) return Pending{}; 5045 if (!PromiseResultTraits9::IsOk(*p)) { 5046 return PromiseResultTraits9::template ReturnValue<Result>( 5047 std::move(*p)); 5048 } 5049 Destruct(&prior.prior.prior.current_promise); 5050 auto next_promise = PromiseResultTraits9::CallFactory( 5051 &prior.prior.prior.next_factory, std::move(*p)); 5052 Destruct(&prior.prior.prior.next_factory); 5053 Construct(&prior.prior.current_promise, std::move(next_promise)); 5054 state = State::kState10; 5055 } 5056 ABSL_FALLTHROUGH_INTENDED; 5057 case State::kState10: { 5058 GRPC_TRACE_LOG(promise_primitives, INFO) 5059 .AtLocation(whence.file(), whence.line()) 5060 << "seq[" << this << "]: begin poll step 11/13"; 5061 auto result = prior.prior.current_promise(); 5062 PromiseResult10* p = result.value_if_ready(); 5063 GRPC_TRACE_LOG(promise_primitives, INFO) 5064 .AtLocation(whence.file(), whence.line()) 5065 << "seq[" << this << "]: poll step 11/13 gets " 5066 << (p != nullptr 5067 ? (PromiseResultTraits10::IsOk(*p) 5068 ? "ready" 5069 : absl::StrCat( 5070 "early-error:", 5071 PromiseResultTraits10::ErrorString(*p)) 5072 .c_str()) 5073 : "pending"); 5074 if (p == nullptr) return Pending{}; 5075 if (!PromiseResultTraits10::IsOk(*p)) { 5076 return PromiseResultTraits10::template ReturnValue<Result>( 5077 std::move(*p)); 5078 } 5079 Destruct(&prior.prior.current_promise); 5080 auto next_promise = PromiseResultTraits10::CallFactory( 5081 &prior.prior.next_factory, std::move(*p)); 5082 Destruct(&prior.prior.next_factory); 5083 Construct(&prior.current_promise, std::move(next_promise)); 5084 state = State::kState11; 5085 } 5086 ABSL_FALLTHROUGH_INTENDED; 5087 case State::kState11: { 5088 GRPC_TRACE_LOG(promise_primitives, INFO) 5089 .AtLocation(whence.file(), whence.line()) 5090 << "seq[" << this << "]: begin poll step 12/13"; 5091 auto result = prior.current_promise(); 5092 PromiseResult11* p = result.value_if_ready(); 5093 GRPC_TRACE_LOG(promise_primitives, INFO) 5094 .AtLocation(whence.file(), whence.line()) 5095 << "seq[" << this << "]: poll step 12/13 gets " 5096 << (p != nullptr 5097 ? (PromiseResultTraits11::IsOk(*p) 5098 ? "ready" 5099 : absl::StrCat( 5100 "early-error:", 5101 PromiseResultTraits11::ErrorString(*p)) 5102 .c_str()) 5103 : "pending"); 5104 if (p == nullptr) return Pending{}; 5105 if (!PromiseResultTraits11::IsOk(*p)) { 5106 return PromiseResultTraits11::template ReturnValue<Result>( 5107 std::move(*p)); 5108 } 5109 Destruct(&prior.current_promise); 5110 auto next_promise = PromiseResultTraits11::CallFactory( 5111 &prior.next_factory, std::move(*p)); 5112 Destruct(&prior.next_factory); 5113 Construct(¤t_promise, std::move(next_promise)); 5114 state = State::kState12; 5115 } 5116 ABSL_FALLTHROUGH_INTENDED; 5117 default: 5118 case State::kState12: { 5119 GRPC_TRACE_LOG(promise_primitives, INFO) 5120 .AtLocation(whence.file(), whence.line()) 5121 << "seq[" << this << "]: begin poll step 13/13"; 5122 auto result = current_promise(); 5123 GRPC_TRACE_LOG(promise_primitives, INFO) 5124 .AtLocation(whence.file(), whence.line()) 5125 << "seq[" << this << "]: poll step 13/13 gets " 5126 << (result.ready() ? "ready" : "pending"); 5127 auto* p = result.value_if_ready(); 5128 if (p == nullptr) return Pending{}; 5129 return Result(std::move(*p)); 5130 } 5131 } 5132 } 5133 }; 5134 5135 } // namespace promise_detail 5136 } // namespace grpc_core 5137 5138 #endif // GRPC_SRC_CORE_LIB_PROMISE_DETAIL_SEQ_STATE_H 5139