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

data/ext/third_party/asio/asio/src/examples/cpp11/multicast/.gitignore

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

data/ext/third_party/asio/asio/src/examples/cpp11/multicast/receiver.cpp

@@ -1,88 +0,0 @@
-//
-// receiver.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 <array>
-#include <iostream>
-#include <string>
-#include "asio.hpp"
-
-constexpr short multicast_port = 30001;
-
-class receiver
-{
-public:
-  receiver(asio::io_context& io_context,
-      const asio::ip::address& listen_address,
-      const asio::ip::address& multicast_address)
-    : socket_(io_context)
-  {
-    // Create the socket so that multiple may be bound to the same address.
-    asio::ip::udp::endpoint listen_endpoint(
-        listen_address, multicast_port);
-    socket_.open(listen_endpoint.protocol());
-    socket_.set_option(asio::ip::udp::socket::reuse_address(true));
-    socket_.bind(listen_endpoint);
-
-    // Join the multicast group.
-    socket_.set_option(
-        asio::ip::multicast::join_group(multicast_address));
-
-    do_receive();
-  }
-
-private:
-  void do_receive()
-  {
-    socket_.async_receive_from(
-        asio::buffer(data_), sender_endpoint_,
-        [this](std::error_code ec, std::size_t length)
-        {
-          if (!ec)
-          {
-            std::cout.write(data_.data(), length);
-            std::cout << std::endl;
-
-            do_receive();
-          }
-        });
-  }
-
-  asio::ip::udp::socket socket_;
-  asio::ip::udp::endpoint sender_endpoint_;
-  std::array<char, 1024> data_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: receiver <listen_address> <multicast_address>\n";
-      std::cerr << "  For IPv4, try:\n";
-      std::cerr << "    receiver 0.0.0.0 239.255.0.1\n";
-      std::cerr << "  For IPv6, try:\n";
-      std::cerr << "    receiver 0::0 ff31::8000:1234\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-    receiver r(io_context,
-        asio::ip::make_address(argv[1]),
-        asio::ip::make_address(argv[2]));
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}

data/ext/third_party/asio/asio/src/examples/cpp11/multicast/sender.cpp

@@ -1,91 +0,0 @@
-//
-// sender.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 <sstream>
-#include <string>
-#include "asio.hpp"
-
-constexpr short multicast_port = 30001;
-constexpr int max_message_count = 10;
-
-class sender
-{
-public:
-  sender(asio::io_context& io_context,
-      const asio::ip::address& multicast_address)
-    : endpoint_(multicast_address, multicast_port),
-      socket_(io_context, endpoint_.protocol()),
-      timer_(io_context),
-      message_count_(0)
-  {
-    do_send();
-  }
-
-private:
-  void do_send()
-  {
-    std::ostringstream os;
-    os << "Message " << message_count_++;
-    message_ = os.str();
-
-    socket_.async_send_to(
-        asio::buffer(message_), endpoint_,
-        [this](std::error_code ec, std::size_t /*length*/)
-        {
-          if (!ec && message_count_ < max_message_count)
-            do_timeout();
-        });
-  }
-
-  void do_timeout()
-  {
-    timer_.expires_after(std::chrono::seconds(1));
-    timer_.async_wait(
-        [this](std::error_code ec)
-        {
-          if (!ec)
-            do_send();
-        });
-  }
-
-private:
-  asio::ip::udp::endpoint endpoint_;
-  asio::ip::udp::socket socket_;
-  asio::steady_timer timer_;
-  int message_count_;
-  std::string message_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: sender <multicast_address>\n";
-      std::cerr << "  For IPv4, try:\n";
-      std::cerr << "    sender 239.255.0.1\n";
-      std::cerr << "  For IPv6, try:\n";
-      std::cerr << "    sender ff31::8000:1234\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-    sender s(io_context, asio::ip::make_address(argv[1]));
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}

data/ext/third_party/asio/asio/src/examples/cpp11/nonblocking/.gitignore

@@ -1,10 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-third_party_lib
-*.ilk
-*.manifest
-*.pdb
-*.tds

data/ext/third_party/asio/asio/src/examples/cpp11/nonblocking/third_party_lib.cpp

