couchbase 4.2.0 → 4.2.2

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/examples.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)
@@ -27,6 +27,9 @@ facilities. These examples do not make direct use of Boost C++ libraries.
 * [link asio.examples.cpp17_examples C++17 Examples]: Selected examples
 illustrating C++17 usage in conjunction with Technical Specifications.
 
+* [link asio.examples.cpp20_examples C++20 Examples]: Selected examples
+using C++20 language features.
+
 
 [section:cpp03_examples C++03 Examples]
 
@@ -378,6 +381,15 @@ and asynchronous operations.
 * [@../src/examples/cpp11/echo/blocking_udp_echo_server.cpp] ([@examples/diffs/echo/blocking_udp_echo_server.cpp.html diff to C++03])
 
 
+[heading Deferred]
+
+Examples showing how to use the [link asio.reference.deferred `deferred`]
+completion token.
+
+* [@../src/examples/cpp11/deferred/deferred_1.cpp]
+* [@../src/examples/cpp11/deferred/deferred_2.cpp]
+
+
 [heading Fork]
 
 These POSIX-specific examples show how to use Asio in conjunction with the
@@ -523,6 +535,8 @@ Examples showing how to use UNIX domain (local) sockets.
 * [@../src/examples/cpp11/local/iostream_client.cpp] ([@examples/diffs/local/iostream_client.cpp.html diff to C++03])
 * [@../src/examples/cpp11/local/stream_server.cpp] ([@examples/diffs/local/stream_server.cpp.html diff to C++03])
 * [@../src/examples/cpp11/local/stream_client.cpp] ([@examples/diffs/local/stream_client.cpp.html diff to C++03])
+* [@../src/examples/cpp11/local/fd_passing_stream_server.cpp]
+* [@../src/examples/cpp11/local/fd_passing_stream_client.cpp]
 
 
 [endsect]
@@ -533,8 +547,8 @@ Examples showing how to use UNIX domain (local) sockets.
 
 [heading Deferred]
 
-Examples showing how to use the [link asio.reference.experimental__deferred
-`experimental::deferred`] completion token.
+Examples showing how to use the [link asio.reference.deferred `deferred`]
+completion token.
 
 * [@../src/examples/cpp14/deferred/deferred_1.cpp]
 * [@../src/examples/cpp14/deferred/deferred_2.cpp]
@@ -593,6 +607,10 @@ Examples showing how to implement composed asynchronous operations as reusable l
 * [@../src/examples/cpp14/operations/composed_7.cpp]
 * [@../src/examples/cpp14/operations/composed_8.cpp]
 
+Examples showing how to expose callback-based APIs as asynchronous operations.
+
+* [@../src/examples/cpp14/operations/callback_wrapper.cpp]
+* [@../src/examples/cpp14/operations/c_callback_wrapper.cpp]
 
 [heading Parallel Groups]
 
@@ -628,4 +646,52 @@ Coroutines TS.
 [endsect]
 
 
