generator.h

Go to the documentation of this file.

#ifndef DED82BB9_7596_4598_B34D_B60883A4775D
#define DED82BB9_7596_4598_B34D_B60883A4775D

 
#include <coroutine>
#include <exception>
#include <iterator>
#include <memory>
#include <ranges>
#include <type_traits>
#include <utility>
 
#include "detail.h"
#include "exceptions.h"
 
namespace wwa::coro {

template<typename Result>
class [[nodiscard]] generator : public std::ranges::view_interface<generator<Result>> {
public:
    class promise_type {
    public:
        using value_type     = std::remove_reference_t<Result>;
        using reference_type = std::add_lvalue_reference_t<value_type>;
        using pointer_type   = std::add_pointer_t<value_type>;

        generator<Result> get_return_object() noexcept
        {
            using coroutine_handle = std::coroutine_handle<promise_type>;
            return generator<Result>{coroutine_handle::from_promise(*this)};
        }

        [[nodiscard]] constexpr auto initial_suspend() const noexcept { return std::suspend_always{}; }

        [[nodiscard]] constexpr auto final_suspend() const noexcept { return std::suspend_always{}; }

        constexpr auto yield_value(std::add_const_t<reference_type> value) noexcept
        {
            this->m_value = std::addressof(value);
            return std::suspend_always{};
        }

        constexpr auto yield_value(std::add_rvalue_reference_t<std::remove_cvref_t<value_type>> value) noexcept
        {
            /*
             * This seems to be safe.
             *   - `yield` calls `generator_promise::yield_value(T&&)`;
             *   - `yield_value` stores the address of the temporary value;
             *   - the generator suspends and the control is transferred to the calling function;
             *   - after the generator is resumed, the temporary gets destroyed.
             */
            this->m_value = std::addressof(value);
            return std::suspend_always{};
        }

        constexpr void unhandled_exception() noexcept { this->m_exception = std::current_exception(); }

        constexpr void return_void() const noexcept {}

        [[nodiscard]] reference_type value() const noexcept { return static_cast<reference_type>(*this->m_value); }

        void await_transform() = delete;

        void rethrow_if_exception()
        {
            if (this->m_exception) {
                std::rethrow_exception(std::move(this->m_exception));
            }
        }
 
    private:
        pointer_type m_value           = nullptr;
        std::exception_ptr m_exception = nullptr;
    };
    class promise_type {…};

    class iterator {
    public:
        using iterator_concept = std::input_iterator_tag;

        using difference_type = std::ptrdiff_t;


        using value_type = promise_type::value_type;

        explicit iterator(std::coroutine_handle<promise_type> coroutine) noexcept : m_coroutine(coroutine) {}

        iterator() noexcept = default;

        [[nodiscard]] constexpr bool operator==(const iterator& other) const noexcept
        {
            return this->m_coroutine == other.m_coroutine ||
                   (!detail::is_good_handle(this->m_coroutine) && !detail::is_good_handle(other.m_coroutine));
        }
        [[nodiscard]] constexpr bool operator==(const iterator& other) const noexcept {…}

        iterator& operator++()
        {
            if (detail::is_good_handle(this->m_coroutine)) [[likely]] {
                this->m_coroutine.resume();
                if (this->m_coroutine.done()) {
                    this->m_coroutine.promise().rethrow_if_exception();
                }
 
                return *this;
            }
 
            throw bad_result_access{"Incrementing past the end of the generator"};
        }
        iterator& operator++() {…}

        void operator++(int) { this->operator++(); }

        promise_type::reference_type operator*() const
        {
            if (detail::is_good_handle(this->m_coroutine)) [[likely]] {
                return this->m_coroutine.promise().value();
            }
 
            throw bad_result_access("Access past the end of the generator");
        }
        promise_type::reference_type operator*() const {…}
 
    private:
        std::coroutine_handle<promise_type> m_coroutine;
    };
    class iterator {…};

    generator() noexcept = default;

    generator(generator&& other) noexcept : m_coroutine(std::exchange(other.m_coroutine, {})) {}

    ~generator()
    {
        if (this->m_coroutine) {
            this->m_coroutine.destroy();
        }
    }
    ~generator() {…}

    generator& operator=(generator&& other) noexcept
    {
        if (this != std::addressof(other)) {
            if (this->m_coroutine) {
                this->m_coroutine.destroy();
            }
 
            this->m_coroutine = std::exchange(other.m_coroutine, nullptr);
        }
 
        return *this;
    }
    generator& operator=(generator&& other) noexcept {…}

    generator(const generator&)            = delete;
    generator& operator=(const generator&) = delete;

    [[nodiscard]] iterator begin()
    {
        this->advance();
        return iterator(this->m_coroutine);
    }
    [[nodiscard]] iterator begin() {…}

    [[nodiscard]] iterator begin() const
    {
        this->advance();
        return iterator(this->m_coroutine);
    }
    [[nodiscard]] iterator begin() const {…}

    [[nodiscard]] constexpr iterator end() const noexcept { return iterator(nullptr); }
 
private:
    std::coroutine_handle<promise_type> m_coroutine;

    explicit generator(std::coroutine_handle<promise_type> coroutine) noexcept : m_coroutine(coroutine) {}

    void advance() const
    {
        if (detail::is_good_handle(this->m_coroutine)) {
            this->m_coroutine.resume();
            if (this->m_coroutine.done()) {
                this->m_coroutine.promise().rethrow_if_exception();
            }
        }
    }
};
class [[nodiscard]] generator : public std::ranges::view_interface<generator<Result>> {…};



 
}  // namespace wwa::coro
 
#endif /* DED82BB9_7596_4598_B34D_B60883A4775D */