@@ -1,212 +0,0 @@
-//
-// third_party_lib.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.hpp>
-#include <array>
-#include <iostream>
-#include <memory>
-
-using asio::ip::tcp;
-
-namespace third_party_lib {
-
-// Simulation of a third party library that wants to perform read and write
-// operations directly on a socket. It needs to be polled to determine whether
-// it requires a read or write operation, and notified when the socket is ready
-// for reading or writing.
-class session
-{
-public:
-  session(tcp::socket& socket)
-    : socket_(socket)
-  {
-  }
-
-  // Returns true if the third party library wants to be notified when the
-  // socket is ready for reading.
-  bool want_read() const
-  {
-    return state_ == reading;
-  }
-
-  // Notify that third party library that it should perform its read operation.
-  void do_read(std::error_code& ec)
-  {
-    if (std::size_t len = socket_.read_some(asio::buffer(data_), ec))
-    {
-      write_buffer_ = asio::buffer(data_, len);
-      state_ = writing;
-    }
-  }
-
-  // Returns true if the third party library wants to be notified when the
-  // socket is ready for writing.
-  bool want_write() const
-  {
-    return state_ == writing;
-  }
-
-  // Notify that third party library that it should perform its write operation.
-  void do_write(std::error_code& ec)
-  {
-    if (std::size_t len = socket_.write_some(
-          asio::buffer(write_buffer_), ec))
-    {
-      write_buffer_ = write_buffer_ + len;
-      state_ = asio::buffer_size(write_buffer_) > 0 ? writing : reading;
-    }
-  }
-
-private:
-  tcp::socket& socket_;
-  enum { reading, writing } state_ = reading;
-  std::array<char, 128> data_;
-  asio::const_buffer write_buffer_;
-};
-
-} // namespace third_party_lib
-
-// The glue between asio's sockets and the third party library.
-class connection
-  : public std::enable_shared_from_this<connection>
-{
-public:
-  connection(tcp::socket socket)
-    : socket_(std::move(socket))
-  {
-  }
-
-  void start()
-  {
-    // Put the socket into non-blocking mode.
-    socket_.non_blocking(true);
-
-    do_operations();
-  }
-
-private:
-  void do_operations()
-  {
-    auto self(shared_from_this());
-
-    // Start a read operation if the third party library wants one.
-    if (session_impl_.want_read() && !read_in_progress_)
-    {
-      read_in_progress_ = true;
-      socket_.async_wait(tcp::socket::wait_read,
-          [this, self](std::error_code ec)
-          {
-            read_in_progress_ = false;
-
-            // Notify third party library that it can perform a read.
-            if (!ec)
-              session_impl_.do_read(ec);
-
-            // The third party library successfully performed a read on the
-            // socket. Start new read or write operations based on what it now
-            // wants.
-            if (!ec || ec == asio::error::would_block)
-              do_operations();
-
-            // Otherwise, an error occurred. Closing the socket cancels any
-            // outstanding asynchronous read or write operations. The
-            // connection object will be destroyed automatically once those
-            // outstanding operations complete.
-            else
-              socket_.close();
-          });
-    }
-
-    // Start a write operation if the third party library wants one.
-    if (session_impl_.want_write() && !write_in_progress_)
-    {
-      write_in_progress_ = true;
-      socket_.async_wait(tcp::socket::wait_write,
-          [this, self](std::error_code ec)
-          {
-            write_in_progress_ = false;
-
-            // Notify third party library that it can perform a write.
-            if (!ec)
-              session_impl_.do_write(ec);
-
-            // The third party library successfully performed a write on the
-            // socket. Start new read or write operations based on what it now
-            // wants.
-            if (!ec || ec == asio::error::would_block)
-              do_operations();
-
-            // Otherwise, an error occurred. Closing the socket cancels any
-            // outstanding asynchronous read or write operations. The
-            // connection object will be destroyed automatically once those
-            // outstanding operations complete.
-            else
-              socket_.close();
-          });
-    }
-  }
-
-private:
-  tcp::socket socket_;
-  third_party_lib::session session_impl_{socket_};
-  bool read_in_progress_ = false;
-  bool write_in_progress_ = false;
-};
-
-class server
-{
-public:
-  server(asio::io_context& io_context, unsigned short port)
-    : acceptor_(io_context, {tcp::v4(), port})
-  {
-    do_accept();
-  }
-
-private:
-  void do_accept()
-  {
-    acceptor_.async_accept(
-        [this](std::error_code ec, tcp::socket socket)
-        {
-          if (!ec)
-          {
-            std::make_shared<connection>(std::move(socket))->start();
-          }
-
-          do_accept();
-        });
-  }
-
-  tcp::acceptor acceptor_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: third_party_lib <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server s(io_context, std::atoi(argv[1]));
-
-    io_context.run();
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}

data/ext/third_party/asio/asio/src/examples/cpp11/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/cpp11/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>.
-  -> typename asio::async_result<
-    typename std::decay<CompletionToken>::type,
-    void(std::error_code, std::size_t)>::return_type
-{
-  // 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();
-}