+[section:cpp20_examples C++20 Examples]
+
+
+[heading Channels]
+
+Example showing how to use a channel in conjunction with C++20 coroutines.
+
+* [@boost_asio/example/cpp20/channels/throttling_proxy.cpp]
+
+
+[heading Coroutines]
+
+Examples showing how to implement a chain of asynchronous operations using C++20
+Coroutines.
+
+* [@../src/examples/cpp20/coroutines/echo_server.cpp]
+* [@../src/examples/cpp20/coroutines/echo_server_with_default.cpp]
+* [@../src/examples/cpp20/coroutines/echo_server_with_as_tuple_default.cpp]
+* [@../src/examples/cpp20/coroutines/echo_server_with_as_single_default.cpp]
+* [@../src/examples/cpp20/coroutines/echo_server_with_deferred.cpp]
+* [@../src/examples/cpp20/coroutines/echo_server_with_deferred_default.cpp]
+* [@../src/examples/cpp20/coroutines/refactored_echo_server.cpp]
+* [@../src/examples/cpp20/coroutines/chat_server.cpp]
+* [@../src/examples/cpp20/coroutines/timeout.cpp]
+
+
+[heading Operations]
+
+Examples showing how to implement composed asynchronous operations as reusable library functions.
+
+* [@../src/examples/cpp20/operations/composed_1.cpp]
+* [@../src/examples/cpp20/operations/composed_2.cpp]
+* [@../src/examples/cpp20/operations/composed_3.cpp]
+* [@../src/examples/cpp20/operations/composed_4.cpp]
+* [@../src/examples/cpp20/operations/composed_5.cpp]
+* [@../src/examples/cpp20/operations/composed_6.cpp]
+* [@../src/examples/cpp20/operations/composed_7.cpp]
+* [@../src/examples/cpp20/operations/composed_8.cpp]
+
+Examples showing how to expose callback-based APIs as asynchronous operations.
+
+* [@../src/examples/cpp20/operations/callback_wrapper.cpp]
+* [@../src/examples/cpp20/operations/c_callback_wrapper.cpp]
+
+
+[endsect]
+
+
 [endsect]

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/history.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)
@@ -7,6 +7,392 @@
 
 [section:history Revision History]
 
