libstdc++
generator
Go to the documentation of this file.
1// <generator> -*- C++ -*-
2
3// Copyright (C) 2023-2024 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file include/generator
26 * This is a Standard C++ Library header.
27 */
28
29#ifndef _GLIBCXX_GENERATOR
30#define _GLIBCXX_GENERATOR
31
32#include <ranges>
33#pragma GCC system_header
34
35#include <bits/c++config.h>
36
37#define __glibcxx_want_generator
38#include <bits/version.h>
39
40#ifdef __cpp_lib_generator // C++ >= 23 && __glibcxx_coroutine
41#include <new>
42#include <bits/move.h>
43#include <bits/ranges_util.h>
44#include <bits/elements_of.h>
45#include <bits/uses_allocator.h>
46#include <bits/exception_ptr.h>
47#include <cstddef>
48#include <cstdint>
49#include <cstring>
50#include <coroutine>
51
52#include <type_traits>
53#include <variant>
54#include <concepts>
55
56#if _GLIBCXX_HOSTED
57# include <bits/memory_resource.h>
58#endif // HOSTED
59
60namespace std _GLIBCXX_VISIBILITY(default)
61{
62_GLIBCXX_BEGIN_NAMESPACE_VERSION
63
64 /**
65 * @defgroup generator_coros Range generator coroutines
66 * @addtogroup ranges
67 * @since C++23
68 * @{
69 */
70
71 /** @brief A range specified using a yielding coroutine.
72 *
73 * `std::generator` is a utility class for defining ranges using coroutines
74 * that yield elements as a range. Generator coroutines are synchronous.
75 *
76 * @headerfile generator
77 * @since C++23
78 */
79 template<typename _Ref, typename _Val = void, typename _Alloc = void>
80 class generator;
81
82 /// @cond undocumented
83 namespace __gen
84 {
85 /// _Reference type for a generator whose reference (first argument) and
86 /// value (second argument) types are _Ref and _Val.
87 template<typename _Ref, typename _Val>
88 using _Reference_t = __conditional_t<is_void_v<_Val>,
89 _Ref&&, _Ref>;
90
91 /// Type yielded by a generator whose _Reference type is _Reference.
92 template<typename _Reference>
93 using _Yield_t = __conditional_t<is_reference_v<_Reference>,
94 _Reference,
95 const _Reference&>;
96
97 /// _Yield_t * _Reference_t
98 template<typename _Ref, typename _Val>
99 using _Yield2_t = _Yield_t<_Reference_t<_Ref, _Val>>;
100
101 template<typename> constexpr bool __is_generator = false;
102 template<typename _Val, typename _Ref, typename _Alloc>
103 constexpr bool __is_generator<std::generator<_Val, _Ref, _Alloc>> = true;
104
105 /// Allocator and value type erased generator promise type.
106 /// \tparam _Yielded The corresponding generators yielded type.
107 template<typename _Yielded>
108 class _Promise_erased
109 {
110 static_assert(is_reference_v<_Yielded>);
111 using _Yielded_deref = remove_reference_t<_Yielded>;
112 using _Yielded_decvref = remove_cvref_t<_Yielded>;
113 using _ValuePtr = add_pointer_t<_Yielded>;
114 using _Coro_handle = std::coroutine_handle<_Promise_erased>;
115
116 template<typename, typename, typename>
117 friend class std::generator;
118
119 template<typename _Gen>
120 struct _Recursive_awaiter;
121 template<typename>
122 friend struct _Recursive_awaiter;
123 struct _Copy_awaiter;
124 struct _Subyield_state;
125 struct _Final_awaiter;
126 public:
127 suspend_always
128 initial_suspend() const noexcept
129 { return {}; }
130
131 suspend_always
132 yield_value(_Yielded __val) noexcept
133 {
134 _M_bottom_value() = ::std::addressof(__val);
135 return {};
136 }
137
138 auto
139 yield_value(const _Yielded_deref& __val)
140 noexcept (is_nothrow_constructible_v<_Yielded_decvref,
141 const _Yielded_deref&>)
142 requires (is_rvalue_reference_v<_Yielded>
143 && constructible_from<_Yielded_decvref,
144 const _Yielded_deref&>)
145 { return _Copy_awaiter(__val, _M_bottom_value()); }
146
147 template<typename _R2, typename _V2, typename _A2, typename _U2>
148 requires std::same_as<_Yield2_t<_R2, _V2>, _Yielded>
149 auto
150 yield_value(ranges::elements_of<generator<_R2, _V2, _A2>&&, _U2> __r)
151 noexcept
152 { return _Recursive_awaiter { std::move(__r.range) }; }
153
154 template<ranges::input_range _R, typename _Alloc>
155 requires convertible_to<ranges::range_reference_t<_R>, _Yielded>
156 auto
157 yield_value(ranges::elements_of<_R, _Alloc> __r)
158 {
159 auto __n = [] (allocator_arg_t, _Alloc,
160 ranges::iterator_t<_R> __i,
161 ranges::sentinel_t<_R> __s)
162 -> generator<_Yielded, ranges::range_value_t<_R>, _Alloc> {
163 for (; __i != __s; ++__i)
164 co_yield static_cast<_Yielded>(*__i);
165 };
166 return yield_value(ranges::elements_of(__n(allocator_arg,
167 __r.allocator,
168 ranges::begin(__r.range),
169 ranges::end(__r.range))));
170 }
171
172
173 _Final_awaiter
174 final_suspend() noexcept
175 { return {}; }
176
177 void
178 unhandled_exception()
179 {
180 // To get to this point, this coroutine must have been active. In that
181 // case, it must be the top of the stack. The current coroutine is
182 // the sole entry of the stack iff it is both the top and the bottom. As
183 // it is the top implicitly in this context it will be the sole entry iff
184 // it is the bottom.
185 if (_M_nest._M_is_bottom())
186 throw;
187 else
188 this->_M_except = std::current_exception();
189 }
190
191 void await_transform() = delete;
192 void return_void() const noexcept {}
193
194 private:
195 _ValuePtr&
196 _M_bottom_value() noexcept
197 { return _M_nest._M_bottom_value(*this); }
198
199 _ValuePtr&
200 _M_value() noexcept
201 { return _M_nest._M_value(*this); }
202
203 _Subyield_state _M_nest;
204 std::exception_ptr _M_except;
205 };
206
207 template<typename _Yielded>
208 struct _Promise_erased<_Yielded>::_Subyield_state
209 {
210 struct _Frame
211 {
212 _Coro_handle _M_bottom;
213 _Coro_handle _M_parent;
214 };
215
216 struct _Bottom_frame
217 {
218 _Coro_handle _M_top;
219 _ValuePtr _M_value = nullptr;
220 };
221
222 std::variant<
223 _Bottom_frame,
224 _Frame
225 > _M_stack;
226
227 bool
228 _M_is_bottom() const noexcept
229 { return !std::holds_alternative<_Frame>(this->_M_stack); }
230
231 _Coro_handle&
232 _M_top() noexcept
233 {
234 if (auto __f = std::get_if<_Frame>(&this->_M_stack))
235 return __f->_M_bottom.promise()._M_nest._M_top();
236
237 auto __bf = std::get_if<_Bottom_frame>(&this->_M_stack);
238 __glibcxx_assert(__bf);
239 return __bf->_M_top;
240 }
241
242 void
243 _M_push(_Coro_handle __current, _Coro_handle __subyield) noexcept
244 {
245 __glibcxx_assert(&__current.promise()._M_nest == this);
246 __glibcxx_assert(this->_M_top() == __current);
247
248 __subyield.promise()._M_nest._M_jump_in(__current, __subyield);
249 }
250
251 std::coroutine_handle<>
252 _M_pop() noexcept
253 {
254 if (auto __f = std::get_if<_Frame>(&this->_M_stack))
255 {
256 // We aren't a bottom coroutine. Restore the parent to the top
257 // and resume.
258 auto __p = this->_M_top() = __f->_M_parent;
259 return __p;
260 }
261 else
262 // Otherwise, there's nothing to resume.
263 return std::noop_coroutine();
264 }
265
266 void
267 _M_jump_in(_Coro_handle __rest, _Coro_handle __new) noexcept
268 {
269 __glibcxx_assert(&__new.promise()._M_nest == this);
270 __glibcxx_assert(this->_M_is_bottom());
271 // We're bottom. We're also top if top is unset (note that this is
272 // not true if something was added to the coro stack and then popped,
273 // but in that case we can't possibly be yielded from, as it would
274 // require rerunning begin()).
275 __glibcxx_assert(!this->_M_top());
276
277 auto& __rn = __rest.promise()._M_nest;
278 __rn._M_top() = __new;
279
280 // Presume we're the second frame...
281 auto __bott = __rest;
282 if (auto __f = std::get_if<_Frame>(&__rn._M_stack))
283 // But, if we aren't, get the actual bottom. We're only the second
284 // frame if our parent is the bottom frame, i.e. it doesn't have a
285 // _Frame member.
286 __bott = __f->_M_bottom;
287
288 this->_M_stack = _Frame {
289 ._M_bottom = __bott,
290 ._M_parent = __rest
291 };
292 }
293
294 _ValuePtr&
295 _M_bottom_value(_Promise_erased& __current) noexcept
296 {
297 __glibcxx_assert(&__current._M_nest == this);
298 if (auto __bf = std::get_if<_Bottom_frame>(&this->_M_stack))
299 return __bf->_M_value;
300 auto __f = std::get_if<_Frame>(&this->_M_stack);
301 __glibcxx_assert(__f);
302 auto& __p = __f->_M_bottom.promise();
303 return __p._M_nest._M_value(__p);
304 }
305
306 _ValuePtr&
307 _M_value(_Promise_erased& __current) noexcept
308 {
309 __glibcxx_assert(&__current._M_nest == this);
310 auto __bf = std::get_if<_Bottom_frame>(&this->_M_stack);
311 __glibcxx_assert(__bf);
312 return __bf->_M_value;
313 }
314 };
315
316 template<typename _Yielded>
317 struct _Promise_erased<_Yielded>::_Final_awaiter
318 {
319 bool await_ready() noexcept
320 { return false; }
321
322 template<typename _Promise>
323 auto await_suspend(std::coroutine_handle<_Promise> __c) noexcept
324 {
326 _Promise_erased, _Promise>);
327
328 auto& __n = __c.promise()._M_nest;
329 return __n._M_pop();
330 }
331
332 void await_resume() noexcept {}
333 };
334
335 template<typename _Yielded>
336 struct _Promise_erased<_Yielded>::_Copy_awaiter
337 {
338 _Yielded_decvref _M_value;
339 _ValuePtr& _M_bottom_value;
340
341 constexpr bool await_ready() noexcept
342 { return false; }
343
344 template<typename _Promise>
345 void await_suspend(std::coroutine_handle<_Promise>) noexcept
346 {
348 _Promise_erased, _Promise>);
349 _M_bottom_value = ::std::addressof(_M_value);
350 }
351
352 constexpr void
353 await_resume() const noexcept
354 {}
355 };
356
357 template<typename _Yielded>
358 template<typename _Gen>
359 struct _Promise_erased<_Yielded>::_Recursive_awaiter
360 {
361 _Gen _M_gen;
362 static_assert(__is_generator<_Gen>);
363 static_assert(std::same_as<typename _Gen::yielded, _Yielded>);
364
365 _Recursive_awaiter(_Gen __gen) noexcept
366 : _M_gen(std::move(__gen))
367 { this->_M_gen._M_mark_as_started(); }
368
369 constexpr bool
370 await_ready() const noexcept
371 { return false; }
372
373
374 template<typename _Promise>
375 std::coroutine_handle<>
376 await_suspend(std::coroutine_handle<_Promise> __p) noexcept
377 {
379 _Promise_erased, _Promise>);
380
381 auto __c = _Coro_handle::from_address(__p.address());
382 auto __t = _Coro_handle::from_address(this->_M_gen._M_coro.address());
383 __p.promise()._M_nest._M_push(__c, __t);
384 return __t;
385 }
386
387 void await_resume()
388 {
389 if (auto __e = _M_gen._M_coro.promise()._M_except)
391 }
392 };
393
394 struct _Alloc_block
395 {
396 alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
397 char _M_data[__STDCPP_DEFAULT_NEW_ALIGNMENT__];
398
399 static auto
400 _M_cnt(std::size_t __sz) noexcept
401 {
402 auto __blksz = sizeof(_Alloc_block);
403 return (__sz + __blksz - 1) / __blksz;
404 }
405 };
406
407 template<typename _All>
408 concept _Stateless_alloc = (allocator_traits<_All>::is_always_equal::value
409 && default_initializable<_All>);
410
411 template<typename _Alloc>
412 class _Promise_alloc
413 {
414 using _ATr = allocator_traits<_Alloc>;
415 using _Rebound = typename _ATr::template rebind_alloc<_Alloc_block>;
416 using _Rebound_ATr = typename _ATr
417 ::template rebind_traits<_Alloc_block>;
418 static_assert(is_pointer_v<typename _Rebound_ATr::pointer>,
419 "Must use allocators for true pointers with generators");
420
421 static auto
422 _M_alloc_address(std::uintptr_t __fn, std::uintptr_t __fsz) noexcept
423 {
424 auto __an = __fn + __fsz;
425 auto __ba = alignof(_Rebound);
426 return reinterpret_cast<_Rebound*>(((__an + __ba - 1) / __ba) * __ba);
427 }
428
429 static auto
430 _M_alloc_size(std::size_t __csz) noexcept
431 {
432 auto __ba = alignof(_Rebound);
433 // Our desired layout is placing the coroutine frame, then pad out to
434 // align, then place the allocator. The total size of that is the
435 // size of the coroutine frame, plus up to __ba bytes, plus the size
436 // of the allocator.
437 return __csz + __ba + sizeof(_Rebound);
438 }
439
440 static void*
441 _M_allocate(_Rebound __b, std::size_t __csz)
442 {
443 if constexpr (_Stateless_alloc<_Rebound>)
444 // Only need room for the coroutine.
445 return __b.allocate(_Alloc_block::_M_cnt(__csz));
446 else
447 {
448 auto __nsz = _Alloc_block::_M_cnt(_M_alloc_size(__csz));
449 auto __f = __b.allocate(__nsz);
450 auto __fn = reinterpret_cast<std::uintptr_t>(__f);
451 auto __an = _M_alloc_address(__fn, __csz);
452 ::new (__an) _Rebound(std::move(__b));
453 return __f;
454 }
455 }
456
457 public:
458 void*
459 operator new(std::size_t __sz)
460 requires default_initializable<_Rebound> // _Alloc is non-void
461 { return _M_allocate({}, __sz); }
462
463 template<typename _Na, typename... _Args>
464 void*
465 operator new(std::size_t __sz,
466 allocator_arg_t, const _Na& __na,
467 const _Args&...)
468 requires convertible_to<const _Na&, _Alloc>
469 {
470 return _M_allocate(static_cast<_Rebound>(static_cast<_Alloc>(__na)),
471 __sz);
472 }
473
474 template<typename _This, typename _Na, typename... _Args>
475 void*
476 operator new(std::size_t __sz,
477 const _This&,
478 allocator_arg_t, const _Na& __na,
479 const _Args&...)
480 requires convertible_to<const _Na&, _Alloc>
481 {
482 return _M_allocate(static_cast<_Rebound>(static_cast<_Alloc>(__na)),
483 __sz);
484 }
485
486 void
487 operator delete(void* __ptr, std::size_t __csz) noexcept
488 {
489 if constexpr (_Stateless_alloc<_Rebound>)
490 {
491 _Rebound __b;
492 return __b.deallocate(reinterpret_cast<_Alloc_block*>(__ptr),
493 _Alloc_block::_M_cnt(__csz));
494 }
495 else
496 {
497 auto __nsz = _Alloc_block::_M_cnt(_M_alloc_size(__csz));
498 auto __fn = reinterpret_cast<std::uintptr_t>(__ptr);
499 auto __an = _M_alloc_address(__fn, __csz);
500 _Rebound __b(std::move(*__an));
501 __an->~_Rebound();
502 __b.deallocate(reinterpret_cast<_Alloc_block*>(__ptr), __nsz);
503 }
504 }
505 };
506
507 template<>
508 class _Promise_alloc<void>
509 {
510 using _Dealloc_fn = void (*)(void*, std::size_t);
511
512 static auto
513 _M_dealloc_address(std::uintptr_t __fn, std::uintptr_t __fsz) noexcept
514 {
515 auto __an = __fn + __fsz;
516 auto __ba = alignof(_Dealloc_fn);
517 auto __aligned = ((__an + __ba - 1) / __ba) * __ba;
518 return reinterpret_cast<_Dealloc_fn*>(__aligned);
519 }
520
521 template<typename _Rebound>
522 static auto
523 _M_alloc_address(std::uintptr_t __fn, std::uintptr_t __fsz) noexcept
524 requires (!_Stateless_alloc<_Rebound>)
525 {
526 auto __ba = alignof(_Rebound);
527 auto __da = _M_dealloc_address(__fn, __fsz);
528 auto __aan = reinterpret_cast<std::uintptr_t>(__da);
529 __aan += sizeof(_Dealloc_fn);
530 auto __aligned = ((__aan + __ba - 1) / __ba) * __ba;
531 return reinterpret_cast<_Rebound*>(__aligned);
532 }
533
534 template<typename _Rebound>
535 static auto
536 _M_alloc_size(std::size_t __csz) noexcept
537 {
538 // This time, we want the coroutine frame, then the deallocator
539 // pointer, then the allocator itself, if any.
540 std::size_t __aa = 0;
541 std::size_t __as = 0;
542 if constexpr (!std::same_as<_Rebound, void>)
543 {
544 __aa = alignof(_Rebound);
545 __as = sizeof(_Rebound);
546 }
547 auto __ba = __aa + alignof(_Dealloc_fn);
548 return __csz + __ba + __as + sizeof(_Dealloc_fn);
549 }
550
551 template<typename _Rebound>
552 static void
553 _M_deallocator(void* __ptr, std::size_t __csz) noexcept
554 {
555 auto __asz = _M_alloc_size<_Rebound>(__csz);
556 auto __nblk = _Alloc_block::_M_cnt(__asz);
557
558 if constexpr (_Stateless_alloc<_Rebound>)
559 {
560 _Rebound __b;
561 __b.deallocate(reinterpret_cast<_Alloc_block*>(__ptr), __nblk);
562 }
563 else
564 {
565 auto __fn = reinterpret_cast<std::uintptr_t>(__ptr);
566 auto __an = _M_alloc_address<_Rebound>(__fn, __csz);
567 _Rebound __b(std::move(*__an));
568 __an->~_Rebound();
569 __b.deallocate(reinterpret_cast<_Alloc_block*>(__ptr), __nblk);
570 }
571 }
572
573 template<typename _Na>
574 static void*
575 _M_allocate(const _Na& __na, std::size_t __csz)
576 {
577 using _Rebound = typename std::allocator_traits<_Na>
578 ::template rebind_alloc<_Alloc_block>;
579 using _Rebound_ATr = typename std::allocator_traits<_Na>
580 ::template rebind_traits<_Alloc_block>;
581
582 static_assert(is_pointer_v<typename _Rebound_ATr::pointer>,
583 "Must use allocators for true pointers with generators");
584
585 _Dealloc_fn __d = &_M_deallocator<_Rebound>;
586 auto __b = static_cast<_Rebound>(__na);
587 auto __asz = _M_alloc_size<_Rebound>(__csz);
588 auto __nblk = _Alloc_block::_M_cnt(__asz);
589 void* __p = __b.allocate(__nblk);
590 auto __pn = reinterpret_cast<std::uintptr_t>(__p);
591 *_M_dealloc_address(__pn, __csz) = __d;
592 if constexpr (!_Stateless_alloc<_Rebound>)
593 {
594 auto __an = _M_alloc_address<_Rebound>(__pn, __csz);
595 ::new (__an) _Rebound(std::move(__b));
596 }
597 return __p;
598 }
599 public:
600 void*
601 operator new(std::size_t __sz)
602 {
603 auto __nsz = _M_alloc_size<void>(__sz);
604 _Dealloc_fn __d = [] (void* __ptr, std::size_t __sz)
605 {
606 ::operator delete(__ptr, _M_alloc_size<void>(__sz));
607 };
608 auto __p = ::operator new(__nsz);
609 auto __pn = reinterpret_cast<uintptr_t>(__p);
610 *_M_dealloc_address(__pn, __sz) = __d;
611 return __p;
612 }
613
614 template<typename _Na, typename... _Args>
615 void*
616 operator new(std::size_t __sz,
617 allocator_arg_t, const _Na& __na,
618 const _Args&...)
619 { return _M_allocate(__na, __sz); }
620
621 template<typename _This, typename _Na, typename... _Args>
622 void*
623 operator new(std::size_t __sz,
624 const _This&,
625 allocator_arg_t, const _Na& __na,
626 const _Args&...)
627 { return _M_allocate(__na, __sz); }
628
629 void
630 operator delete(void* __ptr, std::size_t __sz) noexcept
631 {
632 _Dealloc_fn __d;
633 auto __pn = reinterpret_cast<uintptr_t>(__ptr);
634 __d = *_M_dealloc_address(__pn, __sz);
635 __d(__ptr, __sz);
636 }
637 };
638
639 template<typename _Tp>
640 concept _Cv_unqualified_object = is_object_v<_Tp>
641 && same_as<_Tp, remove_cv_t<_Tp>>;
642 } // namespace __gen
643 /// @endcond
644
645 template<typename _Ref, typename _Val, typename _Alloc>
646 class generator
647 : public ranges::view_interface<generator<_Ref, _Val, _Alloc>>
648 {
649 using _Value = __conditional_t<is_void_v<_Val>,
650 remove_cvref_t<_Ref>,
651 _Val>;
652 static_assert(__gen::_Cv_unqualified_object<_Value>,
653 "Generator value must be a cv-unqualified object type");
654 using _Reference = __gen::_Reference_t<_Ref, _Val>;
655 static_assert(is_reference_v<_Reference>
656 || (__gen::_Cv_unqualified_object<_Reference>
657 && copy_constructible<_Reference>),
658 "Generator reference type must be either a cv-unqualified "
659 "object type that is trivially constructible or a "
660 "reference type");
661
662 using _RRef = __conditional_t<
663 is_reference_v<_Reference>,
664 remove_reference_t<_Reference>&&,
665 _Reference>;
666
667 /* Required to model indirectly_readable, and input_iterator. */
668 static_assert(common_reference_with<_Reference&&, _Value&&>);
669 static_assert(common_reference_with<_Reference&&, _RRef&&>);
670 static_assert(common_reference_with<_RRef&&, const _Value&>);
671
672 using _Yielded = __gen::_Yield_t<_Reference>;
673 using _Erased_promise = __gen::_Promise_erased<_Yielded>;
674
675 struct _Iterator;
676
677 friend _Erased_promise;
678 friend struct _Erased_promise::_Subyield_state;
679 public:
680 using yielded = _Yielded;
681
682 struct promise_type : _Erased_promise, __gen::_Promise_alloc<_Alloc>
683 {
684 generator get_return_object() noexcept
685 { return { coroutine_handle<promise_type>::from_promise(*this) }; }
686 };
687
688 static_assert(is_pointer_interconvertible_base_of_v<_Erased_promise,
689 promise_type>);
690
691 generator(const generator&) = delete;
692
693 generator(generator&& __other) noexcept
694 : _M_coro(std::__exchange(__other._M_coro, nullptr)),
695 _M_began(std::__exchange(__other._M_began, false))
696 {}
697
698 ~generator()
699 {
700 if (auto& __c = this->_M_coro)
701 __c.destroy();
702 }
703
704 generator&
705 operator=(generator __other) noexcept
706 {
707 swap(__other._M_coro, this->_M_coro);
708 swap(__other._M_began, this->_M_began);
709 }
710
711 _Iterator
712 begin()
713 {
714 this->_M_mark_as_started();
715 auto __h = _Coro_handle::from_promise(_M_coro.promise());
716 __h.promise()._M_nest._M_top() = __h;
717 return { __h };
718 }
719
720 default_sentinel_t
721 end() const noexcept
722 { return default_sentinel; }
723
724 private:
725 using _Coro_handle = std::coroutine_handle<_Erased_promise>;
726
727 generator(coroutine_handle<promise_type> __coro) noexcept
728 : _M_coro { move(__coro) }
729 {}
730
731 void
732 _M_mark_as_started() noexcept
733 {
734 __glibcxx_assert(!this->_M_began);
735 this->_M_began = true;
736 }
737
738 coroutine_handle<promise_type> _M_coro;
739 bool _M_began = false;
740 };
741
742 template<class _Ref, class _Val, class _Alloc>
743 struct generator<_Ref, _Val, _Alloc>::_Iterator
744 {
745 using value_type = _Value;
746 using difference_type = ptrdiff_t;
747
748 friend bool
749 operator==(const _Iterator& __i, default_sentinel_t) noexcept
750 { return __i._M_coro.done(); }
751
752 friend class generator;
753
754 _Iterator(_Iterator&& __o) noexcept
755 : _M_coro(std::__exchange(__o._M_coro, {}))
756 {}
757
758 _Iterator&
759 operator=(_Iterator&& __o) noexcept
760 {
761 this->_M_coro = std::__exchange(__o._M_coro, {});
762 return *this;
763 }
764
765 _Iterator&
766 operator++()
767 {
768 _M_next();
769 return *this;
770 }
771
772 void
773 operator++(int)
774 { this->operator++(); }
775
776 _Reference
777 operator*()
778 const noexcept(is_nothrow_move_constructible_v<_Reference>)
779 {
780 auto& __p = this->_M_coro.promise();
781 return static_cast<_Reference>(*__p._M_value());
782 }
783
784 private:
785 friend class generator;
786
787 _Iterator(_Coro_handle __g)
788 : _M_coro { __g }
789 { this->_M_next(); }
790
791 void _M_next()
792 {
793 auto& __t = this->_M_coro.promise()._M_nest._M_top();
794 __t.resume();
795 }
796
797 _Coro_handle _M_coro;
798 };
799
800 /// @}
801
802#if _GLIBCXX_HOSTED
803 namespace pmr {
804 template<typename _Ref, typename _Val = void>
805 using generator = std::generator<_Ref, _Val, polymorphic_allocator<std::byte>>;
806 }
807#endif // HOSTED
808
809_GLIBCXX_END_NAMESPACE_VERSION
810} // namespace std
811#endif // __cpp_lib_generator
812
813#endif // _GLIBCXX_GENERATOR
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
Definition complex:400
constexpr bool is_pointer_interconvertible_base_of_v
Definition type_traits:3722
constexpr _Tp * addressof(_Tp &__r) noexcept
Returns the actual address of the object or function referenced by r, even in the presence of an over...
Definition move.h:162
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition move.h:126
_Tp * end(valarray< _Tp > &__va) noexcept
Return an iterator pointing to one past the last element of the valarray.
Definition valarray:1249
_Tp * begin(valarray< _Tp > &__va) noexcept
Return an iterator pointing to the first element of the valarray.
Definition valarray:1227
exception_ptr current_exception() noexcept
void rethrow_exception(exception_ptr)
Throw the object pointed to by the exception_ptr.
ISO C++ entities toplevel namespace is std.
constexpr default_sentinel_t default_sentinel
A default sentinel value.
Uniform interface to all allocator types.
An opaque pointer to an arbitrary exception.