couchbase 4.2.0 → 4.2.1

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/overview/promises.qbk

@@ -0,0 +1,96 @@
+[/
+ / 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)
+ /]
+
+[section:promises Promises]
+
+[note This is an experimental feature.]
+
+The [link asio.reference.experimental__promise_lt__void_lp_Ts_ellipsis__rp__comma__Executor__gt_
+`experimental::promise`] type and [link asio.reference.experimental__use_promise
+`experimental::use_promise`] completion token allow eager execution and
+synchronisation of asynchronous operations. For example:
+
+  auto promise = async_read(
+      stream, asio::buffer(my_buffer),
+      asio::experimental::use_promise);
+
+  ... do other stuff while the read is going on ...
+
+  promise.async_wait( // completion the operation
+      [](error_code ec, std::size_t bytes_read)
+      {
+        ...
+      });
+
+Promises can be safely disregarded if the result is no longer required.
+Different operations can be combined to either wait for all to complete or for
+one to complete (and cancel the rest). For example, to wait for one to
+complete:
+
+  auto timeout_promise =
+    timer.async_wait(
+      asio::experimental::use_promise);
+
+  auto read_promise = async_read(
+      stream, asio::buffer(my_buffer),
+      asio::experimental::use_promise);
+
+  auto promise =
+    asio::experimental::make_parallel_group(
+      timeout_promise.async_wait(asio::deferred),
+      read_promise.async_wait(asio::deferred)
+    ).async_wait(
+      asio::experimental::wait_for_one(),
+      asio::experimental::use_promise);
+
+  promise.async_wait(
+      [](std::array<std::size_t, 2> order,
+         error_code timer_ec,
+         error_code read_ec, std::size_t read_size)
+      {
+        if (order[0] == 0)
+        {
+          // timed out
+        }
+        else
+        {
+          // completed in time
+        }
+      });
+
+or to wait for all to complete:
+
+  auto write_promise = async_write(
+      stream, asio::buffer(my_write_buffer),
+      asio::experimental::use_promise);
+
+  auto read_promise = async_read(
+      stream, asio::buffer(my_buffer),
+      asio::experimental::use_promise);
+
+  auto promise =
+    asio::experimental::make_parallel_group(
+      timeout_promise.async_wait(asio::deferred),
+      read_promise.async_wait(asio::deferred)
+    ).async_wait(
+      asio::experimental::wait_for_all(),
+      asio::experimental::use_promise);
+
+  promise.async_wait(
+      [](std::array<std::size_t, 2> order,
+         error_code timer_ec,
+         error_code read_ec, std::size_t read_size)
+      {
+        // ...
+      });
+
+[heading See Also]
+
+[link asio.reference.experimental__promise_lt__void_lp_Ts_ellipsis__rp__comma__Executor__gt_ promise],
+[link asio.reference.experimental__use_promise use_promise].
+
+[endsect]

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/overview/protocols.qbk