+[heading Asio 1.24.0]
+
+* Improved the performance of `awaitable<>`-based coroutines when they directly
+  `co_await` an asynchronous operation, by eliminating the copy of the operation
+  object in `await_transform`.
+
+* Improved the performance of `spawn()`-based stackful coroutines by storing a
+  reference to the yield context in the completion handler, rather than storing
+  a copy of the executor.
+
+* Fixed a C++03 build error by disabling `index_sequence` emulation when
+  variadic templates are unavailable.
+
+* Fixed detection of `std::aligned_alloc` for older Apple platforms.
+
+* Removed faulty assertions from `experimental::coro` implementation.
+
+* Added defence against Qt-defined macros when building with Intel C++.
+
+* Ensured that a `spawn()`-based stackful coroutine is cleaned up immediately
+  after it completes.
+
+* Changed the implementation of the `select_reactor`, on Windows, to ensure that
+  any exception resulting from failure to recreate its interrupter's sockets
+  will be allowed to propagate out through `io_context::run()`.
+
+* Changed the MSVC version used for the `system_error` workaround, as more
+  recent runtime redistributables appear to have fixed the issue.
+
+* Changed the `async_compose` example to use a return type compatible with the
+  new `async_result` form.
+
+[heading Asio 1.23.0]
+
+* Added a deduced trailing return type, using `decltype`, to all asynchronous
+  operations' initiating functions when using C++11. This change enables the
+  new form of `async_result`, where the return type can vary per operation,
+  for C++11.
+
+* Moved `append`, `prepend`, `as_tuple`, and `deferred` to the `asio`
+  namespace, and made them compatible with C++11. These are no longer
+  experimental facilities, although the names have temporarily been retained
+  under the `asio::experimental` namespace for backwards compatibility.
+
+* Added `buffer()` overloads for contiguous containers, such as `std::span`.
+
+* Added the ability for `awaitable<>`-based coroutines to directly `co_await`
+  operations that are packaged as function objects. For example, using
+  `deferred`:[br]
+  ``
+  asio::awaitable<void> my_coro()
+  {
+    asio::steady_timer timer(co_await asio::this_coro::executor);
+    timer.expires_after(std::chrono::seconds(5));
+
+    co_await timer.async_wait(asio::deferred);
+  }
+  ``
+  or with a handcrafted function object:[br]
+  ``
+  asio::awaitable<void> my_coro()
+  {
+    asio::steady_timer timer(co_await asio::this_coro::executor);
+    timer.expires_after(std::chrono::seconds(5));
+
+    co_await [&](auto&& token)
+    {
+      return timer.async_wait(std::forward<decltype(token)>(token));
+    };
+  }
+  ``[br]
+
+* Changed `spawn()` to be a completion token-based asynchronous operation. This
+  introduces new `spawn()` overloads that conform to the requirements for
+  asynchronous operations. For example:[br]
+  ``
+  std::string do_read(asio::yield_context yield)
+  {
+    char data[1024];
+    size_t n = my_socket.async_read_some(asio::buffer(data), yield);
+    return std::string(data, n);
+  }
+
+  asio::spawn(my_executor, do_read,
+      [](std::exception_ptr ex, std::string result)
+      {
+        // ...
+      });
+  ``
+  These new `spawn()` overloads support cancellation, and the
+  `basic_yield_context` completion token has also been enhanced to support
+  move-only and variadic result types. When targeting C++11 and later, these
+  functions are implemented in terms of Boost.Context directly. The existing
+  overloads have been retained but are deprecated.
+
+* Added the `is_async_operation` trait and `async_operation` concept. The
+  `is_async_operation` trait may be used to determine if a function object, and
+  optional arguments, may be called to initiate an asynchronous operation. For
+  example, when using `deferred`:[br]
+  ``
+  auto d = my_timer.async_wait(asio::deferred);
+  static_assert(asio::is_async_operation<decltype(d)>::value);
+  ``[br]
+  or with a handcrafted asynchronous operation:[br]
+  ``
+  struct my_async_op
+  {
+    asio::ip::tcp::socket& socket_ = ...;
+
+    template <typename Token>
+    auto operator()(asio::const_buffer data, Token&& token)
+    {
+      return asio::async_write(socket_, data,
+          std::forward<Token>(token));
+    }
+  };
+
+  static_assert(
+      asio::is_async_operation<
+        my_async_op, asio::const_buffer>::value);
+  ``[br]
+
+* Added the `completion_signature_of` trait. The `completion_signature_of`
+  trait (and corresponding type alias `completion_signature_of_t`) may be used
+  to determine the completion signature of an asynchronous operation. For
+  example:[br]
+  ``
+  auto d = my_timer.async_wait(asio::deferred);
+  using sig = asio::completion_signature_of<decltype(d)>::type;
+  // sig is void(error_code)
+  ``[br]
+  or with a handcrafted asynchronous operation:[br]
+  ``
+  struct my_async_op
+  {
+    asio::ip::tcp::socket& socket_ = ...;
+
+    template <typename Token>
+    auto operator()(asio::const_buffer data, Token&& token)
+    {
+      return asio::async_write(socket_, data,
+          std::forward<Token>(token));
+    }
+  };
+
+  using sig =
+    asio::completion_signature_of<
+      my_async_op, asio::const_buffer>::type;
+  // sig is void(error_code, size_t)
+  ``[br]
+
+* Added converting move construction/assignment to posix descriptors, serial
+  ports, pipes, Windows `object_handle`, Windows stream handles, and Windows
+  random-access handles.
+
+* Added `release()` member functions to pipes, Windows stream handles, and
+  Windows random-access handles.
+
+* Enabled support for `Endpoint` implementations that return `void` pointers
+  from their `data()` member functions, as per the documented `Endpoint` type
+  requirements.
+
+* Removed `all()` and `race()` from `experimental::promise`, as
+  `experimental::parallel_group` covers this functionality.
+
+* Added source locations to exceptions and error codes produced by the
+  synchronous and asynchronous operations.
+
+* Fixed compatibility with OpenSSL 3.0.4 and later.
+
+* Fixed compatibility with with [^-masm=intel].
+
+* Explicitly stated that socket `shutdown()` calls are thread-safe with respect
+  to certain other synchronous operations on the same socket.
+
+* Optimised the move construction of I/O objects where only the executor type
+  differs.
+
+* Fixed the detection of `std::invoke_result` for clang/libc++.
+
+* Fixed an issue where `experimental::parallel_group` initiation incorrectly
+  moved arguments instead of forwarding them.
+
+* Fixed a sequencing issue in the implementation of `post()`, `dispatch()`,
+  and `defer()`, where the the associated allocator may be obtained from an
+  already moved-from completion handler.
+
+* Fixed the `awaitable<>` implementation to propagate exceptions from awaited
+  initiation functions through the current completion handler.
+
+* Fixed detection of `std::aligned_alloc` with [^gcc].
+
+* Changed to avoid using the soon-to-be-deprecated `std::aligned_storage` on
+  newer compilers.
+
+* Fixed various compiler warnings.
+
+* Updated all composed operations examples, and the C++11 timeouts example, to
+  use the new `async_result` form.
+
+* Added composed operation and coroutine examples for C++20.
+
+* Added pkg-config support.
+
+[heading Asio 1.22.2]
+
+* On Windows, changed the file support to open files using the same sharing mode
+  as `fopen()`.
+
+* On Linux, fixed the UNIX domain sockets implementation to correctly handle
+  `EAGAIN` as an indication of an in-progress connect operation.
+
+* Fixed `experimental::basic_channel::reset()` and
+  `experimental::basic_concurrent_channel::reset()` so that they work correctly
+  for an unclosed channel.
+
+* Fixed potential undefined behaviour in the `experimental::promise` operations
+  `race()` and `all()`.
+
+* Changed the `co_spawn` implementation to explicitly dispatch cancellation
+  signals through the specified executor, if the the completion handler has an
+  associated executor of its own.
+
+* Added more detailed reference documentation to `make_strand()`,
+  `make_work_guard()`, `ip::address_v4`, `ip::address_v6`,
+  `experimental::basic_channel`, and `experimental::basic_concurrent_channel`.
+
+* Re-arranged and extended the Overview documentation to cover files, pipes,
+  `async_compose`, `experimental::deferred`, `experimental::parallel_group`,
+  `experimental::promise`, channels, and completion token adapters.
+
+* Reverted the `io_context` reference documentation to use `executor_work_guard`
+  when preventing the `io_context` from running out of work.
+
+* Removed references to `deadline_timer` from the Overview documentation.
+
+* Added reference documentation cross-references to asynchronous model elements.
+
+[heading Asio 1.22.1]
+
+* Added `bind_allocator`, to simplify associating a custom allocator with a
+  completion token or handler.
+
+* Added the `file_base::sync_all_on_write` flag, which maps to `O_SYNC` on POSIX
+  and `FILE_FLAG_WRITE_THROUGH` on Windows.
+
+* Added missing implementation of `basic_file::release()`.
+
+* Added per-operation cancellation support to signal sets.
+
+* Exposed `recycling_allocator` as part of the public interface.
+
+* Added the `nodiscard` attribute to the following functions:
+  * `bind_allocator()`
+  * `bind_cancellation_slot()`
+  * `bind_executor()`
+  * `buffer()`
+  * `dynamic_buffer()`
+  * `experimental::append()`
+  * `experimental::as_single()`
+  * `experimental::as_tuple()`
+  * `experimental::make_parallel_group()`
+  * `experimental::prepend()`
+  * `get_associated_allocator()`
+  * `get_associated_cancellation_slot()`
+  * `get_associated_executor()`
+  * `make_work_guard()`
+
+* Added compatibility with OpenSSL 3.0, particularly when deprecated
+  functionality is disabled.
+
+* Added support for adopting an existing `SSL*` into an `ssl::stream<>`.
+
+* Enabled `executor_work_guard<>` even when `ASIO_NO_TS_EXECUTORS` is defined.
+
+* Enabled movable socket iostreams when using clang.
+
+* Fixed `bind_cancellation_slot` compatibility with legacy completion tokens.
+
+* Fixed `bind_executor` compatibility with legacy completion tokens.
+
+* Fixed `associator` specialisations for `experimental::append` and
+  `experimental::prepend`, to correctly propagate the associated allocator,
+  executor, and cancellation slot.
+
+* Fixed 'zero as null pointer constant' warning in C++20 coroutines
+  implementation of `awaitable`.
+
+* Ensured concurrency hint preprocessor macros are made available when
+  [^asio/io_context.hpp] is included.
+
+* Fixed issue where the primary `associated_allocator` template was not
+  correctly detecting the nested `T::allocator_type`.
+
+* Fixed [^io_uring] implementation of `async_receive_from` operation for
+  sockets.
+
+* Fixed [^io_uring] implementation of `write_some_at` operation for files.
+
+* Changed [^io_uring] implementation to correctly check that it is not the
+  default before registering with reactor.
+
+* Fixed a circular inclusion issue when using [^io_uring] in some build
+  configurations.
+
+* Fixed `experimental::coro`'s per-operation cancellation to clear the slot at
+  completion of each operation.
+
+* Fixed memory management in `experimental::promise`'s type-erased completion
+  handlers.
+
+* Fixed move `operator=` implementation for `ssl::stream`.
+
+* Fixed `any_io_executor` implementation to work when both
+  `ASIO_USE_TS_EXECUTOR_AS_DEFAULT` and `ASIO_SEPARATE_COMPILATION` are
+  defined.
+
+* Fixed implementation of `basic_socket::at_mark()` when using the
+  `sockatmark()` system call.
+
+* Changed the recycling allocator to use the default alignment as the minimum
+  alignment for allocations.
+
+* Added additional standard header file includes, as required by newer
+  compilers.
+
+* Added a workaround for apparent coroutine codegen bug with Apple's clang.
+
+* Fixed various warnings in the examples and unit tests.
+
+* Added a C++11 example showing file descriptor passing over local sockets.
+  Thanks to Heiko Hund for providing this example.
+
+* Added C++14 examples of wrapping callback-based APIs in asynchronous
+  operations.
+
+* Added an overview of Asio's asynchronous model to the documentation.
+
+* Reworked reference documentation in terms of completion tokens.
+
+* Updated documentation of asynchronous operation requirements to use new
+  completion token form.
+
+* Updated documentation for `dispatch()`, `post()`, and `defer()` to cover both
+  the old and new executor forms.
+
+* Documented per-operation cancellation for serial ports.
+
+* Clarified the non-concurrency guarantees made for allocators.
+
+[heading Asio 1.22.0]
+
+* Improved error messages emitted by `ssl` facilities.
+
+* Fixed `bind_executor` compatibility with completion tokens.
+
+* Fixed build errors when `ASIO_USE_TS_EXECUTOR_AS_DEFAULT` is defined.
+
+* Fixed corruption, cleanup issues in channel implementation.
+
+* Added missing move assignment operator to `awaitable<>`.
+
+* Fixed an access violation when using coroutines with MSVC, due to incorrect
+  alignment of allocated memory.
+
+* Fixed a cleanup issue in `experimental::parallel_group` that occured when the
+  execution context was shut down with parallel operations still pending.
+
+* Fixed header inclusion order problem when io_uring is enabled.
+
+* Eliminated `shared_ptr` use from `experimental::coro` `co_spawn()`
+  implementation.
+
+* Prevented `async_resume` from being called on `experimental::coro`
+  temporaries.
+
+* Made `awaitable_operators.hpp` header self-contained.
+
+* Added clarifications to the documentation on concurrency hints.
+
+* Added documentation on error handling techniques for C++20 coroutines.
+
+* Added channel-based proxy example.
+
+* Regenerated `ssl` certificates used in examples.
+
 [heading Asio 1.21.0]
 
 * Added an io_uring backend. This backend may be used for all I/O objects,
