couchbase 4.2.0 → 4.2.1

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/experimental/detail/completion_handler_erasure.hpp

@@ -2,8 +2,8 @@
 // experimental/detail/completion_handler_erasure.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2021 Klemens D. Morgenstern
-//                    (klemens dot morgenstern at gmx dot net)
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
 //
 // 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)
@@ -12,6 +12,7 @@
 #ifndef ASIO_EXPERIMENTAL_DETAIL_COMPLETION_HANDLER_ERASURE_HPP
 #define ASIO_EXPERIMENTAL_DETAIL_COMPLETION_HANDLER_ERASURE_HPP
 
+#include <new>
 #include "asio/associated_allocator.hpp"
 #include "asio/dispatch.hpp"
 
@@ -28,7 +29,7 @@ struct completion_handler_erasure_base;
 template<typename Func, typename Signature, typename Executor>
 struct completion_handler_erasure_impl;
 
-template<typename Return,  typename ... Args, typename Executor>
+template<typename Return, typename... Args, typename Executor>
 struct completion_handler_erasure_base<Return(Args...), Executor>
 {
   Executor executor;
@@ -38,23 +39,83 @@ struct completion_handler_erasure_base<Return(Args...), Executor>
   {
   }
 
-  virtual Return call(Args ...args) = 0;
+  virtual Return call(Args... args) = 0;
+  virtual void destroy() = 0;
   virtual ~completion_handler_erasure_base() = default;
 };
 
