npm - couchbase - Versions diffs - 4.3.0 → 4.3.1 - Mend

couchbase 4.3.0 → 4.3.1

Files changed (1394) hide show

package/deps/couchbase-cxx-cache/asio/a1d8afc0fa0ccceae5729647623b3f7fd6859548/asio/asio/include/asio/impl/thread_pool.hpp DELETED Viewed

@@ -1,354 +0,0 @@
-//
-// impl/thread_pool.hpp
-// ~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef ASIO_IMPL_THREAD_POOL_HPP
-#define ASIO_IMPL_THREAD_POOL_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include "asio/detail/blocking_executor_op.hpp"
-#include "asio/detail/bulk_executor_op.hpp"
-#include "asio/detail/executor_op.hpp"
-#include "asio/detail/fenced_block.hpp"
-#include "asio/detail/non_const_lvalue.hpp"
-#include "asio/detail/type_traits.hpp"
-#include "asio/execution_context.hpp"
-#include "asio/detail/push_options.hpp"
-namespace asio {
-inline thread_pool::executor_type
-thread_pool::get_executor() ASIO_NOEXCEPT
-{
-  return executor_type(*this);
-}
-inline thread_pool::executor_type
-thread_pool::executor() ASIO_NOEXCEPT
-{
-  return executor_type(*this);
-}
-inline thread_pool::scheduler_type
-thread_pool::scheduler() ASIO_NOEXCEPT
-{
-  return scheduler_type(*this);
-}
-template <typename Allocator, unsigned int Bits>
-thread_pool::basic_executor_type<Allocator, Bits>&
-thread_pool::basic_executor_type<Allocator, Bits>::operator=(
-    const basic_executor_type& other) ASIO_NOEXCEPT
-{
-  if (this != &other)
-  {
-    thread_pool* old_thread_pool = pool_;
-    pool_ = other.pool_;
-    allocator_ = other.allocator_;
-    bits_ = other.bits_;
-    if (Bits & outstanding_work_tracked)
-    {
-      if (pool_)
-        pool_->scheduler_.work_started();
-      if (old_thread_pool)
-        old_thread_pool->scheduler_.work_finished();
-    }
-  }
-  return *this;
-}
-#if defined(ASIO_HAS_MOVE)
-template <typename Allocator, unsigned int Bits>
-thread_pool::basic_executor_type<Allocator, Bits>&
-thread_pool::basic_executor_type<Allocator, Bits>::operator=(
-    basic_executor_type&& other) ASIO_NOEXCEPT
-{
-  if (this != &other)
-  {
-    thread_pool* old_thread_pool = pool_;
-    pool_ = other.pool_;
-    allocator_ = std::move(other.allocator_);
-    bits_ = other.bits_;
-    if (Bits & outstanding_work_tracked)
-    {
-      other.pool_ = 0;
-      if (old_thread_pool)
-        old_thread_pool->scheduler_.work_finished();
-    }
-  }
-  return *this;
-}
-#endif // defined(ASIO_HAS_MOVE)
-template <typename Allocator, unsigned int Bits>
-inline bool thread_pool::basic_executor_type<Allocator,
-    Bits>::running_in_this_thread() const ASIO_NOEXCEPT
-{
-  return pool_->scheduler_.can_dispatch();
-}
-template <typename Allocator, unsigned int Bits>
-template <typename Function>
-void thread_pool::basic_executor_type<Allocator,
-    Bits>::do_execute(ASIO_MOVE_ARG(Function) f, false_type) const
-{
-  typedef typename decay<Function>::type function_type;
-  // Invoke immediately if the blocking.possibly property is enabled and we are
-  // already inside the thread pool.
-  if ((bits_ & blocking_never) == 0 && pool_->scheduler_.can_dispatch())
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(ASIO_MOVE_CAST(Function)(f));
-#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
-  && !defined(ASIO_NO_EXCEPTIONS)
-    try
-    {
-#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
-       //   && !defined(ASIO_NO_EXCEPTIONS)
-      detail::fenced_block b(detail::fenced_block::full);
-      asio_handler_invoke_helpers::invoke(tmp, tmp);
-      return;
-#if defined(ASIO_HAS_STD_EXCEPTION_PTR) \
-  && !defined(ASIO_NO_EXCEPTIONS)
-    }
-    catch (...)
-    {
-      pool_->scheduler_.capture_current_exception();
-      return;
-    }
-#endif // defined(ASIO_HAS_STD_EXCEPTION_PTR)
-       //   && !defined(ASIO_NO_EXCEPTIONS)
-  }
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, Allocator> op;
-  typename op::ptr p = { detail::addressof(allocator_),
-      op::ptr::allocate(allocator_), 0 };
-  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), allocator_);
-  if ((bits_ & relationship_continuation) != 0)
-  {
-    ASIO_HANDLER_CREATION((*pool_, *p.p,
-          "thread_pool", pool_, 0, "execute(blk=never,rel=cont)"));
-  }
-  else
-  {
-    ASIO_HANDLER_CREATION((*pool_, *p.p,
-          "thread_pool", pool_, 0, "execute(blk=never,rel=fork)"));
-  }
-  pool_->scheduler_.post_immediate_completion(p.p,
-      (bits_ & relationship_continuation) != 0);
-  p.v = p.p = 0;
-}
-template <typename Allocator, unsigned int Bits>
-template <typename Function>
-void thread_pool::basic_executor_type<Allocator,
-    Bits>::do_execute(ASIO_MOVE_ARG(Function) f, true_type) const
-{
-  // Obtain a non-const instance of the function.
-  detail::non_const_lvalue<Function> f2(f);
-  // Invoke immediately if we are already inside the thread pool.
-  if (pool_->scheduler_.can_dispatch())
-  {
-#if !defined(ASIO_NO_EXCEPTIONS)
-    try
-    {
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-      detail::fenced_block b(detail::fenced_block::full);
-      asio_handler_invoke_helpers::invoke(f2.value, f2.value);
-      return;
-#if !defined(ASIO_NO_EXCEPTIONS)
-    }
-    catch (...)
-    {
-      std::terminate();
-    }
-#endif // !defined(ASIO_NO_EXCEPTIONS)
-  }
-  // Construct an operation to wrap the function.
-  typedef typename decay<Function>::type function_type;
-  detail::blocking_executor_op<function_type> op(f2.value);
-  ASIO_HANDLER_CREATION((*pool_, op,
-        "thread_pool", pool_, 0, "execute(blk=always)"));
-  pool_->scheduler_.post_immediate_completion(&op, false);
-  op.wait();
-}
-template <typename Allocator, unsigned int Bits>
-template <typename Function>
-void thread_pool::basic_executor_type<Allocator, Bits>::do_bulk_execute(
-    ASIO_MOVE_ARG(Function) f, std::size_t n, false_type) const
-{
-  typedef typename decay<Function>::type function_type;
-  typedef detail::bulk_executor_op<function_type, Allocator> op;
-  // Allocate and construct operations to wrap the function.
-  detail::op_queue<detail::scheduler_operation> ops;
-  for (std::size_t i = 0; i < n; ++i)
-  {
-    typename op::ptr p = { detail::addressof(allocator_),
-        op::ptr::allocate(allocator_), 0 };
-    p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), allocator_, i);
-    ops.push(p.p);
-    if ((bits_ & relationship_continuation) != 0)
-    {
-      ASIO_HANDLER_CREATION((*pool_, *p.p,
-            "thread_pool", pool_, 0, "bulk_execute(blk=never,rel=cont)"));
-    }
-    else
-    {
-      ASIO_HANDLER_CREATION((*pool_, *p.p,
-            "thread_pool", pool_, 0, "bulk)execute(blk=never,rel=fork)"));
-    }
-    p.v = p.p = 0;
-  }
-  pool_->scheduler_.post_immediate_completions(n,
-      ops, (bits_ & relationship_continuation) != 0);
-}
-template <typename Function>
-struct thread_pool_always_blocking_function_adapter
-{
-  typename decay<Function>::type* f;
-  std::size_t n;
-  void operator()()
-  {
-    for (std::size_t i = 0; i < n; ++i)
-    {
-      (*f)(i);
-    }
-  }
-};
-template <typename Allocator, unsigned int Bits>
-template <typename Function>
-void thread_pool::basic_executor_type<Allocator, Bits>::do_bulk_execute(
-    ASIO_MOVE_ARG(Function) f, std::size_t n, true_type) const
-{
-  // Obtain a non-const instance of the function.
-  detail::non_const_lvalue<Function> f2(f);
-  thread_pool_always_blocking_function_adapter<Function>
-    adapter = { detail::addressof(f2.value), n };
-  this->do_execute(adapter, true_type());
-}
-#if !defined(ASIO_NO_TS_EXECUTORS)
-template <typename Allocator, unsigned int Bits>
-inline thread_pool& thread_pool::basic_executor_type<
-    Allocator, Bits>::context() const ASIO_NOEXCEPT
-{
-  return *pool_;
-}
-template <typename Allocator, unsigned int Bits>
-inline void thread_pool::basic_executor_type<Allocator,
-    Bits>::on_work_started() const ASIO_NOEXCEPT
-{
-  pool_->scheduler_.work_started();
-}
-template <typename Allocator, unsigned int Bits>
-inline void thread_pool::basic_executor_type<Allocator,
-    Bits>::on_work_finished() const ASIO_NOEXCEPT
-{
-  pool_->scheduler_.work_finished();
-}
-template <typename Allocator, unsigned int Bits>
-template <typename Function, typename OtherAllocator>
-void thread_pool::basic_executor_type<Allocator, Bits>::dispatch(
-    ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
-{
-  typedef typename decay<Function>::type function_type;
-  // Invoke immediately if we are already inside the thread pool.
-  if (pool_->scheduler_.can_dispatch())
-  {
-    // Make a local, non-const copy of the function.
-    function_type tmp(ASIO_MOVE_CAST(Function)(f));
-    detail::fenced_block b(detail::fenced_block::full);
-    asio_handler_invoke_helpers::invoke(tmp, tmp);
-    return;
-  }
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, OtherAllocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
-  ASIO_HANDLER_CREATION((*pool_, *p.p,
-        "thread_pool", pool_, 0, "dispatch"));
-  pool_->scheduler_.post_immediate_completion(p.p, false);
-  p.v = p.p = 0;
-}
-template <typename Allocator, unsigned int Bits>
-template <typename Function, typename OtherAllocator>
-void thread_pool::basic_executor_type<Allocator, Bits>::post(
-    ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
-{
-  typedef typename decay<Function>::type function_type;
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, OtherAllocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
-  ASIO_HANDLER_CREATION((*pool_, *p.p,
-        "thread_pool", pool_, 0, "post"));
-  pool_->scheduler_.post_immediate_completion(p.p, false);
-  p.v = p.p = 0;
-}
-template <typename Allocator, unsigned int Bits>
-template <typename Function, typename OtherAllocator>
-void thread_pool::basic_executor_type<Allocator, Bits>::defer(
-    ASIO_MOVE_ARG(Function) f, const OtherAllocator& a) const
-{
-  typedef typename decay<Function>::type function_type;
-  // Allocate and construct an operation to wrap the function.
-  typedef detail::executor_op<function_type, OtherAllocator> op;
-  typename op::ptr p = { detail::addressof(a), op::ptr::allocate(a), 0 };
-  p.p = new (p.v) op(ASIO_MOVE_CAST(Function)(f), a);
-  ASIO_HANDLER_CREATION((*pool_, *p.p,
-        "thread_pool", pool_, 0, "defer"));
-  pool_->scheduler_.post_immediate_completion(p.p, true);
-  p.v = p.p = 0;
-}
-#endif // !defined(ASIO_NO_TS_EXECUTORS)
-} // namespace asio
-#include "asio/detail/pop_options.hpp"
-#endif // ASIO_IMPL_THREAD_POOL_HPP

package/deps/couchbase-cxx-cache/asio/a1d8afc0fa0ccceae5729647623b3f7fd6859548/asio/asio/include/asio/impl/use_awaitable.hpp DELETED Viewed

@@ -1,301 +0,0 @@
-//
-// impl/use_awaitable.hpp
-// ~~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2023 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-#ifndef ASIO_IMPL_USE_AWAITABLE_HPP
-#define ASIO_IMPL_USE_AWAITABLE_HPP
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
-#include "asio/detail/config.hpp"
-#include "asio/async_result.hpp"
-#include "asio/cancellation_signal.hpp"
-#include "asio/detail/push_options.hpp"
-namespace asio {
-namespace detail {
-template <typename Executor, typename T>
-class awaitable_handler_base
-  : public awaitable_thread<Executor>
-{
-public:
-  typedef void result_type;
-  typedef awaitable<T, Executor> awaitable_type;
-  // Construct from the entry point of a new thread of execution.
-  awaitable_handler_base(awaitable<awaitable_thread_entry_point, Executor> a,
-      const Executor& ex, cancellation_slot pcs, cancellation_state cs)
-    : awaitable_thread<Executor>(std::move(a), ex, pcs, cs)
-  {
-  }
-  // Transfer ownership from another awaitable_thread.
-  explicit awaitable_handler_base(awaitable_thread<Executor>* h)
-    : awaitable_thread<Executor>(std::move(*h))
-  {
-  }
-protected:
-  awaitable_frame<T, Executor>* frame() noexcept
-  {
-    return static_cast<awaitable_frame<T, Executor>*>(
-        this->entry_point()->top_of_stack_);
-  }
-};
-template <typename, typename...>
-class awaitable_handler;
-template <typename Executor>
-class awaitable_handler<Executor>
-  : public awaitable_handler_base<Executor, void>
-{
-public:
-  using awaitable_handler_base<Executor, void>::awaitable_handler_base;
-  void operator()()
-  {
-    this->frame()->attach_thread(this);
-    this->frame()->return_void();
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-template <typename Executor>
-class awaitable_handler<Executor, asio::error_code>
-  : public awaitable_handler_base<Executor, void>
-{
-public:
-  using awaitable_handler_base<Executor, void>::awaitable_handler_base;
-  void operator()(const asio::error_code& ec)
-  {
-    this->frame()->attach_thread(this);
-    if (ec)
-      this->frame()->set_error(ec);
-    else
-      this->frame()->return_void();
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-template <typename Executor>
-class awaitable_handler<Executor, std::exception_ptr>
-  : public awaitable_handler_base<Executor, void>
-{
-public:
-  using awaitable_handler_base<Executor, void>::awaitable_handler_base;
-  void operator()(std::exception_ptr ex)
-  {
-    this->frame()->attach_thread(this);
-    if (ex)
-      this->frame()->set_except(ex);
-    else
-      this->frame()->return_void();
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-template <typename Executor, typename T>
-class awaitable_handler<Executor, T>
-  : public awaitable_handler_base<Executor, T>
-{
-public:
-  using awaitable_handler_base<Executor, T>::awaitable_handler_base;
-  template <typename Arg>
-  void operator()(Arg&& arg)
-  {
-    this->frame()->attach_thread(this);
-    this->frame()->return_value(std::forward<Arg>(arg));
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-template <typename Executor, typename T>
-class awaitable_handler<Executor, asio::error_code, T>
-  : public awaitable_handler_base<Executor, T>
-{
-public:
-  using awaitable_handler_base<Executor, T>::awaitable_handler_base;
-  template <typename Arg>
-  void operator()(const asio::error_code& ec, Arg&& arg)
-  {
-    this->frame()->attach_thread(this);
-    if (ec)
-      this->frame()->set_error(ec);
-    else
-      this->frame()->return_value(std::forward<Arg>(arg));
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-template <typename Executor, typename T>
-class awaitable_handler<Executor, std::exception_ptr, T>
-  : public awaitable_handler_base<Executor, T>
-{
-public:
-  using awaitable_handler_base<Executor, T>::awaitable_handler_base;
-  template <typename Arg>
-  void operator()(std::exception_ptr ex, Arg&& arg)
-  {
-    this->frame()->attach_thread(this);
-    if (ex)
-      this->frame()->set_except(ex);
-    else
-      this->frame()->return_value(std::forward<Arg>(arg));
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-template <typename Executor, typename... Ts>
-class awaitable_handler
-  : public awaitable_handler_base<Executor, std::tuple<Ts...>>
-{
-public:
-  using awaitable_handler_base<Executor,
-    std::tuple<Ts...>>::awaitable_handler_base;
-  template <typename... Args>
-  void operator()(Args&&... args)
-  {
-    this->frame()->attach_thread(this);
-    this->frame()->return_values(std::forward<Args>(args)...);
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-template <typename Executor, typename... Ts>
-class awaitable_handler<Executor, asio::error_code, Ts...>
-  : public awaitable_handler_base<Executor, std::tuple<Ts...>>
-{
-public:
-  using awaitable_handler_base<Executor,
-    std::tuple<Ts...>>::awaitable_handler_base;
-  template <typename... Args>
-  void operator()(const asio::error_code& ec, Args&&... args)
-  {
-    this->frame()->attach_thread(this);
-    if (ec)
-      this->frame()->set_error(ec);
-    else
-      this->frame()->return_values(std::forward<Args>(args)...);
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-template <typename Executor, typename... Ts>
-class awaitable_handler<Executor, std::exception_ptr, Ts...>
-  : public awaitable_handler_base<Executor, std::tuple<Ts...>>
-{
-public:
-  using awaitable_handler_base<Executor,
-    std::tuple<Ts...>>::awaitable_handler_base;
-  template <typename... Args>
-  void operator()(std::exception_ptr ex, Args&&... args)
-  {
-    this->frame()->attach_thread(this);
-    if (ex)
-      this->frame()->set_except(ex);
-    else
-      this->frame()->return_values(std::forward<Args>(args)...);
-    this->frame()->clear_cancellation_slot();
-    this->frame()->pop_frame();
-    this->pump();
-  }
-};
-} // namespace detail
-#if !defined(GENERATING_DOCUMENTATION)
-#if defined(_MSC_VER)
-template <typename T>
-T dummy_return()
-{
-  return std::move(*static_cast<T*>(nullptr));
-}
-template <>
-inline void dummy_return()
-{
-}
-#endif // defined(_MSC_VER)
-template <typename Executor, typename R, typename... Args>
-class async_result<use_awaitable_t<Executor>, R(Args...)>
-{
-public:
-  typedef typename detail::awaitable_handler<
-      Executor, typename decay<Args>::type...> handler_type;
-  typedef typename handler_type::awaitable_type return_type;
-  template <typename Initiation, typename... InitArgs>
-#if defined(__APPLE_CC__) && (__clang_major__ == 13)
-  __attribute__((noinline))
-#endif // defined(__APPLE_CC__) && (__clang_major__ == 13)
-  static handler_type* do_init(
-      detail::awaitable_frame_base<Executor>* frame, Initiation& initiation,
-      use_awaitable_t<Executor> u, InitArgs&... args)
-  {
-    (void)u;
-    ASIO_HANDLER_LOCATION((u.file_name_, u.line_, u.function_name_));
-    handler_type handler(frame->detach_thread());
-    std::move(initiation)(std::move(handler), std::move(args)...);
-    return nullptr;
-  }
-  template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation initiation,
-      use_awaitable_t<Executor> u, InitArgs... args)
-  {
-    co_await [&] (auto* frame)
-      {
-        return do_init(frame, initiation, u, args...);
-      };
-    for (;;) {} // Never reached.
-#if defined(_MSC_VER)
-    co_return dummy_return<typename return_type::value_type>();
-#endif // defined(_MSC_VER)
-  }
-};
-#endif // !defined(GENERATING_DOCUMENTATION)
-} // namespace asio
-#include "asio/detail/pop_options.hpp"
-#endif // ASIO_IMPL_USE_AWAITABLE_HPP