@@ -966,15 +1352,14 @@
   operation is launched with location information, it outputs lines using the
   [*<action>] [^n^m], prior to the [^n*m] line that signifies the beginning
   of the asynchronous operation. For example:
-  ``
+  [pre
   @asio|1589423304.861944|>7|ec=system:0,bytes_transferred=5
   @asio|1589423304.861952|7^8|in 'async_write' (./../../../include/asio/impl/write.hpp:330)
   @asio|1589423304.861952|7^8|called from 'do_write' (handler_tracking/async_tcp_echo_server.cpp:62)
   @asio|1589423304.861952|7^8|called from 'operator()' (handler_tracking/async_tcp_echo_server.cpp:51)
   @asio|1589423304.861952|7*8|socket@0x7ff61c008230.async_send
   @asio|1589423304.861975|.8|non_blocking_send,ec=system:0,bytes_transferred=5
-  @asio|1589423304.861980|<7|
-  ``[br]
+  @asio|1589423304.861980|<7|][br]
   If `std::source_location` or `std::experimental::source_location` are
   available, the `use_awaitable_t` token (when default-constructed or used as a
   default completion token) will also cause handler tracking to output a source
@@ -1009,21 +1394,18 @@
   include only those events in the tree that produced the nominated handlers.
   For example, to filter the output to include only the events associated with
   handlers `123`, `456`, and their predecessors:
