examples

coro-generator2.cpp (5882B)

---

 #include <coroutine>
 #include <exception>
 #include <iostream>
 #include <optional>
 #include <utility>
 #include <cstdio>
 #include <unistd.h>
 
 auto exchange_default(auto& x)
 {
 	return std::exchange(x, {});
 }
 
 struct resume_null_coroutine : std::exception
 {
 	~resume_null_coroutine() override = default;
 	char const* what() const noexcept override
 	{
 		return "resume_null_coroutine";
 	}
 };
 
 struct resume_finished_coroutine : std::exception
 {
 	~resume_finished_coroutine() override = default;
 	char const* what() const noexcept override
 	{
 		return "resume_finished_coroutine";
 	}
 };
 
 template <typename T = void>
 struct [[nodiscard]] coroutine_owner
 {
 	coroutine_owner() = default;
 
 	template <typename U>
 	explicit coroutine_owner(std::coroutine_handle<U> h) noexcept
 	:   h{h}
 	{}
 
 	coroutine_owner(coroutine_owner const&) = delete;
 	coroutine_owner& operator =(coroutine_owner const&) = delete;
 
 	template <typename U>
 	coroutine_owner(coroutine_owner<U>&& old) noexcept
 	:   h{old.release()}
 	{}
 
 	coroutine_owner& operator =(coroutine_owner&& old)
 	{
 		cancel();
 		h = old.release();
 		return *this;
 	}
 
 	~coroutine_owner() noexcept
 	try {
 		cancel();
 	} catch (...)
 	{}
 
 	void cancel()
 	{
 		if (auto x = release())
 			x.destroy();
 	}
 
 	[[nodiscard]]
 	std::coroutine_handle<T> get() noexcept
 	{
 		return h;
 	}
 
 	[[nodiscard]]
 	std::coroutine_handle<T> release() noexcept
 	{
 		return exchange_default(h);
 	}
 
 	[[nodiscard]]
 	std::coroutine_handle<T>const* operator->() const noexcept
 	{
 		return &h;
 	}
 
 	[[nodiscard]]
 	std::coroutine_handle<T>* operator->() noexcept
 	{
 		return &h;
 	}
 
 	void resume()
 	{
 		if (not h)
 			throw resume_null_coroutine{};
 		if (h.done())
 			throw resume_finished_coroutine{};
 		h.resume();
 	}
 
 	void operator() ()
 	{
 		resume();
 	}
 
 private:
 	std::coroutine_handle<T> h;
 };
 
 template <typename T, typename U = T>
 coroutine_owner<U> make_coroutine_owner(T& promise) noexcept
 {
  	return coroutine_owner<U>{std::coroutine_handle<T>::from_promise(promise)};
 }
 
 struct yield_blocked : std::exception
 {
 	~yield_blocked() override = default;
 	char const* what() const noexcept override
 	{
 		return "yield_blocked";
 	}
 };
 
 struct symmetric_transfer : std::suspend_always
 {
 	std::coroutine_handle<> await_suspend(std::coroutine_handle<>) noexcept
 	{
 		return std::exchange(waiting, std::noop_coroutine());
 	}
 	std::coroutine_handle<>& waiting;
 };
 
 template <typename T>
 struct [[nodiscard]] generator
 {
 	struct promise_type
 	{
 		promise_type() = default;
 		~promise_type() noexcept
 		try {
 			if (ep)
 				std::rethrow_exception(ep);
 		} catch (std::exception const& e)
 		{
 			std::cerr << "Dropped exception '" << e.what() << "'\n";
 		} catch (...)
 		{
 			std::cerr << "Dropped unknown exception type\n";
 		}
 
 		auto get_return_object() { return generator{*this}; }
 		auto initial_suspend() const noexcept { return std::suspend_always{}; }
 		auto yield_value(T v)
 		{
 			return_value(std::move(v));
 			return symmetric_transfer{{}, waiting};
 		}
 		void return_value(T v)
 		{
 			if (yielded_value)
 				throw yield_blocked{};
 			yielded_value = std::move(v);
 		}
 		void unhandled_exception() noexcept { ep = std::current_exception(); }
 		auto final_suspend() noexcept { return symmetric_transfer{{}, waiting}; }
 
 		friend struct generator;
 	private:
 		std::optional<T> yielded_value;
 		std::exception_ptr ep;
 		std::coroutine_handle<> waiting = std::noop_coroutine();
 	};
 
 	struct [[nodiscard]] awaitable
 	{
 		bool await_ready()
 		{
 			return !!coro->promise().yielded_value;
 		}
 		std::coroutine_handle<> await_suspend(std::coroutine_handle<> h)
 		{
 			coro->promise().waiting = h;
 			return coro.get();
 		}
 		T await_resume()
 		{
 			if (auto ep = exchange_default(coro->promise().ep))
 				std::rethrow_exception(ep);
 			return exchange_default(coro->promise().yielded_value).value();
 		}
 		coroutine_owner<promise_type>& coro;
 	};
 
 	awaitable get_awaitable() { return {coro}; }
 
 	T generate()
 	{
 		auto& promise = coro->promise();
 		if (not promise.yielded_value)
 		{
 			coro.resume();
 			if (auto ep = exchange_default(promise.ep))
 				std::rethrow_exception(ep);
 		}
 		return exchange_default(promise.yielded_value).value();
 	}
 
 	T operator() () { return generate(); }
 
 private:
 	explicit generator(promise_type& p)
 	:   coro{make_coroutine_owner<promise_type>(p)}
 	{}
 
 	coroutine_owner<promise_type> coro;
 };
 
 generator<unsigned char> fd_charize(int fd)
 {
 	for (;;)
 	{
 		unsigned char buf[1024];
 		ssize_t n = ::read(fd, buf, sizeof buf);
 
 		if (n < 0)
 			throw std::runtime_error{"read() failed"};
 		else if (not n)
 			co_return '\0';
 
 		for (ssize_t i = 0; i < n; ++i)
 			if (buf[i])
 				co_yield buf[i];
 			else
 				throw std::runtime_error{"null in char stream"};
 	}
 }
 
 generator<std::string> tokenize(generator<unsigned char>& chars, int(*is_delimiter)(int))
 {
 	std::string rval;
 
 	while (auto c = chars.generate())
 	{
 		while (is_delimiter(c))
 			if (not (c = chars.generate()))
 				goto empty;
 
 		while (not is_delimiter(c))
 		{
 			rval.push_back(c);
 			if (not (c = chars.generate()))
 				goto empty;
 		}
 
 		co_yield std::move(rval);
 		rval.clear();
 	}
 empty:
 	if (not rval.empty())
 		co_yield std::move(rval);
 	co_return {};
 }
 
 generator<std::string> tokenize2(generator<unsigned char>& chars, int(*is_delimiter)(int))
 {
 	std::string rval;
 
 	auto a = chars.get_awaitable();
 
 	while (auto c = co_await a)
 	{
 		while (is_delimiter(c))
 			if (not (c = co_await a))
 				goto empty;
 
 		while (not is_delimiter(c))
 		{
 			rval.push_back(c);
 			if (not (c = co_await a))
 				goto empty;
 		}
 
 		co_yield std::move(rval);
 		rval.clear();
 	}
 empty:
 	if (not rval.empty())
 		co_yield std::move(rval);
 	co_return {};
 }
 
 int main()
 {
 	std::cerr << std::boolalpha;
 	auto chars = fd_charize(0);
 	auto strings = tokenize2(chars, std::isspace);
 	for (auto str = strings.generate(); not str.empty(); str = strings.generate())
 		std::cout << '[' << str << "]\n";
 }