Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::noop_coroutine(3)	      C++ Standard Libary	std::noop_coroutine(3)

NAME
       std::noop_coroutine - std::noop_coroutine

Synopsis
	  Defined in header <coroutine>
	  std::noop_coroutine_handle noop_coroutine() noexcept;	 (since	C++20)

	  Returns a coroutine handle referring to a no-op coroutine.

	  If  there  has been already a	coroutine state	of no-op coroutine, it
       is unspecified
	  whether a subsequent call to noop_coroutine returns a	previously ob-
       tained coroutine
	  handle, or a coroutine handle	referring to a new coroutine state  of
       no-op coroutine.

Parameters
	  (none)

Return value
	  A std::noop_coroutine_handle referring to a no-op coroutine.

Notes
	  Return values	from different calls to	noop_coroutine may and may not
       compare equal.

	  noop_coroutine  may only return a noop_coroutine_handle referring to
       a coroutine
	  state	object without starting	a coroutine.

Example
       // Run this code

	#include <coroutine>
	#include <utility>
	#include <iostream>

	template<class T>
	struct task {
	    struct promise_type	{
		auto get_return_object() {
		    return			      task(std::coroutine_han-
       dle<promise_type>::from_promise(*this));
		}
		std::suspend_always initial_suspend() {	return {}; }
		struct final_awaiter {
		    bool await_ready() noexcept	{ return false;	}
		    void await_resume()	noexcept {}
		    std::coroutine_handle<>  await_suspend(std::coroutine_han-
       dle<promise_type> h) noexcept {
			// final_awaiter::await_suspend	is called when the ex-
       ecution of the
			// current coroutine (referred to by 'h') is about  to
       finish.
			//  If	the  current  coroutine	was resumed by another
       coroutine via
			// co_await get_task(),	a handle to that coroutine has
       been stored
			// as h.promise().previous. In that case,  return  the
       handle to resume
			// the previous	coroutine.
			//  Otherwise,	return noop_coroutine(), whose resump-
       tion does nothing.

			auto previous =	h.promise().previous;
			if (previous) {
			    return previous;
			} else {
			    return std::noop_coroutine();
			}
		    }
		};
		final_awaiter final_suspend() noexcept { return	{}; }
		void unhandled_exception() { throw; }
		void return_value(T value) { result = std::move(value);	}
		T result;
		std::coroutine_handle<>	previous;
	    };

	    task(std::coroutine_handle<promise_type> h)	: coro(h) {}
	    task(task&&	t) = delete;
	    ~task() { coro.destroy(); }

	    struct awaiter {
		bool await_ready() { return false; }
		T await_resume() { return std::move(coro.promise().result); }
		auto await_suspend(std::coroutine_handle<> h) {
		    coro.promise().previous = h;
		    return coro;
		}
		std::coroutine_handle<promise_type> coro;
	    };
	    awaiter operator co_await()	{ return awaiter{coro};	}
	    T operator()() {
		coro.resume();
		return std::move(coro.promise().result);
	    }
	private:
	    std::coroutine_handle<promise_type>	coro;
	};

	task<int> get_random() {
	    std::cout << "in get_random()\n";
	    co_return 4;
	}
	task<int> test() {
	    task<int> v	= get_random();
	    task<int> u	= get_random();
	    std::cout << "in test()\n";
	    int	x = (co_await v	+ co_await u);
	    co_return x;
	}

	int main() {
	    task<int> t	= test();
	    int	result = t();
	    std::cout << result	<< '\n';
	}

Output:
	in test()
	in get_random()
	in get_random()
	8

See also
	  noop_coroutine_promise used for coroutines with  no  observable  ef-
       fects
	  (C++20)		 (class)
	  noop_coroutine_handle		std::coroutine_handle<std::noop_corou-
       tine_promise>, intended
	  (C++20)		 to refer to a no-op coroutine
				 (typedef)

http://cppreference.com		  2022.07.31		std::noop_coroutine(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::noop_coroutine&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help