couchbase 3.0.0.alpha.4-universal-darwin-19 → 3.0.0.alpha.5-universal-darwin-19

data/ext/third_party/asio/asio/src/examples/cpp14/echo/blocking_tcp_echo_server.cpp

@@ -1,77 +0,0 @@
-//
-// blocking_tcp_echo_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 <iostream>
-#include <thread>
-#include <utility>
-#include <asio/ts/buffer.hpp>
-#include <asio/ts/internet.hpp>
-
-using asio::ip::tcp;
-
-const int max_length = 1024;
-
-void session(tcp::socket sock)
-{
-  try
-  {
-    for (;;)
-    {
-      char data[max_length];
-
-      std::error_code error;
-      size_t length = sock.read_some(asio::buffer(data), error);
-      if (error == asio::stream_errc::eof)
-        break; // Connection closed cleanly by peer.
-      else if (error)
-        throw std::system_error(error); // Some other error.
-
-      asio::write(sock, asio::buffer(data, length));
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception in thread: " << e.what() << "\n";
-  }
-}
-
-void server(asio::io_context& io_context, unsigned short port)
-{
-  tcp::acceptor a(io_context, tcp::endpoint(tcp::v4(), port));
-  for (;;)
-  {
-    tcp::socket sock(io_context);
-    a.accept(sock);
-    std::thread(session, std::move(sock)).detach();
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: blocking_tcp_echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server(io_context, std::atoi(argv[1]));
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}

data/ext/third_party/asio/asio/src/examples/cpp14/echo/blocking_udp_echo_client.cpp

@@ -1,59 +0,0 @@
-//
-// blocking_udp_echo_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 <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <asio/ts/buffer.hpp>
-#include <asio/ts/internet.hpp>
-
-using asio::ip::udp;
-
-enum { max_length = 1024 };
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 3)
-    {
-      std::cerr << "Usage: blocking_udp_echo_client <host> <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    udp::socket s(io_context, udp::endpoint(udp::v4(), 0));
-
-    udp::resolver resolver(io_context);
-    udp::endpoint endpoint =
-      *resolver.resolve(udp::v4(), argv[1], argv[2]).begin();
-
-    std::cout << "Enter message: ";
-    char request[max_length];
-    std::cin.getline(request, max_length);
-    size_t request_length = std::strlen(request);
-    s.send_to(asio::buffer(request, request_length), endpoint);
-
-    char reply[max_length];
-    udp::endpoint sender_endpoint;
-    size_t reply_length = s.receive_from(
-        asio::buffer(reply, max_length), sender_endpoint);
-    std::cout << "Reply is: ";
-    std::cout.write(reply, reply_length);
-    std::cout << "\n";
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}

data/ext/third_party/asio/asio/src/examples/cpp14/echo/blocking_udp_echo_server.cpp

@@ -1,53 +0,0 @@
-//
-// blocking_udp_echo_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 <iostream>
-#include <asio/ts/buffer.hpp>
-#include <asio/ts/internet.hpp>
-
-using asio::ip::udp;
-
-enum { max_length = 1024 };
-
-void server(asio::io_context& io_context, unsigned short port)
-{
-  udp::socket sock(io_context, udp::endpoint(udp::v4(), port));
-  for (;;)
-  {
-    char data[max_length];
-    udp::endpoint sender_endpoint;
-    size_t length = sock.receive_from(
-        asio::buffer(data, max_length), sender_endpoint);
-    sock.send_to(asio::buffer(data, length), sender_endpoint);
-  }
-}
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 2)
-    {
-      std::cerr << "Usage: blocking_udp_echo_server <port>\n";
-      return 1;
-    }
-
-    asio::io_context io_context;
-
-    server(io_context, std::atoi(argv[1]));
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}

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

@@ -1,6 +0,0 @@
-actor
-async_[0-9]
-bank_account_[0-9]
-fork_join
-pipeline
-priority_scheduler

data/ext/third_party/asio/asio/src/examples/cpp14/executors/actor.cpp

