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

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

@@ -1,271 +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:cpp2011 C++ 2011 Support]
-
-[/boostify: non-boost docs start here]
-
-[link asio.overview.cpp2011.system_error System Errors and Error Codes]
-
-[/boostify: non-boost docs end here]
-
-[link asio.overview.cpp2011.move_objects Movable I/O Objects]
-
-[link asio.overview.cpp2011.move_handlers Movable Handlers]
-
-[link asio.overview.cpp2011.variadic Variadic Templates]
-
-[link asio.overview.cpp2011.array Array Container]
-
-[link asio.overview.cpp2011.atomic Atomics]
-
-[link asio.overview.cpp2011.shared_ptr Shared Pointers]
-
-[link asio.overview.cpp2011.chrono Chrono]
-
-[link asio.overview.cpp2011.futures Futures]
-
-[/boostify: non-boost docs start here]
-
-[section:system_error System Errors and Error Codes]
-
-When available, Asio can use the `std::error_code` and `std::system_error`
-classes for reporting errors. In this case, the names `asio::error_code` and
-`asio::system_error` will be typedefs for these standard classes.
-
-System error support is automatically enabled for [^g++] 4.6 and later, when
-the [^-std=c++0x] or [^-std=gnu++0x] compiler options are used. It may be
-disabled by defining `ASIO_DISABLE_STD_SYSTEM_ERROR`, or explicitly enabled for
-other compilers by defining `ASIO_HAS_STD_SYSTEM_ERROR`.
-
-[endsect]
-
-[/boostify: non-boost docs end here]
-
-[section:move_objects Movable I/O Objects]
-
-When move support is available (via rvalue references), Asio allows move
-construction and assignment of sockets, serial ports, POSIX descriptors and
-Windows handles.
-
-Move support allows you to write code like:
-
-  tcp::socket make_socket(io_context& i)
-  {
-    tcp::socket s(i);
-    ...
-    std::move(s);
-  }
-
-or:
-
-  class connection : public enable_shared_from_this<connection>
-  {
-  private:
-    tcp::socket socket_;
-    ...
-  public:
-    connection(tcp::socket&& s) : socket_(std::move(s)) {}
-    ...
-  };
-
-  ...
-
-  class server
-  {
-  private:
-    tcp::acceptor acceptor_;
-    ...
-    void handle_accept(error_code ec, tcp::socket socket)
-    {
-      if (!ec)
-        std::make_shared<connection>(std::move(socket))->go();
-      acceptor_.async_accept(...);
-    }
-    ...
-  };
-
-as well as:
-
-  std::vector<tcp::socket> sockets;
-  sockets.push_back(tcp::socket(...));
-
-A word of warning: There is nothing stopping you from moving these objects
-while there are pending asynchronous operations, but it is unlikely to be a
-good idea to do so. In particular, composed operations like [link
-asio.reference.async_read async_read()] store a reference to the stream object.
-Moving during the composed operation means that the composed operation may
-attempt to access a moved-from object.
-
-Move support is automatically enabled for [^g++] 4.5 and later, when the
-[^-std=c++0x] or [^-std=gnu++0x] compiler options are used. It may be disabled
-by defining `ASIO_DISABLE_MOVE`, or explicitly enabled for other compilers by
-defining `ASIO_HAS_MOVE`. Note that these macros also affect the availability
-of [link asio.overview.cpp2011.move_handlers movable handlers].
-
-[endsect]
-
-[section:move_handlers Movable Handlers]
-
-With C++11 and later, user-defined completion handlers are only required to be
-move constructible, and are not required to be copy constructible.
-
-When move support is enabled, asynchronous that are documented as follows:
-
-  template <typename Handler>
-  void async_XYZ(..., Handler handler);
-
-are actually declared as:
-
-  template <typename Handler>
-  void async_XYZ(..., Handler&& handler);
-
-The handler argument is perfectly forwarded and the move construction occurs
-within the body of `async_XYZ()`. This ensures that all other function
-arguments are evaluated prior to the move. This is critical when the other
-arguments to `async_XYZ()` are members of the handler. For example:
-
-  struct my_operation
-  {
-    unique_ptr<tcp::socket> socket;
-    unique_ptr<vector<char>> buffer;
-    ...
-    void operator(error_code ec, size_t length)
-    {
-      ...
-      socket->async_read_some(asio::buffer(*buffer), std::move(*this));
-      ...
-    }
-  };
-
-Move support is automatically enabled for [^g++] 4.5 and later, when the
-[^-std=c++0x] or [^-std=gnu++0x] compiler options are used. It may be disabled
-by defining `ASIO_DISABLE_MOVE`, or explicitly enabled for other compilers by
-defining `ASIO_HAS_MOVE`. Note that these macros also affect the availability
-of [link asio.overview.cpp2011.move_objects movable I/O objects].
-
-[endsect]
-
-[section:variadic Variadic Templates]
-
-When supported by a compiler, Asio can use variadic templates to implement the
-[link asio.reference.basic_socket_streambuf.connect
-basic_socket_streambuf::connect()] and [link
-asio.reference.basic_socket_iostream.connect basic_socket_iostream::connect()]
-functions.
-
-Support for variadic templates is automatically enabled for [^g++] 4.3 and
-later, when the [^-std=c++0x] or [^-std=gnu++0x] compiler options are used. It
-may be disabled by defining `ASIO_DISABLE_VARIADIC_TEMPLATES`, or explicitly
-enabled for other compilers by defining `ASIO_HAS_VARIADIC_TEMPLATES`.
-
-[endsect]
-
-[section:array Array Container]
-
-Where the standard library provides `std::array<>`, Asio:
-
-* Provides overloads for the [link asio.reference.buffer buffer()] function.
-
-* Uses it in preference to `boost::array<>` for the
-  [link asio.reference.ip__address_v4.bytes_type ip::address_v4::bytes_type] and
-  [link asio.reference.ip__address_v6.bytes_type ip::address_v6::bytes_type]
-  types.
-
-* Uses it in preference to `boost::array<>` where a fixed size array type is
-  needed in the implementation.
-
-Support for `std::array<>` is automatically enabled for [^g++] 4.3 and later,
-when the [^-std=c++0x] or [^-std=gnu++0x] compiler options are used, as well as
-for Microsoft Visual C++ 10. It may be disabled by defining
-`ASIO_DISABLE_STD_ARRAY`, or explicitly enabled for other compilers by
-defining `ASIO_HAS_STD_ARRAY`.
-
-[endsect]
-
-[section:atomic Atomics]
-
-Asio's implementation can use `std::atomic<>` in preference to
-`boost::detail::atomic_count`.
-
-Support for the standard atomic integer template is automatically enabled for
-[^g++] 4.5 and later, when the [^-std=c++0x] or [^-std=gnu++0x] compiler
-options are used. It may be disabled by defining `ASIO_DISABLE_STD_ATOMIC`, or
-explicitly enabled for other compilers by defining `ASIO_HAS_STD_ATOMIC`.
-
-[endsect]
-
-[section:shared_ptr Shared Pointers]
-
-Asio's implementation can use `std::shared_ptr<>` and `std::weak_ptr<>` in
-preference to the Boost equivalents.
-
-Support for the standard smart pointers is automatically enabled for [^g++] 4.3
-and later, when the [^-std=c++0x] or [^-std=gnu++0x] compiler options are used,
-as well as for Microsoft Visual C++ 10. It may be disabled by defining
-`ASIO_DISABLE_STD_SHARED_PTR`, or explicitly enabled for other compilers by
-defining `ASIO_HAS_STD_SHARED_PTR`.
-
-[endsect]
-
-[section:chrono Chrono]
-
-Asio provides timers based on the `std::chrono` facilities via the [link
-asio.reference.basic_waitable_timer basic_waitable_timer] class template.
-The typedefs [link asio.reference.system_timer system_timer], [link
-asio.reference.steady_timer steady_timer] and [link
-asio.reference.high_resolution_timer high_resolution_timer] utilise the
-standard clocks `system_clock`, `steady_clock` and `high_resolution_clock`
-respectively.
-
-Support for the `std::chrono` facilities is automatically enabled for [^g++]
-4.6 and later, when the [^-std=c++0x] or [^-std=gnu++0x] compiler options are
-used. (Note that, for [^g++], the draft-standard `monotonic_clock` is used in
-place of `steady_clock`.) Support may be disabled by defining
-`ASIO_DISABLE_STD_CHRONO`, or explicitly enabled for other compilers by
-defining `ASIO_HAS_STD_CHRONO`.
-
-When standard `chrono` is unavailable, Asio will otherwise use the Boost.Chrono
-library. The [link asio.reference.basic_waitable_timer basic_waitable_timer]
-class template may be used with either.
-
-[endsect]
-
-[section:futures Futures]
-
-The `asio::use_future` special value provides first-class support for returning a
-C++11 `std::future` from an asynchronous operation's initiating function.
-
-To use `asio::use_future`, pass it to an asynchronous operation instead of
-a normal completion handler. For example:
-
-  std::future<std::size_t> length =
-    my_socket.async_read_some(my_buffer, asio::use_future);
-
-Where a handler signature has the form:
-
-  void handler(asio::error_code ec, result_type result);
-
-the initiating function returns a `std::future` templated on `result_type`.
-In the above example, this is `std::size_t`. If the asynchronous operation
-fails, the `error_code` is converted into a `system_error` exception and
-passed back to the caller through the future.
-
-Where a handler signature has the form:
-
-  void handler(asio::error_code ec);
-
-the initiating function returns `std::future<void>`. As above, an error
-is passed back in the future as a `system_error` exception.
-
-[link asio.reference.use_future use_future],
-[link asio.reference.use_future_t use_future_t],
-[link asio.examples.cpp11_examples.futures Futures example (C++11)].
-
-[endsect]
-
-[endsect]

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

