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/cpp11/http/server/request_parser.hpp

@@ -1,96 +0,0 @@
-//
-// request_parser.hpp
-// ~~~~~~~~~~~~~~~~~~
-//
-// 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)
-//
-
-#ifndef HTTP_REQUEST_PARSER_HPP
-#define HTTP_REQUEST_PARSER_HPP
-
-#include <tuple>
-
-namespace http {
-namespace server {
-
-struct request;
-
-/// Parser for incoming requests.
-class request_parser
-{
-public:
-  /// Construct ready to parse the request method.
-  request_parser();
-
-  /// Reset to initial parser state.
-  void reset();
-
-  /// Result of parse.
-  enum result_type { good, bad, indeterminate };
-
-  /// Parse some data. The enum return value is good when a complete request has
-  /// been parsed, bad if the data is invalid, indeterminate when more data is
-  /// required. The InputIterator return value indicates how much of the input
-  /// has been consumed.
-  template <typename InputIterator>
-  std::tuple<result_type, InputIterator> parse(request& req,
-      InputIterator begin, InputIterator end)
-  {
-    while (begin != end)
-    {
-      result_type result = consume(req, *begin++);
-      if (result == good || result == bad)
-        return std::make_tuple(result, begin);
-    }
-    return std::make_tuple(indeterminate, begin);
-  }
-
-private:
-  /// Handle the next character of input.
-  result_type consume(request& req, char input);
-
-  /// Check if a byte is an HTTP character.
-  static bool is_char(int c);
-
-  /// Check if a byte is an HTTP control character.
-  static bool is_ctl(int c);
-
-  /// Check if a byte is defined as an HTTP tspecial character.
-  static bool is_tspecial(int c);
-
-  /// Check if a byte is a digit.
-  static bool is_digit(int c);
-
-  /// The current state of the parser.
-  enum state
-  {
-    method_start,
-    method,
-    uri,
-    http_version_h,
-    http_version_t_1,
-    http_version_t_2,
-    http_version_p,
-    http_version_slash,
-    http_version_major_start,
-    http_version_major,
-    http_version_minor_start,
-    http_version_minor,
-    expecting_newline_1,
-    header_line_start,
-    header_lws,
-    header_name,
-    space_before_header_value,
-    header_value,
-    expecting_newline_2,
-    expecting_newline_3
-  } state_;
-};
-
-} // namespace server
-} // namespace http
-
-#endif // HTTP_REQUEST_PARSER_HPP

data/ext/third_party/asio/asio/src/examples/cpp11/http/server/server.cpp

@@ -1,94 +0,0 @@
-//
-// 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 "server.hpp"
-#include <signal.h>
-#include <utility>
-
-namespace http {
-namespace server {
-
-server::server(const std::string& address, const std::string& port,
-    const std::string& doc_root)
-  : io_context_(1),
-    signals_(io_context_),
-    acceptor_(io_context_),
-    connection_manager_(),
-    request_handler_(doc_root)
-{
-  // Register to handle the signals that indicate when the server should exit.
-  // It is safe to register for the same signal multiple times in a program,
-  // provided all registration for the specified signal is made through Asio.
-  signals_.add(SIGINT);
-  signals_.add(SIGTERM);
-#if defined(SIGQUIT)
-  signals_.add(SIGQUIT);
-#endif // defined(SIGQUIT)
-
-  do_await_stop();
-
-  // Open the acceptor with the option to reuse the address (i.e. SO_REUSEADDR).
-  asio::ip::tcp::resolver resolver(io_context_);
-  asio::ip::tcp::endpoint endpoint =
-    *resolver.resolve(address, port).begin();
-  acceptor_.open(endpoint.protocol());
-  acceptor_.set_option(asio::ip::tcp::acceptor::reuse_address(true));
-  acceptor_.bind(endpoint);
-  acceptor_.listen();
-
-  do_accept();
-}
-
-void server::run()
-{
-  // The io_context::run() call will block until all asynchronous operations
-  // have finished. While the server is running, there is always at least one
-  // asynchronous operation outstanding: the asynchronous accept call waiting
-  // for new incoming connections.
-  io_context_.run();
-}
-
-void server::do_accept()
-{
-  acceptor_.async_accept(
-      [this](std::error_code ec, asio::ip::tcp::socket socket)
-      {
-        // Check whether the server was stopped by a signal before this
-        // completion handler had a chance to run.
-        if (!acceptor_.is_open())
-        {
-          return;
-        }
-
-        if (!ec)
-        {
-          connection_manager_.start(std::make_shared<connection>(
-              std::move(socket), connection_manager_, request_handler_));
-        }
-
-        do_accept();
-      });
-}
-
-void server::do_await_stop()
-{
-  signals_.async_wait(
-      [this](std::error_code /*ec*/, int /*signo*/)
-      {
-        // The server is stopped by cancelling all outstanding asynchronous
-        // operations. Once all operations have finished the io_context::run()
-        // call will exit.
-        acceptor_.close();
-        connection_manager_.stop_all();
-      });
-}
-
-} // namespace server
-} // namespace http

