enumerable_generator.hpp

Go to the documentation of this file.

#pragma once
#include "ienumerable.hpp"
#include "ienumerator.hpp"
#define __XTD_CORE_INTERNAL__
#include "../../internal/__string_definitions.hpp"
#undef __XTD_CORE_INTERNAL__
#include "../../helpers/throw_helper.hpp"
#include "../../object.hpp"
#include "../../raw_type.hpp"
//#include "../../string.hpp"
#include <coroutine>
#include <exception>

namespace xtd {
  namespace collections {
    namespace generic {
      template<typename type_t>
      class enumerable_generator : public xtd::object, public xtd::collections::generic::ienumerable<type_t> {
      public:
        struct promise_type {
          using value_type = xtd::raw_type<type_t>;
          value_type current_value;
          
          std::exception_ptr exception;
 
          
          enumerable_generator get_return_object() {return enumerable_generator {std::coroutine_handle<promise_type>::from_promise(*this)};}
          
          std::suspend_always initial_suspend() noexcept {return {};}

          std::suspend_always final_suspend() noexcept {return {};}

          void return_void() noexcept {}
          
          void unhandled_exception() noexcept {exception = std::current_exception();}
          
          template<typename value_t>
          std::suspend_always yield_value(value_t&& value) noexcept {
            // The following must be refactor.
            current_value = (decltype(current_value)&)std::forward<value_t>(value);
            return {};
          }
        };
        
        enumerable_generator(const enumerable_generator& other) = delete;
        enumerable_generator& operator =(const enumerable_generator& other) = delete;
        enumerable_generator(enumerable_generator&& other) noexcept : handle_(std::exchange(other.handle_, {})) {}
        enumerable_generator& operator =(enumerable_generator&& other) noexcept {
          if (handle_) handle_.destroy();
          handle_ = std::exchange(other.handle_, {});
          return *this;
        }
        ~enumerable_generator() override {if (handle_) handle_.destroy();}
        
        
        xtd::collections::generic::enumerator<type_t> get_enumerator() const override {
          struct generator_enumerator final : xtd::collections::generic::ienumerator<type_t> {
            explicit generator_enumerator(std::coroutine_handle<promise_type> handle) : handle_(handle) {}
            const type_t& current() const override {
              if (!started_) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_operation);
              return handle_.promise().current_value;
            }
            bool move_next() override {
              started_ = true;
              if (!handle_ || handle_.done()) return false;
              
              handle_.resume();
              
              if (handle_.promise().exception)
                std::rethrow_exception(handle_.promise().exception);
              
              return !handle_.done();
            }
            void reset() override {xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::not_supported);}
            
          private:
            bool started_ = false;
            std::coroutine_handle<promise_type> handle_;
          };
          
          return {new_ptr<generator_enumerator>(handle_)};
        }
        
        [[nodiscard]] auto to_string() const -> xtd::string override; // Defined in xtd/string.hpp
        
      private:
        explicit enumerable_generator(std::coroutine_handle<promise_type> handle) : handle_(handle) {}
        
        mutable std::coroutine_handle<promise_type> handle_;
      };
    }
  }
}