@@ -1,281 +0,0 @@
-#include <asio/ts/executor.hpp>
-#include <condition_variable>
-#include <deque>
-#include <memory>
-#include <mutex>
-#include <typeinfo>
-#include <vector>
-
-using asio::defer;
-using asio::executor;
-using asio::post;
-using asio::strand;
-using asio::system_executor;
-
-//------------------------------------------------------------------------------
-// A tiny actor framework
-// ~~~~~~~~~~~~~~~~~~~~~~
-
-class actor;
-
-// Used to identify the sender and recipient of messages.
-typedef actor* actor_address;
-
-// Base class for all registered message handlers.
-class message_handler_base
-{
-public:
-  virtual ~message_handler_base() {}
-
-  // Used to determine which message handlers receive an incoming message.
-  virtual const std::type_info& message_id() const = 0;
-};
-
-// Base class for a handler for a specific message type.
-template <class Message>
-class message_handler : public message_handler_base
-{
-public:
-  // Handle an incoming message.
-  virtual void handle_message(Message msg, actor_address from) = 0;
-};
-
-// Concrete message handler for a specific message type.
-template <class Actor, class Message>
-class mf_message_handler : public message_handler<Message>
-{
-public:
-  // Construct a message handler to invoke the specified member function.
-  mf_message_handler(void (Actor::* mf)(Message, actor_address), Actor* a)
-    : function_(mf), actor_(a)
-  {
-  }
-
-  // Used to determine which message handlers receive an incoming message.
-  virtual const std::type_info& message_id() const
-  {
-    return typeid(Message);
-  }
-
-  // Handle an incoming message.
-  virtual void handle_message(Message msg, actor_address from)
-  {
-    (actor_->*function_)(std::move(msg), from);
-  }
-
-  // Determine whether the message handler represents the specified function.
-  bool is_function(void (Actor::* mf)(Message, actor_address)) const
-  {
-    return mf == function_;
-  }
-
-private:
-  void (Actor::* function_)(Message, actor_address);
-  Actor* actor_;
-};
-
-// Base class for all actors.
-class actor
-{
-public:
-  virtual ~actor()
-  {
-  }
-
-  // Obtain the actor's address for use as a message sender or recipient.
-  actor_address address()
-  {
-    return this;
-  }
-
-  // Send a message from one actor to another.
-  template <class Message>
-  friend void send(Message msg, actor_address from, actor_address to)
-  {
-    // Execute the message handler in the context of the target's executor.
-    post(to->executor_,
-      [=, msg=std::move(msg)]
-      {
-        to->call_handler(std::move(msg), from);
-      });
-  }
-
-protected:
-  // Construct the actor to use the specified executor for all message handlers.
-  actor(executor e)
-    : executor_(std::move(e))
-  {
-  }
-
-  // Register a handler for a specific message type. Duplicates are permitted.
-  template <class Actor, class Message>
-  void register_handler(void (Actor::* mf)(Message, actor_address))
-  {
-    handlers_.push_back(
-      std::make_shared<mf_message_handler<Actor, Message>>(
-        mf, static_cast<Actor*>(this)));
-  }
-
-  // Deregister a handler. Removes only the first matching handler.
-  template <class Actor, class Message>
-  void deregister_handler(void (Actor::* mf)(Message, actor_address))
-  {
-    const std::type_info& id = typeid(Message);
-    for (auto iter = handlers_.begin(); iter != handlers_.end(); ++iter)
-    {
-      if ((*iter)->message_id() == id)
-      {
-        auto mh = static_cast<mf_message_handler<Actor, Message>*>(iter->get());
-        if (mh->is_function(mf))
-        {
-          handlers_.erase(iter);
-          return;
-        }
-      }
-    }
-  }
-
-  // Send a message from within a message handler.
-  template <class Message>
-  void tail_send(Message msg, actor_address to)
-  {
-    // Execute the message handler in the context of the target's executor.
-    defer(to->executor_,
-      [=, msg=std::move(msg), from=this]
-      {
-        to->call_handler(std::move(msg), from);
-      });
-  }
-
-private:
-  // Find the matching message handlers, if any, and call them.
-  template <class Message>
-  void call_handler(Message msg, actor_address from)
-  {
-    const std::type_info& message_id = typeid(Message);
-    for (auto& h: handlers_)
-    {
-      if (h->message_id() == message_id)
-      {
-        auto mh = static_cast<message_handler<Message>*>(h.get());
-        mh->handle_message(msg, from);
-      }
-    }
-  }
-
-  // All messages associated with a single actor object should be processed
-  // non-concurrently. We use a strand to ensure non-concurrent execution even
-  // if the underlying executor may use multiple threads.
-  strand<executor> executor_;
-
-  std::vector<std::shared_ptr<message_handler_base>> handlers_;
-};
-
-// A concrete actor that allows synchronous message retrieval.
-template <class Message>
-class receiver : public actor
-{
-public:
-  receiver()
-    : actor(system_executor())
-  {
-    register_handler(&receiver::message_handler);
-  }
-
-  // Block until a message has been received.
-  Message wait()
-  {
-    std::unique_lock<std::mutex> lock(mutex_);
-    condition_.wait(lock, [this]{ return !message_queue_.empty(); });
-    Message msg(std::move(message_queue_.front()));
-    message_queue_.pop_front();
-    return msg;
-  }
-
-private:
-  // Handle a new message by adding it to the queue and waking a waiter.
-  void message_handler(Message msg, actor_address /* from */)
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    message_queue_.push_back(std::move(msg));
-    condition_.notify_one();
-  }
-
-  std::mutex mutex_;
-  std::condition_variable condition_;
-  std::deque<Message> message_queue_;
-};
-
-//------------------------------------------------------------------------------
-
-#include <asio/thread_pool.hpp>
-#include <iostream>
-
-using asio::thread_pool;
-
-class member : public actor
-{
-public:
-  explicit member(executor e)
-    : actor(std::move(e))
-  {
-    register_handler(&member::init_handler);
-  }
-
-private:
-  void init_handler(actor_address next, actor_address from)
-  {
-    next_ = next;
-    caller_ = from;
-
-    register_handler(&member::token_handler);
-    deregister_handler(&member::init_handler);
-  }
-
-  void token_handler(int token, actor_address /*from*/)
-  {
-    int msg(token);
-    actor_address to(caller_);
-
-    if (token > 0)
-    {
-      msg = token - 1;
-      to = next_;
-    }
-
-    tail_send(msg, to);
-  }
-
-  actor_address next_;
-  actor_address caller_;
-};
-
-int main()
-{
-  const std::size_t num_threads = 16;
-  const int num_hops = 50000000;
-  const std::size_t num_actors = 503;
-  const int token_value = (num_hops + num_actors - 1) / num_actors;
-  const std::size_t actors_per_thread = num_actors / num_threads;
-
-  struct single_thread_pool : thread_pool { single_thread_pool() : thread_pool(1) {} };
-  single_thread_pool pools[num_threads];
-  std::vector<std::shared_ptr<member>> members(num_actors);
-  receiver<int> rcvr;
-
-  // Create the member actors.
-  for (std::size_t i = 0; i < num_actors; ++i)
-    members[i] = std::make_shared<member>(pools[(i / actors_per_thread) % num_threads].get_executor());
-
-  // Initialise the actors by passing each one the address of the next actor in the ring.
-  for (std::size_t i = num_actors, next_i = 0; i > 0; next_i = --i)
-    send(members[next_i]->address(), rcvr.address(), members[i - 1]->address());
-
-  // Send exactly one token to each actor, all with the same initial value, rounding up if required.
-  for (std::size_t i = 0; i < num_actors; ++i)
-    send(token_value, rcvr.address(), members[i]->address());
-
-  // Wait for all signal messages, indicating the tokens have all reached zero.
-  for (std::size_t i = 0; i < num_actors; ++i)
-    rcvr.wait();
-}