couchbase 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19

data/ext/third_party/asio/asio/src/doc/overview/iostreams.qbk

@@ -1,72 +0,0 @@
-[/
- / 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)
- /]
-
-[section:iostreams Socket Iostreams]
-
-Asio includes classes that implement iostreams on top of sockets. These hide
-away the complexities associated with endpoint resolution, protocol
-independence, etc. To create a connection one might simply write:
-
-  ip::tcp::iostream stream("www.boost.org", "http");
-  if (!stream)
-  {
-    // Can't connect.
-  }
-
-The iostream class can also be used in conjunction with an acceptor to create
-simple servers. For example:
-
-  io_context ioc;
-
-  ip::tcp::endpoint endpoint(tcp::v4(), 80);
-  ip::tcp::acceptor acceptor(ios, endpoint);
-
-  for (;;)
-  {
-    ip::tcp::iostream stream;
-    acceptor.accept(stream.socket());
-    ...
-  }
-
-Timeouts may be set by calling `expires_at()` or `expires_from_now()` to
-establish a deadline. Any socket operations that occur past the deadline will
-put the iostream into a "bad" state.
-
-For example, a simple client program like this:
-
-  ip::tcp::iostream stream;
-  stream.expires_from_now(boost::posix_time::seconds(60));
-  stream.connect("www.boost.org", "http");
-  stream << "GET /LICENSE_1_0.txt HTTP/1.0\r\n";
-  stream << "Host: www.boost.org\r\n";
-  stream << "Accept: */*\r\n";
-  stream << "Connection: close\r\n\r\n";
-  stream.flush();
-  std::cout << stream.rdbuf();
-
-will fail if all the socket operations combined take longer than 60 seconds.
-
-If an error does occur, the iostream's `error()` member function may be used to
-retrieve the error code from the most recent system call:
-
-  if (!stream)
-  {
-    std::cout << "Error: " << stream.error().message() << "\n";
-  }
-
-[heading See Also]
-
-[link asio.reference.ip__tcp.iostream ip::tcp::iostream],
-[link asio.reference.basic_socket_iostream basic_socket_iostream],
-[link asio.examples.cpp03_examples.iostreams iostreams examples].
-
-[heading Notes]
-
-These iostream templates only support `char`, not `wchar_t`, and do not perform
-any code conversion.
-
-[endsect]

data/ext/third_party/asio/asio/src/doc/overview/line_based.qbk

