couchbase 4.2.0 → 4.2.2

package/deps/couchbase-cxx-client/third_party/asio/asio/src/examples/cpp20/operations/callback_wrapper.cpp

@@ -0,0 +1,154 @@
+//
+// callback_wrapper.cpp
+// ~~~~~~~~~~~~~~~~~~~~
+//
+// 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)
+//
+
+#include <asio.hpp>
+#include <iostream>
+
+//------------------------------------------------------------------------------
+
+// This is a mock implementation of an API that uses a move-only function object
+// for exposing a callback. The callback has the signature void(std::string).
+
+template <typename Callback>
+void read_input(const std::string& prompt, Callback cb)
+{
+  std::thread(
+      [prompt, cb = std::move(cb)]() mutable
+      {
+        std::cout << prompt << ": ";
+        std::cout.flush();
+        std::string line;
+        std::getline(std::cin, line);
+        std::move(cb)(std::move(line));
+      }).detach();
+}
+
+//------------------------------------------------------------------------------
+
+// This is an asynchronous operation that wraps the callback-based API.
+
+// The initiating function for the asynchronous operation.
+template <asio::completion_token_for<void(std::string)> CompletionToken>
+auto async_read_input(const std::string& prompt, CompletionToken&& token)
+{
+  // Define a function object that contains the code to launch the asynchronous
+  // operation. This is passed the concrete completion handler, followed by any
+  // additional arguments that were passed through the call to async_initiate.
+  auto init = [](
+      asio::completion_handler_for<void(std::string)> auto handler,
+      const std::string& prompt)
+  {
+    // According to the rules for asynchronous operations, we need to track
+    // outstanding work against the handler's associated executor until the
+    // asynchronous operation is complete.
+    auto work = asio::make_work_guard(handler);
+
+    // Launch the operation with a callback that will receive the result and
+    // pass it through to the asynchronous operation's completion handler.
+    read_input(prompt,
+        [
+          handler = std::move(handler),
+          work = std::move(work)
+        ](std::string result) mutable
+        {
+          // Get the handler's associated allocator. If the handler does not
+          // specify an allocator, use the recycling allocator as the default.
+          auto alloc = asio::get_associated_allocator(
+              handler, asio::recycling_allocator<void>());
+
+          // Dispatch the completion handler through the handler's associated
+          // executor, using the handler's associated allocator.
+          asio::dispatch(work.get_executor(),
+              asio::bind_allocator(alloc,
+                [
+                  handler = std::move(handler),
+                  result = std::string(result)
+                ]() mutable
+                {
+                  std::move(handler)(result);
+                }));
+        });
+  };
+
+  // The async_initiate function is used to transform the supplied completion
+  // token to the completion handler. When calling this function we explicitly
+  // specify the completion signature of the operation. We must also return the
+  // result of the call since the completion token may produce a return value,
+  // such as a future.
+  return asio::async_initiate<CompletionToken, void(std::string)>(
+      init, // First, pass the function object that launches the operation,
+      token, // then the completion token that will be transformed to a handler,
+      prompt); // and, finally, any additional arguments to the function object.
+}
+
+//------------------------------------------------------------------------------
+
+void test_callback()
+{
+  asio::io_context io_context;
+
+  // Test our asynchronous operation using a lambda as a callback. We will use
+  // an io_context to specify an associated executor.
+  async_read_input("Enter your name",
+      asio::bind_executor(io_context,
+        [](const std::string& result)
+        {
+          std::cout << "Hello " << result << "\n";
+        }));
+
+  io_context.run();
+}
+
+//------------------------------------------------------------------------------
+
+void test_deferred()
+{
+  asio::io_context io_context;
+
+  // Test our asynchronous operation using the deferred completion token. This
+  // token causes the operation's initiating function to package up the
+  // operation with its arguments to return a function object, which may then be
+  // used to launch the asynchronous operation.
+  auto op = async_read_input("Enter your name", asio::deferred);
+
+  // Launch our asynchronous operation using a lambda as a callback. We will use
+  // an io_context to obtain an associated executor.
+  std::move(op)(
+      asio::bind_executor(io_context,
+        [](const std::string& result)
+        {
+          std::cout << "Hello " << result << "\n";
+        }));
+
+  io_context.run();
+}
+
+//------------------------------------------------------------------------------
+
+void test_future()
+{
+  // Test our asynchronous operation using the use_future completion token.
+  // This token causes the operation's initiating function to return a future,
+  // which may be used to synchronously wait for the result of the operation.
+  std::future<std::string> f =
+    async_read_input("Enter your name", asio::use_future);
+
+  std::string result = f.get();
+  std::cout << "Hello " << result << "\n";
+}
+
+//------------------------------------------------------------------------------
+
+int main()
+{
+  test_callback();
+  test_deferred();
+  test_future();
+}

