couchbase 3.5.2 → 3.5.3

data/ext/cache/asio/6a3b5a552ffb18a235024ec851619cfcb1337a98/asio/asio/include/asio/executor.hpp

@@ -0,0 +1,363 @@
+//
+// executor.hpp
+// ~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 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_EXECUTOR_HPP
+#define ASIO_EXECUTOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#if !defined(ASIO_NO_TS_EXECUTORS)
+
+#include <new>
+#include <typeinfo>
+#include "asio/detail/cstddef.hpp"
+#include "asio/detail/executor_function.hpp"
+#include "asio/detail/memory.hpp"
+#include "asio/detail/throw_exception.hpp"
+#include "asio/execution_context.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+/// Exception thrown when trying to access an empty polymorphic executor.
+class bad_executor
+  : public std::exception
+{
+public:
+  /// Constructor.
+  ASIO_DECL bad_executor() noexcept;
+
+  /// Obtain message associated with exception.
+  ASIO_DECL virtual const char* what() const
+    noexcept;
+};
+
+/// Polymorphic wrapper for executors.
+class executor
+{
+public:
+  /// Default constructor.
+  executor() noexcept
+    : impl_(0)
+  {
+  }
+
+  /// Construct from nullptr.
+  executor(nullptr_t) noexcept
+    : impl_(0)
+  {
+  }
+
+  /// Copy constructor.
+  executor(const executor& other) noexcept
+    : impl_(other.clone())
+  {
+  }
+
+  /// Move constructor.
+  executor(executor&& other) noexcept
+    : impl_(other.impl_)
+  {
+    other.impl_ = 0;
+  }
+
+  /// Construct a polymorphic wrapper for the specified executor.
+  template <typename Executor>
+  executor(Executor e);
+
+  /// Construct a polymorphic executor that points to the same target as
+  /// another polymorphic executor.
+  executor(std::nothrow_t, const executor& other) noexcept
+    : impl_(other.clone())
+  {
+  }
+
+  /// Construct a polymorphic executor that moves the target from another
+  /// polymorphic executor.
+  executor(std::nothrow_t, executor&& other) noexcept
+    : impl_(other.impl_)
+  {
+    other.impl_ = 0;
+  }
+
+  /// Construct a polymorphic wrapper for the specified executor.
+  template <typename Executor>
+  executor(std::nothrow_t, Executor e) noexcept;
+
+  /// Allocator-aware constructor to create a polymorphic wrapper for the
+  /// specified executor.
+  template <typename Executor, typename Allocator>
+  executor(allocator_arg_t, const Allocator& a, Executor e);
+
+  /// Destructor.
+  ~executor()
+  {
+    destroy();
+  }
+
+  /// Assignment operator.
+  executor& operator=(const executor& other) noexcept
+  {
+    destroy();
+    impl_ = other.clone();
+    return *this;
+  }
+
+  // Move assignment operator.
+  executor& operator=(executor&& other) noexcept
+  {
+    destroy();
+    impl_ = other.impl_;
+    other.impl_ = 0;
+    return *this;
+  }
+
+  /// Assignment operator for nullptr_t.
+  executor& operator=(nullptr_t) noexcept
+  {
+    destroy();
+    impl_ = 0;
+    return *this;
+  }
+
+  /// Assignment operator to create a polymorphic wrapper for the specified
+  /// executor.
+  template <typename Executor>
+  executor& operator=(Executor&& e) noexcept
+  {
+    executor tmp(static_cast<Executor&&>(e));
+    destroy();
+    impl_ = tmp.impl_;
+    tmp.impl_ = 0;
+    return *this;
+  }
+
+  /// Obtain the underlying execution context.
+  execution_context& context() const noexcept
+  {
+    return get_impl()->context();
+  }
+
+  /// Inform the executor that it has some outstanding work to do.
+  void on_work_started() const noexcept
+  {
+    get_impl()->on_work_started();
+  }
+
+  /// Inform the executor that some work is no longer outstanding.
+  void on_work_finished() const noexcept
+  {
+    get_impl()->on_work_finished();
+  }
+
+  /// Request the executor to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object is executed according to the rules of the
+   * target executor object.
+   *
+   * @param f The function object to be called. The executor will make a copy
+   * of the handler object as required. The function signature of the function
+   * object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void dispatch(Function&& f, const Allocator& a) const;
+
+  /// Request the executor to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object is executed according to the rules of the
+   * target executor object.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void post(Function&& f, const Allocator& a) const;
+
+  /// Request the executor to invoke the given function object.
+  /**
+   * This function is used to ask the executor to execute the given function
+   * object. The function object is executed according to the rules of the
+   * target executor object.
+   *
+   * @param f The function object to be called. The executor will make
+   * a copy of the handler object as required. The function signature of the
+   * function object must be: @code void function(); @endcode
+   *
+   * @param a An allocator that may be used by the executor to allocate the
+   * internal storage needed for function invocation.
+   */
+  template <typename Function, typename Allocator>
+  void defer(Function&& f, const Allocator& a) const;
+
+  struct unspecified_bool_type_t {};
+  typedef void (*unspecified_bool_type)(unspecified_bool_type_t);
+  static void unspecified_bool_true(unspecified_bool_type_t) {}
+
+  /// Operator to test if the executor contains a valid target.
+  operator unspecified_bool_type() const noexcept
+  {
+    return impl_ ? &executor::unspecified_bool_true : 0;
+  }
+
+  /// Obtain type information for the target executor object.
+  /**
+   * @returns If @c *this has a target type of type @c T, <tt>typeid(T)</tt>;
+   * otherwise, <tt>typeid(void)</tt>.
+   */
+#if !defined(ASIO_NO_TYPEID) || defined(GENERATING_DOCUMENTATION)
+  const std::type_info& target_type() const noexcept
+  {
+    return impl_ ? impl_->target_type() : typeid(void);
+  }
+#else // !defined(ASIO_NO_TYPEID) || defined(GENERATING_DOCUMENTATION)
+  const void* target_type() const noexcept
+  {
+    return impl_ ? impl_->target_type() : 0;
+  }
+#endif // !defined(ASIO_NO_TYPEID) || defined(GENERATING_DOCUMENTATION)
+
+  /// Obtain a pointer to the target executor object.
+  /**
+   * @returns If <tt>target_type() == typeid(T)</tt>, a pointer to the stored
+   * executor target; otherwise, a null pointer.
+   */
+  template <typename Executor>
+  Executor* target() noexcept;
+
+  /// Obtain a pointer to the target executor object.
+  /**
+   * @returns If <tt>target_type() == typeid(T)</tt>, a pointer to the stored
+   * executor target; otherwise, a null pointer.
+   */
+  template <typename Executor>
+  const Executor* target() const noexcept;
+
+  /// Compare two executors for equality.
+  friend bool operator==(const executor& a,
+      const executor& b) noexcept
+  {
+    if (a.impl_ == b.impl_)
+      return true;
+    if (!a.impl_ || !b.impl_)
+      return false;
+    return a.impl_->equals(b.impl_);
+  }
+
+  /// Compare two executors for inequality.
+  friend bool operator!=(const executor& a,
+      const executor& b) noexcept
+  {
+    return !(a == b);
+  }
+
+private:
+#if !defined(GENERATING_DOCUMENTATION)
+  typedef detail::executor_function function;
+  template <typename, typename> class impl;
+
+#if !defined(ASIO_NO_TYPEID)
+  typedef const std::type_info& type_id_result_type;
+#else // !defined(ASIO_NO_TYPEID)
+  typedef const void* type_id_result_type;
+#endif // !defined(ASIO_NO_TYPEID)
+
+  template <typename T>
+  static type_id_result_type type_id()
+  {
+#if !defined(ASIO_NO_TYPEID)
+    return typeid(T);
+#else // !defined(ASIO_NO_TYPEID)
+    static int unique_id;
+    return &unique_id;
+#endif // !defined(ASIO_NO_TYPEID)
+  }
+
+  // Base class for all polymorphic executor implementations.
+  class impl_base
+  {
+  public:
+    virtual impl_base* clone() const noexcept = 0;
+    virtual void destroy() noexcept = 0;
+    virtual execution_context& context() noexcept = 0;
+    virtual void on_work_started() noexcept = 0;
+    virtual void on_work_finished() noexcept = 0;
+    virtual void dispatch(function&&) = 0;
+    virtual void post(function&&) = 0;
+    virtual void defer(function&&) = 0;
+    virtual type_id_result_type target_type() const noexcept = 0;
+    virtual void* target() noexcept = 0;
+    virtual const void* target() const noexcept = 0;
+    virtual bool equals(const impl_base* e) const noexcept = 0;
+
+  protected:
+    impl_base(bool fast_dispatch) : fast_dispatch_(fast_dispatch) {}
+    virtual ~impl_base() {}
+
+  private:
+    friend class executor;
+    const bool fast_dispatch_;
+  };
+
+  // Helper function to check and return the implementation pointer.
+  impl_base* get_impl() const
+  {
+    if (!impl_)
+    {
+      bad_executor ex;
+      asio::detail::throw_exception(ex);
+    }
+    return impl_;
+  }
+
+  // Helper function to clone another implementation.
+  impl_base* clone() const noexcept
+  {
+    return impl_ ? impl_->clone() : 0;
+  }
+
+  // Helper function to destroy an implementation.
+  void destroy() noexcept
+  {
+    if (impl_)
+      impl_->destroy();
+  }
+
+  impl_base* impl_;
+#endif // !defined(GENERATING_DOCUMENTATION)
+};
+
+} // namespace asio
+
+ASIO_USES_ALLOCATOR(asio::executor)
+
+#include "asio/detail/pop_options.hpp"
+
+#include "asio/impl/executor.hpp"
+#if defined(ASIO_HEADER_ONLY)
+# include "asio/impl/executor.ipp"
+#endif // defined(ASIO_HEADER_ONLY)
+
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
+#endif // ASIO_EXECUTOR_HPP

