couchbase 3.0.0.alpha.2-universal-darwin-19 → 3.0.0-universal-darwin-19

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

@@ -1,219 +0,0 @@
-//
-// composed_7.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/compose.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_compose function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation shows composition of multiple underlying operations.
-// It automatically serialises a message, using its I/O streams insertion
-// operator, before sending it N times on the socket. To do this, it must
-// allocate a buffer for the encoded message and ensure this buffer's validity
-// until all underlying async_write operation complete. A one second delay is
-// inserted prior to each write operation, using a steady_timer.
-
-template <typename T, typename CompletionToken>
-auto async_write_messages(tcp::socket& socket,
-    const T& message, std::size_t repeat_count,
-    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.
-{
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the composed asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // Create a steady_timer to be used for the delay between messages.
-  std::unique_ptr<asio::steady_timer> delay_timer(
-      new asio::steady_timer(socket.get_executor()));
-
-  // To manage the cycle between the multiple underlying asychronous
-  // operations, our implementation is a state machine.
-  enum { starting, waiting, writing };
-
-  // The asio::async_compose function takes:
-  //
-  // - our asynchronous operation implementation,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any I/O objects (or executors) used by the operation
-  //
-  // It then wraps our implementation, which is implemented here as a state
-  // machine in a lambda, in an intermediate completion handler that meets the
-  // requirements of a conforming asynchronous operation. This includes
-  // tracking outstanding work against the I/O executors associated with the
-  // operation (in this example, this is the socket's executor).
-  //
-  // The first argument to our lambda is a reference to the enclosing
-  // intermediate completion handler. This intermediate completion handler is
-  // provided for us by the asio::async_compose function, and takes care
-  // of all the details required to implement a conforming asynchronous
-  // operation. When calling an underlying asynchronous operation, we pass it
-  // this enclosing intermediate completion handler as the completion token.
-  //
-  // All arguments to our lambda after the first must be defaulted to allow the
-  // state machine to be started, as well as to allow the completion handler to
-  // match the completion signature of both the async_write and
-  // steady_timer::async_wait operations.
-  return asio::async_compose<
-    CompletionToken, void(std::error_code)>(
-      [
-        // The implementation holds a reference to the socket as it is used for
-        // multiple async_write operations.
-        &socket,
-
-        // The allocated buffer for the encoded message. The std::unique_ptr
-        // smart pointer is move-only, and as a consequence our lambda
-        // implementation is also move-only.
-        encoded_message = std::move(encoded_message),
-
-        // The repeat count remaining.
-        repeat_count,
-
-        // A steady timer used for introducing a delay.
-        delay_timer = std::move(delay_timer),
-
-        // To manage the cycle between the multiple underlying asychronous
-        // operations, our implementation is a state machine.
-        state = starting
-      ]
-      (
-        auto& self,
-        const std::error_code& error = {},
-        std::size_t = 0
-      ) mutable
-      {
-        if (!error)
-        {
-          switch (state)
-          {
-          case starting:
-          case writing:
-            if (repeat_count > 0)
-            {
-              --repeat_count;
-              state = waiting;
-              delay_timer->expires_after(std::chrono::seconds(1));
-              delay_timer->async_wait(std::move(self));
-              return; // Composed operation not yet complete.
-            }
-            break; // Composed operation complete, continue below.
-          case waiting:
-            state = writing;
-            asio::async_write(socket,
-                asio::buffer(*encoded_message), std::move(self));
-            return; // Composed operation not yet complete.
-          }
-        }
-
-        // This point is reached only on completion of the entire composed
-        // operation.
-
-        // Deallocate the encoded message and delay timer before calling the
-        // user-supplied completion handler.
-        encoded_message.reset();
-        delay_timer.reset();
-
-        // Call the user-supplied handler with the result of the operation.
-        self.complete(error);
-      },
-      token, socket);
-}
-
-//------------------------------------------------------------------------------
-
-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_messages(socket, "Testing callback\r\n", 5,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages 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_messages(
-      socket, "Testing future\r\n", 5, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Messages sent\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_8.cpp

@@ -1,212 +0,0 @@
-//
-// composed_8.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/compose.hpp>
-#include <asio/coroutine.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_future.hpp>
-#include <asio/write.hpp>
-#include <functional>
-#include <iostream>
-#include <memory>
-#include <sstream>
-#include <string>
-#include <type_traits>
-#include <utility>
-
-using asio::ip::tcp;
-
-// NOTE: This example requires the new asio::async_compose function. For
-// an example that works with the Networking TS style of completion tokens,
-// please see an older version of asio.
-
-//------------------------------------------------------------------------------
-
-// This composed operation shows composition of multiple underlying operations,
-// using asio's stackless coroutines support to express the flow of control. It
-// automatically serialises a message, using its I/O streams insertion
-// operator, before sending it N times on the socket. To do this, it must
-// allocate a buffer for the encoded message and ensure this buffer's validity
-// until all underlying async_write operation complete. A one second delay is
-// inserted prior to each write operation, using a steady_timer.
-
-#include <asio/yield.hpp>
-
-template <typename T, typename CompletionToken>
-auto async_write_messages(tcp::socket& socket,
-    const T& message, std::size_t repeat_count,
-    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.
-{
-  // Encode the message and copy it into an allocated buffer. The buffer will
-  // be maintained for the lifetime of the composed asynchronous operation.
-  std::ostringstream os;
-  os << message;
-  std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
-
-  // Create a steady_timer to be used for the delay between messages.
-  std::unique_ptr<asio::steady_timer> delay_timer(
-      new asio::steady_timer(socket.get_executor()));
-
-  // The asio::async_compose function takes:
-  //
-  // - our asynchronous operation implementation,
-  // - the completion token,
-  // - the completion handler signature, and
-  // - any I/O objects (or executors) used by the operation
-  //
-  // It then wraps our implementation, which is implemented here as a stackless
-  // coroutine in a lambda, in an intermediate completion handler that meets the
-  // requirements of a conforming asynchronous operation. This includes
-  // tracking outstanding work against the I/O executors associated with the
-  // operation (in this example, this is the socket's executor).
-  //
-  // The first argument to our lambda is a reference to the enclosing
-  // intermediate completion handler. This intermediate completion handler is
-  // provided for us by the asio::async_compose function, and takes care
-  // of all the details required to implement a conforming asynchronous
-  // operation. When calling an underlying asynchronous operation, we pass it
-  // this enclosing intermediate completion handler as the completion token.
-  //
-  // All arguments to our lambda after the first must be defaulted to allow the
-  // state machine to be started, as well as to allow the completion handler to
-  // match the completion signature of both the async_write and
-  // steady_timer::async_wait operations.
-  return asio::async_compose<
-    CompletionToken, void(std::error_code)>(
-      [
-        // The implementation holds a reference to the socket as it is used for
-        // multiple async_write operations.
-        &socket,
-
-        // The allocated buffer for the encoded message. The std::unique_ptr
-        // smart pointer is move-only, and as a consequence our lambda
-        // implementation is also move-only.
-        encoded_message = std::move(encoded_message),
-
-        // The repeat count remaining.
-        repeat_count,
-
-        // A steady timer used for introducing a delay.
-        delay_timer = std::move(delay_timer),
-
-        // The coroutine state.
-        coro = asio::coroutine()
-      ]
-      (
-        auto& self,
-        const std::error_code& error = {},
-        std::size_t = 0
-      ) mutable
-      {
-        reenter (coro)
-        {
-          while (repeat_count > 0)
-          {
-            --repeat_count;
-
-            delay_timer->expires_after(std::chrono::seconds(1));
-            yield delay_timer->async_wait(std::move(self));
-            if (error)
-              break;
-
-            yield asio::async_write(socket,
-                asio::buffer(*encoded_message), std::move(self));
-            if (error)
-              break;
-          }
-
-          // Deallocate the encoded message and delay timer before calling the
-          // user-supplied completion handler.
-          encoded_message.reset();
-          delay_timer.reset();
-
-          // Call the user-supplied handler with the result of the operation.
-          self.complete(error);
-        }
-      },
-      token, socket);
-}
-
-#include <asio/unyield.hpp>
-
-//------------------------------------------------------------------------------
-
-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_messages(socket, "Testing callback\r\n", 5,
-      [](const std::error_code& error)
-      {
-        if (!error)
-        {
-          std::cout << "Messages 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_messages(
-      socket, "Testing future\r\n", 5, asio::use_future);
-
-  io_context.run();
-
-  try
-  {
-    // Get the result of the operation.
-    f.get();
-    std::cout << "Messages sent\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/cpp17/Makefile.am

@@ -1,8 +0,0 @@
-EXTRA_DIST = \
-	coroutines_ts/chat_server.cpp \
-	coroutines_ts/echo_server.cpp \
-	coroutines_ts/range_based_for.cpp \
-	coroutines_ts/refactored_echo_server.cpp
-
-MAINTAINERCLEANFILES = \
-	$(srcdir)/Makefile.in

data/ext/third_party/asio/asio/src/examples/cpp17/coroutines_ts/chat_server.cpp

@@ -1,225 +0,0 @@
-//
-// chat_server.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 <cstdlib>
-#include <deque>
-#include <iostream>
-#include <list>
-#include <memory>
-#include <set>
-#include <string>
-#include <utility>
-#include <asio/awaitable.hpp>
-#include <asio/detached.hpp>
-#include <asio/co_spawn.hpp>
-#include <asio/io_context.hpp>
-#include <asio/ip/tcp.hpp>
-#include <asio/read_until.hpp>
-#include <asio/redirect_error.hpp>
-#include <asio/signal_set.hpp>
-#include <asio/steady_timer.hpp>
-#include <asio/use_awaitable.hpp>
-#include <asio/write.hpp>
-
-using asio::ip::tcp;
-using asio::awaitable;
-using asio::co_spawn;
-using asio::detached;
-using asio::redirect_error;
-using asio::use_awaitable;
-
-//----------------------------------------------------------------------
-
-class chat_participant
-{
-public:
-  virtual ~chat_participant() {}
-  virtual void deliver(const std::string& msg) = 0;
-};
-
-typedef std::shared_ptr<chat_participant> chat_participant_ptr;
-
-//----------------------------------------------------------------------
-
-class chat_room
-{
-public:
-  void join(chat_participant_ptr participant)
-  {
-    participants_.insert(participant);
-    for (auto msg: recent_msgs_)
-      participant->deliver(msg);
-  }
-
-  void leave(chat_participant_ptr participant)
-  {
-    participants_.erase(participant);
-  }
-
-  void deliver(const std::string& msg)
-  {
-    recent_msgs_.push_back(msg);
-    while (recent_msgs_.size() > max_recent_msgs)
-      recent_msgs_.pop_front();
-
-    for (auto participant: participants_)
-      participant->deliver(msg);
-  }
-
-private:
-  std::set<chat_participant_ptr> participants_;
-  enum { max_recent_msgs = 100 };
-  std::deque<std::string> recent_msgs_;
-};
-
-//----------------------------------------------------------------------
-
-class chat_session
-  : public chat_participant,
-    public std::enable_shared_from_this<chat_session>
-{
-public:
-  chat_session(tcp::socket socket, chat_room& room)
-    : socket_(std::move(socket)),
-      timer_(socket_.get_executor()),
-      room_(room)
-  {
-    timer_.expires_at(std::chrono::steady_clock::time_point::max());
-  }
-
-  void start()
-  {
-    room_.join(shared_from_this());
-
-    co_spawn(socket_.get_executor(),
-        [self = shared_from_this()]{ return self->reader(); },
-        detached);
-
-    co_spawn(socket_.get_executor(),
-        [self = shared_from_this()]{ return self->writer(); },
-        detached);
-  }
-
-  void deliver(const std::string& msg)
-  {
-    write_msgs_.push_back(msg);
-    timer_.cancel_one();
-  }
-
-private:
-  awaitable<void> reader()
-  {
-    try
-    {
-      for (std::string read_msg;;)
-      {
-        std::size_t n = co_await asio::async_read_until(socket_,
-            asio::dynamic_buffer(read_msg, 1024), "\n", use_awaitable);
-
-        room_.deliver(read_msg.substr(0, n));
-        read_msg.erase(0, n);
-      }
-    }
-    catch (std::exception&)
-    {
-      stop();
-    }
-  }
-
-  awaitable<void> writer()
-  {
-    try
-    {
-      while (socket_.is_open())
-      {
-        if (write_msgs_.empty())
-        {
-          asio::error_code ec;
-          co_await timer_.async_wait(redirect_error(use_awaitable, ec));
-        }
-        else
-        {
-          co_await asio::async_write(socket_,
-              asio::buffer(write_msgs_.front()), use_awaitable);
-          write_msgs_.pop_front();
-        }
-      }
-    }
-    catch (std::exception&)
-    {
-      stop();
-    }
-  }
-
-  void stop()
-  {
-    room_.leave(shared_from_this());
-    socket_.close();
-    timer_.cancel();
-  }
-
-  tcp::socket socket_;
-  asio::steady_timer timer_;
-  chat_room& room_;
-  std::deque<std::string> write_msgs_;
-};
-
-//----------------------------------------------------------------------
-
-awaitable<void> listener(tcp::acceptor acceptor)
-{
-  chat_room room;
-
-  for (;;)
-  {
-    std::make_shared<chat_session>(
-        co_await acceptor.async_accept(use_awaitable),
-        room
-      )->start();
-  }
-}
-
-//----------------------------------------------------------------------
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc < 2)
-    {
-      std::cerr << "Usage: chat_server <port> [<port> ...]\n";
-      return 1;
-    }
-
-    asio::io_context io_context(1);
-
-    for (int i = 1; i < argc; ++i)
-    {
-      unsigned short port = std::atoi(argv[i]);
-      co_spawn(io_context,
-          [&io_context, port]
-          {
-            return listener(tcp::acceptor(io_context, {tcp::v4(), port}));
-          },
-          detached);
-    }
-
-    asio::signal_set signals(io_context, SIGINT, SIGTERM);
-    signals.async_wait([&](auto, auto){ io_context.stop(); });
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}