-  ``
-  cat output.txt | perl handlertree.pl 123 456
-  ``
+  [pre
+  cat output.txt | perl handlertree.pl 123 456]
   or:
-  ``
-  perl handlertree.pl 123 456 < output.txt
-  ``[br]
+  [pre
+  perl handlertree.pl 123 456 < output.txt][br]
   This script may be combined with handerlive.pl and handlerviz.pl to produce a
   graph of the "live" asynchronous operation chains. For example:
-  ``
+  [pre
   cat output.txt | \
     perl handlertree.pl `perl handlerlive.pl output.txt` | \
     perl handlerviz.pl | \
-    dot -Tsvg > output.svg
-  ``[br]
+    dot -Tsvg > output.svg][br]
 
 * Added changes for clang-based Embarcadero C++ compilers.
 
@@ -1971,19 +2353,18 @@
   stackful coroutines, based on the Boost.Coroutine library. The `spawn()`
   function enables programs to implement asynchronous logic in a synchronous
   manner. For example: `size_t n = my_socket.async_read_some(my_buffer, yield);`.
-  For further information, see [link asio.overview.core.spawn Stackful
+  For further information, see [link asio.overview.composition.spawn Stackful
   Coroutines].
 
 * Added the `asio::use_future` special value, which provides first-class
   support for returning a C++11 `std::future` from an asynchronous
   operation's initiating function. For example:
   `future<size_t> = my_socket.async_read_some(my_buffer, asio::use_future);`.
-  For further information, see [link asio.overview.cpp2011.futures C++
-  2011 Support - Futures].
+  For further information, see [link asio.overview.composition.futures Futures].
 
 * Promoted the stackless coroutine class and macros to be part of Asio's
   documented interface, rather than part of the HTTP server 4 example.
-  For further information, see [link asio.overview.core.coroutine
+  For further information, see [link asio.overview.composition.coroutine
   Stackless Coroutines].
 
 * Added a new handler hook called `asio_handler_is_continuation`.

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/index.xml

@@ -2,7 +2,7 @@
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN" "../../../boost/tools/boostbook/dtd/boostbook.dtd">
 
 <!--
-  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/makepdf.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)

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/net_ts.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/allocation.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)
@@ -72,12 +72,18 @@ associated handler is invoked, which means the memory is ready to be reused for
 any new asynchronous operations started by the handler.
 
 The custom memory allocation functions may be called from any user-created
-thread that is calling a library function. The implementation guarantees that,
-for the asynchronous operations included the library, the implementation will
-not make concurrent calls to the memory allocation functions for that handler.
-The implementation will insert appropriate memory barriers to ensure correct
-memory visibility should allocation functions need to be called from different
-threads.
+thread that is calling an Asio library function. The implementation guarantees,
+for the asynchronous operations included with the library, that within the
+context of an individual operation the implementation will not make concurrent
+calls to the memory allocation functions for that handler. The implementation
+will insert appropriate memory barriers to ensure correct memory visibility
+should an asynchronous operation need to call the allocation functions from
+different threads. (Note: If the same allocator is shared across multiple
+concurrent asynchronous operations, this can result in concurrent calls to the
+memory allocation functions. Use of a [link asio.overview.core.strands strand]
+does not prevent these concurrent calls, as an operation may need to allocate
+memory from outside the strand. In this case, the shared allocator is
+responsible for providing the necessary thread safety guarantees.)
 
 [heading See Also]
 

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/overview/async.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/basics.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/bsd_sockets.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/buffers.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)