RubyGems - couchbase - Versions diffs - 3.0.0-universal-darwin-19 → 3.0.1-universal-darwin-19 - Mend

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

Files changed (902) hide show

data/ext/third_party/asio/asio/src/doc/history.qbk DELETED

@@ -1,1794 +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:history Revision History]
-[heading Asio 1.16.1]
-* Fixed compatibility with C++20 concept syntax.
-* Marked the POSIX descriptor classes' move constructors as `noexcept`.
-* Added the `ssl::host_name_verification` class, which is a drop-in replacement
-  for `ssl::rfc2818_verification`. The `ssl::rfc2818_verification` class has
-  been marked as deprecated. As a consequence of this change, SSL support now
-  depends on functions that were introduced in OpenSSL 1.0.2.
-* Added an `ssl::context` constructor to take ownership of a native handle.
-* Changed C++ language version detection with [^gcc] to use `__cplusplus` macro.
-* Fixed a work counting issue in the asynchronous resolve operation for
-  endpoints.
-* Fixed the `strand<>` converting constructors and assignment operators.
-* Ensured that resolvers are restarted correctly after a fork.
-* Fixed compatibility with the current NetBSD release.
-* Removed spurious handler requirement checks in some `async_read` overloads.
-* Changed the `ssl::context` class to propagate non-EOF errors from the
-  `add_certificate_authority` function.
-* Fixed a Windows-specific `thread_pool` destructor hang that occurred when the
-  pool had an associated I/O object.
-* Changed the [^select] reactor to recreate the "self pipe trick" sockets on
-  error. This addresses an issue on some versions of Windows, where these
-  sockets are discconected after a system sleep.
-* Fixed a compile error in the buffered streams due to the lack of reference
-  collapsing in C++98.
-* Changed the `priority_scheduler` example to demonstrate calls to `shutdown()`
-  and `destroy()`.
-* Removed some unnecessary null pointer checks.
-* Changed Windows platform detection to recognise TV titles as Windows apps.
-* Added some emscripten compatibility patches.
-* Fixed a compile error in the `use_awaitable_t::as_default_on` function.
-* Changed all uses of the boost.bind placeholders to use the
-  `boost::placeholders` namespace.
-* Fixed a potential compile error in the `async_compose` implementation due to
-  incorrect overload selection.
-* Suppressed some non-virtual destructor warnings.
-* Various documentation fixes and improvements.
-[heading Asio 1.16.0]
-* Changed the `async_initiate` helper function to automatically deduce its
-  return type. This is enabled for C++11 or later.
-* Changed all asynchronous operations to use automatically deduced return
-  types. This allows completion token implementations to incorporate the
-  asynchronous operation initiation into the initiating function's return type,
-  without type erasure. Note that C++14 or later is required to support
-  completion tokens that use per-operation return type deduction. For C++11 or
-  earlier, a completion token's async_result specialisation must still provide
-  the nested typedef `return_type`.
-* Introduced three new concepts to support `async_initiate`.
-  * `completion_signature<T>`: Checks if `T` is a signature of the form
-    `R(Args...)`.
-  * `completion_handler_for<T, Signature>`: Checks if `T` is usable as a
-    completion handler with the specified signature.
-  * `completion_token_for<T, Signature>`: Checks if `T` is a completion token
-    that can be used with async_initiate and the specified signature.
-  * For backward compatibility with pre-concepts C++, the macros
-    `(BOOST_)ASIO_COMPLETION_SIGNATURE`, `(BOOST_)ASIO_COMPLETION_HANDLER_FOR`, and
-    `(BOOST_)ASIO_COMPLETION_TOKEN_FOR` are provided. These macros expand to
-    `typename` when concepts are unsupported.
-* Added the nested template type `rebind_executor` to all I/O object types, as
-  a way to generically rebind them to use alternative I/O executors. For
-  example:
-  ``
-  using my_socket_type = tcp::socket::rebind_executor<my_executor_type>::other;
-  ``[br]
-* Changed the asynchronous operations' initiation function objects to report
-  their associated I/O executor via the nested type `executor_type` and member
-  function `get_executor()`. Note that the presence of `executor_type` and
-  `get_executor()` should be treated as optional, and consequently it may be
-  preferable to access them via the `associated_executor` trait and the
-  `get_associated_executor()` helper function.
-* Added the `default_completion_token` trait, so that every I/O executor type
-  now has an associated default completion token type. This trait may be used
-  in asynchronous operation declarations as follows:
-  ``
-  template <
-      typename IoObject,
-      typename CompletionToken =
-        typename default_completion_token<
-          typename IoObject::executor_type
-        >::type
-    >
-  auto async_xyz(
-      IoObject& io_object,
-      CompletionToken&& token =
-        typename default_completion_token<
-          typename IoObject::executor_type
-        >::type{}
-    );
-  ``[br]
-  If not specialised, this trait type is `void`, meaning no default completion
-  token type is available for the given I/O executor.
-* Specialised the `default_completion_token` trait for the `use_awaitable`
-  completion token, so that it may be used as shown in the following example:
-  ``
-  auto socket = use_awaitable.as_default_on(tcp::socket(my_context));
-  // ...
-  co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.
-  ``[br]
-  In this example, the type of the `socket` object is transformed from
-  `tcp::socket` to have an I/O executor with the default completion token set
-  to `use_awaitable`. Alternatively, the socket type may be computed directly:
-  ``
-  using tcp_socket = use_awaitable_t<>::as_default_on_t<tcp::socket>;
-  tcp_socket socket(my_context);
-  // ...
-  co_await socket.async_connect(my_endpoint); // Defaults to use_awaitable.
-  ``[br]
-* Added missing `async_initiate` to the Windows-specific I/O objects'
-  asynchronous operations.
-* Ensured that the executor type is propagated to newly accepted sockets.
-  When synchronously or asynchronously accepting a new connection, but
-  without specifying an executor or execution context, the accept
-  operation will now correctly propagate the executor type from the
-  acceptor to the socket. For example, if your acceptor type is:
-  ``
-  basic_socket_acceptor<ip::tcp, my_executor_type>
-  ``[br]
-  then your accepted socket type will be:
-  ``
-  basic_stream_socket<ip::tcp, my_executor_type>
-  ``[br]
-* Changed to require that `Protocol` copy and move operations never throw.
-* Changed to require that `Endpoint` default constructor and move operations
-  never throw.
-* Added the `noexcept` qualifier to protocol accessors.
-* Added the `noexcept` qualifier to socket move constructors.
-* Fixed issues associated with opening serial ports on Windows:
-  * Use the correct constant to initialise the RTS control flag.
-  * Specify a default baud rate (9600).
-* Fixed a lost "outstanding work count" that can occur when an asynchronous
-  accept operation is automatically restarted.
-[heading Asio 1.14.1]
-* Improved performance slightly by eliminating a redundant move construction
-  when completed handlers are dispatched.
-* Eliminated a compiler warning by annotating a `case` fall-through in
-  the free function `connect()` implementation.
-* Fixed the `is_*_buffer_sequence` detection traits for user-defined sequence
-  types.
-* Fixed some Windows-specific warnings about an incompatible pointer cast when
-  obtaining the `CancelIoEx` entry point.
-* Changed to automatically set the defaults when opening a serial port on
-  Windows.
-* Changed the serial port `get_option()` member function to be const.
-* Fixed a name hiding issue with the WinRT stream-oriented socket backend's
-  `shutdown` function.
-* Applied a minor fix to the documentation for `is_dynamic_buffer`.
-* Added some support for Haiku OS.
-* Added wolfSSL compatability.
-* Changed to require C++17 or later for coroutines TS support with clang.
-* Fixed a doxygen generation problem in the tutorial.
-[heading Asio 1.14.0]
-* Improved I/O object performance by adding runtime detection of native I/O
-  executors when using the polymorphic executor wrapper.
-* Changed I/O object move constructors so that the executor is copied, not
-  moved. This ensures that the moved-from I/O object is left in the same state
-  as if constructed with a valid executor but without a resource.
-* On Windows, fixed an issue where global object destructors were not being
-  run.
-* Fixed move-based `async_accept` between sockets with different executor
-  types.
-[heading Asio 1.13.0]
-* Added custom I/O executor support to I/O objects.
-  * All I/O objects now have an additional `Executor` template parameter. This
-    template parameter defaults to the `asio::executor` type (the polymorphic
-    executor wrapper) but can be used to specify a user-defined executor
-    type.
-  * I/O objects' constructors and functions that previously took an
-    `asio::io_context&` now accept either an `Executor` or a reference to a
-    concrete `ExecutionContext` (such as `asio::io_context` or
-    `asio::thread_pool`).
-  * Note: One potential source of breakage in existing user code is when reusing an
-    I/O object's `io_context` for constructing another I/O object, as in:
-    ``
-    asio::steady_timer my_timer(my_socket.get_executor().context());
-    ``[br]
-    To fix this, either construct the second I/O object using the first I/O
-    object's executor:[br]
-    ``
-    asio::steady_timer my_timer(my_socket.get_executor());
-    ``[br]
-    or otherwise explicitly pass the `io_context`:[br]
-    ``
-    asio::steady_timer my_timer(my_io_context);
-    ``[br]
-  * The previously deprecated `get_io_context` and `get_io_service`
-    member functions have now been removed.
-  * The previously deprecated service template parameters, and the
-    corresponding classes, have now been removed.
-* Added a new `async_result` form with an `initiate` static member function.
-  * The `async_result` template now supports a new form:
-    ``
-    template <typename CompletionToken, typename Signature>
-    struct async_result
-    {
-      typedef /* ... */ return_type;
-      template <typename Initiation,
-          typename RawCompletionToken,
-          typename... Args>
-      static return_type initiate(
-          Initiation&& initiation,
-          RawCompletionToken&& token,
-          Args&&... args);
-    };
-    ``[br]
-  * The `initiate` member function must: (a) transform the token into a
-    completion handler object `handler`; (b) cause the invocation of the
-    function object `initiation` as if by calling
-    `std::forward<Initiation>(initiation)(std::move(handler),
-    std::forward<Args>(args)...)`. Note that the invocation of `initiation`
-    may be deferred (e.g. lazily evaluated), in which case `initiation` and
-    `args` must be decay-copied and moved as required.
-  * A helper function template `async_initiate` has also been added as a
-    wrapper for the invocation of `async_result<>::initiate`. For backward
-    compatibility, this function supports both the old and new `async_result`
-    forms.
-  * The composed operations examples have been updated to use `async_initiate`.
-  * The previously deprecated `handler_type` trait and single-argument form of
-    `async_result` have now been removed.
-* Updated the Coroutines TS support and promoted it to the `asio` namespace.
-  * The `awaitable<>`, `co_spawn`, `this_coro`, `detached`, and
-    `redirect_error` facilities have been moved from the `asio::experimental`
-    namespace to namespace `asio`. As part of this change, the
-    `this_coro::token()` awaitable has been superseded by the
-    `asio::use_awaitable` completion token.
-  * Please note that the `use_awaitable` and `redirect_error` completion tokens
-    work only with asynchronous operations that use the new form of
-    `async_result` with member function `initiate`. Furthermore, when using
-    `use_awaitable`, please be aware that the asynchronous operation is not
-    initiated until `co_await` is applied to the `awaitable<>`.
-* Added a new `DynamicBuffer_v2` concept which is CopyConstructible.
-  * This change adds a new set of type requirements for dynamic buffers,
-    `DynamicBuffer_v2`, which supports copy construction. These new type
-    requirements enable dynamic buffers to be used as arguments to
-    user-defined composed operations, where the same dynamic buffer object
-    is used repeatedly for multiple underlying operations. For example:[br]
-    ``
-      template <typename DynamicBuffer>
-      void echo_line(tcp::socket& sock, DynamicBuffer buf)
-      {
-        n = asio::read_until(sock, buf, '\n');
-        asio::write(sock, buf, asio::transfer_exactly(n));
-      }
-    ``[br]
-  * The original `DynamicBuffer` type requirements have been renamed to
-    `DynamicBuffer_v1`. These requirements continue to be compatible with the
-    Networking TS.
-  * New type traits `is_dynamic_buffer_v1` and `is_dynamic_buffer_v2` have been
-    added to test for conformance to `DynamicBuffer_v1` and `DynamicBuffer_v2`
-    respectively. The existing `is_dynamic_buffer` trait has been retained and
-    delegates to `is_dynamic_buffer_v1` (unless `ASIO_NO_DYNAMIC_BUFFER_V1` is
-    explicitly defined, in which case it delegates to `is_dynamic_buffer_v2`).
-  * For convenience, the `dynamic_string_buffer` and `dynamic_vector_buffer`
-    classes conform to both `DynamicBuffer_v1` and `DynamicBuffer_v2`
-    requirements.
-  * When `ASIO_NO_DYNAMIC_BUFFER_V1` is defined, all support for
-    `DynamicBuffer_v1` types and functions is #ifdef-ed out. Support for using
-    `basic_streambuf` with the `read`, `async_read`, `read_until`,
-    `async_read_until`, `write`, and `async_write` functions is also disabled
-    as a consequence.
-  * Note: This change should have no impact on existing source code that simply
-    uses dynamic buffers in conjunction with Asio's composed operations.
-* Added a new `async_compose` function that simplifies the implementation of
-  user-defined asynchronous operations.
-* Added a `make_strand` function, which creates a `strand` with a deduced
-  `Executor` template argument.
-* Relaxed the completion condition type requirements to only require
-  move-constructibility rather than copy-constructibility.
-* Added a constructor for `local::basic_endpoint` that takes a `string_view`.
-* Added the noexcept qualifier to various member functions of the
-  `ip::address`, `ip::address_v4`, `ip::address_v6`, `ip::basic_endpoint`, and
-  `executor_work_guard` classes.
-* Added the noexcept qualifier to the `buffer_sequence_begin` and
-  `buffer_sequence_end` functions.
-* Added a new `ASIO_DISABLE_VISIBILITY` configuration `#define` that allows
-  visibility pragmas to be disabled. (Note: If symbols are hidden, extra care
-  must be taken to ensure that Asio types are not passed across shared
-  library API boundaries.)
-* Changed compile-time feature detection to define `ASIO_STANDALONE`
-  automatically if C++11 or later is detected.
-  * Users should define `ASIO_ENABLE_BOOST` to explicitly disable standalone
-    mode when compiling with C++11 or later.
-  * The `configure` script now defaults to a standalone build unless Boost is
-    specified or detected.
-* Enabled recycling of the memory used to type-erase a function object with the
-  polymorphic executor.
-* Changed receive operations to return the correct number of bytes transferred
-  when truncation (`error::message_size`) occurs on a datagram-oriented socket.
-* Fixed multicast behaviour on QNX by automatically applying `SO_REUSEPORT`
-  when the `reuse_address` option is set.
-* Added inclusion of `unistd.h` when targeting Haiku OS, to fix feature detection.
-* Added the `network_v[46].hpp` headers to the top-level convenience header.
-* Fixed calculation of absolute timeout when the backend uses
-  `pthread_cond_timedwait`.
-* Changed the range-based asynchronous connect operation to deduce the
-  `EndpointSequence` iterator type rather than assume the presence of a
-  `const_iterator` typedef.
-* Fixed `buffer_sequence_begin` and `buffer_sequence_end` to prevent implicit
-  conversion. This change addresses an issue where a call to
-  `buffer_sequence_begin` or `buffer_sequence_end` could trigger an implicit
-  conversion to `const_buffer` or `mutable_buffer`. Whenever this implicit
-  conversion occurred, the return value of `buffer_sequence_begin` or
-  `buffer_sequence_end` would point to a temporary object.
-* Ensured SSL handshake errors are propagated to the peer before the local
-  operation completes.
-* Suppressed the `eof` error on SSL shutdown as it actually indicates success.
-* Added a fallback error code for when we OpenSSL produces an
-  `SSL_ERROR_SYSCALL` result without an associated error.
-* Changed composed asynchronous read and write operations to move, rather than
-  copy, the buffer sequence objects when the composed operation implementation
-  is moved.
-* Changed to use `<atomic>` when targeting apple/clang/libc++ with recent Xcode
-  versions, even for C++03. This fixes a warning about the deprecation of
-  `OSMemoryBarrier`.
-* Fixed compile errors that occur when using the composed read and write
-  operations with MSVC 11.0, by disabling `decltype` support for that compiler.
-* Increased the default value of `_WIN32_WINNT` to `0x0601` (Windows 7).
-* Fixed `dispatch` documentation to note that it may call the supplied function
-  object in the current thread.
-* Updated `post` and `defer` documentation to clarify the the distinction
-  between them.
-[heading Asio 1.12.2]
-* Fixed a problem with the detection of `std::future` availability with
-  libstdc++.
-* Fixed compile error in regex overload of `read_until`.
-* Fixed a timer heap corruption issue that can occur when moving a cancelled
-  timer.
-* Fixed detection of `std::experimental::string_view` and `std::string_view`
-  with newer clang/libc++.
-* Fixed MSVC version detection for availability of `std::invoke_result`.
-* Fixed the buffer sequence traits to test the new requirements, if `decltype`
-  is available.
-* Fixed an MSVC issue when building with exceptions disabled.
-* Added SSL context options for TLS v1.3.
-* Added a compile-time test for TLS v1 support.
-* Fixed the macro used to test for TLS v1.2 support.
-* Prevented global objects from being created once per thread on Windows.
-* Fixed a crash when using `size()`, `max_size()` or `empty()` on
-  default-constructed resolver results.
-* Changed to move the return value in basic_resolver_results::begin() to avoid
-  copying.
-* Enabled move support for the Intel Compiler.
-* Fixed `std::string_view` detection issue when using clang-cl.
-* Fixed the handler tracking operation name for
-  `io_context::executor_type::dispatch`.
-* Fixed a buffer overflow that could occur when parsing an address string with
-  a 64-bit scope id.
-* Added examples showing how to write composed operations.
-* Added C++11 versions of the Timeouts, Timers, SOCKS4 and SSL examples.
-* Fixed minor issues in documentation and examples.
-[heading Asio 1.12.1]
-* Added missing const qualifier to `basic_socket_acceptor::get_option`.
-* Worked around a parsing error that occurs with some versions of gcc.
-* Fixed broken code samples in tutorial.
-* Added new experimental features. (Note that "experimental" features may be
-  changed without notice in subsequent releases.)
-  * Added `experimental::detached` completion token.
-  * Added `experimental::redirect_error` completion token.
-  * Added `experimental::co_spawn` facility for integration with the coroutines
-    technical specification.
-* Updated timeout examples to use latest features.
-  * Used `asio::steady_timer` rather than `asio::deadline_timer`.
-  * Used `asio::dynamic_buffer` rather than `asio::streambuf`.
-  * Used timed `asio::io_context::run_for()` function for blocking clients.
-  * Added example showing a custom completion token for blocking with timeouts.
-* Fixed unit tests to compile when `(BOOST_)ASIO_NO_DEPRECATED` is defined.
-* Changed socket iostreams to use chrono by default, to fix compatibility with
-  the Networking TS. Define `(BOOST_)ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM`
-  to enable the old Boost.Date_Time interface in `basic_socket_streambuf` and
-  `basic_socket_iostream`.
-* Updated examples to use chrono rather than Boost.Date_Time.
-* Fixed an incorrect member function detector in the `is_dynamic_buffer` trait.
-* Fixed an `async_result` incompatibility with deprecated `handler_type`.
-* Added a missing move optimisation in the SSL stream implementation.
-* Fixed incorrect `basic_resolver_results::value_type` typedef.
-* Fixed a compile error with some OpenSSL versions when `SSL_OP_NO_COMPRESSION`
-  is defined.
-* Changed `add_certificate_authority` to process multiple certificates in a bundle.
-* Eliminated deprecation warning with MSVC by using `std::invoke_result` rather
-  than `std::result_of`.
-* Changed to use `std::string_view` for C++17 or later, and
-  `std::experimental::string_view` for C++14. Define the preprocessor macro
-  `(BOOST_)ASIO_DISABLE_STD_STRING_VIEW` to force the use of
-  std::experimental::string_view (assuming it is available) when compiling in
-  C++17 mode.
-* Ensured `DynamicBuffer` template arguments are decayed before using in
-  `enable_if` tests.
-* Changed documentation to distinguish legacy completion handlers (which are
-  still required to be CopyConstructible) from new MoveConstructible handlers.
-* Suppressed a discarded return value warning in the buffer debugging support.
-* Fixed `basic_yield_context` to work with completion signatures containing
-  reference parameters.
-* Ensured that stackful coroutines launched using `spawn()` correctly store
-  decayed copies of their function and handler arguments.
-* Fixed some compatibility issues with Android.
-* Fixed some minor portability issues in examples.
-[heading Asio 1.12.0]
-* Completed the interface changes to reflect the Networking TS
-	([@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/n4656.pdf N4656]).
-	* See the [link asio.net_ts list] of new interfaces and, where
-    applicable, the corresponding old interfaces that have been superseded.
-	* The service template parameters, and the corresponding classes, are disabled
-		by default. For example, instead of `basic_socket<Protocol, SocketService>` we
-		now have simply `basic_socket<Protocol>`. The old interface can be enabled by
-		defining the `(BOOST_)ASIO_ENABLE_OLD_SERVICES` macro.
-* Added support for customised handler tracking.
-* Added reactor-related (i.e. descriptor readiness) events to handler tracking.
-* Added special [link asio.overview.core.concurrency_hint concurrency
-  hint] values that may be used to disable locking on a per `io_context` basis.
-* Enabled perfect forwarding for the first `ssl::stream<>` constructor argument.
-* Added ability to release ownership of the underlying native socket. (Requires
-	Windows 8.1 or later when using the I/O completion port backend.)
-[heading Asio 1.11.0]
-* Implemented changes to substantially reflect the Networking Library Proposal
-  ([@www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4370.html N4370]).
-  * New `Executor` type requirements and classes to support an executor
-    framework, including the `execution_context` base class, the
-    `executor_work` class for tracking outstanding work, and the `executor`
-    polymorphic wrapper. Free functions `dispatch()`, `post()` and `defer()`
-    have been added and are used to submit function objects to executors.
-  * Completion handlers now have an associated executor and associated
-    allocator. The free function `wrap()` is used to associate an executor with
-    a handler or other object. The handler hooks for allocation, invocation and
-    continuation have been deprecated.
-  * A `system_executor` class has been added as a default executor.
-  * The `io_service` class is now derived from `execution_context` and
-    implements the executor type requirements in its nested `executor_type`
-    class. The member functions `dispatch()`, `post()`, `defer()` and `wrap()`
-    have been deprecated. The `io_service::work` class has been deprecated.
-  * The `io_service` member function `reset()` has been renamed to `restart()`.
-    The old name is retained for backward compatibility but has been
-    deprecated.
-  * The `make_service<>()` function is now used to add a new service to an
-    execution context such as an `io_service`. The `add_service()` function has
-    been deprecated.
-  * A new `strand<>` template has been added to allow strand functionality to
-    be used with generic executor types.
-  * I/O objects (such as sockets and timers) now provide access to their
-    associated `io_service` via a `context()` member function. The
-    `get_io_service()` member function is deprecated.
-  * All asynchronous operations and executor operations now support move-only
-    handlers. However, the deprecated `io_service::post()`,
-    `io_service::dispatch()`, `io_service::strand::post()` and
-    `io_service::strand::dispatch()` functions still require copyable handlers.
-  * Waitable timer objects are now movable.
-  * Waitable timers, socket iostreams and socket streambufs now provide an
-    `expiry()` member function for obtaining the expiry time. The accessors
-    `expires_at()` and `expires_after()` have been deprecated, though those
-    names are retained for the mutating members.
-  * The `std::packaged_task` class template is now supported as a completion
-    handler. The initiating operation automatically returns the future
-    associated with the task. The `package()` function has been added as a
-    convenient factory for packaged tasks.
-  * Sockets, socket acceptors and descriptors now provide `wait()` and
-    `async_wait()` operations that may be used to wait for readiness. The
-    `null_buffers` type has been deprecated.
-  * The proposed error code enum classes are simulated using namespaces.
-    Existing asio error codes now have a correspondence with the standard error
-    conditions.
-  * Conversion between IP address types, and conversion from string to address,
-    is now supported via the `address_cast<>()`, `make_address()`,
-    `make_address_v4()` and `make_address_v6()` free functions. The
-    `from_string()`, `to_v4()`, `to_v6()` and `v4_mapped()` member functions
-    have been deprecated.
-  * A default-constructed `ip::address` now represents an invalid address value
-    that is neither IPv4 nor IPv6.
-  * New `buffer()` overloads that generate mutable buffers for non-const
-    `string` objects.
-  * Support for dynamic buffer sequences that automatically grow and shrink to
-    accomodate data as it is read or written. This is a generic facility
-    similar to the existing `asio::streambuf` class. This support includes:
-    * New `dynamic_string_buffer` and `dynamic_vector_buffer` adapter classes
-      that meet the `DynamicBufferSequence` type requirements.
-    * New `dynamic_buffer()` factory functions for creating a dynamic buffer
-      adapter for a `vector` or `string`.
-    * New overloads for the `read()`, `async_read()`, `write()` and
-      `async_write()`, `read_until()` and `async_read_until()` free functions
-      that directly support dynamic buffer sequences.
-  * Support for networks and address ranges. Thanks go to Oliver Kowalke for
-    contributing to the design and providing the implementation on which this
-    facility is based. The following new classes have been added:
-    * `address_iterator_v4` for iterating across IPv4 addresses
-    * `address_iterator_v6` for iterating across IPv6 addresses
-    * `address_range_v4` to represent a range of IPv4 addresses
-    * `address_range_v6` to represent a range of IPv6 addresses
-    * `network_v4` for manipulating IPv4 CIDR addresses, e.g. 1.2.3.0/24
-    * `network_v6` for manipulating IPv6 CIDR addresses, e.g. ffe0:/120
-  * New convenience headers in [^<asio/ts/*.hpp>] that correspond to the headers
-    in the proposal.
-* Added a new, executor-aware `thread_pool` class.
-* Changed `spawn()` to be executor-aware.
-* Added a new `spawn()` overload that takes only a function object.
-* Changed `spawn()` and `yield_context` to permit nested calls to the
-  completion handler.
-* Removed previously deprecated functions.
-* Added options for disabling TLS v1.1 and v1.2.
-* Changed the SSL wrapper to call the password callback when loading an
-  in-memory key.
-* Changed the tutorial to use `std::endl` to ensure output is flushed.
-* Fixed false SSL error reports by ensuring that the SSL error queue is cleared
-  prior to each operation.
-* Fixed an `ssl::stream<>` bug that may result in spurious 'short read' errors.
-* Enabled perfect forwarding for the first `ssl::stream<>` constructor argument.
-* Added standalone Asio support for Clang when used with libstdc++ and C++11.
-* Fixed an unsigned integer overflow reported by Clang's integer sanitizer.
-* Added support for move-only return types when using a `yield_context` object
-  with asynchronous operations.
-* Ensured errors generated by Windows' `ConnectEx` function are mapped to their
-  portable equivalents.
-* Changed multicast test to treat certain `join_group` failures as non-fatal.
-[heading Asio 1.10.5]
-* Fixed the [^kqueue] reactor so that it works on FreeBSD.
-* Fixed an issue in the [^kqueue] reactor which resulted in spinning when using
-  serial ports on Mac OS.
-* Fixed [^kqueue] reactor support for read-only file descriptors.
-* Fixed a compile error when using the [^/dev/poll] reactor.
-* Changed the Windows backend to use `WSASocketW`, as `WSASocketA` has been
-  deprecated.
-* Fixed some warnings reported by Visual C++ 2013.
-* Fixed integer type used in the WinRT version of the byte-order conversion
-  functions.
-* Changed documentation to indicate that `use_future` and `spawn()` are not
-  made available when including the `asio.hpp` convenience header.
-* Explicitly marked `asio::strand` as deprecated. Use
-  `asio::io_service::strand` instead.
-[heading Asio 1.10.4]
-* Stopped using certain Winsock functions that are marked as deprecated in the
-  latest Visual C++ and Windows SDK.
-* Fixed a shadow variable warning on Windows.
-* Fixed a regression in the [^kqueue] backend that was introduced in Asio
-  1.10.2.
-* Added a workaround for building the unit tests with [^gcc] on AIX.
-[heading Asio 1.10.3]
-* Worked around a [^gcc] problem to do with anonymous enums.
-* Reverted the Windows `HANDLE` backend change to ignore `ERROR_MORE_DATA`.
-  Instead, the error will be propagated as with any other (i.e. in an
-  `error_code` or thrown as a `system_error`), and the number of bytes
-  transferred will be returned. For code that needs to handle partial messages,
-  the `error_code` overload should be used.
-* Fixed an off-by-one error in the `signal_set` implementation's signal
-  number check.
-* Changed the Windows IOCP backend to not assume that
-  `SO_UPDATE_CONNECT_CONTEXT` is defined.
-* Fixed a Windows-specific issue, introduced in Asio 1.10.2, by using
-  `VerifyVersionInfo` rather than `GetVersionEx`, as `GetVersionEx` has been
-  deprecated.
-* Changed to use SSE2 intrinsics rather than inline assembly, to allow the
-  Cray compiler to work.
-[heading Asio 1.10.2]
-* Fixed `asio::spawn()` to work correctly with new Boost.Coroutine interface.
-* Ensured that incomplete `asio::spawn()` coroutines are correctly unwound when
-  cleaned up by the `io_service` destructor.
-* Fixed delegation of continuation hook for handlers produced by
-  `io_service::wrap()` and `strand::wrap()`.
-* Changed the Windows I/O completion port backend to use `ConnectEx`, if
-  available, for connection-oriented IP sockets.
-* Changed the `io_service` backend for non-Windows (and non-IOCP Windows)
-  platforms to use a single condition variable per `io_service` instance.
-  This addresses a potential race condition when `run_one()` is used from
-  multiple threads.
-* Prevented integer overflow when computing timeouts based on some
-  `boost::chrono` and `std::chrono` clocks.
-* Made further changes to `EV_CLEAR` handling in the kqueue backend, to address
-  other cases where the `close()` system call may hang on Mac OS X.
-* Fixed infinite recursion in implementation of
-  `resolver_query_base::flags::operator~`.
-* Made the `select` reactor more efficient on Windows for large numbers of
-  sockets.
-* Fixed a Windows-specific type-aliasing issue reported by [^gcc].
-* Prevented execution of compile-time-only buffer test to avoid triggering an
-  address sanitiser warning.
-* Disabled the `GetQueuedCompletionStatus` timeout workaround on recent
-  versions of Windows.
-* Changed implementation for Windows Runtime to use `FormatMessageW` rather
-  than `FormatMessageA`, as the Windows store does not permit the latter.
-* Added support for string-based scope IDs when using link-local multicast
-  addresses.
-* Changed IPv6 multicast group join to use the address's scope ID as the
-  interface, if an interface is not explicitly specified.
-* Fixed multicast test failure on Mac OS X and the BSDs by using a link-local
-  multicast address.
-* Various minor documentation improvements.
-[heading Asio 1.10.1]
-* Implemented a limited port to Windows Runtime. This support requires that the
-  language extensions be enabled. Due to the restricted facilities exposed by
-  the Windows Runtime API, the port also comes with the following caveats:
-  * The core facilities such as the `io_service`, `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.
-* Extended the ability to use Asio without Boost to include Microsoft Visual
-  Studio 2012. When using a C++11 compiler, most of Asio may now be used
-  without a dependency on Boost header files or libraries. To use Asio in this
-  way, define `ASIO_STANDALONE` on your compiler command line or as part of the
-  project options. This standalone configuration has been tested for the
-  following platforms and compilers:
-  * Microsoft Visual Studio 2012
-  * Linux with g++ 4.7 or 4.8 (requires [^-std=c++11])
-  * Mac OS X with clang++ / Xcode 4.6 (requires [^-std=c++11 -stdlib=libc++])
-* Fixed a regression (introduced in 1.10.0) where, on some platforms, errors
-  from `async_connect` were not correctly propagated through to the completion
-  handler.
-* Fixed a Windows-specific regression (introduced in 1.10.0) that occurs when
-  multiple threads are running an `io_service`. When the bug occurs, the result
-  of an asynchronous operation (error and bytes tranferred) is incorrectly
-  discarded and zero values used instead. For TCP sockets this results in
-  spurious end-of-file notifications.
-* Fixed a bug in handler tracking, where it was not correctly printing out some
-  handler IDs.
-* Fixed the comparison used to test for successful synchronous accept
-  operations so that it works correctly with unsigned socket descriptors.
-* Ensured the signal number is correctly passed to the completion handler when
-  starting an `async_wait` on a signal that is already raised.
-* Suppressed a g++ 4.8+ warning about unused typedefs.
-* Enabled the move optimisation for handlers that use the default invocation
-  hook.
-* Clarified that programs must not issue overlapping `async_write_at`
-  operations.
-* Changed the Windows `HANDLE` backend to treat `ERROR_MORE_DATA` as a
-  non-fatal error when returned by `GetOverlappedResult` for a synchronous
-  read.
-* Visual C++ language extensions use `generic` as a keyword. Added a
-  workaround that renames the namespace to `cpp_generic` when those language
-  extensions are in effect.
-* Fixed some asynchronous operations that missed out on getting `async_result`
-  support in 1.10.0. In particular, the buffered stream templates have been
-  updated so that they adhere to current handler patterns.
-* Enabled move support for Microsoft Visual Studio 2012.
-* Added `use_future` support for Microsoft Visual Studio 2012.
-* Removed a use of `std::min` in the Windows IOCP backend to avoid a
-  dependency on the `<algorithm>` header.
-* Eliminated some unnecessary handler copies.
-* Fixed support for older versions of OpenSSL that do not provide the
-  `SSL_CTX_clear_options` function.
-* Fixed various minor and cosmetic issues in code and documentation.
-[heading Asio 1.10.0]
-* Added new traits classes, `handler_type` and `async_result`, that allow the
-  customisation of the return type of an initiating function.
-* Added the `asio::spawn()` function, a high-level wrapper for running
-  stackful coroutines, based on the Boost.Coroutine library. The `spawn()`
-  function enables programs to implement asynchronous logic in a synchronous
-  manner. For example: `size_t n = my_socket.async_read_some(my_buffer, yield);`.
-  For further information, see [link asio.overview.core.spawn Stackful
-  Coroutines].
-* Added the `asio::use_future` special value, which provides first-class
-  support for returning a C++11 `std::future` from an asynchronous
-  operation's initiating function. For example:
-  `future<size_t> = my_socket.async_read_some(my_buffer, asio::use_future);`.
-  For further information, see [link asio.overview.cpp2011.futures C++
-  2011 Support - Futures].
-* Promoted the stackless coroutine class and macros to be part of Asio's
-  documented interface, rather than part of the HTTP server 4 example.
-  For further information, see [link asio.overview.core.coroutine
-  Stackless Coroutines].
-* Added a new handler hook called `asio_handler_is_continuation`.
-  Asynchronous operations may represent a continuation of the asynchronous
-  control flow associated with the current executing handler. The
-  `asio_handler_is_continuation` hook can be customised to return `true` if
-  this is the case, and Asio's implementation can use this knowledge to
-  optimise scheduling of the new handler. To cover common cases, Asio
-  customises the hook for strands, `spawn()` and composed asynchronous
-  operations.
-* Added four new generic protocol classes, `generic::datagram_protocol`,
-  `generic::raw_protocol`, `generic::seq_packet_protocol` and
-  `generic::stream_protocol`, which implement the `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 further information, see [link
-  asio.overview.networking.other_protocols Support for Other Protocols].
-* Added C++11 move constructors that allow the conversion of a socket (or
-  acceptor) into a more generic type. For example, an `ip::tcp::socket` can
-  be converted into a `generic::stream_protocol::socket` via move
-  construction.
-  For further information, see [link
-  asio.overview.networking.other_protocols Support for Other Protocols].
-* Extended the `basic_socket_acceptor<>`'s `accept()` and `async_accept()`
-  functions to allow a new connection to be accepted directly into a socket
-  of a more generic type. For example, an `ip::tcp::acceptor` can be used to
-  accept into a `generic::stream_protocol::socket` object.
-  For further information, see [link
-  asio.overview.networking.other_protocols Support for Other Protocols].
-* Moved existing examples into a C++03-specific directory, and added a new
-  directory for C++11-specific examples. A limited subset of the C++03
-  examples have been converted to their C++11 equivalents.
-* Add the ability to use Asio without Boost, for a limited set of platforms.
-  When using a C++11 compiler, most of Asio may now be used without a
-  dependency on Boost header files or libraries. To use Asio in this way,
-  define `ASIO_STANDALONE` on your compiler command line or as part of the
-  project options. This standalone configuration has currently been tested for
-  the following platforms and compilers:
-  * Linux with g++ 4.7 (requires [^-std=c++11])
-  * Mac OS X with clang++ / Xcode 4.6 (requires [^-std=c++11 -stdlib=libc++])
-* Various SSL enhancements. Thanks go to Nick Jones, on whose work these changes
-  are based.
-  * Added support for SSL handshakes with re-use of data already read from
-    the wire. New overloads of the `ssl::stream<>` class's `handshake()` and
-    `async_handshake()` functions have been added. These accept a
-    `ConstBufferSequence` to be used as initial input to the ssl engine for
-    the handshake procedure.
-  * Added support for creation of TLSv1.1 and TLSv1.2 `ssl::context` objects.
-  * Added a `set_verify_depth()` function to the `ssl::context` and
-    `ssl::stream<>` classes.
-  * Added the ability to load SSL certificate and key data from memory
-    buffers. New functions, `add_certificate_authority()`,
-    `use_certificate()`, `use_certificate_chain()`, `use_private_key()`,
-    `use_rsa_private_key()` and `use_tmp_dh()`, have been added to the
-    `ssl::context` class.
-  * Changed `ssl::context` to automatically disable SSL compression by
-    default. To enable, use the new `ssl::context::clear_options()` function,
-    as in `my_context.clear_options(ssl::context::no_compression)`.
-* Fixed a potential deadlock in `signal_set` implementation.
-* Fixed an error in acceptor example in documentation.
-* Fixed copy-paste errors in waitable timer documentation.
-* Added assertions to satisfy some code analysis tools.
-* Fixed a malformed `#warning` directive.
-* Fixed a potential data race in the Linux `epoll` implementation.
-* Fixed a Windows-specific bug, where certain operations might generate an
-  `error_code` with an invalid (i.e. `NULL`) `error_category`.
-* Fixed `basic_waitable_timer`'s underlying implementation so that it can
-  handle any `time_point` value without overflowing the intermediate duration
-  objects.
-* Fixed a problem with lost thread wakeups that can occur when making
-  concurrent calls to `run()` and `poll()` on the same `io_service` object.
-* Fixed implementation of asynchronous connect operation so that it can cope
-  with spurious readiness notifications from the reactor.
-* Fixed a memory leak in the `ssl::rfc2818_verification` class.
-* Added a mechanism for disabling automatic Winsock initialisation. See the
-  header file [^asio/detail/winsock_init.hpp] for details.
-[heading Asio 1.8.3]
-* Fixed some 64-to-32-bit conversion warnings.
-* Fixed various small errors in documentation and comments.
-* Fixed an error in the example embedded in `basic_socket::get_option`'s
-  documentation.
-* Changed to use `long` rather than `int` for SSL_CTX options, to match OpenSSL.
-* Changed to use `_snwprintf` to address a compile error due to the changed
-  `swprintf` signature in recent versions of MinGW.
-* Fixed a deadlock that can occur on Windows when shutting down a pool of
-  `io_service` threads due to running out of work.
-* Changed UNIX domain socket example to treat errors from `accept` as non-fatal.
-* Added a small block recycling optimisation to improve default memory
-  allocation behaviour.
-[heading Asio 1.8.2]
-* Fixed an incompatibility between `ip::tcp::iostream` and C++11.
-* Decorated GCC attribute names with underscores to prevent interaction
-  with user-defined macros.
-* Added missing `#include <cctype>`, needed for some versions of MinGW.
-* Changed to use [^gcc]'s atomic builtins on ARM CPUs, when available.
-* Changed strand destruction to be a no-op, to allow strand objects to be
-  destroyed after their associated `io_service` has been destroyed.
-* Added support for some newer versions of glibc which provide the
-  `epoll_create1()` function but always fail with ENOSYS.
-* Changed the SSL implementation to throw an exception if SSL engine
-  initialisation fails.
-* Fixed another regression in `buffered_write_stream`.
-* Implemented various minor performance improvements, primarily targeted at
-  Linux x86 and x86-64 platforms.
-[heading Asio 1.8.1]
-* Changed the `epoll_reactor` backend to do lazy registration for `EPOLLOUT`
-  events.
-* Fixed the `epoll_reactor` handling of out-of-band data, which was broken by
-  an incomplete fix in the last release.
-* Changed Asio's SSL wrapper to respect OpenSSL's `OPENSSL_NO_ENGINE` feature
-  test `#define`.
-* Fixed `windows::object_handle` so that it works with Windows compilers that
-  support C++11 move semantics (such as [^g++]).
-* Improved the performance of strand rescheduling.
-* Added support for [^g++] 4.7 when compiling in C++11 mode.
-* Fixed a problem where `signal_set` handlers were not being delivered when
-  the `io_service` was constructed with a `concurrency_hint` of 1.
-[heading Asio 1.8.0]
-* Added a new class template `basic_waitable_timer` based around the C++11 clock
-  type requirements. It may be used with the clocks from the C++11 `<chrono>`
-  library facility or, if those are not available, Boost.Chrono. The typedefs
-  `high_resolution_timer`, `steady_timer` and `system_timer` may be used to
-  create timer objects for the standard clock types.
-* Added a new `windows::object_handle` class for performing waits on Windows
-  kernel objects. Thanks go to Boris Schaeling for contributing substantially
-  to the development of this feature.
-* On Linux, `connect()` can return EAGAIN in certain circumstances. Remapped
-  this to another error so that it doesn't look like a non-blocking operation.
-* Fixed a compile error on NetBSD.
-* Fixed deadlock on Mac OS X.
-* Fixed a regression in `buffered_write_stream`.
-* Fixed a non-paged pool "leak" on Windows when an `io_service` is repeatedly
-  run without anything to do.
-* Reverted earlier change to allow some speculative operations to be performed
-  without holding the lock, as it introduced a race condition in some
-  multithreaded scenarios.
-* Fixed a bug where the second buffer in an array of two buffers may be ignored
-  if the first buffer is empty.
-[heading Asio 1.6.1]
-* Implemented various performance improvements, including:
-  * Using thread-local operation queues in single-threaded use cases (i.e. when
-    `concurrency_hint` is 1) to eliminate a lock/unlock pair.
-  * Allowing some `epoll_reactor` speculative operations to be performed
-    without holding the lock.
-  * Improving locality of reference by performing an `epoll_reactor`'s I/O
-    operation immediately before the corresponding handler is called. This also
-    improves scalability across CPUs when multiple threads are running the
-    `io_service`.
-  * Specialising asynchronous read and write operations for buffer sequences
-    that are arrays (`boost::array` or `std::array`) of exactly two buffers.
-* Fixed a compile error in the regex overload of `async_read_until`.
-* Fixed a Windows-specific compile error by explicitly specifying the
-  `signal()` function from the global namespace.
-* Changed the `deadline_timer` implementation so that it does not read the
-  clock unless the timer heap is non-empty.
-* Changed the SSL stream's buffers' sizes so that they are large enough to hold
-  a complete TLS record.
-* Fixed the behaviour of the synchronous `null_buffers` operations so that they
-  obey the user's non-blocking setting.
-* Changed to set the size of the select `fd_set` at runtime when using Windows.
-* Disabled an MSVC warning due to const qualifier being applied to function type.
-* Fixed a crash that occurs when using the Intel C++ compiler.
-* Changed the initialisation of the OpenSSL library so that it supports all
-  available algorithms.
-* Fixed the SSL error mapping used when the session is gracefully shut down.
-* Added some latency test programs.
-* Clarified that a read operation ends when the buffer is full.
-* Fixed an exception safety issue in `epoll_reactor` initialisation.
-* Made the number of strand implementations configurable by defining
-  `(BOOST_)ASIO_STRAND_IMPLEMENTATIONS` to the desired number.
-* Added support for a new `(BOOST_)ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION` flag
-  which switches the allocation of strand implementations to use a round-robin
-  approach rather than hashing.
-* Fixed potential strand starvation issue that can occur when `strand.post()`
-  is used.
-[heading Asio 1.6.0]
-* Improved support for C++0x move construction to further reduce copying of
-  handler objects. In certain designs it is possible to eliminate virtually all
-  copies. Move support is now enabled when compiling in [^-std=c++0x] mode on
-  g++ 4.5 or higher.
-* Added build support for platforms that don't provide either of `signal()` or
-  `sigaction()`.
-* Changed to use C++0x variadic templates when they are available, rather than
-  generating function overloads using the Boost.Preprocessor library.
-* Ensured the value of `errno` is preserved across the implementation's signal
-  handler.
-* On Windows, ensured the count of outstanding work is decremented for
-  abandoned operations (i.e. operations that are being cleaned up within the
-  `io_service` destructor).
-* Fixed behaviour of zero-length reads and writes in the new SSL implementation.
-* Added support for building with OpenSSL 1.0 when `OPENSSL_NO_SSL2` is defined.
-* Changed most examples to treat a failure by an accept operation as non-fatal.
-* Fixed an error in the [^tick_count_timer] example by making the duration type
-  signed. Previously, a wait on an already-passed deadline would not return for
-  a very long time.
-[heading Asio 1.5.3]
-* Added a new, completely rewritten SSL implementation. The new implementation
-  compiles faster, shows substantially improved performance, and supports
-  custom memory allocation and handler invocation. It includes new API features
-  such as certificate verification callbacks and has improved error reporting.
-  The new implementation is source-compatible with the old for most uses.
-  However, if necessary, the old implementation may still be used by defining
-  `(BOOST_)ASIO_ENABLE_OLD_SSL`.
-* Added new `asio::buffer()` overloads for `std::array`, when available. The
-  support is automatically enabled when compiling in [^-std=c++0x] mode on g++
-  4.3 or higher, or when using MSVC 10. The support may be explicitly enabled
-  by defining `(BOOST_)ASIO_HAS_STD_ARRAY`, or disabled by defining
-  `(BOOST_)ASIO_DISABLE_STD_ARRAY`.
-* Changed to use the C++0x standard library templates `array`, `shared_ptr`,
-  `weak_ptr` and `atomic` when they are available, rather than the Boost
-  equivalents.
-* Support for `std::error_code` and `std::system_error` is no longer enabled by
-  default for g++ 4.5, as that compiler's standard library does not implement
-  `std::system_error::what()` correctly.
-[heading Asio 1.5.2]
-* Added support for C++0x move construction and assignment to sockets, serial
-  ports, POSIX descriptors and Windows handles.
-* Added support for the `fork()` system call. Programs that use `fork()` must
-  call `io_service.notify_fork()` at the appropriate times. Two new examples
-  have been added showing how to use this feature.
-* Cleaned up the handling of errors reported by the `close()` system call. In
-  particular, assume that most operating systems won't have `close()` fail with
-  `EWOULDBLOCK`, but if it does then set the blocking mode and restart the call.
-  If any other error occurs, assume the descriptor is closed.
-* The kqueue flag `EV_ONESHOT` seems to cause problems on some versions of Mac
-  OS X, with the `io_service` destructor getting stuck inside the `close()`
-  system call. Changed the kqueue backend to use `EV_CLEAR` instead.
-* Changed exception reporting to include the function name in exception `what()`
-  messages.
-* Fixed an insufficient initialisers warning with MinGW.
-* Changed the `shutdown_service()` member functions to be private.
-* Added archetypes for testing socket option functions.
-* Added a missing lock in `signal_set_service::cancel()`.
-* Fixed a copy/paste error in `SignalHandler` example.
-* Added the inclusion of the signal header to `signal_set_service.hpp` so that
-  constants like `NSIG` may be used.
-* Changed the `signal_set_service` implementation so that it doesn't assume
-  that `SIGRTMAX` is a compile-time constant.
-* Changed the Boost.Asio examples so that they don't use Boost.Thread's
-  convenience header. Use the header file that is specifically for the
-  boost::thread class instead.
-[heading Asio 1.5.1]
-* Added support for signal handling, using a new class called `signal_set`.
-  Programs may add one or more signals to the set, and then perform an
-  `async_wait()` operation. The specified handler will be called when one of
-  the signals occurs. The same signal number may registered with multiple
-  `signal_set` objects, however the signal number must be used only with Asio.
-* Added handler tracking, a new debugging aid. When enabled by defining
-  `(BOOST_)ASIO_ENABLE_HANDLER_TRACKING`, Asio writes debugging output to the
-  standard error stream. The output records asynchronous operations and the
-  relationships between their handlers. It may be post-processed using the
-  included [^handlerviz.pl] tool to create a visual representation of the
-  handlers (requires GraphViz).
-* Fixed a bug in `asio::streambuf` where the `consume()` function did not
-  always update the internal buffer pointers correctly. The problem may occur
-  when the `asio::streambuf` is filled with data using the standard C++ member
-  functions such as `sputn()`. (Note: the problem does not manifest when the
-  streambuf is populated by the Asio free functions `read()`,
-  `async_read()`, `read_until()` or `async_read_until()`.)
-* Fixed a bug on kqueue-based platforms, where reactor read operations that
-  return false from their `perform()` function are not correctly re-registered
-  with kqueue.
-* Support for `std::error_code` and `std::system_error` is no longer enabled by
-  default for MSVC10, as that compiler's standard library does not implement
-  `std::system_error::what()` correctly.
-* Modified the `buffers_iterator<>` and `ip::basic_resolver_iterator` classes
-  so that the value_type typedefs are non-const byte types.
-[heading Asio 1.5.0]
-* Added support for timeouts on socket iostreams, such as `ip::tcp::iostream`.
-  A timeout is set by calling `expires_at()` or `expires_from_now()` to
-  establish a deadline. Any socket operations which occur past the deadline
-  will put the iostream into a bad state.
-* Added a new `error()` member function to socket iostreams, for retrieving the
-  error code from the most recent system call.
-* Added a new `basic_deadline_timer::cancel_one()` function. This function lets
-  you cancel a single waiting handler on a timer. Handlers are cancelled in
-  FIFO order.
-* Added a new `transfer_exactly()` completion condition. This can be used to
-  send or receive a specified number of bytes even if the total size of the
-  buffer (or buffer sequence) is larger.
-* Added new free functions `connect()` and `async_connect()`. These operations
-  try each endpoint in a list until the socket is successfully connected.
-* Extended the `buffer_size()` function so that it works for buffer sequences
-  in addition to individual buffers.
-* Added a new `buffer_copy()` function that can be used to copy the raw bytes
-  between individual buffers and buffer sequences.
-* Added new non-throwing overloads of `read()`, `read_at()`, `write()` and
-  `write_at()` that do not require a completion condition.
-* Added friendlier compiler errors for when a completion handler does not meet
-  the necessary type requirements. When C++0x is available (currently supported
-  for g++ 4.5 or later, and MSVC 10), `static_assert` is also used to generate
-  an informative error message. This checking may be disabled by defining
-  `(BOOST_)ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS`.
-* Added support for using `std::error_code` and `std::system_error`, when
-  available. The support is automatically enabled when compiling in
-  [^-std=c++0x] mode on g++ 4.5 or higher, or when using MSVC 10. The support
-  may be explicitly enabled by defining `ASIO_HAS_STD_SYSTEM_ERROR`, or
-  disabled by defining `ASIO_DISABLE_STD_SYSTEM_ERROR`. (Available in non-Boost
-  version of Asio only.)
-* Made the `is_loopback()`, `is_unspecified()` and `is_multicast()` functions
-  consistently available across the `ip::address`, `ip::address_v4` and
-  `ip::address_v6` classes.
-* Added new `non_blocking()` functions for managing the non-blocking behaviour
-  of a socket or descriptor. The `io_control()` commands named `non_blocking_io`
-  are now deprecated in favour of these new functions.
-* Added new `native_non_blocking()` functions for managing the non-blocking
-  mode of the underlying socket or descriptor. These functions are intended to
-  allow the encapsulation of arbitrary non-blocking system calls as
-  asynchronous operations, in a way that is transparent to the user of the
-  socket object. The functions have no effect on the behaviour of the
-  synchronous operations of the socket or descriptor.
-* Added the `io_control()` member function for socket acceptors.
-* For consistency with the C++0x standard library, deprecated the `native_type`
-  typedefs in favour of `native_handle_type`, and the `native()` member
-  functions in favour of `native_handle()`.
-* Added a `release()` member function to posix descriptors. This function
-  releases ownership of the underlying native descriptor to the caller.
-* Added support for sequenced packet sockets (`SOCK_SEQPACKET`).
-* Added a new `io_service::stopped()` function that can be used to determine
-  whether the `io_service` has stopped (i.e. a `reset()` call is needed prior
-  to any further calls to `run()`, `run_one()`, `poll()` or `poll_one()`).
-* Reduced the copying of handler function objects.
-* Added support for C++0x move construction to further reduce copying of
-  handler objects. Move support is enabled when compiling in [^-std=c++0x] mode
-  on g++ 4.5 or higher, or when using MSVC10.
-* Removed the dependency on OS-provided macros for the well-known IPv4 and IPv6
-  addresses. This should eliminate the annoying "missing braces around
-  initializer" warnings.
-* Reduced the size of `ip::basic_endpoint<>` objects (such as
-  `ip::tcp::endpoint` and `ip::udp::endpoint`).
-* Changed the reactor backends to assume that any descriptors or sockets added
-  using `assign()` may have been `dup()`-ed, and so require explicit
-  deregistration from the reactor.
-* Changed the SSL error category to return error strings from the OpenSSL
-  library.
-* Changed the separate compilation support such that, to use Asio's SSL
-  capabilities, you should also include 'asio/ssl/impl/src.hpp` in one source
-  file in your program.
-* Removed the deprecated member functions named `io_service()`. The
-  `get_io_service()` member functions should be used instead.
-* Removed the deprecated typedefs `resolver_query` and `resolver_iterator` from
-  the `ip::tcp`, `ip::udp` and `ip::icmp` classes.
-* Fixed a compile error on some versions of g++ due to anonymous enums.
-* Added an explicit cast to the `FIONBIO` constant to int to suppress a compiler
-  warning on some platforms.
-* Fixed warnings reported by g++'s [^-Wshadow] compiler option.
-[heading Asio 1.4.8]
-* Fixed an integer overflow problem that occurs when
-  `ip::address_v4::broadcast()` is used on 64-bit platforms.
-* Fixed a problem on older Linux kernels (where epoll is used without `timerfd`
-  support) that prevents timely delivery of `deadline_timer` handlers, after the
-  program has been running for some time.
-[heading Asio 1.4.7]
-* Fixed a problem on kqueue-based platforms where a `deadline_timer` may
-  never fire if the `io_service` is running in a background thread.
-* Fixed a const-correctness issue that prevented valid uses of
-  `has_service<>` from compiling.
-* Fixed MinGW cross-compilation.
-* Removed dependency on deprecated Boost.System functions (Boost.Asio only).
-* Ensured `close()`/`closesocket()` failures are correctly propagated.
-* Added a check for errors returned by `InitializeCriticalSectionAndSpinCount`.
-* Added support for hardware flow control on QNX.
-* Always use `pselect()` on HP-UX, if it is available.
-* Ensured handler arguments are passed as lvalues.
-* Fixed Windows build when thread support is disabled.
-* Fixed a Windows-specific problem where `deadline_timer` objects with expiry
-  times set more than 5 minutes in the future may never expire.
-* Fixed the resolver backend on BSD platforms so that an empty service name
-  resolves to port number `0`, as per the documentation.
-* Fixed read operations so that they do not accept buffer sequences of type
-  `const_buffers_1`.
-* Redefined `Protocol` and `id` to avoid clashing with Objective-C++ keywords.
-* Fixed a `vector` reallocation performance issue that can occur when there are
-  many active `deadline_timer` objects.
-* Fixed the kqueue backend so that it compiles on NetBSD.
-* Fixed the socket `io_control()` implementation on 64-bit Mac OS X and BSD
-  platforms.
-* Fixed a Windows-specific problem where failures from `accept()` are
-  incorrectly treated as successes.
-* Deprecated the separate compilation header `asio/impl/src.cpp` in
-  favour of `asio/impl/src.hpp`.
-[heading Asio 1.4.6]
-* Reduced compile times. (Note that some programs may need to add additional
-  `#include`s, e.g. if the program uses boost::array but does not explicitly
-  include `<boost/array.hpp>`.)
-* Reduced the size of generated code.
-* Refactored `deadline_timer` implementation to improve performance.
-* Improved multiprocessor scalability on Windows by using a dedicated hidden
-  thread to wait for timers.
-* Improved performance of `asio::streambuf` with `async_read()` and
-  `async_read_until()`. These read operations now use the existing capacity of
-  the `streambuf` when reading, rather than limiting the read to 512 bytes.
-* Added optional separate compilation. To enable, include
-  `asio/impl/src.cpp` in one source file in a program, then
-  build the program with `(BOOST_)ASIO_SEPARATE_COMPILATION` defined in the
-  project\/compiler settings. Alternatively, `(BOOST_)ASIO_DYN_LINK` may be
-  defined to build a separately-compiled Asio as part of a shared library.
-* Added new macro `(BOOST_)ASIO_DISABLE_FENCED_BLOCK` to permit the disabling of
-  memory fences around completion handlers, even if thread support is enabled.
-* Reworked timeout examples to better illustrate typical use cases.
-* Ensured that handler arguments are passed as const types.
-* Fixed incorrect parameter order in `null_buffers` variant of `async_send_to`.
-* Ensured unsigned char is used with `isdigit` in `getaddrinfo` emulation.
-* Fixed handling of very small but non-zero timeouts.
-* Fixed crash that occurred when an empty buffer sequence was passed to a
-  composed read or write operation.
-* Added missing operator+ overload in `buffers_iterator`.
-* Implemented cancellation of `null_buffers` operations on Windows.
-[heading Asio 1.4.5]
-* Improved performance.
-* Reduced compile times.
-* Reduced the size of generated code.
-* Extended the guarantee that background threads don't call user code to
-  all asynchronous operations.
-* Changed to use edge-triggered epoll on Linux.
-* Changed to use `timerfd` for dispatching timers on Linux, when
-  available.
-* Changed to use one-shot notifications with kqueue on Mac OS X and BSD
-  platforms.
-* Added a bitmask type `ip::resolver_query_base::flags` as per the TR2
-  proposal. This type prevents implicit conversion from `int` to
-  `flags`, allowing the compiler to catch cases where users incorrectly
-  pass a numeric port number as the service name.
-* Added `#define NOMINMAX` for all Windows compilers. Users can define
-  `(BOOST_)ASIO_NO_NOMINMAX` to suppress this definition.
-* Fixed a bug where 0-byte asynchronous reads were incorrectly passing
-  an `error::eof` result to the completion handler.
-* Changed the `io_control()` member functions to always call `ioctl` on
-  the underlying descriptor when modifying blocking mode.
-* Changed the resolver implementation so that it no longer requires the
-  typedefs `InternetProtocol::resolver_query` and
-  `InternetProtocol::resolver_iterator`, as neither typedef is part of
-  the documented `InternetProtocol` requirements. The corresponding
-  typedefs in the `ip::tcp`, `ip::udp` and `ip::icmp` classes have been
-  deprecated.
-* Fixed out-of-band handling for reactors not based on `select()`.
-* Added new `(BOOST_)ASIO_DISABLE_THREADS` macro that allows Asio's
-  threading support to be independently disabled.
-* Minor documentation improvements.
-[heading Asio 1.4.4]
-* Added a new HTTP Server 4 example illustrating the use of stackless
-  coroutines with Asio.
-* Changed handler allocation and invocation to use `boost::addressof` to
-  get the address of handler objects, rather than applying `operator&`
-  directly.
-* Restricted MSVC buffer debugging workaround to 2008, as it causes a
-  crash with 2010 beta 2.
-* Fixed a problem with the lifetime of handler memory, where Windows
-  needs the `OVERLAPPED` structure to be valid until both the initiating
-  function call has returned and the completion packet has been
-  delivered.
-* Don't block signals while performing system calls, but instead restart
-  the calls if they are interrupted.
-* Documented the guarantee made by strand objects with respect to order
-  of handler invocation.
-* Changed strands to use a pool of implementations, to make copying of
-  strands cheaper.
-* Ensured that kqueue support is enabled for BSD platforms.
-* Added a `boost_` prefix to the `extern "C"` thread entry point
-  function.
-* In `getaddrinfo` emulation, only check the socket type (`SOCK_STREAM`
-  or `SOCK_DGRAM`) if a service name has been specified. This should
-  allow the emulation to work with raw sockets.
-* Added a workaround for some broken Windows firewalls that make a
-  socket appear bound to 0.0.0.0 when it is in fact bound to 127.0.0.1.
-* Applied a fix for reported excessive CPU usage under Solaris.
-* Added some support for platforms that use older compilers such as g++
-  2.95.
-[heading Asio 1.4.3]
-* Added a new ping example to illustrate the use of ICMP sockets.
-* Changed the `buffered*_stream<>` templates to treat 0-byte reads and
-  writes as no-ops, to comply with the documented type requirements for
-  `SyncReadStream`, `AsyncReadStream`, `SyncWriteStream` and
-  `AsyncWriteStream`.
-* Changed some instances of the `throw` keyword to
-  `boost::throw_exception()` to allow Asio to be used when exception
-  support is disabled. Note that the SSL wrappers still require
-  exception support.
-* Made Asio compatible with the OpenSSL 1.0 beta.
-* Eliminated a redundant system call in the Solaris /dev/poll backend.
-* Fixed a bug in resizing of the bucket array in the internal hash maps.
-* Ensured correct propagation of the error code when a synchronous
-  accept fails.
-* Ensured correct propagation of the error code when a synchronous read
-  or write on a Windows `HANDLE` fails.
-* Fixed failures reported when `_GLIBCXX_DEBUG` is defined.
-* Fixed custom memory allocation support for timers.
-* Tidied up various warnings reported by g++.
-* Various documentation improvements, including more obvious hyperlinks
-  to function overloads, header file information, examples for the
-  handler type requirements, and adding enum values to the index.
-[heading Asio 1.4.2]
-* Implement automatic resizing of the bucket array in the internal hash
-  maps. This is to improve performance for very large numbers of
-  asynchronous operations and also to reduce memory usage for very small
-  numbers. A new macro `(BOOST_)ASIO_HASH_MAP_BUCKETS` may be used to
-  tweak the sizes used for the bucket arrays. (N.B. this feature
-  introduced a bug which was fixed in Asio 1.4.3 / Boost 1.40.)
-* Add performance optimisation for the Windows IOCP backend for when no
-  timers are used.
-* Prevent locale settings from affecting formatting of TCP and UDP
-  endpoints.
-* Fix a memory leak that occurred when an asynchronous SSL operation's
-  completion handler threw an exception.
-* Fix the implementation of `io_control()` so that it adheres to the
-  documented type requirements for IoControlCommand.
-* Fix incompatibility between Asio and ncurses.h.
-* On Windows, specifically handle the case when an overlapped `ReadFile`
-  call fails with `ERROR_MORE_DATA`. This enables a hack where a
-  `windows::stream_handle` can be used with a message-oriented named
-  pipe.
-* Fix system call wrappers to always clear the error on success, as
-  POSIX allows successful system calls to modify errno.
-* Don't include termios.h if `(BOOST_)ASIO_DISABLE_SERIAL_PORT` is
-  defined.
-* Cleaned up some more MSVC level 4 warnings.
-* Various documentation fixes.
-[heading Asio 1.4.1]
-* Improved compatibility with some Windows firewall software.
-* Ensured arguments to `windows::overlapped_ptr::complete()` are correctly
-  passed to the completion handler.
-* Fixed a link problem and multicast failure on QNX.
-* Fixed a compile error in SSL support on MinGW / g++ 3.4.5.
-* Drop back to using a pipe for notification if eventfd is not available
-  at runtime on Linux.
-* Various minor bug and documentation fixes.
-[heading Asio 1.4.0]
-* Enhanced CompletionCondition concept with the signature
-  `size_t CompletionCondition(error_code ec, size_t total)`, where the return
-  value indicates the maximum number of bytes to be transferred on the next
-  read or write operation. (The old CompletionCondition signature is still
-  supported for backwards compatibility).
-* New `windows::overlapped_ptr` class to allow arbitrary overlapped I/O
-  functions (such as `TransmitFile`) to be used with Asio.
-* On recent versions of Linux, an `eventfd` descriptor is now used (rather than
-  a pipe) to interrupt a blocked select/epoll reactor.
-* Added const overloads of `lowest_layer()`.
-* Synchronous read, write, accept and connect operations are now thread safe
-  (meaning that it is now permitted to perform concurrent synchronous
-  operations on an individual socket, if supported by the OS).
-* Reactor-based `io_service` implementations now use lazy initialisation to
-  reduce the memory usage of an `io_service` object used only as a message
-  queue.
-[heading Asio 1.2.0]
-* Added support for serial ports.
-* Added support for UNIX domain sockets.
-* Added support for raw sockets and ICMP.
-* Added wrappers for POSIX stream-oriented file descriptors (excluding regular
-  files).
-* Added wrappers for Windows stream-oriented `HANDLE`s such as named pipes
-  (requires `HANDLE`s that work with I/O completion ports).
-* Added wrappers for Windows random-access `HANDLE`s such as files (requires
-  `HANDLE`s that work with I/O completion ports).
-* Added support for reactor-style operations (i.e. they report readiness but
-  perform no I/O) using a new `null_buffers` type.
-* Added an iterator type for bytewise traversal of buffer sequences.
-* Added new `read_until()` and `async_read_until()` overloads that take a
-  user-defined function object for locating message boundaries.
-* Added an experimental two-lock queue (enabled by defining
-  `(BOOST_)ASIO_ENABLE_TWO_LOCK_QUEUE`) that may provide better `io_service`
-  scalability across many processors.
-* Various fixes, performance improvements, and more complete coverage of the
-  custom memory allocation support.
-[heading Asio 1.0.0]
-First stable release of Asio.
-[endsect]