Standard library header  (C++23) (original) (raw)

Contents 1 Classes 2 Synopsis 2.1 Class template std::generator 2.2 Class std::generator::promise_type 2.3 Class std::generator::iterator 3 References Classes

[edit] Synopsis

namespace std { // class template generator template<class Ref, class V = void, class Allocator = void> class generator;   namespace pmr { template<class Ref, class V = void> using generator = std::generator<Ref, V, polymorphic_allocator<>>; } }

[edit] Class template std::generator

namespace std { template<class Ref, class V = void, class Allocator = void> class generator : public ranges::view_interface<generator<Ref, V, Allocator>> { private: using /value/ = conditional_t<is_void_v, remove_cvref_t< Ref >, V>; // exposition-only using /reference/ = conditional_t<is_void_v, Ref&&, Ref>; // exposition-only   // class generator::iterator class /iterator/; // exposition-only   public: using yielded = conditional_t<is_reference_v</*reference*/>, /reference/, const /reference/&>;   // class generator::promise_type class promise_type;   generator(const generator&) = delete; generator(generator&& other) noexcept;   ~generator();   generator& operator=(generator other) noexcept;   /iterator/ begin(); default_sentinel_t end() const noexcept;   private: coroutine_handle /coroutine_/ = nullptr; // exposition-only unique_ptr<stack<coroutine_handle<>>> /active_/; // exposition-only }; }

[edit] Class std::generator::promise_type

namespace std { template<class Ref, class V, class Allocator> class generator<Ref, V, Allocator>::promise_type { public: generator get_return_object() noexcept;   suspend_always initial_suspend() const noexcept { return {}; } auto final_suspend() noexcept;   suspend_always yield_value(yielded val) noexcept;   auto yield_value(const remove_reference_t& lval) requires is_rvalue_reference_v && constructible_from<remove_cvref_t, const remove_reference_t&>;   template<class R2, class V2, class Alloc2, class Unused> requires same_as<typename generator<R2, V2, Alloc2>::yielded, yielded> auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&&, Unused> g) noexcept; template<class R2, class V2, class Alloc2, class Unused> requires same_as<typename generator<R2, V2, Alloc2>::yielded, yielded> auto yield_value(ranges::elements_of<generator<R2, V2, Alloc2>&, Unused> g) noexcept;   template<ranges::input_range R, class Alloc> requires convertible_to<ranges::range_reference_t, yielded> auto yield_value(ranges::elements_of<R, Alloc> r);   void await_transform() = delete;   void return_void() const noexcept {} void unhandled_exception();   void* operator new(size_t size) requires same_as<Allocator, void> || default_initializable;   template<class Alloc, class... Args> void* operator new(size_t size, allocator_arg_t, const Alloc& alloc, const Args&...);   template<class This, class Alloc, class... Args> void* operator new(size_t size, const This&, allocator_arg_t, const Alloc& alloc, const Args&...);   void operator delete(void* pointer, size_t size) noexcept;   private: add_pointer_t /value_/ = nullptr; // exposition-only exception_ptr /except_/; // exposition-only }; }

[edit] Class std::generator::iterator

namespace std { template<class Ref, class V, class Allocator> class generator<Ref, V, Allocator>::/iterator/ { public: using value_type = /value/; using difference_type = ptrdiff_t;   /iterator/(/iterator/&& other) noexcept; /iterator/& operator=(/iterator/&& other) noexcept;   /reference/ operator*() const noexcept(is_nothrow_copy_constructible_v</*reference*/>); /iterator/& operator++(); void operator++(int);   friend bool operator==(const /iterator/& i, default_sentinel_t);   private: coroutine_handle /coroutine_/; // exposition-only }; }

[edit] References