@@ -1,220 +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:handler_tracking Handler Tracking]
-
-To aid in debugging asynchronous programs, Asio provides support for handler
-tracking. When enabled by defining `ASIO_ENABLE_HANDLER_TRACKING`, Asio
-writes debugging output to the standard error stream. The output records
-asynchronous operations and the relationships between their handlers.
-
-[teletype]
-This feature is useful when debugging and you need to know how your
-asynchronous operations are chained together, or what the pending asynchronous
-operations are. As an illustration, here is the output when you run the HTTP
-Server example, handle a single request, then shut down via Ctrl+C:
-
-  @asio|1512254357.979980|0*1|signal_set@0x7ffeaaaa20d8.async_wait
-  @asio|1512254357.980127|0*2|socket@0x7ffeaaaa20f8.async_accept
-  @asio|1512254357.980150|.2|non_blocking_accept,ec=asio.system:11
-  @asio|1512254357.980162|0|resolver@0x7ffeaaaa1fd8.cancel
-  @asio|1512254368.457147|.2|non_blocking_accept,ec=system:0
-  @asio|1512254368.457193|>2|ec=system:0
-  @asio|1512254368.457219|2*3|socket@0x55cf39f0a238.async_receive
-  @asio|1512254368.457244|.3|non_blocking_recv,ec=system:0,bytes_transferred=141
-  @asio|1512254368.457275|2*4|socket@0x7ffeaaaa20f8.async_accept
-  @asio|1512254368.457293|.4|non_blocking_accept,ec=asio.system:11
-  @asio|1512254368.457301|<2|
-  @asio|1512254368.457310|>3|ec=system:0,bytes_transferred=141
-  @asio|1512254368.457441|3*5|socket@0x55cf39f0a238.async_send
-  @asio|1512254368.457502|.5|non_blocking_send,ec=system:0,bytes_transferred=156
-  @asio|1512254368.457511|<3|
-  @asio|1512254368.457519|>5|ec=system:0,bytes_transferred=156
-  @asio|1512254368.457544|5|socket@0x55cf39f0a238.close
-  @asio|1512254368.457559|<5|
-  @asio|1512254371.385106|>1|ec=system:0,signal_number=2
-  @asio|1512254371.385130|1|socket@0x7ffeaaaa20f8.close
-  @asio|1512254371.385163|<1|
-  @asio|1512254371.385175|>4|ec=asio.system:125
-  @asio|1512254371.385182|<4|
-  @asio|1512254371.385202|0|signal_set@0x7ffeaaaa20d8.cancel
-
-Each line is of the form:
-
-  <tag>|<timestamp>|<action>|<description>
-
-The `<tag>` is always `@asio`, and is used to identify and extract the handler
-tracking messages from the program output.
-
-The `<timestamp>` is seconds and microseconds from 1 Jan 1970 UTC.
-
-The `<action>` takes one of the following forms:
-
-[variablelist
-  [
-    [>n]
-    [The program entered the handler number `n`. The `<description>` shows the
-    arguments to the handler.]
-  ]
-  [
-    [<n]
-    [The program left handler number `n`.]
-  ]
-  [
-    [!n]
-    [The program left handler number n due to an exception.]
-  ]
-  [
-    [~n]
-    [The handler number `n` was destroyed without having been invoked. This is
-    usually the case for any unfinished asynchronous operations when the
-    `io_context` is destroyed.]
-  ]
-  [
-    [n*m]
-    [The handler number `n` created a new asynchronous operation with completion
-    handler number `m`. The `<description>` shows what asynchronous operation
-    was started.]
-  ]
-  [
-    [n]
-    [The handler number `n` performed some other operation. The `<description>`
-    shows what function was called. Currently only `close()` and `cancel()`
-    operations are logged, as these may affect the state of pending
-    asynchronous operations.]
-  ]
-  [
-    [.n]
-    [The implementation performed a system call as part of the asynchronous
-    operation for which handler number `n` is the completion handler. The
-    `<description>` shows what function was called and its results. These
-    tracking events are only emitted when using a reactor-based
-    implementation.]
-  ]
-]
-
-Where the `<description>` shows a synchronous or asynchronous operation, the
-format is `<object-type>@<pointer>.<operation>`. For handler entry, it shows a
-comma-separated list of arguments and their values.
-
-As shown above, Each handler is assigned a numeric identifier. Where the
-handler tracking output shows a handler number of 0, it means that the action
-was performed outside of any handler.
-
-[heading Visual Representations]
-
-The handler tracking output may be post-processed using the included
-[^handlerviz.pl] tool to create a visual representation of the handlers
-(requires the GraphViz tool [^dot]).
-[c++]
-
-[heading Custom Tracking]
-
-Handling tracking may be customised by defining the
-`ASIO_CUSTOM_HANDLER_TRACKING` macro to the name of a header file
-(enclosed in `""` or `<>`). This header file must implement the following
-preprocessor macros:
-
-[table
-  [[Macro] [Description]]
-  [
-    [`ASIO_INHERIT_TRACKED_HANDLER`]
-    [Specifies a base class for classes that implement asynchronous operations.
-    When used, the macro immediately follows the class name, so it must have
-    the form `: public my_class`.]
-  ]
-  [
-    [`ASIO_ALSO_INHERIT_TRACKED_HANDLER`]
-    [Specifies a base class for classes that implement asynchronous operations.
-    When used, the macro follows other base classes, so it must have the form
-    `, public my_class`.]
-  ]
-  [
-    [`ASIO_HANDLER_TRACKING_INIT(args)`]
-    [An expression that is used to initialise the tracking mechanism.]
-  ]
-  [
-    [`ASIO_HANDLER_CREATION(args)`]
-    [An expression that is called on creation of an asynchronous operation.
-    `args` is a parenthesised function argument list containing the owning
-    execution context, the tracked handler, the name of the object type, a
-    pointer to the object, the object's native handle, and the operation name.]
-  ]
-  [
-    [`ASIO_HANDLER_COMPLETION(args)`]
-    [An expression that is called on completion of an asynchronous operation.
-    `args` is a parenthesised function argument list containing the tracked
-    handler.]
-  ]
-  [
-    [`ASIO_HANDLER_INVOCATION_BEGIN(args)`]
-    [An expression that is called immediately before a completion handler is
-    invoked. `args` is a parenthesised function argument list containing the
-    arguments to the completion handler.]
-  ]
-  [
-    [`ASIO_HANDLER_INVOCATION_END`]
-    [An expression that is called immediately after a completion handler is
-    invoked.]
-  ]
-  [
-    [`ASIO_HANDLER_OPERATION(args)`]
-    [An expression that is called when some synchronous object operation is
-    called (such as `close()` or `cancel()`). `args` is a parenthesised
-    function argument list containing the owning execution context, the name
-    of the object type, a pointer to the object, the object's native handle,
-    and the operation name.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_REGISTRATION(args)`]
-    [An expression that is called when an object is registered with the
-    reactor. `args` is a parenthesised function argument list containing the
-    owning execution context, the object's native handle, and a unique
-    registration key.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_DEREGISTRATION(args)`]
-    [An expression that is called when an object is deregistered from the
-    reactor. `args` is a parenthesised function argument list containing the
-    owning execution context, the object's native handle, and a unique
-    registration key.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_READ_EVENT`]
-    [A bitmask constant used to identify reactor read readiness events.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_WRITE_EVENT`]
-    [A bitmask constant used to identify reactor write readiness events.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_ERROR_EVENT`]
-    [A bitmask constant used to identify reactor error readiness events.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_EVENTS(args)`]
-    [An expression that is called when an object registered with the reactor
-    becomes ready. `args` is a parenthesised function argument list containing
-    the owning execution context, the unique registration key, and a bitmask of
-    the ready events.]
-  ]
-  [
-    [`ASIO_HANDLER_REACTOR_OPERATION(args)`]
-    [An expression that is called when the implementation performs a system
-    call as part of a reactor-based asynchronous operation. `args` is a
-    parenthesised function argument list containing the tracked handler, the
-    operation name, the error code produced by the operation, and (optionally)
-    the number of bytes transferred.]
-  ]
-]
-
-[heading See Also]
-
-[link asio.examples.cpp11_examples.handler_tracking Custom handler tracking
-example].
-
-[endsect]