coroutine_context.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>
 
#include "libcopp/coroutine/coroutine_context_base.h"
#include "libcopp/coroutine/stackful_channel_common.h"
 
#ifdef LIBCOPP_MACRO_USE_SEGMENTED_STACKS
#  define COROUTINE_CONTEXT_BASE_USING_BASE_SEGMENTED_STACKS(base_type) using base_type::caller_stack_;
#else
#  define COROUTINE_CONTEXT_BASE_USING_BASE_SEGMENTED_STACKS(base_type)
#endif
 
#define COROUTINE_CONTEXT_BASE_USING_BASE(base_type) \
 protected:                                          \
  using base_type::caller_;                          \
  using base_type::callee_;                          \
  using base_type::callee_stack_;                    \
  COROUTINE_CONTEXT_BASE_USING_BASE_SEGMENTED_STACKS(base_type)
#define COROUTINE_CONTEXT_BASE_USING_BASE(base_type) \ …
 
LIBCOPP_COPP_NAMESPACE_BEGIN
class coroutine_context : public coroutine_context_base {
 public:
  using ptr_type = LIBCOPP_COPP_NAMESPACE_ID::memory::intrusive_ptr<coroutine_context>;
  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 *from_co;
    coroutine_context *to_co;
    void *priv_data;
  };
  struct jump_src_data_t {…};
 
  friend struct libcopp_internal_api_set;
 
 protected:
  fcontext::fcontext_t caller_; 
  fcontext::fcontext_t callee_; 
  stack_context callee_stack_; 
#ifdef LIBCOPP_MACRO_USE_SEGMENTED_STACKS
  stack_context caller_stack_; 
#endif
 
 protected:
  LIBCOPP_COPP_API coroutine_context() LIBCOPP_MACRO_NOEXCEPT;
 
 public:
  LIBCOPP_COPP_API ~coroutine_context();
 
 private:
  coroutine_context(const coroutine_context &) = delete;
  coroutine_context &operator=(const coroutine_context &) = delete;
  coroutine_context(const coroutine_context &&) = delete;
  coroutine_context &operator=(const coroutine_context &&) = delete;
 
 public:
  static LIBCOPP_COPP_API int create(coroutine_context *p, callback_type &&runner, const stack_context &callee_stack,
                                     size_t coroutine_size, size_t private_buffer_size) LIBCOPP_MACRO_NOEXCEPT;
 
  template <typename TRunner>
  static LIBCOPP_COPP_API_HEAD_ONLY int create(coroutine_context *p, TRunner *runner, const stack_context &callee_stack,
                                               size_t coroutine_size,
                                               size_t private_buffer_size) LIBCOPP_MACRO_NOEXCEPT {
    return create(
        p, [runner](void *private_data) { return (*runner)(private_data); }, callee_stack, coroutine_size,
        private_buffer_size);
  }
  static LIBCOPP_COPP_API_HEAD_ONLY int create(coroutine_context *p, TRunner *runner, const stack_context &callee_stack, {…}
 
  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));
  }
  await_value(TAWAITABLE &&awaitable, TERROR_TRANSFORM &&error_transform) noexcept( {…}
 
  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>>());
  }
  LIBCOPP_COPP_API_HEAD_ONLY inline container_value_type<TAWAITABLE> await_value(TAWAITABLE &&awaitable) noexcept( {…}
};
class coroutine_context : public coroutine_context_base {…};
 
namespace this_coroutine {
LIBCOPP_COPP_API coroutine_context *get_coroutine() LIBCOPP_MACRO_NOEXCEPT;
 
template <typename Tc>
LIBCOPP_COPP_API_HEAD_ONLY Tc *get() {
  return static_cast<Tc *>(get_coroutine());
}
LIBCOPP_COPP_API_HEAD_ONLY Tc *get() {…}
 
LIBCOPP_COPP_API int yield(void **priv_data = nullptr) LIBCOPP_MACRO_NOEXCEPT;
}  // namespace this_coroutine
namespace this_coroutine {…}
LIBCOPP_COPP_NAMESPACE_END