couchbase 4.2.0 → 4.2.1

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/overview/cancellation.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)
@@ -11,8 +11,8 @@
 cancellation. For most use cases, consider using a higher level abstraction,
 such as [link asio.reference.experimental__make_parallel_group
 experimental::make_parallel_group] or the [link
-asio.overview.core.cpp20_coroutines.co_ordinating_parallel_coroutines logical
-operators] for `awaitable`.]
+asio.overview.composition.cpp20_coroutines.co_ordinating_parallel_coroutines
+logical operators] for `awaitable`.]
 
 I/O objects, such as sockets and timers, support object-wide cancellation of
 outstanding asynchronous operations via their `close` or `cancel` member
@@ -229,6 +229,8 @@ operations, or composed operations, is currently supported by:
 * sockets on POSIX and Windows
 * POSIX descriptors
 * Windows HANDLEs
+* signal sets
+* serial ports
 * SSL streams
 * all Asio-provided composed operations such as `async_read` and `async_write`
 * compositions based on `async_compose`

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

@@ -0,0 +1,56 @@
+[/
+ / 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:channels Channels]
+
+[note This is an experimental feature.]
+
+The templates
+[link asio.reference.experimental__basic_channel experimental::basic_channel]
+and [link asio.reference.experimental__basic_concurrent_channel
+experimental::basic_concurrent_channel], with aliases `experimental::channel`
+and `experimental::concurrent_channel`, may be used to send messages between
+different parts of the same application. A ['message] is defined as a
+collection of arguments to be passed to a completion handler, and the set of
+messages supported by a channel is specified by its template parameters.
+Messages may be sent and received using asynchronous or non-blocking
+synchronous operations.
+
+For example:
+
+  // Create a channel with no buffer space.
+  channel<void(error_code, size_t)> ch(ctx);
+
+  // The call to try_send fails as there is no buffer
+  // space and no waiting receive operations.
+  bool ok = ch.try_send(asio::error::eof, 123);
+  assert(!ok);
+
+  // The async_send operation is outstanding until
+  // a receive operation consumes the message.
+  ch.async_send(asio::error::eof, 123,
+      [](error_code ec)
+      {
+        // ...
+      });
+
+  // The async_receive consumes the message. Both the
+  // async_send and async_receive operations complete
+  // immediately.
+  ch.async_receive(
+      [](error_code ec, size_t n)
+      {
+        // ...
+      });
+
+[heading See Also]
+
+[link asio.reference.experimental__basic_channel experimental::basic_channel],
+[link asio.reference.experimental__basic_concurrent_channel experimental::basic_concurrent_channel],
+[link asio.examples.cpp20_examples.channels Channels examples (C++20)].
+
+[endsect]

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

@@ -0,0 +1,101 @@
+[/
+ / 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:compose Compositions as Asynchronous Operations]
+
+Application developers may wish to package their own compositions as conforming
+[link asio.overview.model.async_ops asynchronous operations] within the [link
+asio.overview.model asynchronous model]. Doing so facilitates seamless
+composition of these operations together with the operations already provided
+by Asio.
+
+While these operations may be written from scratch to conform with the [link
+asio.reference.asynchronous_operations requirements on asynchronous
+operations], Asio includes the [link asio.reference.async_compose
+`async_compose`] function to simplify this process. The `async_compose`
+implementation automatically provides an intermediate completion handler that
+correctly propagates the [link asio.overview.model.associators associated
+characteristics] and tracks outstanding work against the I/O executor and
+completion executor.
+
+The following example illustrates an asynchronous echo loop (i.e. read,
+followed by write, and so on), expressed as a simple state machine.
+
+  struct async_echo_implementation
+  {
+    tcp::socket& socket_;
+    asio::mutable_buffer buffer_;
+    enum { starting, reading, writing } state_;
+
+    template <typename Self>
+    void operator()(Self& self,
+        asio::error_code error = {},
+        std::size_t n = 0)
+    {
+      switch (state_)
+      {
+      case starting:
+        state_ = reading;
+        socket_.async_read_some(
+            buffer_, std::move(self));
+        break;
+      case reading:
+        if (error)
+        {
+          self.complete(error, 0);
+        }
+        else
+        {
+          state_ = writing;
+          asio::async_write(socket_, buffer_,
+              asio::transfer_exactly(n),
+              std::move(self));
+        }
+        break;
+      case writing:
+        self.complete(error, n);
+        break;
+      }
+    }
+  };
+
+This implementation is then used in an initiating function, which trivially
+wraps `async_compose`:
+
+  template <typename CompletionToken>
+  auto async_echo(tcp::socket& socket,
+      asio::mutable_buffer buffer,
+      CompletionToken&& token) ->
+    typename asio::async_result<
+      typename std::decay<CompletionToken>::type,
+        void(asio::error_code, std::size_t)>::return_type
+  {
+    return asio::async_compose<CompletionToken,
+      void(asio::error_code, std::size_t)>(
+        async_echo_implementation{socket, buffer,
+          async_echo_implementation::starting},
+        token, socket);
+  }
+
+Here, `async_compose` is first passed the function object that contains the
+implementation of the composed asynchronous operation. The first argument to
+the function object is a non-const reference to the enclosing intermediate
+completion handler. The remaining arguments are any arguments that originate
+from the completion handlers of any asynchronous operations performed by the
+implementation.
+
+The `async_compose` function is also passed the completion token, and zero or
+more I/O objects or I/O executors for which outstanding work must be
+maintained.
+
+[heading See Also]
+
+[link asio.reference.async_compose async_compose],
+[link asio.examples.cpp11_examples.operations Operations examples (C++11)],
+[link asio.examples.cpp14_examples.operations Operations examples (C++14)].
+
+[endsect]

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/overview/concurrency_hint.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)
@@ -31,6 +31,9 @@ following special concurrency hint values:
       new handler is added to a fast thread-local queue (with the consequence
       that the new handler is held back until the currently executing handler
       finishes).