data/ext/third_party/asio/asio/src/examples/cpp11/http/server/server.hpp

@@ -1,64 +0,0 @@
-//
-// server.hpp
-// ~~~~~~~~~~
-//
-// 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)
-//
-
-#ifndef HTTP_SERVER_HPP
-#define HTTP_SERVER_HPP
-
-#include <asio.hpp>
-#include <string>
-#include "connection.hpp"
-#include "connection_manager.hpp"
-#include "request_handler.hpp"
-
-namespace http {
-namespace server {
-
-/// The top-level class of the HTTP server.
-class server
-{
-public:
-  server(const server&) = delete;
-  server& operator=(const server&) = delete;
-
-  /// Construct the server to listen on the specified TCP address and port, and
-  /// serve up files from the given directory.
-  explicit server(const std::string& address, const std::string& port,
-      const std::string& doc_root);
-
-  /// Run the server's io_context loop.
-  void run();
-
-private:
-  /// Perform an asynchronous accept operation.
-  void do_accept();
-
-  /// Wait for a request to stop the server.
-  void do_await_stop();
-
-  /// The io_context used to perform asynchronous operations.
-  asio::io_context io_context_;
-
-  /// The signal_set is used to register for process termination notifications.
-  asio::signal_set signals_;
-
-  /// Acceptor used to listen for incoming connections.
-  asio::ip::tcp::acceptor acceptor_;
-
-  /// The connection manager which owns all live connections.
-  connection_manager connection_manager_;
-
-  /// The handler for all incoming requests.
-  request_handler request_handler_;
-};
-
-} // namespace server
-} // namespace http
-
-#endif // HTTP_SERVER_HPP

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

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

data/ext/third_party/asio/asio/src/examples/cpp11/invocation/prioritised_handlers.cpp