@@ -1,118 +0,0 @@
-[/
- / 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)
- /]
-
-[section:line_based Line-Based Operations]
-
-Many commonly-used internet protocols are line-based, which means that they
-have protocol elements that are delimited by the character sequence `"\r\n"`.
-Examples include HTTP, SMTP and FTP. To more easily permit the implementation
-of line-based protocols, as well as other protocols that use delimiters, Asio
-includes the functions `read_until()` and `async_read_until()`.
-
-The following example illustrates the use of `async_read_until()` in an HTTP
-server, to receive the first line of an HTTP request from a client:
-
-  class http_connection
-  {
-    ...
-
-    void start()
-    {
-      asio::async_read_until(socket_, data_, "\r\n",
-          boost::bind(&http_connection::handle_request_line, this, _1));
-    }
-
-    void handle_request_line(asio::error_code ec)
-    {
-      if (!ec)
-      {
-        std::string method, uri, version;
-        char sp1, sp2, cr, lf;
-        std::istream is(&data_);
-        is.unsetf(std::ios_base::skipws);
-        is >> method >> sp1 >> uri >> sp2 >> version >> cr >> lf;
-        ...
-      }
-    }
-
-    ...
-
-    asio::ip::tcp::socket socket_;
-    asio::streambuf data_;
-  };
-
-The `streambuf` data member serves as a place to store the data that has been
-read from the socket before it is searched for the delimiter. It is important
-to remember that there may be additional data ['after] the delimiter. This
-surplus data should be left in the `streambuf` so that it may be inspected by a
-subsequent call to `read_until()` or `async_read_until()`.
-
-The delimiters may be specified as a single `char`, a `std::string` or a
-`boost::regex`. The `read_until()` and `async_read_until()` functions also
-include overloads that accept a user-defined function object called a match
-condition. For example, to read data into a streambuf until whitespace is
-encountered:
-
-  typedef asio::buffers_iterator<
-      asio::streambuf::const_buffers_type> iterator;
-
-  std::pair<iterator, bool>
-  match_whitespace(iterator begin, iterator end)
-  {
-    iterator i = begin;
-    while (i != end)
-      if (std::isspace(*i++))
-        return std::make_pair(i, true);
-    return std::make_pair(i, false);
-  }
-  ...
-  asio::streambuf b;
-  asio::read_until(s, b, match_whitespace);
-
-To read data into a streambuf until a matching character is found:
-
-  class match_char
-  {
-  public:
-    explicit match_char(char c) : c_(c) {}
-
-    template <typename Iterator>
-    std::pair<Iterator, bool> operator()(
-        Iterator begin, Iterator end) const
-    {
-      Iterator i = begin;
-      while (i != end)
-        if (c_ == *i++)
-          return std::make_pair(i, true);
-      return std::make_pair(i, false);
-    }
-
-  private:
-    char c_;
-  };
-
-  namespace asio {
-    template <> struct is_match_condition<match_char>
-      : public boost::true_type {};
-  } // namespace asio
-  ...
-  asio::streambuf b;
-  asio::read_until(s, b, match_char('a'));
-
-The `is_match_condition<>` type trait automatically evaluates to true for
-functions, and for function objects with a nested `result_type` typedef. For
-other types the trait must be explicitly specialised, as shown above.
-
-[heading See Also]
-
-[link asio.reference.async_read_until async_read_until()],
-[link asio.reference.is_match_condition is_match_condition],
-[link asio.reference.read_until read_until()],
-[link asio.reference.streambuf streambuf],
-[link asio.examples.cpp03_examples.http_client HTTP client example].
-
-[endsect]

data/ext/third_party/asio/asio/src/doc/overview/other_protocols.qbk

@@ -1,94 +0,0 @@
-[/
- / 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)
- /]
-
-[section:other_protocols Support for Other Protocols]
-
-Support for other socket protocols (such as Bluetooth or IRCOMM sockets) can be
-added by implementing the [link asio.reference.Protocol protocol type
-requirements]. However, in many cases these protocols may also be used with
-Asio's generic protocol support. For this, Asio provides the following four
-classes:
-    
-* [link asio.reference.generic__datagram_protocol `generic::datagram_protocol`]
-* [link asio.reference.generic__raw_protocol `generic::raw_protocol`]
-* [link asio.reference.generic__seq_packet_protocol `generic::seq_packet_protocol`]
-* [link asio.reference.generic__stream_protocol `generic::stream_protocol`]
-    
-These classes implement the [link asio.reference.Protocol protocol type
-requirements], but allow the user to specify the address family (e.g. `AF_INET`)
-and protocol type (e.g. `IPPROTO_TCP`) at runtime. For example:
-
-  asio::generic::stream_protocol::socket my_socket(my_io_context);
-  my_socket.open(asio::generic::stream_protocol(AF_INET, IPPROTO_TCP));
-  ...
-
-An endpoint class template, [link asio.reference.generic__basic_endpoint
-`asio::generic::basic_endpoint`], is included to support these protocol
-classes. This endpoint can hold any other endpoint type, provided its native
-representation fits into a `sockaddr_storage` object. This class will also
-convert from other types that implement the [link asio.reference.Endpoint
-endpoint] type requirements:
-
-  asio::ip::tcp::endpoint my_endpoint1 = ...;
-  asio::generic::stream_protocol::endpoint my_endpoint2(my_endpoint1);
-
-The conversion is implicit, so as to support the following use cases:
-
-  asio::generic::stream_protocol::socket my_socket(my_io_context);
-  asio::ip::tcp::endpoint my_endpoint = ...;
-  my_socket.connect(my_endpoint);
-
-[heading C++11 Move Construction]
-    
-When using C++11, it is possible to perform move construction from a socket (or
-acceptor) object to convert to the more generic protocol's socket (or acceptor)
-type. If the protocol conversion is valid:
-
-  Protocol1 p1 = ...;
-  Protocol2 p2(p1);
-
-then the corresponding socket conversion is allowed:
-
-  Protocol1::socket my_socket1(my_io_context);
-  ...
-  Protocol2::socket my_socket2(std::move(my_socket1));
-
-For example, one possible conversion is from a TCP socket to a generic
-stream-oriented socket:
-
-  asio::ip::tcp::socket my_socket1(my_io_context);
-  ...
-  asio::generic::stream_protocol::socket my_socket2(std::move(my_socket1));
-
-These conversions are also available for move-assignment.
-
-These conversions are not limited to the above generic protocol classes.
-User-defined protocols may take advantage of this feature by similarly ensuring
-the conversion from `Protocol1` to `Protocol2` is valid, as above.
-
-[heading Accepting Generic Sockets]
-
-As a convenience, a socket acceptor's `accept()` and `async_accept()` functions
-can directly accept into a different protocol's socket type, provided the
-corresponding protocol conversion is valid. For example, the following is
-supported because the protocol `asio::ip::tcp` is convertible to
-`asio::generic::stream_protocol`:
-
-  asio::ip::tcp::acceptor my_acceptor(my_io_context);
-  ...
-  asio::generic::stream_protocol::socket my_socket(my_io_context);
-  my_acceptor.accept(my_socket);
-
-[heading See Also]
-
-[link asio.reference.generic__datagram_protocol `generic::datagram_protocol`],
-[link asio.reference.generic__raw_protocol `generic::raw_protocol`],
-[link asio.reference.generic__seq_packet_protocol `generic::seq_packet_protocol`],
-[link asio.reference.generic__stream_protocol `generic::stream_protocol`],
-[link asio.reference.Protocol protocol type requirements].
-
-[endsect]