+
+      The `io_context` still provides full thread safety, and distinct I/O
+      objects may be used from any thread.
     ]
   ]
   [
@@ -55,9 +58,11 @@ following special concurrency hint values:
       This special concurrency hint disables locking in the reactor I/O. This
       hint has the following restrictions:
 
-      [mdash] Care must be taken to ensure that run functions on the
-      `io_context`, and all operations on the context's associated I/O objects
-      (such as sockets and timers), occur in only one thread at a time.
+      [mdash] Care must be taken to ensure that the ['run functions] on the
+      `io_context` (i.e. `run`, `run_for`, `run_until`, `run_one`,
+      `run_one_for`, `run_one_until`, `poll`, and `poll_one`), and all
+      operations on the context's associated I/O objects (such as sockets and
+      timers), occur in only one thread at a time.
     ]
   ]
   [

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

@@ -1,6 +1,6 @@
 [/
- / 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)
@@ -8,9 +8,11 @@
 
 [section:coro Resumable C++ 20 Coroutines]
 
+[note This is an experimental feature.]
+
 The [link asio.reference.experimental__coro `experimental::coro`] class provides
-support for a universal C++20 coroutine. The can be used as tasks, generators
-and transfomers, depending on their signature.
+support for a universal C++20 coroutine. These coroutines can be used as tasks,
+generators and transfomers, depending on their signature.
 
   coro<std::string_view> line_reader(tcp::socket stream)
   {
@@ -58,7 +60,7 @@ that it can cover a set of different use cases.
       typename Executor = any_io_executor>
   struct coro;
 
-[h3 Yield]
+[heading Yield]
 
 The `Yield` parameter designates how a `co_yield` statement behaves. It can
 either be a type, like `int` or a signature with zero or one types:
@@ -103,7 +105,7 @@ ignored because the coroutines are lazy.
     assert(25 == co_await sum.async_resume(0, use_awaitable));
   }
 
-[h3 `noexcept`]
+[heading `noexcept`]
 
 A coro may be noexcept:
 
@@ -118,7 +120,7 @@ ends with an exception will cause `std::terminate` to be called.
 Furthermore, calls of `async_resume` and `co_await` of an expired noexcept coro
 will cause undefined behaviour.
 
-[h3 Return]
+[heading Return]
 
 A coro can also define a type that can be used with `co_return`:
 
@@ -129,7 +131,7 @@ A coro can also define a type that can be used with `co_return`:
 
 A coro can have both a `Yield` and `Return` that are non void at the same time.
 
-[h3 Result]
+[heading Result]
 
 The result type of a coroutine is dermined by both `Yield` and `Return`. Note
 that in the follwing table only the yield output value is considered, i.e.
@@ -147,7 +149,7 @@ that in the follwing table only the yield output value is considered, i.e.
     [[`void`] [`T`] [`true`]  [`optional<T>`] [`void(T)`]]
 ]
 
