查了一下，std::coroutine库没有实现默认的generator，我在github上面找了一个三方实现的std::generator。没咋看代码。但是能用。
主要就是使用协程实现递归。后根遍历二叉树。
代码结构如下，
苹果的clang 12.0.5没有完整实现协程库。所以会标红。
实际在fedora最新镜像中是可以编译通过的。
test/CMakeLists.txt
cmake_minimum_required(VERSION 2.6)
if(APPLE)
message(STATUS "This is Apple, do nothing.")
set(CMAKE_MACOSX_RPATH 1)
set(CMAKE_PREFIX_PATH /Users/aabjfzhu/software/vcpkg/ports/cppwork/vcpkg_installed/x64-osx/share )
elseif(UNIX)
message(STATUS "This is linux, set CMAKE_PREFIX_PATH.")
set(CMAKE_PREFIX_PATH /vcpkg/ports/cppwork/vcpkg_installed/x64-linux/share)
endif(APPLE)
project(binary_tree_it_coroutine)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-narrowing")
add_definitions(-g)
find_package(ZLIB)
find_package(OpenCV REQUIRED )
find_package(Arrow CONFIG REQUIRED)
find_package(unofficial-brotli REQUIRED)
find_package(unofficial-utf8proc CONFIG REQUIRED)
find_package(Thrift CONFIG REQUIRED)
find_package(glog REQUIRED)
find_package(OpenSSL REQUIRED)
find_package(Boost REQUIRED COMPONENTS
system
filesystem
serialization
program_options
thread
)
find_package(DataFrame REQUIRED)
if(APPLE)
MESSAGE(STATUS "This is APPLE, set INCLUDE_DIRS")
set(INCLUDE_DIRS ${Boost_INCLUDE_DIRS} /usr/local/include /usr/local/iODBC/include /opt/snowflake/snowflakeodbc/include/ ${CMAKE_CURRENT_SOURCE_DIR}/../include/ ${CMAKE_CURRENT_SOURCE_DIR}/../../../include)
elseif(UNIX)
MESSAGE(STATUS "This is linux, set INCLUDE_DIRS")
set(INCLUDE_DIRS ${Boost_INCLUDE_DIRS} /usr/local/include ${CMAKE_CURRENT_SOURCE_DIR}/../include/ ${CMAKE_CURRENT_SOURCE_DIR}/../../../include/)
endif(APPLE)
if(APPLE)
MESSAGE(STATUS "This is APPLE, set LINK_DIRS")
set(LINK_DIRS /usr/local/lib /usr/local/iODBC/lib /opt/snowflake/snowflakeodbc/lib/universal)
elseif(UNIX)
MESSAGE(STATUS "This is linux, set LINK_DIRS")
set(LINK_DIRS ${Boost_INCLUDE_DIRS} /usr/local/lib /vcpkg/ports/cppwork/vcpkg_installed/x64-linux/lib)
endif(APPLE)
if(APPLE)
MESSAGE(STATUS "This is APPLE, set ODBC_LIBS")
set(ODBC_LIBS iodbc iodbcinst)
elseif(UNIX)
MESSAGE(STATUS "This is linux, set LINK_DIRS")
set(ODBC_LIBS odbc odbcinst ltdl)
endif(APPLE)
include_directories(${INCLUDE_DIRS})
LINK_DIRECTORIES(${LINK_DIRS})
file( GLOB test_file_list ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
file( GLOB APP_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/../impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../include/*.h ${CMAKE_CURRENT_SOURCE_DIR}/../include/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../../include/arr_/impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../../include/http/impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../../include/yaml/impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../../include/df/impl/*.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../../../include/death_handler/impl/*.cpp)
add_library(${PROJECT_NAME}_lib SHARED ${APP_SOURCES} ${test_file})
target_link_libraries(${PROJECT_NAME}_lib ${Boost_LIBRARIES} ZLIB::ZLIB glog::glog DataFrame::DataFrame ${OpenCV_LIBS})
target_link_libraries(${PROJECT_NAME}_lib OpenSSL::SSL OpenSSL::Crypto libgtest.a pystring libyaml-cpp.a libgmock.a ${ODBC_LIBS} libnanodbc.a pthread dl backtrace libzstd.a libbz2.a libsnappy.a re2::re2 parquet lz4 unofficial::brotli::brotlidec-static unofficial::brotli::brotlienc-static unofficial::brotli::brotlicommon-static utf8proc thrift::thrift arrow arrow_dataset)
foreach( test_file ${test_file_list} )
file(RELATIVE_PATH filename ${CMAKE_CURRENT_SOURCE_DIR} ${test_file})
string(REPLACE ".cpp" "" file ${filename})
add_executable(${file} ${test_file})
target_link_libraries(${file} ${PROJECT_NAME}_lib)
endforeach( test_file ${test_file_list})
test/binary_tree_iterator_coroutine_test.cpp
#include "binary_tree_iterator_coroutine.hpp"
#include <glog/logging.h>
#include <gtest/gtest.h>
#include <fstream>
#include <memory>
#include "death_handler/death_handler.h"
int main(int argc, char** argv) {
FLAGS_log_dir = "./";
FLAGS_alsologtostderr = true;
// 日志级别 INFO, WARNING, ERROR, FATAL 的值分别为0、1、2、3
FLAGS_minloglevel = 0;
Debug::DeathHandler dh;
google::InitGoogleLogging("./logs.log");
testing::InitGoogleTest(&argc, argv);
int ret = RUN_ALL_TESTS();
return ret;
}
// 后根遍历迭代器
GTEST_TEST(BinaryTreeIteratorTests, BinaryTreeIt) {
BinaryTree<std::string> family (
new Node<std::string>("me",
new Node<std::string>("mother",
new Node<std::string>("Mother's mother"),
new Node<std::string>("Mother's father")
),
new Node<std::string>("father"))
);
for(auto it: family.post_order()) {
std::cout << (*it).value << "\n";
}
}
include/binary_tree_iterator_coroutine.hpp
#ifndef _FREDRIC_BINARY_TREE_ITERATOR_COROUTINE_HPP_
#define _FREDRIC_BINARY_TREE_ITERATOR_COROUTINE_HPP_
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
#include <generator/generator>
#include <coroutine>
template <typename T>
struct BinaryTree;
template <typename T>
struct Node {
T value{};
Node<T>* left{nullptr}, *right{nullptr}, *parent{nullptr};
BinaryTree<T>* tree{nullptr};
Node(T value_) : value{value_} {}
Node(T value_, Node<T>* left_, Node<T>* right_)
: value(value_), left(left_), right{right_} {
// 初始化左子节点和右子节点的树为同一颗树
this->left->tree = this->right->tree = tree;
// 初始化左子节点和右子节点的父节点为当前节点
this->left->parent = this->right->parent = this;
}
void set_tree(BinaryTree<T>* t) {
tree = t;
if (left) left->set_tree(t);
if (right) right->set_tree(t);
}
~Node() {
if(left) delete left;
if(right) delete right;
}
};
template <typename T>
struct BinaryTree {
Node<T>* root{nullptr};
BinaryTree(Node<T>* root_) : root(root_) {
root->set_tree(this);
}
~BinaryTree() {
if(root) {
delete root;
}
}
std::generator<Node<T>*> post_order() {
return post_order_impl(root);
}
private:
std::generator<Node<T>*> post_order_impl(Node<T>* node) {
// 递归yield 一个node，左右根，后续遍历
if(node) {
for(auto x: post_order_impl(node->left)) {
co_yield x;
}
for(auto y: post_order_impl(node->right)) {
co_yield y;
}
co_yield node;
}
}
};
#endif
include/generator/generator头文件
#ifndef __STD_GENERATOR_INCLUDED
#define __STD_GENERATOR_INCLUDED
///
// Reference implementation of std::generator proposal P2168.
//
// See https://wg21.link/P2168 for details.
//
///
// Copyright Lewis Baker, Corentin Jabot
//
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0.
// (See accompanying file LICENSE or http://www.boost.org/LICENSE_1_0.txt)
///
#pragma once
#if __has_include(<coroutine>)
#include <coroutine>
#else
// Fallback for older experimental implementations of coroutines.
#include <experimental/coroutine>
namespace std {
using std::experimental::coroutine_handle;
using std::experimental::coroutine_traits;
using std::experimental::noop_coroutine;
using std::experimental::suspend_always;
using std::experimental::suspend_never;
} // namespace std
#endif
#include <exception>
#include <iterator>
#include <new>
#include <type_traits>
#include <utility>
#include <concepts>
#include <cassert>
#if __has_include(<ranges>)
# include <ranges>
#else
// Placeholder implementation of the bits we need from <ranges> header
// when we don't have the <ranges> header (e.g. Clang 12 and earlier).
namespace std {
// Don't create naming conflicts with recent libc++ which defines std::iter_reference_t
// in <iterator> but doesn't yet provide a <ranges> header.
template <typename _T>
using __iter_reference_t = decltype(*std::declval<_T&>());
template <typename _T>
using iter_value_t =
typename std::iterator_traits<std::remove_cvref_t<_T>>::value_type;
namespace ranges {
namespace __begin {
void begin();
struct _fn {
template <typename _Range>
requires requires(_Range& __r) {
__r.begin();
}
auto operator()(_Range&& __r) const
noexcept(noexcept(__r.begin()))
-> decltype(__r.begin()) {
return __r.begin();
}
template <typename _Range>
requires
(!requires(_Range& __r) { __r.begin(); }) &&
requires(_Range& __r) { begin(__r); }
auto operator()(_Range&& __r) const
noexcept(noexcept(begin(__r)))
-> decltype(begin(__r)) {
return begin(__r);
}
};
} // namespace __begin
inline namespace __begin_cpo {
inline constexpr __begin::_fn begin = {};
}
namespace __end {
void end();
struct _fn {
template <typename _Range>
requires requires(_Range& __r) { __r.end(); }
auto operator()(_Range&& __r) const
noexcept(noexcept(__r.end()))
-> decltype(__r.end()) {
return __r.end();
}
template <typename _Range>
requires
(!requires(_Range& __r) { __r.end(); }) &&
requires(_Range& __r) { end(__r); }
auto operator()(_Range&& __r) const
noexcept(noexcept(end(__r)))
-> decltype(end(__r)) {
return end(__r);
}
};
} // namespace __end
inline namespace _end_cpo {
inline constexpr __end::_fn end = {};
}
template <typename _Range>
using iterator_t = decltype(begin(std::declval<_Range>()));
template <typename _Range>
using sentinel_t = decltype(end(std::declval<_Range>()));
template <typename _Range>
using range_reference_t = __iter_reference_t<iterator_t<_Range>>;
template <typename _Range>
using range_value_t = iter_value_t<iterator_t<_Range>>;
template <typename _T>
concept range = requires(_T& __t) {
ranges::begin(__t);
ranges::end(__t);
};
} // namespace ranges
} // namespace std
#endif // !__has_include(<ranges>)
namespace std {
template <typename _T>
class __manual_lifetime {
public:
__manual_lifetime() noexcept {}
~__manual_lifetime() {}
template <typename... _Args>
_T& construct(_Args&&... __args) noexcept(std::is_nothrow_constructible_v<_T, _Args...>) {
return *::new (static_cast<void*>(std::addressof(__value_))) _T((_Args&&)__args...);
}
void destruct() noexcept(std::is_nothrow_destructible_v<_T>) {
__value_.~_T();
}
_T& get() & noexcept {
return __value_;
}
_T&& get() && noexcept {
return static_cast<_T&&>(__value_);
}
const _T& get() const & noexcept {
return __value_;
}
const _T&& get() const && noexcept {
return static_cast<const _T&&>(__value_);
}
private:
union {
std::remove_const_t<_T> __value_;
};
};
template <typename _T>
class __manual_lifetime<_T&> {
public:
__manual_lifetime() noexcept : __value_(nullptr) {}
~__manual_lifetime() {}
_T& construct(_T& __value) noexcept {
__value_ = std::addressof(__value);
return __value;
}
void destruct() noexcept {}
_T& get() const noexcept {
return *__value_;
}
private:
_T* __value_;
};
template <typename _T>
class __manual_lifetime<_T&&> {
public:
__manual_lifetime() noexcept : __value_(nullptr) {}
~__manual_lifetime() {}
_T&& construct(_T&& __value) noexcept {
__value_ = std::addressof(__value);
return static_cast<_T&&>(__value);
}
void destruct() noexcept {}
_T&& get() const noexcept {
return static_cast<_T&&>(*__value_);
}
private:
_T* __value_;
};
struct use_allocator_arg {};
namespace ranges {
template <typename _Rng, typename _Allocator = use_allocator_arg>
struct elements_of {
explicit constexpr elements_of(_Rng&& __rng) noexcept
requires std::is_default_constructible_v<_Allocator>
: __range(static_cast<_Rng&&>(__rng))
{}
constexpr elements_of(_Rng&& __rng, _Allocator&& __alloc) noexcept
: __range((_Rng&&)__rng), __alloc((_Allocator&&)__alloc) {}
constexpr elements_of(elements_of&&) noexcept = default;
constexpr elements_of(const elements_of &) = delete;
constexpr elements_of &operator=(const elements_of &) = delete;
constexpr elements_of &operator=(elements_of &&) = delete;
constexpr _Rng&& get() noexcept {
return static_cast<_Rng&&>(__range);
}
constexpr _Allocator get_allocator() const noexcept {
return __alloc;
}
private:
[[no_unique_address]] _Allocator __alloc; // \expos
_Rng && __range; // \expos
};
template <typename _Rng>
elements_of(_Rng &&) -> elements_of<_Rng>;
template <typename _Rng, typename Allocator>
elements_of(_Rng &&, Allocator&&) -> elements_of<_Rng, Allocator>;
} // namespace ranges
template <typename _Alloc>
static constexpr bool __allocator_needs_to_be_stored =
!std::allocator_traits<_Alloc>::is_always_equal::value ||
!std::is_default_constructible_v<_Alloc>;
// Round s up to next multiple of a.
constexpr size_t __aligned_allocation_size(size_t s, size_t a) {
return (s + a - 1) & ~(a - 1);
}
template <typename _Ref,
typename _Value = std::remove_cvref_t<_Ref>,
typename _Allocator = use_allocator_arg>
class generator;
template<typename _Alloc>
class __promise_base_alloc {
static constexpr std::size_t __offset_of_allocator(std::size_t __frameSize) noexcept {
return __aligned_allocation_size(__frameSize, alignof(_Alloc));
}
static constexpr std::size_t __padded_frame_size(std::size_t __frameSize) noexcept {
return __offset_of_allocator(__frameSize) + sizeof(_Alloc);
}
static _Alloc& __get_allocator(void* __frame, std::size_t __frameSize) noexcept {
return *reinterpret_cast<_Alloc*>(
static_cast<char*>(__frame) + __offset_of_allocator(__frameSize));
}
public:
template<typename... _Args>
static void* operator new(std::size_t __frameSize, std::allocator_arg_t, _Alloc __alloc, _Args&...) {
void* __frame = __alloc.allocate(__padded_frame_size(__frameSize));
// Store allocator at end of the coroutine frame.
// Assuming the allocator's move constructor is non-throwing (a requirement for allocators)
::new (static_cast<void*>(std::addressof(__get_allocator(__frame, __frameSize)))) _Alloc(std::move(__alloc));
return __frame;
}
template<typename _This, typename... _Args>
static void* operator new(std::size_t __frameSize, _This&, std::allocator_arg_t, _Alloc __alloc, _Args&...) {
return __promise_base_alloc::operator new(__frameSize, std::allocator_arg, std::move(__alloc));
}
static void operator delete(void* __ptr, std::size_t __frameSize) noexcept {
_Alloc& __alloc = __get_allocator(__ptr, __frameSize);
_Alloc __localAlloc(std::move(__alloc));
__alloc.~Alloc();
__localAlloc.deallocate(static_cast<std::byte*>(__ptr), __padded_frame_size(__frameSize));
}
};
template<typename _Alloc>
requires (!__allocator_needs_to_be_stored<_Alloc>)
class __promise_base_alloc<_Alloc> {
public:
static void* operator new(std::size_t __size) {
_Alloc __alloc;
return __alloc.allocate(__size);
}
static void operator delete(void* __ptr, std::size_t __size) noexcept {
_Alloc __alloc;
__alloc.deallocate(static_cast<std::byte*>(__ptr), __size);
}
};
template<typename _Ref>
struct __generator_promise_base
{
template <typename _Ref2, typename _Value, typename _Alloc>
friend class generator;
__generator_promise_base* __root_;
std::coroutine_handle<> __parentOrLeaf_;
// Note: Using manual_lifetime here to avoid extra calls to exception_ptr
// constructor/destructor in cases where it is not needed (i.e. where this
// generator coroutine is not used as a nested coroutine).
// This member is lazily constructed by the __yield_sequence_awaiter::await_suspend()
// method if this generator is used as a nested generator.
__manual_lifetime<std::exception_ptr> __exception_;
__manual_lifetime<_Ref> __value_;
explicit __generator_promise_base(std::coroutine_handle<> thisCoro) noexcept
: __root_(this)
, __parentOrLeaf_(thisCoro)
{}
~__generator_promise_base() {
if (__root_ != this) {
// This coroutine was used as a nested generator and so will
// have constructed its __exception_ member which needs to be
// destroyed here.
__exception_.destruct();
}
}
std::suspend_always initial_suspend() noexcept {
return {};
}
void return_void() noexcept {}
void unhandled_exception() {
if (__root_ != this) {
__exception_.get() = std::current_exception();
} else {
throw;
}
}
// Transfers control back to the parent of a nested coroutine
struct __final_awaiter {
bool await_ready() noexcept {
return false;
}
template <typename _Promise>
std::coroutine_handle<>
await_suspend(std::coroutine_handle<_Promise> __h) noexcept {
_Promise& __promise = __h.promise();
__generator_promise_base& __root = *__promise.__root_;
if (&__root != &__promise) {
auto __parent = __promise.__parentOrLeaf_;
__root.__parentOrLeaf_ = __parent;
return __parent;
}
return std::noop_coroutine();
}
void await_resume() noexcept {}
};
__final_awaiter final_suspend() noexcept {
return {};
}
std::suspend_always yield_value(_Ref&& __x)
noexcept(std::is_nothrow_move_constructible_v<_Ref>) {
__root_->__value_.construct((_Ref&&)__x);
return {};
}
template <typename _T>
requires
(!std::is_reference_v<_Ref>) &&
std::is_convertible_v<_T, _Ref>
std::suspend_always yield_value(_T&& __x)
noexcept(std::is_nothrow_constructible_v<_Ref, _T>) {
__root_->__value_.construct((_T&&)__x);
return {};
}
template <typename _Gen>
struct __yield_sequence_awaiter {
_Gen __gen_;
__yield_sequence_awaiter(_Gen&& __g) noexcept
// Taking ownership of the generator ensures frame are destroyed
// in the reverse order of their execution.
: __gen_((_Gen&&)__g) {
}
bool await_ready() noexcept {
return false;
}
// set the parent, root and exceptions pointer and
// resume the nested
template<typename _Promise>
std::coroutine_handle<>
await_suspend(std::coroutine_handle<_Promise> __h) noexcept {
__generator_promise_base& __current = __h.promise();
__generator_promise_base& __nested = *__gen_.__get_promise();
__generator_promise_base& __root = *__current.__root_;
__nested.__root_ = __current.__root_;
__nested.__parentOrLeaf_ = __h;
// Lazily construct the __exception_ member here now that we
// know it will be used as a nested generator. This will be
// destroyed by the promise destructor.
__nested.__exception_.construct();
__root.__parentOrLeaf_ = __gen_.__get_coro();
// Immediately resume the nested coroutine (nested generator)
return __gen_.__get_coro();
}
void await_resume() {
__generator_promise_base& __nestedPromise = *__gen_.__get_promise();
if (__nestedPromise.__exception_.get()) {
std::rethrow_exception(std::move(__nestedPromise.__exception_.get()));
}
}
};
template <typename _OValue, typename _OAlloc>
__yield_sequence_awaiter<generator<_Ref, _OValue, _OAlloc>>
yield_value(std::ranges::elements_of<generator<_Ref, _OValue, _OAlloc>> __g) noexcept {
return std::move(__g).get();
}
template <std::ranges::range _Rng, typename _Allocator>
__yield_sequence_awaiter<generator<_Ref, std::remove_cvref_t<_Ref>, _Allocator>>
yield_value(std::ranges::elements_of<_Rng, _Allocator> && __x) {
return [](allocator_arg_t, _Allocator alloc, auto && __rng) -> generator<_Ref, std::remove_cvref_t<_Ref>, _Allocator> {
for(auto && e: __rng)
co_yield static_cast<decltype(e)>(e);
}(std::allocator_arg, __x.get_allocator(), std::forward<_Rng>(__x.get()));
}
void resume() {
__parentOrLeaf_.resume();
}
// Disable use of co_await within this coroutine.
void await_transform() = delete;
};
template<typename _Generator, typename _ByteAllocator, bool _ExplicitAllocator = false>
struct __generator_promise;
template<typename _Ref, typename _Value, typename _Alloc, typename _ByteAllocator, bool _ExplicitAllocator>
struct __generator_promise<generator<_Ref, _Value, _Alloc>, _ByteAllocator, _ExplicitAllocator> final
: public __generator_promise_base<_Ref>
, public __promise_base_alloc<_ByteAllocator> {
__generator_promise() noexcept
: __generator_promise_base<_Ref>(std::coroutine_handle<__generator_promise>::from_promise(*this))
{}
generator<_Ref, _Value, _Alloc> get_return_object() noexcept {
return generator<_Ref, _Value, _Alloc>{
std::coroutine_handle<__generator_promise>::from_promise(*this)
};
}
using __generator_promise_base<_Ref>::yield_value;
template <std::ranges::range _Rng>
typename __generator_promise_base<_Ref>::template __yield_sequence_awaiter<generator<_Ref, _Value, _Alloc>>
yield_value(std::ranges::elements_of<_Rng> && __x) {
static_assert (!_ExplicitAllocator,
"This coroutine has an explicit allocator specified with std::allocator_arg so an allocator needs to be passed "
"explicitely to std::elements_of");
return [](auto && __rng) -> generator<_Ref, _Value, _Alloc> {
for(auto && e: __rng)
co_yield static_cast<decltype(e)>(e);
}(std::forward<_Rng>(__x.get()));
}
};
template<typename _Alloc>
using __byte_allocator_t = typename std::allocator_traits<std::remove_cvref_t<_Alloc>>::template rebind_alloc<std::byte>;
// Type-erased allocator with default allocator behaviour.
template<typename _Ref, typename _Value, typename... _Args>
struct coroutine_traits<generator<_Ref, _Value>, _Args...> {
using promise_type = __generator_promise<generator<_Ref, _Value>, std::allocator<std::byte>>;
};
// Type-erased allocator with std::allocator_arg parameter
template<typename _Ref, typename _Value, typename _Alloc, typename... _Args>
struct coroutine_traits<generator<_Ref, _Value>, allocator_arg_t, _Alloc, _Args...> {
private:
using __byte_allocator = __byte_allocator_t<_Alloc>;
public:
using promise_type = __generator_promise<generator<_Ref, _Value>, __byte_allocator, true /*explicit Allocator*/>;
};
// Type-erased allocator with std::allocator_arg parameter (non-static member functions)
template<typename _Ref, typename _Value, typename _This, typename _Alloc, typename... _Args>
struct coroutine_traits<generator<_Ref, _Value>, _This, allocator_arg_t, _Alloc, _Args...> {
private:
using __byte_allocator = __byte_allocator_t<_Alloc>;
public:
using promise_type = __generator_promise<generator<_Ref, _Value>, __byte_allocator, true /*explicit Allocator*/>;
};
// Generator with specified allocator type
template<typename _Ref, typename _Value, typename _Alloc, typename... _Args>
struct coroutine_traits<generator<_Ref, _Value, _Alloc>, _Args...> {
using __byte_allocator = __byte_allocator_t<_Alloc>;
public:
using promise_type = __generator_promise<generator<_Ref, _Value, _Alloc>, __byte_allocator>;
};
// TODO : make layout compatible promise casts possible
template <typename _Ref, typename _Value, typename _Alloc>
class generator {
using __byte_allocator = __byte_allocator_t<_Alloc>;
public:
using promise_type = __generator_promise<generator<_Ref, _Value, _Alloc>, __byte_allocator>;
friend promise_type;
private:
using __coroutine_handle = std::coroutine_handle<promise_type>;
public:
generator() noexcept = default;
generator(generator&& __other) noexcept
: __coro_(std::exchange(__other.__coro_, {}))
, __started_(std::exchange(__other.__started_, false)) {
}
~generator() noexcept {
if (__coro_) {
if (__started_ && !__coro_.done()) {
__coro_.promise().__value_.destruct();
}
__coro_.destroy();
}
}
generator& operator=(generator && g) noexcept {
swap(g);
return *this;
}
void swap(generator& __other) noexcept {
std::swap(__coro_, __other.__coro_);
std::swap(__started_, __other.__started_);
}
struct sentinel {};
class iterator {
public:
using iterator_category = std::input_iterator_tag;
using difference_type = std::ptrdiff_t;
using value_type = _Value;
using reference = _Ref;
using pointer = std::add_pointer_t<_Ref>;
iterator() noexcept = default;
iterator(const iterator &) = delete;
iterator(iterator&& __other) noexcept
: __coro_(std::exchange(__other.__coro_, {})) {
}
iterator& operator=(iterator&& __other) {
std::swap(__coro_, __other.__coro_);
return *this;
}
~iterator() {
}
friend bool operator==(const iterator &it, sentinel) noexcept {
return it.__coro_.done();
}
iterator &operator++() {
__coro_.promise().__value_.destruct();
__coro_.promise().resume();
return *this;
}
void operator++(int) {
(void)operator++();
}
reference operator*() const noexcept {
return static_cast<reference>(__coro_.promise().__value_.get());
}
private:
friend generator;
explicit iterator(__coroutine_handle __coro) noexcept
: __coro_(__coro) {}
__coroutine_handle __coro_;
};
iterator begin() {
assert(__coro_);
assert(!__started_);
__started_ = true;
__coro_.resume();
return iterator{__coro_};
}
sentinel end() noexcept {
return {};
}
private:
explicit generator(__coroutine_handle __coro) noexcept
: __coro_(__coro) {
}
public: // to get around access restrictions for __yield_sequence_awaitable
std::coroutine_handle<> __get_coro() noexcept { return __coro_; }
promise_type* __get_promise() noexcept { return std::addressof(__coro_.promise()); }
private:
__coroutine_handle __coro_;
bool __started_ = false;
};
// Specialisation for type-erased allocator implementation.
template <typename _Ref, typename _Value>
class generator<_Ref, _Value, use_allocator_arg> {
using __promise_base = __generator_promise_base<_Ref>;
public:
generator() noexcept
: __promise_(nullptr)
, __coro_()
, __started_(false)
{}
generator(generator&& __other) noexcept
: __promise_(std::exchange(__other.__promise_, nullptr))
, __coro_(std::exchange(__other.__coro_, {}))
, __started_(std::exchange(__other.__started_, false)) {
}
~generator() noexcept {
if (__coro_) {
if (__started_ && !__coro_.done()) {
__promise_->__value_.destruct();
}
__coro_.destroy();
}
}
generator& operator=(generator g) noexcept {
swap(g);
return *this;
}
void swap(generator& __other) noexcept {
std::swap(__promise_, __other.__promise_);
std::swap(__coro_, __other.__coro_);
std::swap(__started_, __other.__started_);
}
struct sentinel {};
class iterator {
public:
using iterator_category = std::input_iterator_tag;
using difference_type = std::ptrdiff_t;
using value_type = _Value;
using reference = _Ref;
using pointer = std::add_pointer_t<_Ref>;
iterator() noexcept = default;
iterator(const iterator &) = delete;
iterator(iterator&& __other) noexcept
: __promise_(std::exchange(__other.__promise_, nullptr))
, __coro_(std::exchange(__other.__coro_, {}))
{}
iterator& operator=(iterator&& __other) {
__promise_ = std::exchange(__other.__promise_, nullptr);
__coro_ = std::exchange(__other.__coro_, {});
return *this;
}
~iterator() = default;
friend bool operator==(const iterator &it, sentinel) noexcept {
return it.__coro_.done();
}
iterator& operator++() {
__promise_->__value_.destruct();
__promise_->resume();
return *this;
}
void operator++(int) {
(void)operator++();
}
reference operator*() const noexcept {
return static_cast<reference>(__promise_->__value_.get());
}
private:
friend generator;
explicit iterator(__promise_base* __promise, std::coroutine_handle<> __coro) noexcept
: __promise_(__promise)
, __coro_(__coro)
{}
__promise_base* __promise_;
std::coroutine_handle<> __coro_;
};
iterator begin() {
assert(__coro_);
assert(!__started_);
__started_ = true;
__coro_.resume();
return iterator{__promise_, __coro_};
}
sentinel end() noexcept {
return {};
}
private:
template<typename _Generator, typename _ByteAllocator, bool _ExplicitAllocator>
friend struct __generator_promise;
template<typename _Promise>
explicit generator(std::coroutine_handle<_Promise> __coro) noexcept
: __promise_(std::addressof(__coro.promise()))
, __coro_(__coro)
{}
public: // to get around access restrictions for __yield_sequence_awaitable
std::coroutine_handle<> __get_coro() noexcept { return __coro_; }
__promise_base* __get_promise() noexcept { return __promise_; }
private:
__promise_base* __promise_;
std::coroutine_handle<> __coro_;
bool __started_ = false;
};
#if __has_include(<ranges>)
namespace ranges {
template <typename _T, typename _U, typename _Alloc>
constexpr inline bool enable_view<generator<_T, _U, _Alloc>> = true;
} // namespace ranges
#endif
} // namespace std
#endif // __STD_GENERATOR_INCLUDED
程序输出如下，
