| AArch64 | |
| ppc64le | |
| s390x | |
| x86-64 |
- 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.
- Added some missing C++14 examples.
- Updated C++20 coroutines overview documentation.
- Update to 1.19.2
- Cleaned up memory recycling to ensure the cache size is used consistently.
- Changed parallel_group to use the recycling allocator for shared state.
- Changed awaitable memory recycling to use the configurable cache size.
- Ensured parallel_group respects operations' associated executors.
- Added defence against macros defined by Qt.
- Added missing boost_ prefix to namespaces during boostification.
- Added missing lvalue-qualified overloads for deferred operator().
- Added a tag to disambiguate deferred constructors.
- Added missing push/pop_options includes.
- Fixed argument evaluation order issue with a potentially moved-from variable in awaitable implementation.
- Enabled "expression SFINAE" for recent MSVC using /std:c++latest.
- Fixed compilation errors when dev_poll_reactor backend is used.
- Fixed handler type requirements checking to reflect rvalue completion handler invocation.
- Fixed posix::basic_stream_descriptor move operations to work with non-defaulted executors.
- Added missing move of executor in strand implementation.
- Update to 1.19.1
- Fixed handling of move-only results with awaitable operators && and ||.
- Fixed strand<> to avoid using a potentially moved-from executor.
- Fixed order of _aligned_malloc arguments for MSVC.
- Ensured handler alignment requirements are respected by cancellation_signal.
- Ensured gcc tests are not used for clang when detecting compiler features.
- Disabled coroutines support for the clang shipped with MSVC.
- Fixed compatibility with recent LibreSSL when OPENSSL_NO_SSL_INTERN is defined.
- Documented supported cancellation types for individual asynchronous operations.
- Ensured un-cancelled ops are correctly placed back in the queue.
- Update to 1.19.0
+ Added support for cancellation of individual asynchronous operations.
The ability to cancel individual operations, or composed operations, is currently supported by:
- timers
- sockets on POSIX and Windows
- POSIX descriptors
- Windows HANDLEs
- SSL streams
- all Asio-provided composed operations such as async_read and async_write
- compositions based on async_compose
- C++20 coroutines that use awaitable
- C++20 coroutines that use the new experimental::coro (see below)
- the new experimental::parallel_group operation (see below)
- the new experimental::promise class (see below)
- Added the associator trait.
- Changed all asynchronous operations implemented in Asio to invoke their completion handlers as rvalue references.
- Added support for asynchronous operations with multiple completion signatures.
- Added operator&& and operator|| for awaitable<>. The logical operators || and && have been overloaded for awaitable<>,
to allow coroutines to be trivially awaited in parallel.
- Added the experimental::as_tuple completion token adapter.
- Added the experimental::append completion token adapter.
- Added the experimental::prepend completion token adapter.
- Added the experimental::deferred completion token.
- Added the experimental::parallel_group class and experimental::make_parallel_group function.
- Added experimental::promise. The promise type allows eager execution and synchronisation of async operations.
- Added the experimental::coro class template. The coro type is a C++20 coroutine primitive for resumable functions,
with the ability to combine both asynchronous waiting (co_await) and yielding (co_yield) into a single, stateful control flow.
- Added move assignment to ssl::stream<>.
- Changed co_spawn to dispatch the coroutine's initial step to the executor, and to only post the completion handler if the coroutine
did not otherwise perform a context switch (i.e. a co_await on an asynchronous operation).
- Enabled additional optimisations for any_executor and any_io_executor when used with asynchronous operations.
- Added the nodiscard attribute to awaitable<>.
- Increased the number of cached slots in the default recycling allocator. This number defaults to 2,
but may also be specified by defining the ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE macro.
- Disabled the std::system_error message workaround for recent MSVC.
- Changed the default allocator behaviour to respect alignment requirements, to support over-aligned types.
Requires C++17 or later, or Boost.
- Ensured the result strings are always initialised in reverse name resolution.
- Fixed recursive template instantiation issues in use_awaitable_t::executor_with_default.
- Fixed the any_io_executor equality operators to correctly return a result based on the target executor.
- Update to 1.18.2
* Added ip::scope_id_type type alias.
* Added ip::port_type type alias.
* Added std::hash specialisations for IP addresses.
* Added std::hash specialisations for ip::basic_endpoint<>.
* Added friendship support to customisation points
* Changed any_io_executor to a "strong typedef"-style class.
* Fixed experimental::as_single to work with handler hook deprecation.
* Fixed work tracking for io_context and thread_pool executors
when move-assigned.
* Fixed I/O object move-assignment to ensure the executor is left
in a valid state.
* Prevented the blocking.always property from being used with strand<>,
as it did not produce the correct semantics.
* Removed deprecated file asio/impl/src.cpp.
- Update to version 1.18.1
* Added executor-converting construction and assignment to ip::basic_resolver.
* Added the experimental::as_single completion token adapter.
* Fixed the executor concept to test for a const-qualified execute().
* Fixed the thread_pool unit test to work without RTTI support.
- Update to version 1.18.0
* Added workarounds for various issues in gcc 10's coroutine support.
* Added missing compatibility macros for the execution::receiver_of concept.
* Added constraints to the strand template's constructor
* Changed Asio's internal executor adapters to prevent template
instantiation recursion.
* Changed execution::blocking_t::always_t::is_preferable to be false as
per the specification.
* Added shape_type and index_type to thread_pool executors
* Ensured that the standard executor concept-related traits
* Fixed async_compose support for standard executors.
* Fixed the forward declaration of any_io_executor in asio/ts/netfwd.hpp.
- Update to version 1.17.0
* Added support for the proposed standard executors to Asio's I/O facilities
* Added support for using detached_t as a default completion token
* Added a move constructor to ssl::stream<>.
* Fixed async_compose to work with copyable handlers when passed by lvalue.
* Fixed completion signature deduction in co_spawn.
* Removed a spurious Executor base class from the executor_binder
implementation.
* Various fixes and improvements in the documentation and examples.
- 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.
- Version update to 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.
- Version update to 1.12.1: * Includes changes from 1.11.0 * 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. * 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.)
- Update to stable version 1.10.8 * More recent than 1.11.0 (development release). * Release notes unavailable. * Fixes building with openssl-1.1.0.
- use individual libboost-*-devel packages instead of boost-devel
- Update to 1.11.0
* Implemented changes to substantially reflect the Networking
Library Proposal (N4370).
* 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.
- Remove no longer needed asio-no-multicast-test.patch
- remove multicast check from testsuite as it's failing in OBS (asio-no-multicast-test.patch)
- Enable testsuite
- Version bump to 1.10.4:
* for full list of changes please visit
http://think-async.com/Asio/asio-1.10.4/doc/asio/history.html#asio.history.asio_1_10_4
- Update to stable version 1.10.2
* for full list of changes please visit
http://think-async.com/Asio/asio-1.10.2/doc/asio/history.html#asio.history.asio_1_10_2
- Update to stable version 1.10.1
* many changes as outlined here
http://think-async.com/Asio/asio-1.10.1/doc/asio/history.html#asio.history.asio_1_10_1
- Remove redundant tags/sections from specfile - Add missing make call - Use %_smp_mflags for parallel build
- Update to version 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.
- Update to version 1.4.1. There's no NEWS/ChangeLog, but the 1.3 development cycle brought those new features: + Enhanced CompletionCondition concept. + Wrapper class for Windows overlapped I/O. + Eventfd support on Linux. + Const overloads of lowest_layer(). + Thread-safe synchronous socket operations. + Lazy initialisation of the io_service reactor task. + Bounds checking in ip::address_v4 and ip::address_v6. - Drop asio-gcc43.patch: fixed upstream.
- fix build (add missing includes)
- Update to 1.2.0
* Support for UNIX domain sockets.
* Wrapper classes for POSIX stream-oriented file descriptors.
* Reactor-style ready-to-read/write operations.
* Add the ability to disable uses of the typeid keyword in asio by
defining BOOST_NO_TYPEID or (BOOST_)ASIO_NO_TYPEID.
* Add a new "porthopper" example illustrating mixed synchronous and
asynchronous operations, and how to use Boost.Lambda with asio.
* Rework the "invocation" example to better show how handler
invocation hooks can be used with a variety of asynchronous
operations.
* Improved efficiency of basic_streambuf::consume()
* Fixed infinite recursion in ssl::stream's shutdown()
* Fixed a memory leak in use_tmp_dh_file().
* Fixed a tight spin on epoll (or /dev/poll) that occurs when both
EPOLLERR and EPOLLHUP events are reported for a descriptor and there
are no pending operations.
* Included CREAD and CLOCAL in the default flags for serial ports.
* Various documentation improvements.
- do not redefine debug_package - use nodebuginfo instead and set debuginfo to no in PDB
- Initial checkin