couchbase 3.0.0.alpha.2 → 3.0.0

data/ext/third_party/asio/asio/src/examples/cpp14/iostreams/.gitignore

@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-*_client
-*_server
-*.ilk
-*.manifest
-*.pdb
-*.tds

data/ext/third_party/asio/asio/src/examples/cpp14/iostreams/http_client.cpp

@@ -1,91 +0,0 @@
-//
-// http_client.cpp
-// ~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 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 <iostream>
-#include <istream>
-#include <ostream>
-#include <string>
-#include <asio/ts/internet.hpp>
-
-using asio::ip::tcp;
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cout << "Usage: http_client <server> <path>\n";
-      std::cout << "Example:\n";
-      std::cout << "  http_client www.boost.org /LICENSE_1_0.txt\n";
-      return 1;
-    }
-
-    asio::ip::tcp::iostream s;
-
-    // The entire sequence of I/O operations must complete within 60 seconds.
-    // If an expiry occurs, the socket is automatically closed and the stream
-    // becomes bad.
-    s.expires_after(std::chrono::seconds(60));
-
-    // Establish a connection to the server.
-    s.connect(argv[1], "http");
-    if (!s)
-    {
-      std::cout << "Unable to connect: " << s.error().message() << "\n";
-      return 1;
-    }
-
-    // Send the request. We specify the "Connection: close" header so that the
-    // server will close the socket after transmitting the response. This will
-    // allow us to treat all data up until the EOF as the content.
-    s << "GET " << argv[2] << " HTTP/1.0\r\n";
-    s << "Host: " << argv[1] << "\r\n";
-    s << "Accept: */*\r\n";
-    s << "Connection: close\r\n\r\n";
-
-    // By default, the stream is tied with itself. This means that the stream
-    // automatically flush the buffered output before attempting a read. It is
-    // not necessary not explicitly flush the stream at this point.
-
-    // Check that response is OK.
-    std::string http_version;
-    s >> http_version;
-    unsigned int status_code;
-    s >> status_code;
-    std::string status_message;
-    std::getline(s, status_message);
-    if (!s || http_version.substr(0, 5) != "HTTP/")
-    {
-      std::cout << "Invalid response\n";
-      return 1;
-    }
-    if (status_code != 200)
-    {
-      std::cout << "Response returned with status code " << status_code << "\n";
-      return 1;
-    }
-
-    // Process the response headers, which are terminated by a blank line.
-    std::string header;
-    while (std::getline(s, header) && header != "\r")
-      std::cout << header << "\n";
-    std::cout << "\n";
-
-    // Write the remaining data to output.
-    std::cout << s.rdbuf();
-  }
-  catch (std::exception& e)
-  {
-    std::cout << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}

data/ext/third_party/asio/asio/src/examples/cpp14/operations/.gitignore

@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-composed_[0-9]
-*.ilk
-*.manifest
-*.pdb
-*.tds

data/ext/third_party/asio/asio/src/examples/cpp14/operations/composed_1.cpp

@@ -1,113 +0,0 @@
-//
-// composed_1.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 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/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 <typename 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 CompletionToken type and the completion handler's signature. 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>.
-  //
-  // In C++14 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_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_future();
-}

data/ext/third_party/asio/asio/src/examples/cpp14/operations/composed_2.cpp

@@ -1,131 +0,0 @@
-//
-// composed_2.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 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/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 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 <typename 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 CompletionToken type and the completion handler's signature. 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>.
-  //
-  // In C++14 we can omit the return type as it is automatically deduced from
-  // the return type of our underlying asynchronous operation
-{
-  // As the return type of the initiating function is deduced solely from the
-  // CompletionToken and completion signature, we know that two different
-  // asynchronous operations having the same completion signature will produce
-  // the same return type, when passed the same CompletionToken. This allows us
-  // to trivially delegate to alternate implementations.
-  if (allow_partial_write)
-  {
-    // When delegating to an 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 socket.async_write_some(
-        asio::buffer(message, std::strlen(message)),
-        std::forward<CompletionToken>(token));
-  }
-  else
-  {
-    // As above, we must perfectly forward the completion token when calling
-    // the alternate underlying operation.
-    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", 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_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_future();
-}

data/ext/third_party/asio/asio/src/examples/cpp14/operations/composed_3.cpp

@@ -1,186 +0,0 @@
-//
-// composed_3.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 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/bind_executor.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <cstring>
-#include <functional>
-#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.
-
-//------------------------------------------------------------------------------
-
-// In this composed operation we repackage an existing operation, but with a
-// different completion handler signature. The asynchronous operation
-// requirements are met by delegating responsibility to the underlying
-// operation.
-
-template <typename 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 CompletionToken type and the completion handler's signature. When the
-  // completion token is a simple callback, the return type is always void.
-  // In this example, when the completion token is asio::yield_context
-  // (used for stackful coroutines) the return type would be also be void, as
-  // there is no non-error argument to the completion handler. When the
-  // completion token is asio::use_future it would be std::future<void>.
-  //
-  // In C++14 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)
-  //
-  // 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 = [](auto&& completion_handler,
-      tcp::socket& socket, const char* message)
-  {
-    // The async_write operation has a completion handler signature of:
-    //
-    //   void(std::error_code error, std::size n)
-    //
-    // This differs from our operation's signature in that it is also passed
-    // the number of bytes transferred as an argument of type std::size_t. We
-    // will adapt our completion handler to async_write's completion handler
-    // signature by using std::bind, which drops the additional argument.
-    //
-    // However, it is essential to the correctness of our composed operation
-    // that we preserve the executor of the user-supplied completion handler.
-    // The std::bind function will not do this for us, so we must do this by
-    // first obtaining the completion handler's associated executor (defaulting
-    // to the I/O executor - in this case the executor of the socket - if the
-    // completion handler does not have its own) ...
-    auto executor = asio::get_associated_executor(
-        completion_handler, socket.get_executor());
-
-    // ... and then binding this executor to our adapted completion handler
-    // using the asio::bind_executor function.
-    asio::async_write(socket,
-        asio::buffer(message, std::strlen(message)),
-        asio::bind_executor(executor,
-          std::bind(std::forward<decltype(completion_handler)>(
-              completion_handler), std::placeholders::_1)));
-  };
-
-  // 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)>(
-      initiation, token, std::ref(socket), message);
-}
-
-//------------------------------------------------------------------------------
-
-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)
-      {
-        if (!error)
-        {
-          std::cout << "Message sent\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<void> f = async_write_message(
-      socket, "Testing future\r\n", asio::use_future);
-
-  io_context.run();
-
-  // Get the result of the operation.
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Message sent\n";
-  }
-  catch (const std::exception& e)
-  {
-    std::cout << "Error: " << e.what() << "\n";
-  }
-}
-
-//------------------------------------------------------------------------------
-
-int main()
-{
-  test_callback();
-  test_future();
-}