@@ -1,202 +0,0 @@
-//
-// prioritised_handlers.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 <iostream>
-#include <memory>
-#include <queue>
-
-using asio::ip::tcp;
-
-class handler_priority_queue : public asio::execution_context
-{
-public:
-  template <typename Function>
-  void add(int priority, Function function)
-  {
-    std::unique_ptr<queued_handler_base> handler(
-        new queued_handler<Function>(
-          priority, std::move(function)));
-
-    handlers_.push(std::move(handler));
-  }
-
-  void execute_all()
-  {
-    while (!handlers_.empty())
-    {
-      handlers_.top()->execute();
-      handlers_.pop();
-    }
-  }
-
-  class executor
-  {
-  public:
-    executor(handler_priority_queue& q, int p)
-      : context_(q), priority_(p)
-    {
-    }
-
-    handler_priority_queue& context() const noexcept
-    {
-      return context_;
-    }
-
-    template <typename Function, typename Allocator>
-    void dispatch(Function f, const Allocator&) const
-    {
-      context_.add(priority_, std::move(f));
-    }
-
-    template <typename Function, typename Allocator>
-    void post(Function f, const Allocator&) const
-    {
-      context_.add(priority_, std::move(f));
-    }
-
-    template <typename Function, typename Allocator>
-    void defer(Function f, const Allocator&) const
-    {
-      context_.add(priority_, std::move(f));
-    }
-
-    void on_work_started() const noexcept {}
-    void on_work_finished() const noexcept {}
-
-    bool operator==(const executor& other) const noexcept
-    {
-      return &context_ == &other.context_ && priority_ == other.priority_;
-    }
-
-    bool operator!=(const executor& other) const noexcept
-    {
-      return !operator==(other);
-    }
-
-  private:
-    handler_priority_queue& context_;
-    int priority_;
-  };
-
-  template <typename Handler>
-  asio::executor_binder<Handler, executor>
-  wrap(int priority, Handler handler)
-  {
-    return asio::bind_executor(
-        executor(*this, priority), std::move(handler));
-  }
-
-private:
-  class queued_handler_base
-  {
-  public:
-    queued_handler_base(int p)
-      : priority_(p)
-    {
-    }
-
-    virtual ~queued_handler_base()
-    {
-    }
-
-    virtual void execute() = 0;
-
-    friend bool operator<(const std::unique_ptr<queued_handler_base>& a,
-        const std::unique_ptr<queued_handler_base>& b) noexcept
-    {
-      return a->priority_ < b->priority_;
-    }
-
-  private:
-    int priority_;
-  };
-
-  template <typename Function>
-  class queued_handler : public queued_handler_base
-  {
-  public:
-    queued_handler(int p, Function f)
-      : queued_handler_base(p), function_(std::move(f))
-    {
-    }
-
-    void execute() override
-    {
-      function_();
-    }
-
-  private:
-    Function function_;
-  };
-
-  std::priority_queue<std::unique_ptr<queued_handler_base>> handlers_;
-};
-
-//----------------------------------------------------------------------
-
-void high_priority_handler(const asio::error_code& /*ec*/,
-    tcp::socket /*socket*/)
-{
-  std::cout << "High priority handler\n";
-}
-
-void middle_priority_handler(const asio::error_code& /*ec*/)
-{
-  std::cout << "Middle priority handler\n";
-}
-
-struct low_priority_handler
-{
-  // Make the handler a move-only type.
-  low_priority_handler() = default;
-  low_priority_handler(const low_priority_handler&) = delete;
-  low_priority_handler(low_priority_handler&&) = default;
-
-  void operator()()
-  {
-    std::cout << "Low priority handler\n";
-  }
-};
-
-int main()
-{
-  asio::io_context io_context;
-
-  handler_priority_queue pri_queue;
-
-  // Post a completion handler to be run immediately.
-  asio::post(io_context, pri_queue.wrap(0, low_priority_handler()));
-
-  // Start an asynchronous accept that will complete immediately.
-  tcp::endpoint endpoint(asio::ip::address_v4::loopback(), 0);
-  tcp::acceptor acceptor(io_context, endpoint);
-  tcp::socket server_socket(io_context);
-  acceptor.async_accept(pri_queue.wrap(100, high_priority_handler));
-  tcp::socket client_socket(io_context);
-  client_socket.connect(acceptor.local_endpoint());
-
-  // Set a deadline timer to expire immediately.
-  asio::steady_timer timer(io_context);
-  timer.expires_at(asio::steady_timer::clock_type::time_point::min());
-  timer.async_wait(pri_queue.wrap(42, middle_priority_handler));
-
-  while (io_context.run_one())
-  {
-    // The custom invocation hook adds the handlers to the priority queue
-    // rather than executing them from within the poll_one() call.
-    while (io_context.poll_one())
-      ;
-
-    pri_queue.execute_all();
-  }
-
-  return 0;
-}