-[h3 Executor]
+[heading Executor]
 
 Every coroutine needs to have its own executor. Since the coroutine gets called
 multiple times, it cannot take the executor from the caller like an
@@ -185,7 +187,7 @@ context, to override the one of the object:
     coro<int> my_coro(any_io_executor exec); // it will use exec
   };
 
-[h3 `co_await`]
+[heading `co_await`]
 
 The @c co_await within a `coro` is not the same as `async_resume(use_coro)`,
 unless both coros use different executors. If they use the same, the `coro`
@@ -195,4 +197,64 @@ executor.
 `co_await this_coro::` behaves the same as coroutines that use
 @c asio::awaitable.
 
+[heading Integrating with awaitable]
+
+As the `coro` member function `async_resume` is an asynchronous operation, it
+may also be used in conjunction with `awaitable` coroutines in a single control
+flow. For example:
+
+  #include <asio.hpp>
+  #include <asio/experimental/coro.hpp>
+
+  using asio::ip::tcp;
+
+  asio::experimental::coro<std::string> reader(tcp::socket& sock)
+  {
+    std::string buf;
+    while (sock.is_open())
+    {
+      std::size_t n = co_await asio::async_read_until(
+          sock, asio::dynamic_buffer(buf), '\n',
+          asio::experimental::use_coro);
+      co_yield buf.substr(0, n);
+      buf.erase(0, n);
+    }
+  }
+
+  asio::awaitable<void> consumer(tcp::socket sock)
+  {
+    auto r = reader(sock);
+    auto msg1 = co_await r.async_resume(asio::use_awaitable);
+    std::cout << "Message 1: " << msg1.value_or("\n");
+    auto msg2 = co_await r.async_resume(asio::use_awaitable);
+    std::cout << "Message 2: " << msg2.value_or("\n");
+  }
+
+  asio::awaitable<void> listen(tcp::acceptor& acceptor)
+  {
+    for (;;)
+    {
+      co_spawn(
+          acceptor.get_executor(),
+          consumer(co_await acceptor.async_accept(asio::use_awaitable)),
+          asio::detached);
+    }
+  }
+
+  int main()
+  {
+    asio::io_context ctx;
+    tcp::acceptor acceptor(ctx, {tcp::v4(), 54321});
+    co_spawn(ctx, listen(acceptor), asio::detached);
+    ctx.run();
+  }
+
+[heading See Also]
+
+[link asio.reference.co_spawn co_spawn],
+[link asio.reference.experimental__coro experimental::coro],
+[link asio.overview.composition.cpp20_coroutines C++20 Coroutines],
+[link asio.overview.composition.spawn Stackful Coroutines],
+[link asio.overview.composition.coroutine Stackless Coroutines].
+
 [endsect]

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/overview/coroutine.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)
@@ -46,6 +46,6 @@ documentation provides a complete description of these pseudo-keywords.
 
 [link asio.reference.coroutine coroutine],
 [link asio.examples.cpp03_examples.http_server_4 HTTP Server 4 example],
-[link asio.overview.core.spawn Stackful Coroutines].
+[link asio.overview.composition.spawn Stackful Coroutines].
 
 [endsect]

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/overview/cpp2011.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,8 +27,6 @@
 
 [link asio.overview.cpp2011.chrono Chrono]
 
-[link asio.overview.cpp2011.futures Futures]
-
 [/boostify: non-boost docs start here]
 
 [section:system_error System Errors and Error Codes]
@@ -235,37 +233,4 @@ class template may be used with either.
 
 [endsect]
 
