RubyGems - couchbase - Versions diffs - 3.0.0.alpha.4-x86_64-linux → 3.5.0-x86_64-linux - Mend

couchbase 3.0.0.alpha.4-x86_64-linux → 3.5.0-x86_64-linux

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2212) hide show

data/ext/third_party/asio/asio/src/doc/overview/implementation.qbk DELETED Viewed

@@ -1,305 +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:implementation Platform-Specific Implementation Notes]
-This section lists platform-specific implementation details, such as the
-default demultiplexing mechanism, the number of threads created internally, and
-when threads are created.
-[heading Linux Kernel 2.4]
-Demultiplexing mechanism:
-* Uses `select` for demultiplexing. This means that the number of file
-descriptors in the process cannot be permitted to exceed `FD_SETSIZE`.
-Threads:
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-Scatter-Gather:
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-[heading Linux Kernel 2.6]
-Demultiplexing mechanism:
-* Uses `epoll` for demultiplexing.
-Threads:
-* Demultiplexing using `epoll` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-Scatter-Gather:
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-[heading Solaris]
-Demultiplexing mechanism:
-* Uses [^/dev/poll] for demultiplexing.
-Threads:
-* Demultiplexing using [^/dev/poll] is performed in one of the threads that
-calls `io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-Scatter-Gather:
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-[heading QNX Neutrino]
-Demultiplexing mechanism:
-* Uses `select` for demultiplexing. This means that the number of file
-descriptors in the process cannot be permitted to exceed `FD_SETSIZE`.
-Threads:
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-Scatter-Gather:
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-[heading Mac OS X]
-Demultiplexing mechanism:
-* Uses `kqueue` for demultiplexing.
-Threads:
-* Demultiplexing using `kqueue` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-Scatter-Gather:
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-[heading FreeBSD]
-Demultiplexing mechanism:
-* Uses `kqueue` for demultiplexing.
-Threads:
-* Demultiplexing using `kqueue` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-Scatter-Gather:
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-[heading AIX]
-Demultiplexing mechanism:
-* Uses `select` for demultiplexing. This means that the number of file
-descriptors in the process cannot be permitted to exceed `FD_SETSIZE`.
-Threads:
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-Scatter-Gather:
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-[heading HP-UX]
-Demultiplexing mechanism:
-* Uses `select` for demultiplexing. This means that the number of file
-descriptors in the process cannot be permitted to exceed `FD_SETSIZE`.
-Threads:
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-Scatter-Gather:
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-[heading Tru64]
-Demultiplexing mechanism:
-* Uses `select` for demultiplexing. This means that the number of file
-descriptors in the process cannot be permitted to exceed `FD_SETSIZE`.
-Threads:
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-Scatter-Gather:
-* At most `min(64,IOV_MAX)` buffers may be transferred in a single operation.
-[heading Windows 95, 98 and Me]
-Demultiplexing mechanism:
-* Uses `select` for demultiplexing.
-Threads:
-* Demultiplexing using `select` is performed in one of the threads that calls
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-Scatter-Gather:
-* For sockets, at most 16 buffers may be transferred in a single operation.
-[heading Windows NT, 2000, XP, 2003, Vista, 7 and 8]
-Demultiplexing mechanism:
-* Uses overlapped I/O and I/O completion ports for all asynchronous socket
-operations except for asynchronous connect.
-* Uses `select` for emulating asynchronous connect.
-Threads:
-* Demultiplexing using I/O completion ports is performed in all threads that call
-`io_context::run()`, `io_context::run_one()`, `io_context::poll()` or
-`io_context::poll_one()`.
-* An additional thread per `io_context` is used to trigger timers. This thread
-is created on construction of the first `basic_deadline_timer` or
-`basic_waitable_timer` objects.
-* An additional thread per `io_context` is used for the `select`
-demultiplexing. This thread is created on the first call to `async_connect()`.
-* An additional thread per `io_context` is used to emulate asynchronous host
-resolution. This thread is created on the first call to either
-`ip::tcp::resolver::async_resolve()` or `ip::udp::resolver::async_resolve()`.
-Scatter-Gather:
-* For sockets, at most 64 buffers may be transferred in a single operation.
-* For stream-oriented handles, only one buffer may be transferred in a single
-operation.
-[heading Windows Runtime]
-Asio provides limited support for the Windows Runtime. It requires that the
-language extensions be enabled. Due to the restricted facilities exposed by the
-Windows Runtime API, the support comes with the following caveats:
-* The core facilities such as the `io_context`, `strand`, buffers, composed
-  operations, timers, etc., should all work as normal.
-* For sockets, only client-side TCP is supported.
-* Explicit binding of a client-side TCP socket is not supported.
-* The `cancel()` function is not supported for sockets. Asynchronous
-  operations may only be cancelled by closing the socket.
-* Operations that use `null_buffers` are not supported.
-* Only `tcp::no_delay` and `socket_base::keep_alive` options are supported.
-* Resolvers do not support service names, only numbers. I.e. you must
-  use "80" rather than "http".
-* Most resolver query flags have no effect.
-Demultiplexing mechanism:
-* Uses the `Windows::Networking::Sockets::StreamSocket` class to implement
-  asynchronous TCP socket operations.
-Threads:
-* Event completions are delivered to the Windows thread pool and posted to the
-  `io_context` for the handler to be executed.
-* An additional thread per `io_context` is used to trigger timers. This thread
-  is created on construction of the first timer objects.
-Scatter-Gather:
-* For sockets, at most one buffer may be transferred in a single operation.
-[endsect]

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

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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]