-template<typename Func, typename Return,  typename ... Args, typename Executor>
+template<typename Func, typename Return, typename... Args, typename Executor>
 struct completion_handler_erasure_impl<Func, Return(Args...), Executor> final
     : completion_handler_erasure_base<Return(Args...), Executor>
 {
+  using allocator_base = typename associated_allocator<Func>::type;
+  using allocator_type =
+    typename std::allocator_traits<allocator_base>::template rebind_alloc<
+      completion_handler_erasure_impl>;
+
   completion_handler_erasure_impl(Executor&& exec, Func&& func)
     : completion_handler_erasure_base<Return(Args...), Executor>(
         std::move(exec)), func(std::move(func))
   {
   }
 
-  virtual Return call(Args ...args) override
+  struct uninit_deleter_t
+  {
+    allocator_type allocator;
+
+    uninit_deleter_t(const Func& func)
+      : allocator(get_associated_allocator(func))
+    {
+    }
+
+    void operator()(completion_handler_erasure_impl* p)
+    {
+      std::allocator_traits<allocator_type>::deallocate(allocator, p, 1);
+    }
+  };
+
+  static completion_handler_erasure_impl* make(Executor exec, Func&& func)
+  {
+    uninit_deleter_t deleter(func);
+    std::unique_ptr<completion_handler_erasure_impl, uninit_deleter_t>
+      uninit_ptr(std::allocator_traits<allocator_type>::allocate(
+            deleter.allocator, 1), deleter);
+    completion_handler_erasure_impl* ptr =
+      new (uninit_ptr.get()) completion_handler_erasure_impl(
+        std::move(exec), std::move(func));
+    uninit_ptr.release();
+    return ptr;
+  }
+
+  struct deleter_t
+  {
+    allocator_type allocator;
+
+    deleter_t(const Func& func)
+      : allocator(get_associated_allocator(func))
+    {
+    }
+
+    void operator()(completion_handler_erasure_impl* p)
+    {
+      std::allocator_traits<allocator_type>::destroy(allocator, p);
+      std::allocator_traits<allocator_type>::deallocate(allocator, p, 1);
+    }
+  };
+
+  virtual Return call(Args... args) override
+  {
+    std::unique_ptr<completion_handler_erasure_impl,
+      deleter_t> p(this, deleter_t(func));
+    Func f(std::move(func));
+    p.reset();
+    std::move(f)(std::move(args)...);
+  }
+
+  virtual void destroy() override
   {
-    std::move(func)(std::move(args)...);
+    std::unique_ptr<completion_handler_erasure_impl,
+      deleter_t>(this, deleter_t(func));
   }
 
   Func func;
@@ -63,43 +124,15 @@ struct completion_handler_erasure_impl<Func, Return(Args...), Executor> final
 template<typename Signature, typename Executor = any_io_executor>
 struct completion_handler_erasure;
 
-template<typename Return,  typename ... Args, typename Executor>
+template<typename Return, typename... Args, typename Executor>
 struct completion_handler_erasure<Return(Args...), Executor>
 {
   struct deleter_t
   {
-    using allocator_base = typename associated_allocator<Executor>::type;
-    using allocator_type =
-      typename std::allocator_traits<allocator_base>::template rebind_alloc<
-        completion_handler_erasure_base<Return(Args...), Executor>>;
-
-    allocator_type allocator;
-    std::size_t size;
-
-    template<typename Func>
-    static std::unique_ptr<
-        completion_handler_erasure_base<Return(Args...), Executor>, deleter_t>
-    make(Executor exec, Func&& func)
-    {
-      using type = completion_handler_erasure_impl<
-          std::remove_reference_t<Func>, Return(Args...), Executor>;
-      using alloc_type =  typename std::allocator_traits<
-          allocator_base>::template rebind_alloc<type>;
-      auto alloc = alloc_type(get_associated_allocator(exec));
-      auto size = sizeof(type);
-      auto p = std::allocator_traits<alloc_type>::allocate(alloc, size);
-      auto res = std::unique_ptr<type, deleter_t>(
-          p, deleter_t{allocator_type(alloc), size});
-      std::allocator_traits<alloc_type>::construct(alloc,
-          p, std::move(exec), std::forward<Func>(func));
-      return res;
-    }
-
     void operator()(
-        completion_handler_erasure_base<Return(Args...), Executor> * p)
+        completion_handler_erasure_base<Return(Args...), Executor>* p)
     {
-      std::allocator_traits<allocator_type>::destroy(allocator, p);
-      std::allocator_traits<allocator_type>::deallocate(allocator, p, size);
+      p->destroy();
     }
   };
 
@@ -119,26 +152,29 @@ struct completion_handler_erasure<Return(Args...), Executor>
 
   template<typename Func>
   completion_handler_erasure(Executor exec, Func&& func)
-    : impl_(deleter_t::make(std::move(exec), std::forward<Func>(func)))
+    : impl_(completion_handler_erasure_impl<
+        std::decay_t<Func>, Return(Args...), Executor>::make(
+          std::move(exec), std::forward<Func>(func)))
   {
   }
 
   ~completion_handler_erasure()
   {
-    if (auto f = std::exchange(impl_, nullptr); f != nullptr)
+    if (impl_)
     {
-      asio::dispatch(f->executor,
-          [f = std::move(f)]() mutable
+      Executor executor(impl_->executor);
+      asio::dispatch(executor,
+          [impl = std::move(impl_)]() mutable
           {
-            std::move(f)->call(Args{}...);
+            impl.reset();
           });
     }
   }
 
-  Return operator()(Args ... args)
+  Return operator()(Args... args)
   {
-    if (auto f = std::exchange(impl_, nullptr); f != nullptr)
-      f->call(std::move(args)...);
+    if (impl_)
+      impl_.release()->call(std::move(args)...);
   }
 
   constexpr bool operator==(nullptr_t) const noexcept {return impl_ == nullptr;}

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/experimental/detail/coro_promise_allocator.hpp

@@ -2,8 +2,8 @@
 // experimental/detail/coro_promise_allocator.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2021 Klemens D. Morgenstern
-//                    (klemens dot morgenstern at gmx dot net)
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
 //
 // 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)

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/experimental/detail/has_signature.hpp

@@ -2,7 +2,7 @@
 // experimental/detail/has_signature.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 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)

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/experimental/detail/impl/channel_service.hpp

@@ -2,7 +2,7 @@
 // experimental/detail/impl/channel_service.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 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)
@@ -181,10 +181,8 @@ void channel_service<Mutex>::reset(
 
   typename Mutex::scoped_lock lock(impl.mutex_);
 
-  if (impl.receive_state_ == closed)
-    impl.receive_state_ = block;
-  if (impl.send_state_ == closed)
-    impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
+  impl.receive_state_ = block;
+  impl.send_state_ = impl.max_buffer_size_ ? buffer : block;
   impl.buffer_clear();
 }
 
@@ -204,11 +202,11 @@ void channel_service<Mutex>::close(
   {
     while (channel_operation* op = impl.waiters_.front())
     {
+      impl.waiters_.pop();
       traits_type::invoke_receive_closed(
           complete_receive<payload_type,
             typename traits_type::receive_closed_signature>(
               static_cast<channel_receive<payload_type>*>(op)));
-      impl.waiters_.pop();
     }
   }
 
@@ -237,11 +235,11 @@ void channel_service<Mutex>::cancel(
     }
     else
     {
+      impl.waiters_.pop();
       traits_type::invoke_receive_cancelled(
           complete_receive<payload_type,
             typename traits_type::receive_cancelled_signature>(
               static_cast<channel_receive<payload_type>*>(op)));
-      impl.waiters_.pop();
     }
   }
 
@@ -276,11 +274,11 @@ void channel_service<Mutex>::cancel_by_key(
       }
       else
       {
+        impl.waiters_.pop();
         traits_type::invoke_receive_cancelled(
             complete_receive<payload_type,
               typename traits_type::receive_cancelled_signature>(
                 static_cast<channel_receive<payload_type>*>(op)));
-        impl.waiters_.pop();
       }
     }
     else

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/experimental/detail/partial_promise.hpp

@@ -2,8 +2,8 @@
 // experimental/detail/partial_promise.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2021 Klemens D. Morgenstern
-//                    (klemens dot morgenstern at gmx dot net)
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
 //
 // 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)

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/experimental/impl/as_single.hpp

@@ -2,7 +2,7 @@
 // experimental/impl/as_single.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 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)

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/experimental/impl/channel_error.ipp

@@ -2,7 +2,7 @@
 // experimental/impl/channel_error.ipp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 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)

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/experimental/impl/coro.hpp

@@ -2,8 +2,8 @@
 // experimental/impl/coro.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2021 Klemens D. Morgenstern
-//                    (klemens dot morgenstern at gmx dot net)
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
 //
 // 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)
@@ -94,22 +94,22 @@ struct coro_error<asio::error_code>
 {
   static asio::error_code invalid()
   {
-    return error::fault;
+    return asio::error::fault;
   }
 
   static asio::error_code cancelled()
   {
-    return error::operation_aborted;
+    return asio::error::operation_aborted;
   }
 
   static asio::error_code interrupted()
   {
-    return error::interrupted;
+    return asio::error::interrupted;
   }
 
   static asio::error_code done()
   {
-    return error::broken_pipe;
+    return asio::error::broken_pipe;
   }
 };
 
@@ -212,7 +212,7 @@ struct coro_with_arg
 
           void operator()(cancellation_type ct)
           {
-            asio::dispatch(e, [ct, p = coro_, st = st]() mutable
+            asio::dispatch(e, [ct, st = st]() mutable
             {
               auto & [sig, state] = *st;
               sig.emit(ct);
@@ -989,13 +989,13 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
   typedef Executor executor_type;
 
   explicit initiate_async_resume(coro* self)
-    : self_(self)
+    : coro_(self->coro_)
   {
   }
 
   executor_type get_executor() const noexcept
   {
-    return self_->get_executor();
+    return coro_->get_executor();
   }
 
   template <typename E, typename WaitHandler>
@@ -1003,19 +1003,17 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
       std::true_type /* error is noexcept */,
       std::true_type /* result is void */)  //noexcept
   {
-    return [this, self = self_,
+    return [this, coro = coro_,
         h = std::forward<WaitHandler>(handler),
         exec = std::move(exec)]() mutable
     {
-      assert(self);
+      assert(coro);
 
-      auto ch =
-        detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
+      auto ch = detail::coroutine_handle<promise_type>::from_promise(*coro);
       assert(ch && !ch.done());
-      assert(self->coro_->awaited_from == detail::noop_coroutine());
 
-      self->coro_->awaited_from = post_coroutine(std::move(exec), std::move(h));
-      self->coro_->reset_error();
+      coro->awaited_from = post_coroutine(std::move(exec), std::move(h));
+      coro->reset_error();
       ch.resume();
     };
   }
@@ -1023,26 +1021,24 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
   template <typename E, typename WaitHandler>
   requires (!std::is_void_v<result_type>)
   auto handle(E exec, WaitHandler&& handler,
-              std::true_type /* error is noexcept */,
-              std::false_type  /* result is void */)  //noexcept
+      std::true_type /* error is noexcept */,
+      std::false_type  /* result is void */)  //noexcept
   {
-    return [self = self_,
+    return [coro = coro_,
         h = std::forward<WaitHandler>(handler),
         exec = std::move(exec)]() mutable
     {
-      assert(self);
+      assert(coro);
 
-      auto ch =
-        detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
+      auto ch = detail::coroutine_handle<promise_type>::from_promise(*coro);
       assert(ch && !ch.done());
-      assert(self->coro_->awaited_from == detail::noop_coroutine());
 
-      self->coro_->awaited_from = detail::post_coroutine(exec,
-          [self, h = std::move(h)]() mutable
+      coro->awaited_from = detail::post_coroutine(exec,
+          [coro, h = std::move(h)]() mutable
           {
-            std::move(h)(std::move(self->coro_->result_));
+            std::move(h)(std::move(coro->result_));
           });
-      self->coro_->reset_error();
+      coro->reset_error();
       ch.resume();
     };
   }
@@ -1052,11 +1048,11 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
       std::false_type /* error is noexcept */,
       std::true_type /* result is void */)
   {
-    return [self = self_,
+    return [coro = coro_,
         h = std::forward<WaitHandler>(handler),
         exec = std::move(exec)]() mutable
     {
-      if (!self)
+      if (!coro)
       {
         asio::post(exec,
             [h = std::move(h)]() mutable
@@ -1066,8 +1062,7 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
         return;
       }
 
-      auto ch =
-        detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
+      auto ch = detail::coroutine_handle<promise_type>::from_promise(*coro);
       if (!ch)
       {
         asio::post(exec,
@@ -1086,14 +1081,13 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
       }
       else
       {
-        assert(self->coro_->awaited_from == detail::noop_coroutine());
-        self->coro_->awaited_from =
+        coro->awaited_from =
           detail::post_coroutine(exec,
-              [self, h = std::move(h)]() mutable
+              [coro, h = std::move(h)]() mutable
               {
-                std::move(h)(std::move(self->coro_->error_));
+                std::move(h)(std::move(coro->error_));
               });
-        self->coro_->reset_error();
+        coro->reset_error();
         ch.resume();
       }
     };
@@ -1104,11 +1098,11 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
       std::false_type /* error is noexcept */,
       std::false_type  /* result is void */)
   {
-    return [self = self_,
+    return [coro = coro_,
         h = std::forward<WaitHandler>(handler),
         exec = std::move(exec)]() mutable
     {
-      if (!self)
+      if (!coro)
       {
         asio::post(exec,
             [h = std::move(h)]() mutable
@@ -1119,7 +1113,7 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
       }
 
       auto ch =
-        detail::coroutine_handle<promise_type>::from_promise(*self->coro_);
+        detail::coroutine_handle<promise_type>::from_promise(*coro);
       if (!ch)
       {
         asio::post(exec,
@@ -1138,16 +1132,15 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
       }
       else
       {
-        assert(self->coro_->awaited_from == detail::noop_coroutine());
-        self->coro_->awaited_from =
+        coro->awaited_from =
           detail::post_coroutine(exec,
-              [h = std::move(h), self]() mutable
+              [h = std::move(h), coro]() mutable
               {
                 std::move(h)(
-                    std::move(self->coro_->error_),
-                    std::move(self->coro_->result_));
+                    std::move(coro->error_),
+                    std::move(coro->result_));
               });
-        self->coro_->reset_error();
+        coro->reset_error();
         ch.resume();
       }
     };
@@ -1160,10 +1153,9 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
         get_associated_executor(handler, get_executor()),
         execution::outstanding_work.tracked);
 
-    auto c = self_->coro_;
-    c->cancel = &c->cancel_source.emplace();
-    c->cancel->state = cancellation_state(
-        c->cancel->slot = get_associated_cancellation_slot(handler));
+    coro_->cancel = &coro_->cancel_source.emplace();
+    coro_->cancel->state = cancellation_state(
+        coro_->cancel->slot = get_associated_cancellation_slot(handler));
     asio::dispatch(get_executor(),
         handle(exec, std::forward<WaitHandler>(handler),
           std::integral_constant<bool, is_noexcept>{},
@@ -1177,23 +1169,22 @@ struct coro<Yield, Return, Executor>::initiate_async_resume
         get_associated_executor(handler, get_executor()),
         execution::outstanding_work.tracked);
 
-    auto c = self_->coro_;
-    c->cancel = &c->cancel_source.emplace();
-    c->cancel->state = cancellation_state(
-        c->cancel->slot = get_associated_cancellation_slot(handler));
+    coro_->cancel = &coro_->cancel_source.emplace();
+    coro_->cancel->state = cancellation_state(
+        coro_->cancel->slot = get_associated_cancellation_slot(handler));
     asio::dispatch(get_executor(),
         [h = handle(exec, std::forward<WaitHandler>(handler),
             std::integral_constant<bool, is_noexcept>{},
             std::is_void<result_type>{}),
-            in = std::forward<Input>(input), self = self_]() mutable
+            in = std::forward<Input>(input), coro = coro_]() mutable
         {
-          self->coro_->input_ = std::move(in);
+          coro->input_ = std::move(in);
           std::move(h)();
         });
   }
 
 private:
-  coro* self_;
+  typename coro::promise_type* coro_;
 };
 
 } // namespace experimental

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/experimental/impl/parallel_group.hpp

@@ -2,7 +2,7 @@
 // experimental/impl/parallel_group.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com)
+// Copyright (c) 2003-2022 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)
@@ -106,11 +106,11 @@ struct parallel_group_completion_handler
 
   void operator()()
   {
-    this->invoke(std::make_index_sequence<sizeof...(Ops)>());
+    this->invoke(asio::detail::make_index_sequence<sizeof...(Ops)>());
   }
 
   template <std::size_t... I>
-  void invoke(std::index_sequence<I...>)
+  void invoke(asio::detail::index_sequence<I...>)
   {
     this->invoke(std::tuple_cat(std::move(std::get<I>(args_).get())...));
   }
@@ -118,11 +118,13 @@ struct parallel_group_completion_handler
   template <typename... Args>
   void invoke(std::tuple<Args...>&& args)
   {
-    this->invoke(std::move(args), std::make_index_sequence<sizeof...(Args)>());
+    this->invoke(std::move(args),
+        asio::detail::index_sequence_for<Args...>());
   }
 
   template <typename... Args, std::size_t... I>
-  void invoke(std::tuple<Args...>&& args, std::index_sequence<I...>)
+  void invoke(std::tuple<Args...>&& args,
+      asio::detail::index_sequence<I...>)
   {
     std::move(handler_)(completion_order_, std::move(std::get<I>(args))...);
   }
@@ -133,7 +135,7 @@ struct parallel_group_completion_handler
   std::tuple<
       parallel_group_op_result<
         typename parallel_op_signature_as_tuple<
-          typename parallel_op_signature<Ops>::type
+          typename completion_signature_of<Ops>::type
         >::type
       >...
     > args_{};
@@ -344,18 +346,19 @@ struct parallel_group_cancellation_handler
     // yet completed and requested cancellation, emit a signal for each
     // operation in the group.
     if (cancel_type != cancellation_type::none)
-      if (state_->cancellations_requested_++ == 0)
-        for (std::size_t i = 0; i < sizeof...(Ops); ++i)
-          state_->cancellation_signals_[i].emit(cancel_type);
+      if (auto state = state_.lock())
+        if (state->cancellations_requested_++ == 0)
+          for (std::size_t i = 0; i < sizeof...(Ops); ++i)
+            state->cancellation_signals_[i].emit(cancel_type);
   }
 
-  std::shared_ptr<parallel_group_state<Condition, Handler, Ops...> > state_;
+  std::weak_ptr<parallel_group_state<Condition, Handler, Ops...> > state_;
 };
 
 template <typename Condition, typename Handler,
     typename... Ops, std::size_t... I>
 void parallel_group_launch(Condition cancellation_condition, Handler handler,
-    std::tuple<Ops...>& ops, std::index_sequence<I...>)
+    std::tuple<Ops...>& ops, asio::detail::index_sequence<I...>)
 {
   // Get the user's completion handler's cancellation slot, so that we can allow
   // cancellation of the entire group.
@@ -392,23 +395,6 @@ void parallel_group_launch(Condition cancellation_condition, Handler handler,
 } // namespace detail
 } // namespace experimental
 
-template <typename R, typename... Args>
-class async_result<
-    experimental::detail::parallel_op_signature_probe,
-    R(Args...)>
-{
-public:
-  typedef experimental::detail::parallel_op_signature_probe_result<
-    void(Args...)> return_type;
-
-  template <typename Initiation, typename... InitArgs>
-  static return_type initiate(Initiation&&,
-      experimental::detail::parallel_op_signature_probe, InitArgs&&...)
-  {
-    return return_type{};
-  }
-};
-
 template <template <typename, typename> class Associator,
     typename Handler, typename... Ops, typename DefaultCandidate>
 struct associator<Associator,

package/deps/couchbase-cxx-client/third_party/asio/asio/include/asio/experimental/impl/promise.hpp

@@ -2,8 +2,8 @@
 // experimental/impl/promise.hpp
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 //
-// Copyright (c) 2021 Klemens D. Morgenstern
-//                    (klemens dot morgenstern at gmx dot net)
+// Copyright (c) 2021-2022 Klemens D. Morgenstern
+//                         (klemens dot morgenstern at gmx dot net)
 //
 // 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)