couchbase 3.0.0.alpha.5 → 3.0.3

data/ext/third_party/asio/asio/include/asio/executor.hpp

@@ -16,8 +16,12 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if !defined(ASIO_NO_TS_EXECUTORS)
+
 #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"
@@ -253,7 +257,7 @@ public:
 
 private:
 #if !defined(GENERATING_DOCUMENTATION)
-  class function;
+  typedef detail::executor_function function;
   template <typename, typename> class impl;
 
 #if !defined(ASIO_NO_TYPEID)
@@ -338,4 +342,6 @@ ASIO_USES_ALLOCATOR(asio::executor)
 # include "asio/impl/executor.ipp"
 #endif // defined(ASIO_HEADER_ONLY)
 
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
 #endif // ASIO_EXECUTOR_HPP

data/ext/third_party/asio/asio/include/asio/executor_work_guard.hpp

@@ -1,6 +1,6 @@
 //
 // executor_work_guard.hpp
-// ~~~~~~~~~~~~~~~~~
+// ~~~~~~~~~~~~~~~~~~~~~~~
 //
 // Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
 //
@@ -16,17 +16,33 @@
 #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
 #include "asio/detail/config.hpp"
+
+#if !defined(ASIO_NO_TS_EXECUTORS)
+
 #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>
+class executor_work_guard;
+
+#endif // !defined(ASIO_EXECUTOR_WORK_GUARD_DECL)
+
 /// An object of type @c executor_work_guard controls ownership of executor work
 /// within a scope.
+#if defined(GENERATING_DOCUMENTATION)
 template <typename Executor>
+#else // defined(GENERATING_DOCUMENTATION)
+template <typename Executor, typename>
+#endif // defined(GENERATING_DOCUMENTATION)
 class executor_work_guard
 {
 public:
@@ -108,10 +124,102 @@ private:
   bool owns_;
 };
 
+#if !defined(GENERATING_DOCUMENTATION)
+
+template <typename Executor>
+class executor_work_guard<Executor,
+    typename enable_if<
+      !is_executor<Executor>::value && execution::is_executor<Executor>::value
+    >::type>
+{
+public:
+  typedef Executor executor_type;
+
+  explicit executor_work_guard(const executor_type& e) ASIO_NOEXCEPT
+    : executor_(e),
+      owns_(true)
+  {
+    new (&work_) work_type(asio::prefer(executor_,
+          execution::outstanding_work.tracked));
+  }
+
+  executor_work_guard(const executor_work_guard& other) ASIO_NOEXCEPT
+    : executor_(other.executor_),
+      owns_(other.owns_)
+  {
+    if (owns_)
+    {
+      new (&work_) work_type(asio::prefer(executor_,
+            execution::outstanding_work.tracked));
+    }
+  }
+
+#if defined(ASIO_HAS_MOVE)
+  executor_work_guard(executor_work_guard&& other) ASIO_NOEXCEPT
+    : executor_(ASIO_MOVE_CAST(Executor)(other.executor_)),
+      owns_(other.owns_)
+  {
+    if (owns_)
+    {
+      new (&work_) work_type(
+          ASIO_MOVE_CAST(work_type)(
+            *static_cast<work_type*>(
+              static_cast<void*>(&other.work_))));
+      other.owns_ = false;
+    }
+  }
+#endif //  defined(ASIO_HAS_MOVE)
+
+  ~executor_work_guard()
+  {
+    if (owns_)
+      static_cast<work_type*>(static_cast<void*>(&work_))->~work_type();
+  }
+
+  executor_type get_executor() const ASIO_NOEXCEPT
+  {
+    return executor_;
+  }
+
+  bool owns_work() const ASIO_NOEXCEPT
+  {
+    return owns_;
+  }
+
+  void reset() ASIO_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 typename decay<
+      typename prefer_result<
+        const executor_type&,
+        execution::outstanding_work_t::tracked_t
+      >::type
+    >::type work_type;
+
+  executor_type executor_;
+  typename aligned_storage<sizeof(work_type),
+      alignment_of<work_type>::value>::type work_;
+  bool owns_;
+};
+
+#endif // !defined(GENERATING_DOCUMENTATION)
+
 /// Create an @ref executor_work_guard object.
 template <typename Executor>
 inline executor_work_guard<Executor> make_work_guard(const Executor& ex,
-    typename enable_if<is_executor<Executor>::value>::type* = 0)
+    typename enable_if<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type* = 0)
 {
   return executor_work_guard<Executor>(ex);
 }