package/deps/couchbase-cxx-client/third_party/asio/asio/src/examples/cpp20/operations/composed_1.cpp

@@ -0,0 +1,157 @@
+//
+// composed_1.cpp
+// ~~~~~~~~~~~~~~
+//
+// 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)
+//
+
+#include <asio/deferred.hpp>
+#include <asio/io_context.hpp>
+#include <asio/ip/tcp.hpp>
+#include <asio/use_future.hpp>
+#include <asio/write.hpp>
+#include <cstring>
+#include <iostream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+using asio::ip::tcp;
+
+//------------------------------------------------------------------------------
+
+// This is the simplest example of a composed asynchronous operation, where we
+// simply repackage an existing operation. The asynchronous operation
+// requirements are met by delegating responsibility to the underlying
+// operation.
+
+template <
+  asio::completion_token_for<void(std::error_code, std::size_t)>
+    CompletionToken>
+auto async_write_message(tcp::socket& socket,
+    const char* message, CompletionToken&& token)
+  // The return type of the initiating function is deduced from the combination
+  // of:
+  //
+  // - the CompletionToken type,
+  // - the completion handler signature, and
+  // - the asynchronous operation's initiation function object.
+  //
+  // When the completion token is a simple callback, the return type is void.
+  // However, when the completion token is asio::yield_context (used for
+  // stackful coroutines) the return type would be std::size_t, and when the
+  // completion token is asio::use_future it would be std::future<std::size_t>.
+  // When the completion token is asio::deferred, the return type differs for
+  // each asynchronous operation.
+  //
+  // In C++20 we can omit the return type as it is automatically deduced from
+  // the return type of our underlying asynchronous operation.
+{
+  // When delegating to the underlying operation we must take care to perfectly
+  // forward the completion token. This ensures that our operation works
+  // correctly with move-only function objects as callbacks, as well as other
+  // completion token types.
+  return asio::async_write(socket,
+      asio::buffer(message, std::strlen(message)),
+      std::forward<CompletionToken>(token));
+}
+
+//------------------------------------------------------------------------------
+
+void test_callback()
+{
+  asio::io_context io_context;
+
+  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
+  tcp::socket socket = acceptor.accept();
+
+  // Test our asynchronous operation using a lambda as a callback.
+  async_write_message(socket, "Testing callback\r\n",
+      [](const std::error_code& error, std::size_t n)
+      {
+        if (!error)
+        {
+          std::cout << n << " bytes transferred\n";
+        }
+        else
+        {
+          std::cout << "Error: " << error.message() << "\n";
+        }
+      });
+
+  io_context.run();
+}
+
+//------------------------------------------------------------------------------
+
+void test_deferred()
+{
+  asio::io_context io_context;
+
+  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
+  tcp::socket socket = acceptor.accept();
+
+  // Test our asynchronous operation using the deferred completion token. This
+  // token causes the operation's initiating function to package up the
+  // operation with its arguments to return a function object, which may then be
+  // used to launch the asynchronous operation.
+  asio::async_operation auto op = async_write_message(
+      socket, "Testing deferred\r\n", asio::deferred);
+
+  // Launch the operation using a lambda as a callback.
+  std::move(op)(
+      [](const std::error_code& error, std::size_t n)
+      {
+        if (!error)
+        {
+          std::cout << n << " bytes transferred\n";
+        }
+        else
+        {
+          std::cout << "Error: " << error.message() << "\n";
+        }
+      });
+
+  io_context.run();
+}
+
+//------------------------------------------------------------------------------
+
+void test_future()
+{
+  asio::io_context io_context;
+
+  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
+  tcp::socket socket = acceptor.accept();
+
+  // Test our asynchronous operation using the use_future completion token.
+  // This token causes the operation's initiating function to return a future,
+  // which may be used to synchronously wait for the result of the operation.
+  std::future<std::size_t> f = async_write_message(
+      socket, "Testing future\r\n", asio::use_future);
+
+  io_context.run();
+
+  try
+  {
+    // Get the result of the operation.
+    std::size_t n = f.get();
+    std::cout << n << " bytes transferred\n";
+  }
+  catch (const std::exception& e)
+  {
+    std::cout << "Error: " << e.what() << "\n";
+  }
+}
+
+//------------------------------------------------------------------------------
+
+int main()
+{
+  test_callback();
+  test_deferred();
+  test_future();
+}