@@ -1,5 +1,5 @@
 [/
- / 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/src/doc/overview/rationale.qbk

@@ -1,5 +1,5 @@
 [/
- / 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/src/doc/overview/reactor.qbk

@@ -1,5 +1,5 @@
 [/
- / 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/src/doc/overview/serial_ports.qbk

@@ -1,5 +1,5 @@
 [/
- / 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/src/doc/overview/signals.qbk

@@ -1,5 +1,5 @@
 [/
- / 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/src/doc/overview/spawn.qbk

@@ -1,5 +1,5 @@
 [/
- / 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)
@@ -12,7 +12,7 @@ running stackful coroutines. It is based on the Boost.Coroutine library. The
 `spawn()` function enables programs to implement asynchronous logic in a
 synchronous manner, as shown in the following example:
 
-  asio::spawn(my_strand, do_echo);
+  asio::spawn(my_strand, do_echo, asio::detached);
 
   // ...
 
@@ -37,10 +37,7 @@ synchronous manner, as shown in the following example:
     }
   }
 
-The first argument to `spawn()` may be a
-[link asio.reference.io_context__strand `strand`],
-[link asio.reference.io_context `io_context`], or
-[link asio.reference.CompletionHandler completion handler].
+The first argument to `spawn()` may be an executor or execution context.
 This argument determines the context in which the coroutine is permitted to
 execute. For example, a server's per-client object may consist of multiple
 coroutines; they should all run on the same `strand` so that no explicit
@@ -85,10 +82,10 @@ exception, associate the output variable with the `yield_context` as follows:
     my_socket.async_read_some(
       asio::buffer(data), yield[ec]);
   
-[*Note:] if `spawn()` is used with a custom completion handler of type
-`Handler`, the function object signature is actually:
+[*Note:] if `spawn()` is used with a specified executor of type `Executor`, the
+function object signature is actually:
   
-  void coroutine(asio::basic_yield_context<Handler> yield);
+  void coroutine(asio::basic_yield_context<Executor> yield);
 
 [heading See Also]
 
@@ -97,6 +94,6 @@ exception, associate the output variable with the `yield_context` as follows:
 [link asio.reference.basic_yield_context basic_yield_context],
 [link asio.examples.cpp03_examples.spawn Spawn example (C++03)],
 [link asio.examples.cpp11_examples.spawn Spawn example (C++11)],
-[link asio.overview.core.coroutine Stackless Coroutines].
+[link asio.overview.composition.coroutine Stackless Coroutines].
 
 [endsect]

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/overview/ssl.qbk

@@ -1,5 +1,5 @@
 [/
- / 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/src/doc/overview/strands.qbk

@@ -1,5 +1,5 @@
 [/
- / 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/src/doc/overview/streams.qbk

@@ -1,5 +1,5 @@
 [/
- / 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/src/doc/overview/threads.qbk

@@ -1,5 +1,5 @@
 [/
- / 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/src/doc/overview/timers.qbk

@@ -1,5 +1,5 @@
 [/
- / 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)
@@ -16,8 +16,8 @@ relative time one may write:
 
   io_context i;
   ...
-  deadline_timer t(i);
-  t.expires_from_now(boost::posix_time::seconds(5));
+  steady_timer t(i);
+  t.expires_after(chrono::seconds(5));
   t.wait();
 
 More commonly, a program will perform an asynchronous wait operation on a
@@ -27,26 +27,27 @@ timer:
   ...
   io_context i;
   ...
-  deadline_timer t(i);
-  t.expires_from_now(boost::posix_time::milliseconds(400));
+  steady_timer t(i);
+  t.expires_after(chrono::milliseconds(400));
   t.async_wait(handler);
   ...
   i.run();
 
-The deadline associated with a timer may also be obtained as a relative time:
+The deadline associated with a timer may also be obtained as an absolute time:
 
-  boost::posix_time::time_duration time_until_expiry
-    = t.expires_from_now();
+  steady_timer::time_point time_of_expiry = t.expiry();
 
-or as an absolute time to allow composition of timers:
+which allows composition of timers:
 
-  deadline_timer t2(i);
-  t2.expires_at(t.expires_at() + boost::posix_time::seconds(30));
+  steady_timer t2(i);
+  t2.expires_at(t.expiry() + chrono::seconds(30));
 
 [heading See Also]
 
-[link asio.reference.basic_deadline_timer basic_deadline_timer],
-[link asio.reference.deadline_timer deadline_timer],
+[link asio.reference.basic_waitable_timer basic_waitable_timer],
+[link asio.reference.steady_timer steady_timer],
+[link asio.reference.system_timer system_timer],
+[link asio.reference.high_resolution_timer high_resolution_timer],
 [link asio.tutorial.tuttimer1 timer tutorials].
 
 [endsect]

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/overview/token_adapters.qbk

@@ -0,0 +1,210 @@
+[/
+ / 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)
+ /]
+
+[section:token_adapters Completion Token Adapters]
+
+A ['completion token adapter] is a utility that can be generically applied to a
+[link asio.overview.model.completion_tokens completion token], to produce a new
+completion token with modified behaviour. Common uses of completion token
+adapters include:
+
+* Automatically wrapping the completion handler to add [link
+  asio.overview.model.associators associated characteristics].
+
+* Transforming the completion signature and arguments passed to the completion
+  handler.
+
+Asio includes a number of completion token adapters as described below.
+
+[heading bind_executor, bind_allocator, and bind_cancellation_slot]
+
+The [link asio.reference.bind_executor `bind_executor`] function adapts a
+completion token to imbue the completion handler with an [link
+asio.overview.model.executors associated executor].
+
+This example shows the `bind_executor` adapter applied to a lambda, to specify
+that the handler should execute in the specified strand. The arguments to the
+completion handler are passed through as-is.
+
+  my_socket.async_read_some(my_buffer,
+      asio::bind_executor(my_strand,
+        [](asio::error_code error, std::size_t bytes_transferred)
+        {
+          // ...
+        }));
+
+When applied to completion tokens that cause the initiating function to produce
+a result, such as [link asio.reference.use_awaitable `use_awaitable`], the
+result is returned unmodified.
+
+  asio::awaitable<void> my_coroutine()
+  {
+    // ...
+    std::size_t bytes_transferred =
+      co_await my_socket.async_read_some(my_buffer,
+        asio::bind_executor(my_strand, asio::use_awaitable));
+    // ...
+  }
+
+The [link asio.reference.bind_allocator `bind_allocator`] and [link
+asio.reference.bind_cancellation_slot `bind_cancellation_slot`] adapters work
+similarly, to imbue the completion handler with an [link
+asio.overview.model.allocators associated allocator] or [link
+asio.overview.model.cancellation associated cancellation slot] respectively.
+
+[heading redirect_error]
+
+The [link asio.reference.redirect_error `redirect_error`] function adapts a
+completion token to capture the `error_code` produced by an operation into a
+specified variable. In doing so, it modifies the completion signature to remove
+the initial `error_code` parameter.
+
+This example shows the `redirect_error` adapter applied to a lambda, to specify
+that the error should be captured into `my_error`. The `error_code` is no
+longer passed to the completion handler, but the remaining arguments are passed
+through as-is.
+
+  asio::error_code my_error; // N.B. must be valid until operation completes
+  // ...
+  my_socket.async_read_some(my_buffer,
+      asio::redirect_error(
+        [](std::size_t bytes_transferred)
+        {
+          // ...
+        }, my_error));
+
+When applied to completion tokens that cause the initiating function to produce
+a result, such as [link asio.reference.use_awaitable `use_awaitable`], the
+result is returned unmodified. However, if the operation fails, the `co_await`
+expression will no longer throw an exception on resumption.
+
+  asio::awaitable<void> my_coroutine()
+  {
+    // ...
+    asio::error_code my_error;
+    std::size_t bytes_transferred =
+      co_await my_socket.async_read_some(my_buffer,
+        asio::redirect_error(asio::use_awaitable, my_error));
+    // ...
+  }
+
+[heading as_tuple]
+
+The [link asio.reference.as_tuple `as_tuple`] adapter can be used to specify
+that the completion handler arguments should be combined into a single tuple
+argument.
+
+For example, the `as_tuple` adapter may be used in conjunction with [link
+asio.reference.use_awaitable `use_awaitable`] and structured bindings as
+follows:
+
+  auto [e, n] =
+    co_await my_socket.async_read_some(my_buffer,
+      asio::as_tuple(asio::use_awaitable));
+
+This adapter may also be used as a default completion token:
+
+  using default_token = asio::as_tuple_t<asio::use_awaitable_t<>>;
+  using tcp_socket = default_token::as_default_on_t<tcp::socket>;
+  // ...
+  asio::awaitable<void> do_read(tcp_socket my_socket)
+  {
+    // ...
+    auto [e, n] = co_await my_socket.async_read_some(my_buffer);
+    // ...
+  }
+
+[heading as_single]
+
+[note This is an experimental feature.]
+
+The [link asio.reference.experimental__as_single `experimental::as_single`]
+adapter can be used to specify that the completion handler
+arguments should be combined into a single argument. For completion signatures
+with a single parameter, the argument is passed through as-is. For signatures
+with two or more parameters, the arguments are combined into a tuple.
+
+For example, when applied to a timer wait operation, the single `error_code`
+argument is passed directly to the completion handler:
+
+  my_timer.async_wait(
+      asio::experimental::as_single(
+        [](asio::error_code error)
+        {
+          // ...
+        }));
+
+When applied to a socket read operation, where the completion signature
+specifies two parameters, the handler is passed the result as a tuple:
+
+  my_socket.async_read_some(my_buffer,
+      asio::experimental::as_single,
+        [](std::tuple<asio::error_code, std::size_t> result)
+        {
+          // ...
+        }));
+
+[heading append]
+
+The [link asio.reference.append `append`] completion token adapter can be
+used to pass additional completion handler arguments at the end of the
+completion signature.
+
+For example:
+
+  timer.async_wait(
+      asio::append(
+        [](std::error_code ec, int i)
+        {
+          // ...
+        },
+      42)
+    );
+
+  std::future<int> f = timer.async_wait(
+      asio::append(
+        asio::use_future,
+        42
+      )
+    );
+
+[heading prepend]
+
+The [link asio.reference.prepend `prepend`] completion token adapter can be
+used to pass additional completion handler arguments before the existing
+completion handler arguments.
+
+For example:
+
+  timer.async_wait(
+      asio::prepend(
+        [](int i, std::error_code ec)
+        {
+          // ...
+        },
+      42)
+    );
+
+  std::future<std::tuple<int, std::error_code>> f = timer.async_wait(
+      asio::prepend(
+        asio::use_future,
+        42
+      )
+    );
+
+[heading See Also]
+
+[link asio.reference.bind_executor bind_executor],
+[link asio.reference.bind_allocator bind_allocator],
+[link asio.reference.bind_cancellation_slot bind_cancellation_slot],
+[link asio.reference.redirect_error redirect_error],
+[link asio.reference.as_tuple as_tuple],
+[link asio.reference.experimental__as_single experimental::as_single],
+[link asio.reference.append append],
+[link asio.reference.prepend prepend].
+
+[endsect]

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/overview/windows.qbk

@@ -1,5 +1,5 @@
 [/
- / 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/src/doc/overview.qbk

@@ -1,5 +1,5 @@
 [/
- / 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)
@@ -8,8 +8,19 @@
 [section:overview Overview]
 
 * [link asio.overview.rationale Rationale]
+* [link asio.overview.basics Basic Asio Anatomy]
+* [link asio.overview.model Asynchronous Model]
+  * [link asio.overview.model.async_ops Asynchronous Operations]
+  * [link asio.overview.model.async_agents Asynchronous Agents]
+  * [link asio.overview.model.associators Associated Characteristics and Associators]
+  * [link asio.overview.model.child_agents Child Agents]
+  * [link asio.overview.model.executors Executors]
+  * [link asio.overview.model.allocators Allocators]
+  * [link asio.overview.model.cancellation Cancellation]
+  * [link asio.overview.model.completion_tokens Completion Tokens]
+  * [link asio.overview.model.library_elements Supporting Library Elements]
+  * [link asio.overview.model.higher_levels Higher Level Abstractions]
 * [link asio.overview.core Core Concepts and Functionality]
-  * [link asio.overview.core.basics Basic Asio Anatomy]
   * [link asio.overview.core.async The Proactor Design Pattern: Concurrency Without Threads]
   * [link asio.overview.core.threads Threads and Asio]
   * [link asio.overview.core.strands Strands: Use Threads Without Explicit Locking]
@@ -21,18 +32,28 @@
   * [link asio.overview.core.cancellation Per-Operation Cancellation]
   * [link asio.overview.core.handler_tracking Handler Tracking]
   * [link asio.overview.core.concurrency_hint Concurrency Hints]
-  * [link asio.overview.core.coroutine Stackless Coroutines]
-  * [link asio.overview.core.spawn Stackful Coroutines]
-  * [link asio.overview.core.cpp20_coroutines C++20 Coroutines Support]
-  * [link asio.overview.core.coro Resumable C++20 Coroutines (experimental)]
+* [link asio.overview.composition Composition and Completion Tokens]
+  * [link asio.overview.composition.coroutine Stackless Coroutines]
+  * [link asio.overview.composition.spawn Stackful Coroutines]
+  * [link asio.overview.composition.futures Futures]
+  * [link asio.overview.composition.cpp20_coroutines C++20 Coroutines Support]
+  * [link asio.overview.composition.coro Resumable C++20 Coroutines (experimental)]
+  * [link asio.overview.composition.deferred Deferred Operations (experimental)]
+  * [link asio.overview.composition.promises Promises (experimental)]
+  * [link asio.overview.composition.parallel_group Co-ordinating Parallel Operations (experimental)]
+  * [link asio.overview.composition.compose Compositions as Asynchronous Operations]
+  * [link asio.overview.composition.token_adapters Completion Token Adapters]
 * [link asio.overview.networking Networking]
   * [link asio.overview.networking.protocols TCP, UDP and ICMP]
   * [link asio.overview.networking.other_protocols Support for Other Protocols]
   * [link asio.overview.networking.iostreams Socket Iostreams]
   * [link asio.overview.networking.bsd_sockets The BSD Socket API and Asio]
 * [link asio.overview.timers Timers]
+* [link asio.overview.files Files]
+* [link asio.overview.pipes Pipes]
 * [link asio.overview.serial_ports Serial Ports]
 * [link asio.overview.signals Signal Handling]
+* [link asio.overview.channels Channels (experimental)]
 * [link asio.overview.posix POSIX-Specific Functionality]
   * [link asio.overview.posix.local UNIX Domain Sockets]
   * [link asio.overview.posix.stream_descriptor Stream-Oriented File Descriptors]
@@ -50,14 +71,14 @@
   * [link asio.overview.cpp2011.atomic Atomics]
   * [link asio.overview.cpp2011.shared_ptr Shared Pointers]
   * [link asio.overview.cpp2011.chrono Chrono]
-  * [link asio.overview.cpp2011.futures Futures]
 * [link asio.overview.implementation Platform-Specific Implementation Notes]
 
 [include overview/rationale.qbk]
+[include overview/basics.qbk]
+[include overview/model.qbk]
 
 [section:core Core Concepts and Functionality]
 
-* [link asio.overview.core.basics Basic Asio Anatomy]
 * [link asio.overview.core.async The Proactor Design Pattern: Concurrency Without Threads]
 * [link asio.overview.core.threads Threads and Asio]
 * [link asio.overview.core.strands Strands: Use Threads Without Explicit Locking]
@@ -69,12 +90,7 @@
 * [link asio.overview.core.cancellation Per-Operation Cancellation]
 * [link asio.overview.core.handler_tracking Handler Tracking]
 * [link asio.overview.core.concurrency_hint Concurrency Hints]
-* [link asio.overview.core.coroutine Stackless Coroutines]
-* [link asio.overview.core.spawn Stackful Coroutines]
-* [link asio.overview.core.cpp20_coroutines C++20 Coroutines Support]
-* [link asio.overview.core.coro Resumable C++20 Coroutines (experimental)]
 
-[include overview/basics.qbk]
 [include overview/async.qbk]
 [include overview/threads.qbk]
 [include overview/strands.qbk]
@@ -86,10 +102,32 @@
 [include overview/cancellation.qbk]
 [include overview/handler_tracking.qbk]
 [include overview/concurrency_hint.qbk]
+
+[endsect]
+
+[section:composition Composition and Completion Tokens]
+
+* [link asio.overview.composition.coroutine Stackless Coroutines]
+* [link asio.overview.composition.spawn Stackful Coroutines]
+* [link asio.overview.composition.futures Futures]
+* [link asio.overview.composition.cpp20_coroutines C++20 Coroutines Support]
+* [link asio.overview.composition.coro Resumable C++20 Coroutines (experimental)]
+* [link asio.overview.composition.deferred Deferred Operations (experimental)]
+* [link asio.overview.composition.promises Promises (experimental)]
+* [link asio.overview.composition.parallel_group Co-ordinating Parallel Operations (experimental)]
+* [link asio.overview.composition.compose Compositions as Asynchronous Operations]
+* [link asio.overview.composition.token_adapters Completion Token Adapters]
+
 [include overview/coroutine.qbk]
 [include overview/spawn.qbk]
+[include overview/futures.qbk]
 [include overview/cpp20_coroutines.qbk]
 [include overview/coro.qbk]
+[include overview/deferred.qbk]
+[include overview/promises.qbk]
+[include overview/parallel_group.qbk]
+[include overview/compose.qbk]
+[include overview/token_adapters.qbk]
 
 [endsect]
 
@@ -108,8 +146,11 @@
 [endsect]
 
 [include overview/timers.qbk]
+[include overview/files.qbk]
+[include overview/pipes.qbk]
 [include overview/serial_ports.qbk]
 [include overview/signals.qbk]
+[include overview/channels.qbk]
 [include overview/posix.qbk]
 [include overview/windows.qbk]
 [include overview/ssl.qbk]

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/platform_macros.pl

@@ -1,6 +1,6 @@
 #!/usr/bin/perl -w
 
-# 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)
@@ -22,7 +22,10 @@ while (my $line = <$fh>)
   }
   elsif ($line =~ /^\/\/ (.*)$/)
   {
-    $current_comment = $current_comment . $1 . "\n";
+    if (!($line =~ /boostify/))
+    {
+      $current_comment = $current_comment . $1 . "\n";
+    }
   }
   elsif ($line =~ /^# *define *ASIO_HAS_([A-Z-0-9_]*) 1/)
   {
@@ -39,7 +42,7 @@ while (my $line = <$fh>)
 
 my $intro = <<EOF;
 [/
- / 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)