coroutine_context_fiber.h

Go to the documentation of this file.

// Copyright 2023 owent
 
#pragma once
 
#include <libcopp/utils/config/libcopp_build_features.h>
#include <libcopp/utils/nostd/type_traits.h>
 
// clang-format off
#include <libcopp/utils/config/stl_include_prefix.h>  // NOLINT(build/include_order)
// clang-format on
#include <cstddef>
// clang-format off
#include <libcopp/utils/config/stl_include_suffix.h>  // NOLINT(build/include_order)
// clang-format on
 
#include "libcopp/coroutine/coroutine_context.h"
#include "libcopp/coroutine/stackful_channel_common.h"
 
#if defined(LIBCOPP_MACRO_ENABLE_WIN_FIBER) && LIBCOPP_MACRO_ENABLE_WIN_FIBER
 
#  ifndef WIN32_LEAN_AND_MEAN
#    define WIN32_LEAN_AND_MEAN
#  endif
 
#  include <Windows.h>  // NOLINT(build/include_order)
 
LIBCOPP_COPP_NAMESPACE_BEGIN
class coroutine_context_fiber : public coroutine_context_base {
 public:
  using ptr_type = LIBCOPP_COPP_NAMESPACE_ID::memory::intrusive_ptr<coroutine_context_fiber>;
 
  using callback_type = coroutine_context_base::callback_type;
  using status_type = coroutine_context_base::status_type;
  using flag_type = coroutine_context_base::flag_type;
 
  // Compability with libcopp-1.x
  using ptr_t = ptr_type;
  using callback_t = callback_type;
  using status_t = status_type;
  using flag_t = flag_type;
 
 private:
  using coroutine_context_base::flags_;
  using coroutine_context_base::priv_data_;
  using coroutine_context_base::private_buffer_size_;
  using coroutine_context_base::runner_;
  using coroutine_context_base::runner_ret_code_;
  using coroutine_context_base::status_;
#  if defined(LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR) && LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR
  using coroutine_context_base::unhandle_exception_;
#  endif
 
  struct jump_src_data_t {
    coroutine_context_fiber *from_co;
    LPVOID from_fiber;
    coroutine_context_fiber *to_co;
    LPVOID to_fiber;
    void *priv_data;
  };
 
  friend struct LIBCOPP_COPP_API_HEAD_ONLY libcopp_fiber_internal_api_set;
  friend struct LIBCOPP_COPP_API_HEAD_ONLY fiber_context_tls_data_t;
 
 protected:
  LPVOID caller_; 
  LPVOID callee_; 
  stack_context callee_stack_; 
 protected:
  LIBCOPP_COPP_API coroutine_context_fiber() LIBCOPP_MACRO_NOEXCEPT;
 
 public:
  LIBCOPP_COPP_API ~coroutine_context_fiber();
 
 private:
  coroutine_context_fiber(const coroutine_context_fiber &) = delete;
  coroutine_context_fiber &operator=(const coroutine_context_fiber &) = delete;
  coroutine_context_fiber(const coroutine_context_fiber &&) = delete;
  coroutine_context_fiber &operator=(const coroutine_context_fiber &&) = delete;
 
 public:
  static LIBCOPP_COPP_API int create(coroutine_context_fiber *p, callback_type &&runner,
                                     const stack_context &callee_stack, size_t coroutine_size,
                                     size_t private_buffer_size,
                                     size_t stack_reserve_size_of_fiber = 0) LIBCOPP_MACRO_NOEXCEPT;
 
  template <typename TRunner>
  static LIBCOPP_COPP_API_HEAD_ONLY int create(coroutine_context_fiber *p, TRunner *runner,
                                               const stack_context &callee_stack, size_t coroutine_size,
                                               size_t private_buffer_size,
                                               size_t stack_reserve_size_of_fiber = 0) LIBCOPP_MACRO_NOEXCEPT {
    return create(
        p, [runner](void *private_data) { return (*runner)(private_data); }, callee_stack, coroutine_size,
        private_buffer_size, stack_reserve_size_of_fiber);
  }
 
  LIBCOPP_COPP_API int start(void *priv_data = nullptr);
 
#  if defined(LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR) && LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR
  LIBCOPP_COPP_API int start(std::exception_ptr &unhandled, void *priv_data = nullptr) LIBCOPP_MACRO_NOEXCEPT;
#  endif
 
  LIBCOPP_COPP_API int resume(void *priv_data = nullptr);
 
#  if defined(LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR) && LIBCOPP_MACRO_ENABLE_STD_EXCEPTION_PTR
  LIBCOPP_COPP_API int resume(std::exception_ptr &unhandled, void *priv_data = nullptr) LIBCOPP_MACRO_NOEXCEPT;
#  endif
 
  LIBCOPP_COPP_API int yield(void **priv_data = nullptr) LIBCOPP_MACRO_NOEXCEPT;
 
  template <class TAWAITABLE, class TERROR_TRANSFORM,
            class = nostd::enable_if_t<stackful_inject_awaitable<nostd::remove_cvref_t<TAWAITABLE>>::value>>
  LIBCOPP_COPP_API_HEAD_ONLY inline container_value_type<TAWAITABLE>
  await_value(TAWAITABLE &&awaitable, TERROR_TRANSFORM &&error_transform) noexcept(
      std::is_nothrow_copy_constructible<container_value_type<TAWAITABLE>>::value &&
      noexcept(error_transform(COPP_EC_ARGS_ERROR))) {
    return awaitable.inject_await(this, std::forward<TERROR_TRANSFORM>(error_transform));
  }
 
  template <class TAWAITABLE,
            class = nostd::enable_if_t<stackful_inject_awaitable<nostd::remove_cvref_t<TAWAITABLE>>::value>>
  LIBCOPP_COPP_API_HEAD_ONLY inline container_value_type<TAWAITABLE> await_value(TAWAITABLE &&awaitable) noexcept(
      std::is_nothrow_copy_constructible<container_value_type<TAWAITABLE>>::value &&
      noexcept(stackful_channel_error_transform<container_value_type<TAWAITABLE>>()(COPP_EC_ARGS_ERROR))) {
    return awaitable.inject_await(this, stackful_channel_error_transform<container_value_type<TAWAITABLE>>());
  }
};
 
namespace this_fiber {
LIBCOPP_COPP_API coroutine_context_fiber *get_coroutine() LIBCOPP_MACRO_NOEXCEPT;
 
template <typename Tc>
LIBCOPP_COPP_API_HEAD_ONLY Tc *get() {
  return static_cast<Tc *>(get_coroutine());
}
 
LIBCOPP_COPP_API int yield(void **priv_data = nullptr) LIBCOPP_MACRO_NOEXCEPT;
}  // namespace this_fiber
LIBCOPP_COPP_NAMESPACE_END
 
#endif