data/ext/third_party/asio/asio/src/doc/overview/posix.qbk

@@ -1,152 +0,0 @@
-[/
- / 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)
- /]
-
-[section:posix POSIX-Specific Functionality]
-
-[link asio.overview.posix.local UNIX Domain Sockets]
-
-[link asio.overview.posix.stream_descriptor Stream-Oriented File Descriptors]
-
-[link asio.overview.posix.fork Fork]
-
-[section:local UNIX Domain Sockets]
-
-Asio provides basic support for UNIX domain sockets (also known as local
-sockets). The simplest use involves creating a pair of connected sockets.
-The following code:
-
-  local::stream_protocol::socket socket1(my_io_context);
-  local::stream_protocol::socket socket2(my_io_context);
-  local::connect_pair(socket1, socket2);
-
-will create a pair of stream-oriented sockets. To do the same for
-datagram-oriented sockets, use:
-
-  local::datagram_protocol::socket socket1(my_io_context);
-  local::datagram_protocol::socket socket2(my_io_context);
-  local::connect_pair(socket1, socket2);
-
-A UNIX domain socket server may be created by binding an acceptor to an
-endpoint, in much the same way as one does for a TCP server:
-
-  ::unlink("/tmp/foobar"); // Remove previous binding.
-  local::stream_protocol::endpoint ep("/tmp/foobar");
-  local::stream_protocol::acceptor acceptor(my_io_context, ep);
-  local::stream_protocol::socket socket(my_io_context);
-  acceptor.accept(socket);
-
-A client that connects to this server might look like:
-
-  local::stream_protocol::endpoint ep("/tmp/foobar");
-  local::stream_protocol::socket socket(my_io_context);
-  socket.connect(ep);
-
-Transmission of file descriptors or credentials across UNIX domain sockets is
-not directly supported within Asio, but may be achieved by accessing the
-socket's underlying descriptor using the [link
-asio.reference.basic_socket.native_handle native_handle()] member function.
-
-[heading See Also]
-
-[link asio.reference.local__connect_pair local::connect_pair],
-[link asio.reference.local__datagram_protocol local::datagram_protocol],
-[link asio.reference.local__datagram_protocol.endpoint local::datagram_protocol::endpoint],
-[link asio.reference.local__datagram_protocol.socket local::datagram_protocol::socket],
-[link asio.reference.local__stream_protocol local::stream_protocol],
-[link asio.reference.local__stream_protocol.acceptor local::stream_protocol::acceptor],
-[link asio.reference.local__stream_protocol.endpoint local::stream_protocol::endpoint],
-[link asio.reference.local__stream_protocol.iostream local::stream_protocol::iostream],
-[link asio.reference.local__stream_protocol.socket local::stream_protocol::socket],
-[link asio.examples.cpp03_examples.unix_domain_sockets UNIX domain sockets examples].
-
-[heading Notes]
-
-UNIX domain sockets are only available at compile time if supported by the
-target operating system. A program may test for the macro
-`ASIO_HAS_LOCAL_SOCKETS` to determine whether they are supported.
-
-[endsect]
-
-[section:stream_descriptor Stream-Oriented File Descriptors]
-
-Asio includes classes added to permit synchronous and asynchronous read and
-write operations to be performed on POSIX file descriptors, such as pipes,
-standard input and output, and various devices.
-
-These classes also provide limited support for regular files. This support
-assumes that the underlying read and write operations provided by the operating
-system never fail with `EAGAIN` or `EWOULDBLOCK`. (This assumption normally
-holds for buffered file I/O.)  Synchronous and asynchronous read and write
-operations on file descriptors will succeed but the I/O will always be
-performed immediately. Wait operations, and operations involving
-`asio::null_buffers`, are not portably supported.
-
-For example, to perform read and write operations on standard input
-and output, the following objects may be created:
-
-  posix::stream_descriptor in(my_io_context, ::dup(STDIN_FILENO));
-  posix::stream_descriptor out(my_io_context, ::dup(STDOUT_FILENO));
-
-These are then used as synchronous or asynchronous read and write streams. This
-means the objects can be used with any of the [link asio.reference.read
-read()], [link asio.reference.async_read async_read()], [link
-asio.reference.write write()], [link asio.reference.async_write async_write()],
-[link asio.reference.read_until read_until()] or [link
-asio.reference.async_read_until async_read_until()] free functions.
-
-[heading See Also]
-
-[link asio.reference.posix__stream_descriptor posix::stream_descriptor],
-[link asio.examples.cpp03_examples.chat Chat example (C++03)],
-[link asio.examples.cpp11_examples.chat Chat example (C++11)].
-
-[heading Notes]
-
-POSIX stream descriptors are only available at compile time if supported by the
-target operating system. A program may test for the macro
-`ASIO_HAS_POSIX_STREAM_DESCRIPTOR` to determine whether they are supported.
-
-[endsect]
-
-[section:fork Fork]
-
-Asio supports programs that utilise the `fork()` system call. Provided the
-program calls `io_context.notify_fork()` at the appropriate times, Asio will
-recreate any internal file descriptors (such as the "self-pipe trick"
-descriptor used for waking up a reactor). The notification is usually performed
-as follows:
-
-  io_context_.notify_fork(asio::io_context::fork_prepare);
-  if (fork() == 0)
-  {
-    io_context_.notify_fork(asio::io_context::fork_child);
-    ...
-  }
-  else
-  {
-    io_context_.notify_fork(asio::io_context::fork_parent);
-    ...
-  }
-
-User-defined services can also be made fork-aware by overriding the
-`io_context::service::notify_fork()` virtual function.
-
-Note that any file descriptors accessible via Asio's public API (e.g. the
-descriptors underlying `basic_socket<>`, `posix::stream_descriptor`, etc.) are
-not altered during a fork. It is the program's responsibility to manage these
-as required.
-
-[heading See Also]
-
-[link asio.reference.io_context.notify_fork io_context::notify_fork()],
-[link asio.reference.io_context.fork_event io_context::fork_event],
-[link asio.reference.execution_context__service.notify_fork io_context::service::notify_fork()],
-[link asio.examples.cpp03_examples.fork Fork examples].
-
-[endsect]
-
-[endsect]