-[section:futures Futures]
-
-The `asio::use_future` special value provides first-class support for returning a
-C++11 `std::future` from an asynchronous operation's initiating function.
-
-To use `asio::use_future`, pass it to an asynchronous operation instead of
-a normal completion handler. For example:
-
-  std::future<std::size_t> length =
-    my_socket.async_read_some(my_buffer, asio::use_future);
-
-Where a handler signature has the form:
-
-  void handler(asio::error_code ec, result_type result);
-
-the initiating function returns a `std::future` templated on `result_type`.
-In the above example, this is `std::size_t`. If the asynchronous operation
-fails, the `error_code` is converted into a `system_error` exception and
-passed back to the caller through the future.
-
-Where a handler signature has the form:
-
-  void handler(asio::error_code ec);
-
-the initiating function returns `std::future<void>`. As above, an error
-is passed back in the future as a `system_error` exception.
-
-[link asio.reference.use_future use_future],
-[link asio.reference.use_future_t use_future_t],
-[link asio.examples.cpp11_examples.futures Futures example (C++11)].
-
-[endsect]
-
 [endsect]

package/deps/couchbase-cxx-client/third_party/asio/asio/src/doc/overview/cpp20_coroutines.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)
@@ -78,6 +78,71 @@ Where a handler signature has the form:
 the `co_await` expression produces a `void` result. As above, an error is
 passed back to the coroutine as a `system_error` exception.
 
+[heading Error Handling]
+
+To perform explicit error handling, rather than the default exception-throwing
+behaviour, use the [link asio.reference.as_tuple `as_tuple`] or
+[link asio.reference.redirect_error `redirect_error`] completion token adapters.
+
+The `as_tuple` completion token adapter packages the completion
+handler arguments into a single tuple, which is then returned as the result of
+the awaited operation. For example:
+
+  asio::awaitable<void> echo(tcp::socket socket)
+  {
+    char data[1024];
+    for (;;)
+    {
+      std::tuple<asio::error_code, std::size_t> result =
+        co_await socket.async_read_some(asio::buffer(data),
+          asio::as_tuple(asio::use_awaitable));
+      if (!std::get<0>(result))
+      {
+        // success
+      }
+
+      // ...
+    }
+  }
+
+The result can also be captured directly into a structured binding:
+
+  asio::awaitable<void> echo(tcp::socket socket)
+  {
+    char data[1024];
+    for (;;)
+    {
+      auto [ec, n] = co_await socket.async_read_some(
+          asio::buffer(data), asio::as_tuple(asio::use_awaitable));
+      if (!ec)
+      {
+        // success
+      }
+
+      // ...
+    }
+  }
+
+Alternatively, the `redirect_error` completion token adapter may be used to
+capture the error into a supplied `error_code` variable:
+
+  asio::awaitable<void> echo(tcp::socket socket)
+  {
+    char data[1024];
+    for (;;)
+    {
+      asio::error_code ec;
+      std::size_t n = co_await socket.async_read_some(asio::buffer(data),
+          asio::redirect_error(asio::use_awaitable, ec));
+      if (!ec)
+      {
+        // success
+      }
+
+      // ...
+    }
+  }
+
 [heading Coroutines and Per-Operation Cancellation]
 
 All threads of execution created by `co_spawn` have a cancellation state that
@@ -155,65 +220,11 @@ namespace into scope:
 
   using namespace asio::experimental::awaitable_operators;
 
-[heading Coroutines that Await and Yield]
-
-[note This is an experimental feature.]
-
-The [link asio.reference.experimental__coro `coro`] type is a C++20 coroutine
-primitive for resumable functions, with the ability to combine both
-asynchronous waiting (`co_await`) and yielding (`co_yield`) into a single,
-stateful control flow. For example:
-
-  #include <asio.hpp>
-  #include <asio/experimental/coro.hpp>
-
-  using asio::ip::tcp;
-
-  asio::experimental::coro<std::string> reader(tcp::socket& sock)
-  {
-    std::string buf;
-    while (sock.is_open())
-    {
-      std::size_t n = co_await asio::async_read_until(
-          sock, asio::dynamic_buffer(buf), '\n',
-          asio::experimental::use_coro);
-      co_yield buf.substr(0, n);
-      buf.erase(0, n);
-    }
-  }
-
-  asio::awaitable<void> consumer(tcp::socket sock)
-  {
-    auto r = reader(sock);
-    auto msg1 = co_await r.async_resume(asio::use_awaitable);
-    std::cout << "Message 1: " << msg1.value_or("\n");
-    auto msg2 = co_await r.async_resume(asio::use_awaitable);
-    std::cout << "Message 2: " << msg2.value_or("\n");
-  }
-
-  asio::awaitable<void> listen(tcp::acceptor& acceptor)
-  {
-    for (;;)
-    {
-      co_spawn(
-          acceptor.get_executor(),
-          consumer(co_await acceptor.async_accept(asio::use_awaitable)),
-          asio::detached);
-    }
-  }
-
-  int main()
-  {
-    asio::io_context ctx;
-    tcp::acceptor acceptor(ctx, {tcp::v4(), 54321});
-    co_spawn(ctx, listen(acceptor), asio::detached);
-    ctx.run();
-  }
-
 [heading See Also]
 
 [link asio.reference.co_spawn co_spawn],
 [link asio.reference.detached detached],