data/ext/cache/asio/6a3b5a552ffb18a235024ec851619cfcb1337a98/asio/asio/include/asio/executor_work_guard.hpp

@@ -0,0 +1,362 @@
+//
+// executor_work_guard.hpp
+// ~~~~~~~~~~~~~~~~~~~~~~~
+//
+// Copyright (c) 2003-2024 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_EXECUTOR_WORK_GUARD_HPP
+#define ASIO_EXECUTOR_WORK_GUARD_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+
+#include "asio/detail/config.hpp"
+
+#include "asio/associated_executor.hpp"
+#include "asio/detail/type_traits.hpp"
+#include "asio/execution.hpp"
+#include "asio/is_executor.hpp"
+
+#include "asio/detail/push_options.hpp"
+
+namespace asio {
+
+#if !defined(ASIO_EXECUTOR_WORK_GUARD_DECL)
+#define ASIO_EXECUTOR_WORK_GUARD_DECL
+
+template <typename Executor, typename = void, typename = void>
+class executor_work_guard;
+
+#endif // !defined(ASIO_EXECUTOR_WORK_GUARD_DECL)
+
+#if defined(GENERATING_DOCUMENTATION)
+
+/// An object of type @c executor_work_guard controls ownership of outstanding
+/// executor work within a scope.
+template <typename Executor>
+class executor_work_guard
+{
+public:
+  /// The underlying executor type.
+  typedef Executor executor_type;
+
+  /// Constructs a @c executor_work_guard object for the specified executor.
+  /**
+   * Stores a copy of @c e and calls <tt>on_work_started()</tt> on it.
+   */
+  explicit executor_work_guard(const executor_type& e) noexcept;
+
+  /// Copy constructor.
+  executor_work_guard(const executor_work_guard& other) noexcept;
+
+  /// Move constructor.
+  executor_work_guard(executor_work_guard&& other) noexcept;
+
+  /// Destructor.
+  /**
+   * Unless the object has already been reset, or is in a moved-from state,
+   * calls <tt>on_work_finished()</tt> on the stored executor.
+   */
+  ~executor_work_guard();
+
+  /// Obtain the associated executor.
+  executor_type get_executor() const noexcept;
+
+  /// Whether the executor_work_guard object owns some outstanding work.
+  bool owns_work() const noexcept;
+
+  /// Indicate that the work is no longer outstanding.
+  /**
+   * Unless the object has already been reset, or is in a moved-from state,
+   * calls <tt>on_work_finished()</tt> on the stored executor.
+   */
+  void reset() noexcept;
+};
+
+#endif // defined(GENERATING_DOCUMENTATION)
+
+#if !defined(GENERATING_DOCUMENTATION)
+
+#if !defined(ASIO_NO_TS_EXECUTORS)
+
+template <typename Executor>
+class executor_work_guard<Executor,
+    enable_if_t<
+      is_executor<Executor>::value
+    >>
+{
+public:
+  typedef Executor executor_type;
+
+  explicit executor_work_guard(const executor_type& e) noexcept
+    : executor_(e),
+      owns_(true)
+  {
+    executor_.on_work_started();
+  }
+
+  executor_work_guard(const executor_work_guard& other) noexcept
+    : executor_(other.executor_),
+      owns_(other.owns_)
+  {
+    if (owns_)
+      executor_.on_work_started();
+  }
+
+  executor_work_guard(executor_work_guard&& other) noexcept
+    : executor_(static_cast<Executor&&>(other.executor_)),
+      owns_(other.owns_)
+  {
+    other.owns_ = false;
+  }
+
+  ~executor_work_guard()
+  {
+    if (owns_)
+      executor_.on_work_finished();
+  }
+
+  executor_type get_executor() const noexcept
+  {
+    return executor_;
+  }
+
+  bool owns_work() const noexcept
+  {
+    return owns_;
+  }
+
+  void reset() noexcept
+  {
+    if (owns_)
+    {
+      executor_.on_work_finished();
+      owns_ = false;
+    }
+  }
+
+private:
+  // Disallow assignment.
+  executor_work_guard& operator=(const executor_work_guard&);
+
+  executor_type executor_;
+  bool owns_;
+};
+
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
+template <typename Executor>
+class executor_work_guard<Executor,
+    enable_if_t<
+      !is_executor<Executor>::value
+    >,
+    enable_if_t<
+      execution::is_executor<Executor>::value
+    >>
+{
+public:
+  typedef Executor executor_type;
+
+  explicit executor_work_guard(const executor_type& e) noexcept
+    : executor_(e),
+      owns_(true)
+  {
+    new (&work_) work_type(asio::prefer(executor_,
+          execution::outstanding_work.tracked));
+  }
+
+  executor_work_guard(const executor_work_guard& other) noexcept
+    : executor_(other.executor_),
+      owns_(other.owns_)
+  {
+    if (owns_)
+    {
+      new (&work_) work_type(asio::prefer(executor_,
+            execution::outstanding_work.tracked));
+    }
+  }
+
+  executor_work_guard(executor_work_guard&& other) noexcept
+    : executor_(static_cast<Executor&&>(other.executor_)),
+      owns_(other.owns_)
+  {
+    if (owns_)
+    {
+      new (&work_) work_type(
+          static_cast<work_type&&>(
+            *static_cast<work_type*>(
+              static_cast<void*>(&other.work_))));
+      other.owns_ = false;
+    }
+  }
+
+  ~executor_work_guard()
+  {
+    if (owns_)
+      static_cast<work_type*>(static_cast<void*>(&work_))->~work_type();
+  }
+
+  executor_type get_executor() const noexcept
+  {
+    return executor_;
+  }
+
+  bool owns_work() const noexcept
+  {
+    return owns_;
+  }
+
+  void reset() noexcept
+  {
+    if (owns_)
+    {
+      static_cast<work_type*>(static_cast<void*>(&work_))->~work_type();
+      owns_ = false;
+    }
+  }
+
+private:
+  // Disallow assignment.
+  executor_work_guard& operator=(const executor_work_guard&);
+
+  typedef decay_t<
+      prefer_result_t<
+        const executor_type&,
+        execution::outstanding_work_t::tracked_t
+      >
+    > work_type;
+
+  executor_type executor_;
+  aligned_storage_t<sizeof(work_type), alignment_of<work_type>::value> work_;
+  bool owns_;
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
+/// Create an @ref executor_work_guard object.
+/**
+ * @param ex An executor.
+ *
+ * @returns A work guard constructed with the specified executor.
+ */
+template <typename Executor>
+ASIO_NODISCARD inline executor_work_guard<Executor>
+make_work_guard(const Executor& ex,
+    constraint_t<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    > = 0)
+{
+  return executor_work_guard<Executor>(ex);
+}
+
+/// Create an @ref executor_work_guard object.
+/**
+ * @param ctx An execution context, from which an executor will be obtained.
+ *
+ * @returns A work guard constructed with the execution context's executor,
+ * obtained by performing <tt>ctx.get_executor()</tt>.
+ */
+template <typename ExecutionContext>
+ASIO_NODISCARD inline
+executor_work_guard<typename ExecutionContext::executor_type>
+make_work_guard(ExecutionContext& ctx,
+    constraint_t<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    > = 0)
+{
+  return executor_work_guard<typename ExecutionContext::executor_type>(
+      ctx.get_executor());
+}
+
+/// Create an @ref executor_work_guard object.
+/**
+ * @param t An arbitrary object, such as a completion handler, for which the
+ * associated executor will be obtained.
+ *
+ * @returns A work guard constructed with the associated executor of the object
+ * @c t, which is obtained as if by calling <tt>get_associated_executor(t)</tt>.
+ */
+template <typename T>
+ASIO_NODISCARD inline
+executor_work_guard<
+    typename constraint_t<
+      !is_executor<T>::value
+        && !execution::is_executor<T>::value
+        && !is_convertible<T&, execution_context&>::value,
+      associated_executor<T>
+    >::type>
+make_work_guard(const T& t)
+{
+  return executor_work_guard<associated_executor_t<T>>(
+      associated_executor<T>::get(t));
+}
+
+/// Create an @ref executor_work_guard object.
+/**
+ * @param t An arbitrary object, such as a completion handler, for which the
+ * associated executor will be obtained.
+ *
+ * @param ex An executor to be used as the candidate object when determining the
+ * associated executor.
+ *
+ * @returns A work guard constructed with the associated executor of the object
+ * @c t, which is obtained as if by calling <tt>get_associated_executor(t,
+ * ex)</tt>.
+ */
+template <typename T, typename Executor>
+ASIO_NODISCARD inline
+executor_work_guard<associated_executor_t<T, Executor>>
+make_work_guard(const T& t, const Executor& ex,
+    constraint_t<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    > = 0)
+{
+  return executor_work_guard<associated_executor_t<T, Executor>>(
+      associated_executor<T, Executor>::get(t, ex));
+}
+
+/// Create an @ref executor_work_guard object.
+/**
+ * @param t An arbitrary object, such as a completion handler, for which the
+ * associated executor will be obtained.
+ *
+ * @param ctx An execution context, from which an executor is obtained to use as
+ * the candidate object for determining the associated executor.
+ *
+ * @returns A work guard constructed with the associated executor of the object
+ * @c t, which is obtained as if by calling <tt>get_associated_executor(t,
+ * ctx.get_executor())</tt>.
+ */
+template <typename T, typename ExecutionContext>
+ASIO_NODISCARD inline executor_work_guard<
+  associated_executor_t<T, typename ExecutionContext::executor_type>>
+make_work_guard(const T& t, ExecutionContext& ctx,
+    constraint_t<
+      !is_executor<T>::value
+    > = 0,
+    constraint_t<
+      !execution::is_executor<T>::value
+    > = 0,
+    constraint_t<
+      !is_convertible<T&, execution_context&>::value
+    > = 0,
+    constraint_t<
+      is_convertible<ExecutionContext&, execution_context&>::value
+    > = 0)
+{
+  return executor_work_guard<
+    associated_executor_t<T, typename ExecutionContext::executor_type>>(
+      associated_executor<T, typename ExecutionContext::executor_type>::get(
+        t, ctx.get_executor()));
+}
+
+} // namespace asio
+
+#include "asio/detail/pop_options.hpp"
+
+#endif // ASIO_EXECUTOR_WORK_GUARD_HPP