data/ext/third_party/asio/asio/src/doc/overview/proactor.dot

@@ -1,100 +0,0 @@
-digraph g
-{
-  edge
-    [
-      fontname="Helvetica",
-      fontsize=10,
-      labelfontname="Helvetica",
-      labelfontsize=10
-    ];
-
-  node
-    [
-      fontname="Helvetica",
-      fontsize=10,
-      shape=record
-    ];
-
-  initiator
-    [
-      label="Initiator"
-    ];
-
-  async_processor
-    [
-      label="Asynchronous\nOperation Processor"
-    ];
-
-  async_op
-    [
-      label="Asynchronous\nOperation"
-    ];
-
-  completion_queue
-    [
-      label="Completion\nEvent Queue"
-    ];
-
-  async_event_demuxer
-    [
-      label="Asynchronous\nEvent Demultiplexer"
-    ];
-
-  proactor
-    [
-      label="Proactor"
-    ];
-
-  handler
-    [
-      label="Completion\nHandler"
-    ];
-
-  initiator -> async_processor
-    [
-      label="uses",
-      style="dashed"
-    ];
-
-  initiator -> async_op
-    [
-      label="starts",
-      style="dashed"
-    ];
-
-  initiator -> handler
-    [
-      label="creates",
-      style="dashed"
-    ];
-
-  async_processor -> async_op
-    [
-      label="executes",
-      style="dashed"
-    ];
-
-  async_processor -> completion_queue
-    [
-      label="enqueues",
-      style="dashed"
-    ];
-
-  async_op -> handler;
-
-  async_event_demuxer -> completion_queue
-    [
-      label="dequeues",
-      style="dashed"
-    ];
-
-  proactor -> async_event_demuxer
-    [
-    ];
-
-  proactor -> handler
-    [
-      label="demultiplexes\n& dispatches"
-      style="dashed"
-    ];
-}