+[link asio.reference.as_tuple as_tuple],
 [link asio.reference.redirect_error redirect_error],
 [link asio.reference.awaitable awaitable],
 [link asio.reference.use_awaitable_t use_awaitable_t],
@@ -221,7 +232,8 @@ stateful control flow. For example:
 [link asio.reference.this_coro__executor this_coro::executor],
 [link asio.reference.experimental__coro experimental::coro],
 [link asio.examples.cpp17_examples.coroutines_ts_support Coroutines examples],
-[link asio.overview.core.spawn Stackful Coroutines],
-[link asio.overview.core.coroutine Stackless Coroutines].
+[link asio.overview.composition.coro Resumable C++20 Coroutines],
+[link asio.overview.composition.spawn Stackful Coroutines],
+[link asio.overview.composition.coroutine Stackless Coroutines].
 
 [endsect]

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

@@ -0,0 +1,54 @@
+[/
+ / 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:deferred Deferred Operations]
+
+The [link asio.reference.deferred `deferred`], completion token takes a call to
+an asynchronous operation's initiating function and turns it into a function
+object that accepts a completion token. For example:
+
+  auto deferred_op =
+    timer.async_wait(
+      asio::deferred);
+  ...
+  std::move(deferred_op)(
+      [](asio::error_code ec){ ... });
+
+or:
+
+  auto deferred_op =
+    timer.async_wait(
+      asio::deferred);
+  ...
+  std::future<void> =
+    std::move(deferred_op)(
+      asio::use_future);
+
+The deferred token also supports chaining, to create simple compositions:
+
+  auto deferred_op =
+    timer.async_wait(
+      asio::deferred(
+        [&](asio::error_code ec)
+        {
+          timer.expires_after(
+              std::chrono::seconds(1));
+
+          return timer.async_wait(
+              asio::deferred);
+        });
+  ...
+  std::future<void> = std::move(deferred_op)(asio::use_future);
+
+[heading See Also]
+
+[link asio.reference.deferred deferred],
+[link asio.reference.deferred_t deferred_t],
+[link asio.examples.cpp14_examples.deferred Deferred examples (C++11)],
+[link asio.examples.cpp14_examples.deferred Deferred examples (C++14)].
+
+[endsect]

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

@@ -0,0 +1,49 @@
+[/
+ / 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:files Files]
+
+[note This feature requires I/O completion ports on Windows, and io_uring on
+Linux (define `ASIO_HAS_IO_URING` to enable).]
+
+Asio provides support for manipulating stream-oriented and random-access files.
+For example, to write to a newly created stream-oriented file:
+
+  asio::stream_file file(
+      my_io_context, "/path/to/file",
+      asio::stream_file::write_only
+        | asio::stream_file::create
+        | asio::stream_file::truncate);
+
+  file.async_write_some(my_buffer,
+      [](error_code e, size_t n)
+      {
+        // ...
+      });
+
+or to read from a random-access file:
+
+  asio::random_access_file file(
+      my_io_context, "/path/to/file",
+      asio::random_access_file::read_only);
+
+  file.async_read_some_at(1234, my_buffer,
+      [](error_code e, size_t n)
+      {
+        // ...
+      });
+
+[heading See Also]
+
+[link asio.reference.basic_file basic_file],
+[link asio.reference.basic_random_access_file basic_random_access_file],
+[link asio.reference.basic_stream_file basic_stream_file],
+[link asio.reference.file_base file_base],
+[link asio.reference.random_access_file random_access_file],
+[link asio.reference.stream_file stream_file].
+
+[endsect]