@@ -121,7 +229,8 @@ template <typename ExecutionContext>
 inline executor_work_guard<typename ExecutionContext::executor_type>
 make_work_guard(ExecutionContext& ctx,
     typename enable_if<
-      is_convertible<ExecutionContext&, execution_context&>::value>::type* = 0)
+      is_convertible<ExecutionContext&, execution_context&>::value
+    >::type* = 0)
 {
   return executor_work_guard<typename ExecutionContext::executor_type>(
       ctx.get_executor());
@@ -131,8 +240,10 @@ make_work_guard(ExecutionContext& ctx,
 template <typename T>
 inline executor_work_guard<typename associated_executor<T>::type>
 make_work_guard(const T& t,
-    typename enable_if<!is_executor<T>::value &&
-      !is_convertible<T&, execution_context&>::value>::type* = 0)
+    typename enable_if<
+      !is_executor<T>::value && !execution::is_executor<T>::value
+        && !is_convertible<T&, execution_context&
+    >::value>::type* = 0)
 {
   return executor_work_guard<typename associated_executor<T>::type>(
       associated_executor<T>::get(t));
@@ -142,7 +253,9 @@ make_work_guard(const T& t,
 template <typename T, typename Executor>
 inline executor_work_guard<typename associated_executor<T, Executor>::type>
 make_work_guard(const T& t, const Executor& ex,
-    typename enable_if<is_executor<Executor>::value>::type* = 0)
+    typename enable_if<
+      is_executor<Executor>::value || execution::is_executor<Executor>::value
+    >::type* = 0)
 {
   return executor_work_guard<typename associated_executor<T, Executor>::type>(
       associated_executor<T, Executor>::get(t, ex));
@@ -153,9 +266,11 @@ template <typename T, typename ExecutionContext>
 inline executor_work_guard<typename associated_executor<T,
   typename ExecutionContext::executor_type>::type>
 make_work_guard(const T& t, ExecutionContext& ctx,
-    typename enable_if<!is_executor<T>::value &&
-      !is_convertible<T&, execution_context&>::value &&
-      is_convertible<ExecutionContext&, execution_context&>::value>::type* = 0)
+    typename enable_if<
+      !is_executor<T>::value && !execution::is_executor<T>::value
+        && !is_convertible<T&, execution_context&>::value
+        && is_convertible<ExecutionContext&, execution_context&>::value
+    >::type* = 0)
 {
   return executor_work_guard<typename associated_executor<T,
     typename ExecutionContext::executor_type>::type>(
@@ -167,4 +282,6 @@ make_work_guard(const T& t, ExecutionContext& ctx,
 
 #include "asio/detail/pop_options.hpp"
 
+#endif // !defined(ASIO_NO_TS_EXECUTORS)
+
 #endif // ASIO_EXECUTOR_WORK_GUARD_HPP

data/ext/third_party/asio/asio/include/asio/handler_alloc_hook.hpp

@@ -22,7 +22,30 @@
 
 namespace asio {
 
-/// Default allocation function for handlers.
+#if defined(ASIO_NO_DEPRECATED)
+
+// Places in asio that would have previously called the allocate or deallocate
+// hooks to manage memory, now call them only to check whether the result types
+// are these types. If the result is not the correct type, it indicates that
+// the user code still has the old hooks in place, and if so we want to trigger
+// a compile error.
+enum asio_handler_allocate_is_no_longer_used {};
+enum asio_handler_deallocate_is_no_longer_used {};
+
+typedef asio_handler_allocate_is_no_longer_used
+  asio_handler_allocate_is_deprecated;
+typedef asio_handler_deallocate_is_no_longer_used
+  asio_handler_deallocate_is_deprecated;
+
+#else // defined(ASIO_NO_DEPRECATED)
+
+typedef void* asio_handler_allocate_is_deprecated;
+typedef void asio_handler_deallocate_is_deprecated;
+
+#endif // defined(ASIO_NO_DEPRECATED)
+
+/// (Deprecated: Use the associated_allocator trait.) Default allocation
+/// function for handlers.
 /**
  * Asynchronous operations may need to allocate temporary objects. Since
  * asynchronous operations have a handler function object, these temporary
@@ -54,8 +77,8 @@ namespace asio {
  * }
  * @endcode
  */
-ASIO_DECL void* asio_handler_allocate(
-    std::size_t size, ...);
+ASIO_DECL asio_handler_allocate_is_deprecated
+asio_handler_allocate(std::size_t size, ...);
 
 /// Default deallocation function for handlers.
 /**
@@ -67,8 +90,8 @@ ASIO_DECL void* asio_handler_allocate(
  *
  * @sa asio_handler_allocate.
  */
-ASIO_DECL void asio_handler_deallocate(
-    void* pointer, std::size_t size, ...);
+ASIO_DECL asio_handler_deallocate_is_deprecated
+asio_handler_deallocate(void* pointer, std::size_t size, ...);
 
 } // namespace asio
 

data/ext/third_party/asio/asio/include/asio/handler_invoke_hook.hpp

@@ -23,7 +23,8 @@ namespace asio {
 
 /** @defgroup asio_handler_invoke asio::asio_handler_invoke
  *
- * @brief Default invoke function for handlers.
+ * @brief (Deprecated: Use the associated_executor trait.) Default invoke
+ * function for handlers.
  *
  * Completion handlers for asynchronous operations are invoked by the
  * io_context associated with the corresponding object (e.g. a socket or
@@ -61,19 +62,44 @@ namespace asio {
  */
 /*@{*/
 
+#if defined(ASIO_NO_DEPRECATED)
+
+// Places in asio that would have previously called the invocation hook to
+// execute a handler, now call it only to check whether the result type is this
+// type. If the result is not this type, it indicates that the user code still
+// has the old hooks in place, and if so we want to trigger a compile error.
+enum asio_handler_invoke_is_no_longer_used {};
+
+typedef asio_handler_invoke_is_no_longer_used
+  asio_handler_invoke_is_deprecated;
+
+#else // defined(ASIO_NO_DEPRECATED)
+
+typedef void asio_handler_invoke_is_deprecated;
+
+#endif // defined(ASIO_NO_DEPRECATED)
+
 /// Default handler invocation hook used for non-const function objects.
 template <typename Function>
-inline void asio_handler_invoke(Function& function, ...)
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(Function& function, ...)
 {
   function();
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
 }
 
 /// Default handler invocation hook used for const function objects.
 template <typename Function>
-inline void asio_handler_invoke(const Function& function, ...)
+inline asio_handler_invoke_is_deprecated
+asio_handler_invoke(const Function& function, ...)
 {
   Function tmp(function);
   tmp();
+#if defined(ASIO_NO_DEPRECATED)
+  return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
 }
 
 /*@}*/

data/ext/third_party/asio/asio/include/asio/impl/awaitable.hpp

@@ -404,6 +404,19 @@ protected:
 } // namespace asio
 
 #if !defined(GENERATING_DOCUMENTATION)
+# if defined(ASIO_HAS_STD_COROUTINE)
+
+namespace std {
+
+template <typename T, typename Executor, typename... Args>
+struct coroutine_traits<asio::awaitable<T, Executor>, Args...>
+{
+  typedef asio::detail::awaitable_frame<T, Executor> promise_type;
+};
+
+} // namespace std
+
+# else // defined(ASIO_HAS_STD_COROUTINE)
 
 namespace std { namespace experimental {
 
@@ -415,6 +428,7 @@ struct coroutine_traits<asio::awaitable<T, Executor>, Args...>
 
 }} // namespace std::experimental
 
+# endif // defined(ASIO_HAS_STD_COROUTINE)
 #endif // !defined(GENERATING_DOCUMENTATION)
 
 #include "asio/detail/pop_options.hpp"

data/ext/third_party/asio/asio/include/asio/impl/buffered_read_stream.hpp

@@ -101,19 +101,29 @@ namespace detail
   };
 
   template <typename ReadHandler>
-  inline void* asio_handler_allocate(std::size_t size,
+  inline asio_handler_allocate_is_deprecated
+  asio_handler_allocate(std::size_t size,
       buffered_fill_handler<ReadHandler>* this_handler)
   {
+#if defined(ASIO_NO_DEPRECATED)
+    asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+    return asio_handler_allocate_is_no_longer_used();
+#else // defined(ASIO_NO_DEPRECATED)
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename ReadHandler>
-  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+  inline asio_handler_deallocate_is_deprecated
+  asio_handler_deallocate(void* pointer, std::size_t size,
       buffered_fill_handler<ReadHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename ReadHandler>
@@ -125,19 +135,27 @@ namespace detail
   }
 
   template <typename Function, typename ReadHandler>
-  inline void asio_handler_invoke(Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(Function& function,
       buffered_fill_handler<ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Function, typename ReadHandler>
-  inline void asio_handler_invoke(const Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(const Function& function,
       buffered_fill_handler<ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Stream>
@@ -312,21 +330,31 @@ namespace detail
   };
 
   template <typename MutableBufferSequence, typename ReadHandler>
-  inline void* asio_handler_allocate(std::size_t size,
+  inline asio_handler_allocate_is_deprecated
+  asio_handler_allocate(std::size_t size,
       buffered_read_some_handler<
         MutableBufferSequence, ReadHandler>* this_handler)
   {
+#if defined(ASIO_NO_DEPRECATED)
+    asio_handler_alloc_helpers::allocate(size, this_handler->handler_);
+    return asio_handler_allocate_is_no_longer_used();
+#else // defined(ASIO_NO_DEPRECATED)
     return asio_handler_alloc_helpers::allocate(
         size, this_handler->handler_);
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename MutableBufferSequence, typename ReadHandler>
-  inline void asio_handler_deallocate(void* pointer, std::size_t size,
+  inline asio_handler_deallocate_is_deprecated
+  asio_handler_deallocate(void* pointer, std::size_t size,
       buffered_read_some_handler<
         MutableBufferSequence, ReadHandler>* this_handler)
   {
     asio_handler_alloc_helpers::deallocate(
         pointer, size, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_deallocate_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename MutableBufferSequence, typename ReadHandler>
@@ -340,22 +368,30 @@ namespace detail
 
   template <typename Function, typename MutableBufferSequence,
       typename ReadHandler>
-  inline void asio_handler_invoke(Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(Function& function,
       buffered_read_some_handler<
         MutableBufferSequence, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Function, typename MutableBufferSequence,
       typename ReadHandler>
-  inline void asio_handler_invoke(const Function& function,
+  inline asio_handler_invoke_is_deprecated
+  asio_handler_invoke(const Function& function,
       buffered_read_some_handler<
         MutableBufferSequence, ReadHandler>* this_handler)
   {
     asio_handler_invoke_helpers::invoke(
         function, this_handler->handler_);
+#if defined(ASIO_NO_DEPRECATED)
+    return asio_handler_invoke_is_no_longer_used();
+#endif // defined(ASIO_NO_DEPRECATED)
   }
 
   template <typename Stream>