package/deps/couchbase-cxx-client/third_party/asio/asio/src/examples/cpp20/operations/composed_2.cpp

@@ -0,0 +1,225 @@
+//
+// composed_2.cpp
+// ~~~~~~~~~~~~~~
+//
+// 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)
+//
+
+#include <asio/deferred.hpp>
+#include <asio/io_context.hpp>
+#include <asio/ip/tcp.hpp>
+#include <asio/use_future.hpp>
+#include <asio/write.hpp>
+#include <cstring>
+#include <iostream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+using asio::ip::tcp;
+
+// NOTE: This example requires the new asio::async_initiate function. For
+// an example that works with the Networking TS style of completion tokens,
+// please see an older version of asio.
+
+//------------------------------------------------------------------------------
+
+// This next simplest example of a composed asynchronous operation involves
+// repackaging multiple operations but choosing to invoke just one of them. All
+// of these underlying operations have the same completion signature. The
+// asynchronous operation requirements are met by delegating responsibility to
+// the underlying operations.
+
+template <
+  asio::completion_token_for<void(std::error_code, std::size_t)>
+    CompletionToken>
+auto async_write_message(tcp::socket& socket,
+    const char* message, bool allow_partial_write,
+    CompletionToken&& token)
+  // The return type of the initiating function is deduced from the combination
+  // of:
+  //
+  // - the CompletionToken type,
+  // - the completion handler signature, and
+  // - the asynchronous operation's initiation function object.
+  //
+  // When the completion token is a simple callback, the return type is void.
+  // However, when the completion token is asio::yield_context (used for
+  // stackful coroutines) the return type would be std::size_t, and when the
+  // completion token is asio::use_future it would be std::future<std::size_t>.
+  // When the completion token is asio::deferred, the return type differs for
+  // each asynchronous operation.
+  //
+  // In C++20 we can omit the return type as it is automatically deduced from
+  // the return type of asio::async_initiate.
+{
+  // In addition to determining the mechanism by which an asynchronous
+  // operation delivers its result, a completion token also determines the time
+  // when the operation commences. For example, when the completion token is a
+  // simple callback the operation commences before the initiating function
+  // returns. However, if the completion token's delivery mechanism uses a
+  // future, we might instead want to defer initiation of the operation until
+  // the returned future object is waited upon.
+  //
+  // To enable this, when implementing an asynchronous operation we must
+  // package the initiation step as a function object. The initiation function
+  // object's call operator is passed the concrete completion handler produced
+  // by the completion token. This completion handler matches the asynchronous
+  // operation's completion handler signature, which in this example is:
+  //
+  //   void(std::error_code error, std::size_t)
+  //
+  // The initiation function object also receives any additional arguments
+  // required to start the operation. (Note: We could have instead passed these
+  // arguments in the lambda capture set. However, we should prefer to
+  // propagate them as function call arguments as this allows the completion
+  // token to optimise how they are passed. For example, a lazy future which
+  // defers initiation would need to make a decay-copy of the arguments, but
+  // when using a simple callback the arguments can be trivially forwarded
+  // straight through.)
+  auto initiation = [](
+      asio::completion_handler_for<void(std::error_code, std::size_t)>
+        auto&& completion_handler,
+      tcp::socket& socket,
+      const char* message,
+      bool allow_partial_write)
+  {
+    if (allow_partial_write)
+    {
+      // When delegating to an underlying operation we must take care to
+      // perfectly forward the completion handler. This ensures that our
+      // operation works correctly with move-only function objects as
+      // callbacks.
+      return socket.async_write_some(
+          asio::buffer(message, std::strlen(message)),
+          std::forward<decltype(completion_handler)>(completion_handler));
+    }
+    else
+    {
+      // As above, we must perfectly forward the completion handler when calling
+      // the alternate underlying operation.
+      return asio::async_write(socket,
+          asio::buffer(message, std::strlen(message)),
+          std::forward<decltype(completion_handler)>(completion_handler));
+    }
+  };
+
+  // The asio::async_initiate function takes:
+  //
+  // - our initiation function object,
+  // - the completion token,
+  // - the completion handler signature, and
+  // - any additional arguments we need to initiate the operation.
+  //
+  // It then asks the completion token to create a completion handler (i.e. a
+  // callback) with the specified signature, and invoke the initiation function
+  // object with this completion handler as well as the additional arguments.
+  // The return value of async_initiate is the result of our operation's
+  // initiating function.
+  //
+  // Note that we wrap non-const reference arguments in std::reference_wrapper
+  // to prevent incorrect decay-copies of these objects.
+  return asio::async_initiate<
+    CompletionToken, void(std::error_code, std::size_t)>(
+      initiation, token, std::ref(socket), message, allow_partial_write);
+}
+
+//------------------------------------------------------------------------------
+
+void test_callback()
+{
+  asio::io_context io_context;
+
+  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
+  tcp::socket socket = acceptor.accept();
+
+  // Test our asynchronous operation using a lambda as a callback.
+  async_write_message(socket, "Testing callback\r\n", false,
+      [](const std::error_code& error, std::size_t n)
+      {
+        if (!error)
+        {
+          std::cout << n << " bytes transferred\n";
+        }
+        else
+        {
+          std::cout << "Error: " << error.message() << "\n";
+        }
+      });
+
+  io_context.run();
+}
+
+//------------------------------------------------------------------------------
+
+void test_deferred()
+{
+  asio::io_context io_context;
+
+  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
+  tcp::socket socket = acceptor.accept();
+
+  // Test our asynchronous operation using the deferred completion token. This
+  // token causes the operation's initiating function to package up the
+  // operation with its arguments to return a function object, which may then be
+  // used to launch the asynchronous operation.
+  asio::async_operation auto op = async_write_message(
+      socket, "Testing deferred\r\n", false, asio::deferred);
+
+  // Launch the operation using a lambda as a callback.
+  std::move(op)(
+      [](const std::error_code& error, std::size_t n)
+      {
+        if (!error)
+        {
+          std::cout << n << " bytes transferred\n";
+        }
+        else
+        {
+          std::cout << "Error: " << error.message() << "\n";
+        }
+      });
+
+  io_context.run();
+}
+
+//------------------------------------------------------------------------------
+
+void test_future()
+{
+  asio::io_context io_context;
+
+  tcp::acceptor acceptor(io_context, {tcp::v4(), 55555});
+  tcp::socket socket = acceptor.accept();
+
+  // Test our asynchronous operation using the use_future completion token.
+  // This token causes the operation's initiating function to return a future,
+  // which may be used to synchronously wait for the result of the operation.
+  std::future<std::size_t> f = async_write_message(
+      socket, "Testing future\r\n", false, asio::use_future);
+
+  io_context.run();
+
+  try
+  {
+    // Get the result of the operation.
+    std::size_t n = f.get();
+    std::cout << n << " bytes transferred\n";
+  }
+  catch (const std::exception& e)
+  {
+    std::cout << "Error: " << e.what() << "\n";
+  }
+}
+
+//------------------------------------------------------------------------------
+
+int main()
+{
+  test_callback();
+  test_deferred();
+  test_future();
+}