Thu Jun 27 10:44:46 UTC 2024 - Frantisek Simorda <frantisek.simorda@suse.com>
- update to 1.30.2
* Fixed co_spawn to correctly propagate exceptions resulting from cancellation to the completion handler.
* Added calls to std::launder to fix undefined behaviour in awaitable<> internal storage.
* Added missing handling of the file_base::append flag in the Windows implementation of file support.
* Updated the socket and descriptor implementations to add more cases where they will fall back to fcntl if a call to ioctl fails.
* Fixed a compile error that occurred when channels and experimental::coro were both used in the same translation unit.
* Added missing CancellationSlot type requirements to documentation.
* Minor documentation updates.
- update to 1.30.1
* Fixed the async_result primary template's concept checking to correctly handle lvalue-qualified completion signatures.
* Fixed some compile errors that could arise when using the bind_allocator, bind_executor, bind_immediate_executor and bind_cancellation_slot completion token adapters to adapt each other.
* Changed the experimental::ranged_parallel_group operation so that it moves the completion_order vector when invoking the completion handler.
* Fixed the asio/experimental/parallel_group.hpp header so that it is self-contained.
* Fixed some warnings about deprecated implicit copy constructors on ip::basic_resolver_query, io_context::strand, and coroutine.
* Updated the version specification used to initialise Winsock.
* Fixed the documentation hyperlinks for the deduced return types of asynchronous operations' initiating functions.
- update to 1.30.0
* Fixed compatibility between any_completion_handler and compilation using ASIO_USE_TS_EXECUTOR_AS_DEFAULT.
* Fixed a crash that may occur when attempting to access a default-constructed any_completion_handler object's associators.
* Fixed ssl::stream<> class's async_handshake operation so that it works with a defaulted completion token.
* Updated all examples to use C++11 as the minimum language standard.
- update to 1.29.0
* Changed to require C++11 as the minimum language standard.
* Removed deprecated functionality from the asio::execution namespace.
* Removed deprecated invocation and allocation hooks.
* Added compatibility between Asio's placeholders and std::bind.
* Added try_send_via_dispatch and try_send_n_via_dispatch functions to channels.
* Improved C++11 support for multi-signature channels.
* Fixed compatibility between channel asynchronous operations and any_completion_handler.
* Added missing equality operators for mixed property types belonging to the same category.
* Fixed an issue where spawn-based stackful coroutines would terminate the program when used with asynchronous operations that have a completion signature starting with std::exception_ptr.
- update to 1.28.2
* Fixed the completion token adapters bind_allocator, bind_cancellation_slot and bind_immediate_executor to not require a return_type type alias in the adapted async_result specialisation.
* Fixed a potental crash due to an object lifetime issue in the co_spawn operation's cancellation support.
* Enabled compiler-supported thread locals on more target platforms, using the thread_local keyword if available.
* Fixed the documentation of the per-operation cancellation behaviour for experimental::co_composed to correctly state that terminal cancellation is enabled by default.
* Documented the per-operation cancellation behaviour of async_compose.
* Added bind_immediate_executor to the Completion Token Adapters overview.
* Added an example illustrating how to use an experimental channel for mutual exclusion between cooperating asynchronous actors.
* Added an example showing how to write a minimal completion executor.
- update to 1.28.1
* Added missing compatibility with associated_immediate_executor to any_completion_handler.
* Fixed a null pointer dereference that occurs when using query, require or prefer with an empty any_executor.
* Added a workaround in experimental::coro for a spurious syntax error when compiling with MSVC.
* Fixed an integer truncation issue in per-operation cancellation, when using the reactor backend on 64-bit Windows.
* Added a compile-time check for a minimum Linux kernel version of 5.10, when io_uring support is enabled.
* Fixed a compile error in the converting move constructors for experimental::basic_channel and experimental::basic_concurrent_channel.
* Fixed a memory leak on some signal_set error handling code paths.
* Fixed bad_address_cast to not use a deprecated implicit copy constructor.
* Fixed a copy/paste error in the dev_poll_reactor backend.
* Fixed the io_uring backend to ensure the internal timeout operations, used to implement io_context::run_for and io_context::run_until, are cleaned up correctly.
* Eliminated some duplicated state in the co_spawn implementation's entry point, reducing memory consumption.
Thu Nov 10 13:29:26 UTC 2022 - ecsos <ecsos@opensuse.org>
- Update to 1.24.0
- Improved the performance of awaitable<>-based coroutines when they directly co_await an asynchronous operation,
by eliminating the copy of the operation object in await_transform.
- Improved the performance of spawn()-based stackful coroutines by storing a reference to the yield context in the completion handler,
rather than storing a copy of the executor.
- Fixed a C++03 build error by disabling index_sequence emulation when variadic templates are unavailable.
- Fixed detection of std::aligned_alloc for older Apple platforms.
- Removed faulty assertions from experimental::coro implementation.
- Added defence against Qt-defined macros when building with Intel C++.
- Ensured that a spawn()-based stackful coroutine is cleaned up immediately after it completes.
- Changed the implementation of the select_reactor, on Windows, to ensure that any exception resulting from failure
to recreate its interrupter's sockets will be allowed to propagate out through io_context::run().
- Changed the MSVC version used for the system_error workaround, as more recent runtime redistributables appear to have fixed the issue.
- Changed the async_compose example to use a return type compatible with the new async_result form.
- Update to 1.23.0
- Added a deduced trailing return type, using decltype, to all asynchronous operations' initiating functions when using C++11.
This change enables the new form of async_result, where the return type can vary per operation, for C++11.
- Moved append, prepend, as_tuple, and deferred to the asio namespace, and made them compatible with C++11.
These are no longer experimental facilities, although the names have temporarily been retained under the asio::experimental namespace for backwards compatibility.
- Added buffer() overloads for contiguous containers, such as std::span.
- Added the ability for awaitable<>-based coroutines to directly co_await operations that are packaged as function objects.
- Changed spawn() to be a completion token-based asynchronous operation.
- Added the is_async_operation trait and async_operation concept.
- Added the completion_signature_of trait. The completion_signature_of trait (and corresponding type alias completion_signature_of_t)
may be used to determine the completion signature of an asynchronous operation.
- Added converting move construction/assignment to posix descriptors, serial ports, pipes,
Windows object_handle, Windows stream handles, and Windows random-access handles.
- Added release() member functions to pipes, Windows stream handles, and Windows random-access handles.
- Enabled support for Endpoint implementations that return void pointers from their data() member functions,
as per the documented Endpoint type requirements.
- Removed all() and race() from experimental::promise, as experimental::parallel_group covers this functionality.
- Added source locations to exceptions and error codes produced by the synchronous and asynchronous operations.
- Fixed compatibility with OpenSSL 3.0.4 and later.
- Fixed compatibility with with -masm=intel.
- Explicitly stated that socket shutdown() calls are thread-safe with respect to certain other synchronous operations on the same socket.
- Optimised the move construction of I/O objects where only the executor type differs.
- Fixed the detection of std::invoke_result for clang/libc++.
- Fixed an issue where experimental::parallel_group initiation incorrectly moved arguments instead of forwarding them.
- Fixed a sequencing issue in the implementation of post(), dispatch(), and defer(), where the the associated allocator
may be obtained from an already moved-from completion handler.
- Fixed the awaitable<> implementation to propagate exceptions from awaited initiation functions through the current completion handler.
- Fixed detection of std::aligned_alloc with gcc.
- Changed to avoid using the soon-to-be-deprecated std::aligned_storage on newer compilers.
- Fixed various compiler warnings.
- Updated all composed operations examples, and the C++11 timeouts example, to use the new async_result form.
- Added composed operation and coroutine examples for C++20.
- Added pkg-config support.
- Update to 1.22.2
- On Windows, changed the file support to open files using the same sharing mode as fopen().
- On Linux, fixed the UNIX domain sockets implementation to correctly handle EAGAIN as an indication of an in-progress connect operation.
- Fixed experimental::basic_channel::reset() and experimental::basic_concurrent_channel::reset()
so that they work correctly for an unclosed channel.
- Fixed potential undefined behaviour in the experimental::promise operations race() and all().
- Changed the co_spawn implementation to explicitly dispatch cancellation signals through the specified executor,
if the the completion handler has an associated executor of its own.
- Added more detailed reference documentation to make_strand(), make_work_guard(), ip::address_v4, ip::address_v6,
experimental::basic_channel, and experimental::basic_concurrent_channel.
- Re-arranged and extended the Overview documentation to cover files, pipes, async_compose, experimental::deferred,
experimental::parallel_group, experimental::promise, channels, and completion token adapters.
- Reverted the io_context reference documentation to use executor_work_guard when preventing the io_context from running out of work.
- Removed references to deadline_timer from the Overview documentation.
- Added reference documentation cross-references to asynchronous model elements.
- Update to 1.22.1
- Added bind_allocator, to simplify associating a custom allocator with a completion token or handler.
- Added the file_base::sync_all_on_write flag, which maps to O_SYNC on POSIX and FILE_FLAG_WRITE_THROUGH on Windows.
- Added missing implementation of basic_file::release().
- Added per-operation cancellation support to signal sets.
- Exposed recycling_allocator as part of the public interface.
+ Added the nodiscard attribute to the following functions:
- bind_allocator()
- bind_cancellation_slot()
- bind_executor()
- buffer()
- dynamic_buffer()
- experimental::append()
- experimental::as_single()
- experimental::as_tuple()
- experimental::make_parallel_group()
- experimental::prepend()
- get_associated_allocator()
- get_associated_cancellation_slot()
- get_associated_executor()
- make_work_guard()
- Added compatibility with OpenSSL 3.0, particularly when deprecated functionality is disabled.
- Added support for adopting an existing SSL* into an ssl::stream<>.
- Enabled executor_work_guard<> even when ASIO_NO_TS_EXECUTORS is defined.
- Enabled movable socket iostreams when using clang.
- Fixed bind_cancellation_slot compatibility with legacy completion tokens.
- Fixed bind_executor compatibility with legacy completion tokens.
- Fixed associator specialisations for experimental::append and experimental::prepend,
to correctly propagate the associated allocator, executor, and cancellation slot.
- Fixed 'zero as null pointer constant' warning in C++20 coroutines implementation of awaitable.
- Ensured concurrency hint preprocessor macros are made available when asio/io_context.hpp is included.
- Fixed issue where the primary associated_allocator template was not correctly detecting the nested T::allocator_type.
- Fixed io_uring implementation of async_receive_from operation for sockets.
- Fixed io_uring implementation of write_some_at operation for files.
- Changed io_uring implementation to correctly check that it is not the default before registering with reactor.
- Fixed a circular inclusion issue when using io_uring in some build configurations.
- Fixed experimental::coro's per-operation cancellation to clear the slot at completion of each operation.
- Fixed memory management in experimental::promise's type-erased completion handlers.
- Fixed move operator= implementation for ssl::stream.
- Fixed any_io_executor implementation to work when both ASIO_USE_TS_EXECUTOR_AS_DEFAULT and ASIO_SEPARATE_COMPILATION are defined.
- Fixed implementation of basic_socket::at_mark() when using the sockatmark() system call.
- Changed the recycling allocator to use the default alignment as the minimum alignment for allocations.
- Added additional standard header file includes, as required by newer compilers.
- Added a workaround for apparent coroutine codegen bug with Apple's clang.
- Fixed various warnings in the examples and unit tests.
- Added a C++11 example showing file descriptor passing over local sockets. Thanks to Heiko Hund for providing this example.
- Added C++14 examples of wrapping callback-based APIs in asynchronous operations.
- Added an overview of Asio's asynchronous model to the documentation.
- Reworked reference documentation in terms of completion tokens.
- Updated documentation of asynchronous operation requirements to use new completion token form.
- Updated documentation for dispatch(), post(), and defer() to cover both the old and new executor forms.
- Documented per-operation cancellation for serial ports.
- Clarified the non-concurrency guarantees made for allocators.
- Update to 1.22.0
- Improved error messages emitted by ssl facilities.
- Fixed bind_executor compatibility with completion tokens.
- Fixed build errors when ASIO_USE_TS_EXECUTOR_AS_DEFAULT is defined.
- Fixed corruption, cleanup issues in channel implementation.
- Added missing move assignment operator to awaitable<>.
- Fixed an access violation when using coroutines with MSVC, due to incorrect alignment of allocated memory.
- Fixed a cleanup issue in experimental::parallel_group that occured when the execution context was shut down with parallel operations still pending.
- Fixed header inclusion order problem when io_uring is enabled.
- Eliminated shared_ptr use from experimental::coro co_spawn() implementation.
- Prevented async_resume from being called on experimental::coro temporaries.
- Made awaitable_operators.hpp header self-contained.
- Added clarifications to the documentation on concurrency hints.
- Added documentation on error handling techniques for C++20 coroutines.
- Added channel-based proxy example.
- Regenerated ssl certificates used in examples.
- Update to 1.21.0
- Added an io_uring backend. This backend may be used for all I/O objects, including sockets, timers, and posix descriptors.
- Added support for files. This introduces new classes for stream-oriented and random-access files.
- Added support for portable pipes. This change add supports for pipes on POSIX and Windows (when I/O completion ports are available).
- Added support for registered buffers. The mutable_registered_buffer and const_registered_buffer classes
are buffer sequence types that represent registered buffers.
- Added experimental support for channels. This adds templates experimental::basic_channel and experimental::basic_concurrent_channel,
with aliases experimental::channel and experimental::concurrent_channel. Channels may be used to send completions as messages.
+ Implemented improvements to experimental::coro.
- Added overload so member functions can provide an explicit executor.
- Added co_spawn for coro tasks.
- Added reference and overview documentation.
- Adopted awaitable cancellation model.
- Refactored implementation.
- Disabled aligned_alloc on clang when using an MSVC runtime.
- Changed to use a faster implementation for ip::network_v4::canonical().
- Added template specialisations for common uses to improve compile time.
- Reduced the size of io_context executors to a single pointer.
- Increased the small object buffer size for execution::any_executor and any_io_executor.
- Fixed multi-signature handling when variadic templates are disabled.
- Fixed compatibility with new versions of gcc and clang.
- Fixed compilation on Solaris.
- Fix defence against Qt-defined macros when building with MSVC.
- Fixed various warnings.
- Update to 1.20.0
- Fixed experimental::coro compatibility with gcc.
- Fixed experimental::promise compatibility with gcc.
- Added documentation for per-operation cancellation.
- Added documentation for parallel_group.
- Added overview documentation for experimental::coro.
Wed Jul 22 08:04:04 UTC 2020 - ecsos <ecsos@opensuse.org>
- Version update to 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
* 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
* 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.
* 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.
* Various documentation fixes and improvements.
- Changes from 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.
* 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.
* 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.
* Specialised the default_completion_token trait for the use_awaitable completion token
* 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.
* Changed to require that Protocol copy and move operations never throw.
* Changed to require that Endpoint default constructor and move operations never throw.
- Changes from 1.14.1
* Improved performance slightly by eliminating a redundant move construction
when completed handlers are dispatched.
* Fixed the is_*_buffer_sequence detection traits for user-defined sequence types.
* 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.
- Changes from 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.
* Fixed move-based async_accept between sockets with different executor types.
- Changes from 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
- 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
- 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
- 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.
* 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.
* 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 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.
* Completed the interface changes to reflect the Networking TS (N4656).
* See the 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 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.)
