|  | Home | Libraries | People | FAQ | More | 
CancellationSlot,
          a lightweight cancellation channel that is specified through the new associated_cancellation_slot
          associator. A concrete CancellationSlot implementation is
          provided in the form of the cancellation_signal and cancellation_slot
          classes. In conjunction with the bind_cancellation_slot helper
          function, these may be used to hook cancellation into asynchronous operations.
          However, it should be noted that these classes are the low-level building
          blocks of cancellation, and most use cases should use a higher level abstraction
          for cancellation, such as experimental::parallel_group or
          the new logical operators for awaitable (see below). The ability
          to cancel individual operations, or composed operations, is currently supported
          by:
          async_read
                and async_write
              async_compose
              awaitable
              experimental::coro
                (see below)
              experimental::parallel_group operation (see
                below)
              experimental::promise class (see below)
              associator trait. The associator trait
          is used to generically forward associators, such as associated_executor
          and associated_allocator, through intermediate completion
          handlers. For example:template <typename Handler>
struct intermediate_handler
{
  Handler handler_;
  template <typename... Args>
  void operator()(Args&... args)
  {
    // ...
  }
};
namespace asio {
  template <
      template <typename, typename> class Associator,
      typename Handler,
      typename DefaultCandidate>
  struct associator<
      Associator,
      intermediate_handler<Handler>,
      DefaultCandidate>
  {
    using type =
      typename Associator<Handler, DefaultCandidate>::type;
    static type get(
        const intermediate_handler<Handler>& h,
        const DefaultCandidate& c = DefaultCandidate()) noexcept
    {
      return Associator<Handler, DefaultCandidate>::get(
          h.handler_, c);
    }
  };
} // namespace asio
          noexcept,
          and whether they are lvalue-invocable (and thus do not "consume"
          the completion handler) or rvalue-invocable (and thus do "consume"
          the handler, indicating an end to the asynchronous operation). For example:auto my_async_operation(...,
    asio::completion_token_for<
      void(intermediate_result_type) & noexcept,
      void(final_result_type) &&
    > auto&& token)
{
  // ...
}
          operator&& and operator|| for
          awaitable<>. The logical operators || and
          && have been overloaded for awaitable<>,
          to allow coroutines to be trivially awaited in parallel.&&, the co_await expression
          waits until both operations have completed successfully. As a "short-circuit"
          evaluation, if one operation fails with an exception, the other is immediately
          cancelled. For example:std::tuple<std::size_t, std::size_t> results =
  co_await (
    async_read(socket, input_buffer, use_awaitable)
      && async_write(socket, output_buffer, use_awaitable)
  );
          ||, the co_await expression
          waits until either operation succeeds. As a "short-circuit" evaluation,
          if one operation succeeds without throwing an exception, the other is immediately
          cancelled. For example:std::variant<std::size_t, std::monostate> results =
  co_await (
    async_read(socket, input_buffer, use_awaitable)
      || timer.async_wait(use_awaitable)
  );
          #include:#include <boost/asio/experimental/awaitable_operators.hpp>
experimental::awaitable_operators
          namespace into scope:using namespace asio::experimental::awaitable_operators;
experimental::as_tuple completion token adapter.
          The as_tuple completion token adapter can be used to specify
          that the completion handler arguments should be combined into a single
          tuple argument. The as_tuple adapter may be used in conjunction
          with use_awaitable and structured bindings as follows:auto [e, n] = co_await socket.async_read_some(
    asio::buffer(data), as_tuple(use_awaitable));
          using default_token = as_tuple_t<use_awaitable_t<>>;
using tcp_socket = default_token::as_default_on_t<tcp::socket>;
// ...
awaitable<void> do_read(tcp_socket socket)
{
  // ...
  auto [e, n] = co_await socket.async_read_some(asio::buffer(data));
  // ...
}
          experimental::append completion token adapter. The
          append completion token adapter can be used to pass additional
          completion handler arguments at the end of the completion signature. For
          example:timer.async_wait(
    asio::experimental::append(
      [](boost::system::error_code ec, int i)
      {
        // ...
      },
    42)
  );
std::future<int> f = timer.async_wait(
    asio::experimental::append(
      asio::use_future,
      42
    )
  );
          experimental::prepend completion token adapter.
          The prepend completion token adapter can be used to pass additional
          arguments before the existing completion handler arguments. For example:timer.async_wait(
    asio::experimental::prepend(
      [](int i, boost::system::error_code ec)
      {
        // ...
      },
    42)
  );
std::future<std::tuple<int, boost::system::error_code>> f = timer.async_wait(
    asio::experimental::prepend(
      asio::use_future,
      42
    )
  );
          experimental::deferred completion token. The deferred
          completion token takes a call to an asynchronous operation's initiating
          function and turns it into a function object that accepts a completion
          token. For example:auto deferred_op =
  timer.async_wait(
    asio::experimental::deferred);
...
std::move(deferred_op)(
    [](boost::system::error_code ec){ ... });
          auto deferred_op =
  timer.async_wait(
    asio::experimental::deferred);
...
std::future<void> =
  std::move(deferred_op)(
    asio::use_future);
          auto deferred_op =
  timer.async_wait(
    asio::experimental::deferred(
      [&](boost::system::error_code ec)
      {
        timer.expires_after(
            std::chrono::seconds(1));
        return timer.async_wait(
            asio::experimental::deferred);
      });
...
std::future<void> = std::move(deferred_op)(asio::use_future);
          experimental::parallel_group class and experimental::make_parallel_group
          function. This utility may be used to launch work that is performed in
          parallel, and wait for one or all of the operations to complete. A parallel_group
          implements automatic cancellation of incomplete operations. For example:experimental::make_parallel_group(
    [&](auto token)
    {
      return stream.async_read_some(asio::buffer(data), token);
    },
    [&](auto token)
    {
      return timer.async_wait(token);
    }
  ).async_wait(
    experimental::wait_for_one(),
    [](
        std::array<std::size_t, 2> completion_order,
        boost::system::error_code ec1, std::size_t n1,
        boost::system::error_code ec2
    )
    {
      // ...
    }
  );
          wait_for_all, wait_for_one,
          wait_for_one_success, and wait_for_one_error,
          or with a custom function. The parallel_group class can also
          be combined with deferred as follows:experimental::make_parallel_group(
    stream.async_read_some(asio::buffer(data), experimental::deferred),
    timer.async_wait(experimental::deferred)
  ).async_wait(
    // ...
  );
          parallel_group does
          not propagate the executor automatically to the operations within the group.
        experimental::promise. The promise type
          allows eager execution and synchronisation of async operations. For example:auto promise = async_read(
    stream, asio::buffer(my_buffer),
    asio::experimental::use_promise);
... do other stuff while the read is going on ...
promise.async_wait( // completion the operation
    [](error_code ec, std::size_t bytes_read)
    {
      ...
    });
          auto timeout_promise =
  timer.async_wait(
    asio::experimental::use_promise);
auto read_promise = async_read(
    stream, asio::buffer(my_buffer),
    asio::experimental::use_promise);
auto promise =
  asio::experimental::promise<>::race(
    timeout_promise, read_promise);
promise.async_wait(
    [](std::variant<error_code, std::tuple<error_code, std::size_t>> v)
    {
      if (v.index() == 0) {} //timed out
      else if (v.index() == 1) // completed in time
    });
          auto write_promise = async_write(
    stream, asio::buffer(my_write_buffer),
    asio::experimental::use_promise);
auto read_promise = async_read(
    stream, asio::buffer(my_buffer),
    asio::experimental::use_promise);
auto promise =
  asio::experimental::promise<>::all(
    write_promise, read_promise);
promise.async_wait(
    [](std::tuple<error_code, std::size_t> write_result,
      std::tuple<error_code, std::size_t> read_result)
    {
    });
          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. For example:#include <boost/asio.hpp>
#include <boost/asio/experimental/coro.hpp>
using asio::ip::tcp;
asio::experimental::coro<std::string> reader(tcp::socket& sock)
{
  std::string buf;
  while (sock.is_open())
  {
    std::size_t n = co_await asio::async_read_until(
        sock, asio::dynamic_buffer(buf), '\n',
        asio::experimental::use_coro);
    co_yield buf.substr(0, n);
    buf.erase(0, n);
  }
}
asio::awaitable<void> consumer(tcp::socket sock)
{
  auto r = reader(sock);
  auto msg1 = co_await r.async_resume(asio::use_awaitable);
  std::cout << "Message 1: " << msg1.value_or("\n");
  auto msg2 = co_await r.async_resume(asio::use_awaitable);
  std::cout << "Message 2: " << msg2.value_or("\n");
}
asio::awaitable<void> listen(tcp::acceptor& acceptor)
{
  for (;;)
  {
    co_spawn(
        acceptor.get_executor(),
        consumer(co_await acceptor.async_accept(asio::use_awaitable)),
        asio::detached);
  }
}
int main()
{
  asio::io_context ctx;
  tcp::acceptor acceptor(ctx, {tcp::v4(), 54321});
  co_spawn(ctx, listen(acceptor), asio::detached);
  ctx.run();
}
          ssl::stream<>.
        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).
        any_executor and any_io_executor
          when used with asynchronous operations.
        nodiscard attribute to awaitable<>.
        BOOST_ASIO_RECYCLING_ALLOCATOR_CACHE_SIZE
          macro.
        std::system_error message workaround for recent
          MSVC.
        use_awaitable_t::executor_with_default.
        any_io_executor equality operators to correctly
          return a result based on the target executor.
        strand<> to avoid using a potentially moved-from
          executor.
        gcc tests are not used for clang
          when detecting compiler features.
        clang shipped with
          MSVC.
        OPENSSL_NO_SSL_INTERN
          is defined.
        posix::basic_stream_descriptor move operations to work
          with non-defaulted executors.
        ip::scope_id_type type alias.
        ip::port_type type alias.
        std::hash specialisations for IP addresses.
        std::hash specialisations for ip::basic_endpoint<>.
        any_io_executor to a "strong typedef"-style
          class.
        experimental::as_single to work with handler hook deprecation.
        errno is not overwritten if socket()
          fails on macOS/FreeBSD.
        io_context and thread_pool
          executors when move-assigned.
        call_stack objects are accessed only from
          implementation files.
        blocking.always property from being used with
          strand<>, as it did not produce the correct semantics.
        asio/impl/src.cpp.
        connect_pair function (which will
          fail with an operation_not_supported error).
        ip::basic_resolver.
        experimental::as_single completion token adapter.
          The as_single completion token adapter can be used to specify
          that the completion handler arguments should be combined into a single
          argument. For completion signatures with a single parameter, the argument
          is passed through as-is. For signatures with two or more parameters, the
          arguments are combined into a tuple. The as_single adapter
          may be used in conjunction with use_awaitable and structured
          bindings as follows:auto [e, n] = co_await socket.async_read_some(
    boost::asio::buffer(data), as_single(use_awaitable));
          using default_token = as_single_t<use_awaitable_t<>>;
using tcp_socket = default_token::as_default_on_t<tcp::socket>;
// ...
awaitable<void> do_read(tcp_socket socket)
{
  // ...
  auto [e, n] = co_await socket.async_read_some(boost::asio::buffer(data));
  // ...
}
          MSG_NOSIGNAL on more platforms by using
          _POSIX_VERSION to detect whether it is supported.
        executor concept to test for a const-qualified
          execute().
        any_executor support for builds without RTTI support.
        thread_pool unit test to work without RTTI support.
        asio::query.
        push/pop_options.hpp includes.
        select
          reactor is used on Windows.
        any_executor comparisons
          and conversion.
        strand<> adaptation of Networking TS executors
          when targeting older C++ versions or less conformant compilers.
        io_context::executor_type, thread_pool::executor_type,
                system_executor, and strand executors now
                meet the requirements for the proposed standard executors. These
                classes also continue to meet the existing requirements for the Networking
                TS model of executors.
              dispatch, post, defer, get_associated_executor,
                bind_executor, make_work_guard, spawn,
                co_spawn, async_compose, use_future,
                etc., can interoperate with both new proposed standard executors,
                and with existing Networking TS executors. The implementation determines
                at compile time which model a particular executor meets; the proposed
                standard executor model is used in preference if both are detected.
              any_io_executor type alias has been introduced as
                the new default runtime-polymorphic executor for all I/O objects.
                This type alias points to the execution::any_executor<>
                template with a set of supportable properties specified for use with
                I/O. This change may break existing code that directly uses the old
                polymorphic wrapper, executor. If required for backward
                compatibility, BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
                can be defined, which changes the any_io_executor type
                alias to instead point to the executor polymorphic wrapper.
              BOOST_ASIO_NO_TS_EXECUTORS.
              basic_waitable_timer.
          This enables move construction and assignment between different timer types,
          provided the executor types are convertible. For example:basic_waitable_timer<
    clock_type,
    traits_type,
    io_context::executor_type
  > timer1(my_io_context);
basic_waitable_timer<
    clock_type,
    traits_type,
    any_io_executor // polymorphic wrapper
  > timer2(std::move(timer1));
          gcc 10.
        co_spawn that launch an awaitable. This
          change allows us to write:co_spawn(executor,
    echo(std::move(socket)),
    detached);
          co_spawn(executor,
    [socket = std::move(socket)]() mutable
    {
      return echo(std::move(socket));
    },
    detached);
          use_awaitable_t's default
          executor adapter, to enable conversion between executor types.
        detached_t as a default completion
          token, by adding members as_default_on() and as_default_on_t<>.
        ssl::stream<>.
        ssl::stream<> write operations to linearise
          gather-write buffer sequences.
        asio_handler_invoke
          hook. This hook was deprecated with the introduction of the Networking
          TS trait associated_executor and function get_associated_executor().
          Compiling an application with BOOST_ASIO_NO_DEPRECATED will
          now trigger a compile error if any handler implements the asio_handler_invoke
          hook.
        asio_handler_allocate
          and asio_handle_deallocate hooks. These hooks were deprecated
          with the introduction of the Networking TS trait associated_allocator
          and function get_associated_allocator(). Compiling an application
          with BOOST_ASIO_NO_DEPRECATED will now trigger a compile error
          if any handler implements the asio_handler_allocate or asio_handler_deallocate
          hooks.
        recv rather
                than recvmsg, send rather than sendmsg,
                read rather than readv, and write
                rather than writev.
              executor.
              errno and error codes when on an
                error path.
              io_context::exeutor_type) is detected.
              BOOST_ASIO_HANDLER_LOCATION((file_name,
          line, function_name)) macro may be used to inform the handler tracking
          mechanism of a source location. This macro declares an object that is placed
          on the stack. Then, when an asynchronous operation is launched with location
          information, it outputs lines using the <action>
          n^m, prior to the n*m line that signifies
          the beginning of the asynchronous operation. For example:
@asio|1589423304.861944|>7|ec=system:0,bytes_transferred=5 @asio|1589423304.861952|7^8|in 'async_write' (./../../../include/asio/impl/write.hpp:330) @asio|1589423304.861952|7^8|called from 'do_write' (handler_tracking/async_tcp_echo_server.cpp:62) @asio|1589423304.861952|7^8|called from 'operator()' (handler_tracking/async_tcp_echo_server.cpp:51) @asio|1589423304.861952|7*8|socket@0x7ff61c008230.async_send @asio|1589423304.861975|.8|non_blocking_send,ec=system:0,bytes_transferred=5 @asio|1589423304.861980|<7|
std::source_location or std::experimental::source_location
          are available, the use_awaitable_t token (when default-constructed
          or used as a default completion token) will also cause handler tracking
          to output a source location for each newly created asynchronous operation.
          A use_awaitable_t object may also be explicitly constructed
          with location information.
        handlerviz.pl
          tool.
          handlerlive.pl tool, which processes handler
          tracking output to produce a list of "live" handlers. Live handlers
          are those that are associated with pending asynchronous operations, as
          well as handlers that are currently executing. For example:
cat output.txt | perl handlerlive.plor:
perl handerlive.pl < output.txtor:
perl handlerlive.pl output.txt
handlertree.pl tool, which filters handler
          tracking output to include only those events in the tree that produced
          the nominated handlers. For example, to filter the output to include only
          the events associated with handlers 123, 456,
          and their predecessors:
cat output.txt | perl handlertree.pl 123 456or:
perl handlertree.pl 123 456 < output.txt
cat output.txt | \ perl handlertree.pl `perl handlerlive.pl output.txt` | \ perl handlerviz.pl | \ dot -Tsvg > output.svg
async_compose to work with copyable handlers when passed
          by lvalue.
        co_spawn.
        Executor base class from the executor_binder
          implementation.
        noexcept.
        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.
        ssl::context constructor to take ownership of a native
          handle.
        gcc to use
          __cplusplus macro.
        strand<> converting constructors and assignment
          operators.
        async_read
          overloads.
        ssl::context class to propagate non-EOF errors
          from the add_certificate_authority function.
        thread_pool destructor hang that
          occurred when the pool had an associated I/O object.
        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.
        priority_scheduler example to demonstrate calls
          to shutdown() and destroy().
        use_awaitable_t::as_default_on
          function.
        boost::placeholders
          namespace.
        async_compose implementation
          due to incorrect overload selection.
        async_initiate helper function to automatically
          deduce its return type. This is enabled for C++11 or later.
        return_type.
        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.
              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.
              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;
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.
        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_fyz(
    IoObject& io_object,
    CompletionToken&& token =
      typename default_completion_token<
        typename IoObject::executor_type
      >::type{}
  );
          void, meaning
          no default completion token type is available for the given I/O executor.
        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.
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.
async_initiate to the Windows-specific I/O objects'
          asynchronous operations.
        basic_socket_acceptor<ip::tcp, my_executor_type>
basic_stream_socket<ip::tcp, my_executor_type>
Protocol copy and move operations
          never throw.
        Endpoint default constructor and move
          operations never throw.
        noexcept qualifier to protocol accessors.
        noexcept qualifier to socket move constructors.
        case fall-through
          in the free function connect() implementation.
        is_*_buffer_sequence detection traits for user-defined
          sequence types.
        CancelIoEx entry point.
        get_option() member function to be
          const.
        shutdown function.
        is_dynamic_buffer.
        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.
              asio::io_context& now accept either an Executor
                or a reference to a concrete ExecutionContext (such
                as asio::io_context or asio::thread_pool).
              io_context for constructing
                another I/O object, as in:
asio::steady_timer my_timer(my_socket.get_executor().context());
asio::steady_timer my_timer(my_socket.get_executor());
io_context:asio::steady_timer my_timer(my_io_context);
get_io_context and get_io_service
                member functions have now been removed.
              async_result form with an initiate
          static member function.
          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);
};
                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.
              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.
              async_initiate.
              handler_type trait and single-argument
                form of async_result have now been removed.
              asio
          namespace.
          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.
              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<>.
              DynamicBuffer_v2 concept which is CopyConstructible.
          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: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));
}
                DynamicBuffer type requirements have been
                renamed to DynamicBuffer_v1. These requirements continue
                to be compatible with the Networking TS.
              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 BOOST_ASIO_NO_DYNAMIC_BUFFER_V1 is explicitly
                defined, in which case it delegates to is_dynamic_buffer_v2).
              dynamic_string_buffer and dynamic_vector_buffer
                classes conform to both DynamicBuffer_v1 and DynamicBuffer_v2
                requirements.
              BOOST_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.
              async_compose function that simplifies the implementation
          of user-defined asynchronous operations.
        make_strand function, which creates a strand
          with a deduced Executor template argument.
        local::basic_endpoint that takes a
          string_view.
        ip::address,
          ip::address_v4, ip::address_v6, ip::basic_endpoint,
          and executor_work_guard classes.
        buffer_sequence_begin
          and buffer_sequence_end functions.
        BOOST_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.)
        error::message_size) occurs on a datagram-oriented
          socket.
        SO_REUSEPORT
          when the reuse_address option is set.
        unistd.h when targeting Haiku OS, to fix
          feature detection.
        network_v[46].hpp headers to the top-level convenience
          header.
        pthread_cond_timedwait.
        EndpointSequence
          iterator type rather than assume the presence of a const_iterator
          typedef.
        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.
        eof error on SSL shutdown as it actually indicates
          success.
        SSL_ERROR_SYSCALL
          result without an associated error.
        <atomic> when targeting apple/clang/libc++
          with recent Xcode versions, even for C++03. This fixes a warning about
          the deprecation of OSMemoryBarrier.
        decltype support for
          that compiler.
        _WIN32_WINNT to 0x0601
          (Windows 7).
        dispatch documentation to note that it may call the
          supplied function object in the current thread.
        post and defer documentation to clarify
          the the distinction between them.
        system_executor was not being correctly cleaned up on exit.
        std::future availability
          with libstdc++.
        read_until.
        std::experimental::string_view and std::string_view
          with newer clang/libc++.
        std::invoke_result.
        decltype
          is available.
        size(), max_size() or
          empty() on default-constructed resolver results.
        std::string_view detection issue when using clang-cl.
        io_context::executor_type::dispatch.
        basic_socket_acceptor::get_option.
        experimental::detached completion token.
              experimental::redirect_error completion token.
              experimental::co_spawn facility for integration
                with the coroutines technical specification.
              asio::steady_timer rather than asio::deadline_timer.
              asio::dynamic_buffer rather than asio::streambuf.
              asio::io_context::run_for() function for
                blocking clients.
              BOOST_ASIO_NO_DEPRECATED
          is defined.
        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.
        is_dynamic_buffer
          trait.
        async_result incompatibility with deprecated handler_type.
        basic_resolver_results::value_type typedef.
        SSL_OP_NO_COMPRESSION
          is defined.
        add_certificate_authority to process multiple certificates
          in a bundle.
        std::invoke_result
          rather than std::result_of.
        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.
        DynamicBuffer template arguments are decayed before
          using in enable_if tests.
        basic_yield_context to work with completion signatures
          containing reference parameters.
        spawn() correctly
          store decayed copies of their function and handler arguments.
        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.
              io_context
          basis.
        ssl::stream<>
          constructor argument.
        g++ versions >= 4.7 to use standard
          atomics, to fix a linker error when using g++ 4.6 (#13121).
        constexpr and variadic templates with recent
          MSVC versions.
        auto_ptr.
        asio_handler_is_continuation result
          in reactive async_accept implementation.
        poll.h rather than sys/poll.h
          on some modern POSIX platforms (#12419).
        __thread keyword extension for android/clang/x86
          targets.
        EAGAIN or EWOULDBLOCK)
          with posix::stream_descriptor, when using the Linux epoll
          backend.
        allocator_traits to rebind allocators in C++11
          or later.
        ssl::context_base enumerations to enable support
          for any TLS version, and improved consistency of SSL/TLS version handling
          across OpenSSL releases.
        gcc
          (#12302).
        std::atomic_thread_fence, when available,
          to eliminate a deprecated function warning on newest macOS SDK (#12482).
        getaddrinfo in Apple's NAT64
          environment.
        asio::connect() when the
          connect_condition returns an end iterator (#12354).
        getsockname reports 0.0.0.0 (#12406).
        SSL_COMP_free_compression_methods to fix two
          memory leaks reported at shutdown, for OpenSSL versions >= 1.0.2 and
          < 1.1.0 (#10795).
        use_future compile error encountered on some standard
          library implementations, by changing std::allocator<void>
          use to a non-void template parameter.
        getaddrinfo by default on Apple OSes,
          rather than emulation in terms of getipnodebyname.
        OPENSSL_NO_SSL3
          feature test #define (#11754).
        SSL_CTX_clear_chain_certs
          function, if available.
        strncat in the getaddrinfo
          emulation and in the SSL wrapper's password handling.
        CreateEventW rather
          than CreateEvent (#11732).
        ConnectEx function are
          mapped to their portable equivalents (#10744).
        BOOST_ASIO_DISABLE_CONNECTEX to allow use
          of ConnectEx to be explicitly disabled.
        windows::object_handle when there
          are pending wait operations on destruction (#10624).
        EINVAL.
        ssl::stream<> bug that may result in spurious
          'short read' errors.
        ERR_remove_state.
        std::addressof with g++
          (#10982).
        join_group failures
          as non-fatal.
        std::endl to ensure output is
          flushed.
        yield_context
          object with asynchronous operations.
        yield_context to allow reentrant calls to the completion
          handler from an initiating function.
        kqueue reactor so that it works on FreeBSD
          (#10606).
        kqueue reactor which resulted
          in spinning when using serial ports on Mac OS (#10496).
        kqueue reactor support for read-only file descriptors
          (#10367).
        /dev/poll reactor
          (#10350, #10572).
        WSASocketW, as WSASocketA
          has been deprecated (#10534).
        use_future and spawn()
          are not made available when including the asio.hpp convenience
          header (#10567).
        asio::strand as deprecated. Use asio::io_service::strand
          instead.
        kqueue backend that was introduced
          in Asio 1.10.2.
        gcc
          on AIX.
        gcc problem to do with anonymous enums
          (#10042).
        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 (#10034).
        signal_set implementation's
          signal number check (#9324).
        SO_UPDATE_CONNECT_CONTEXT
          is defined (#10016).
        VerifyVersionInfo
          rather than GetVersionEx, as GetVersionEx has
          been deprecated.
        asio::spawn() to work correctly with new Boost.Coroutine
          interface (#9442, #9928).
        asio::spawn() coroutines are correctly
          unwound when cleaned up by the io_service destructor (#9731).
        io_service::wrap()
          and strand::wrap() (#9741).
        ConnectEx,
          if available, for connection-oriented IP sockets.
        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.
        boost::chrono
          and std::chrono clocks (#9662, #9778).
        EV_CLEAR handling in the kqueue backend,
          to address other cases where the close() system call may hang
          on Mac OS X.
        resolver_query_base::flags::operator~
          (#9548).
        select reactor more efficient on Windows for large
          numbers of sockets (#9528).
        gcc
          (#9550).
        GetQueuedCompletionStatus timeout workaround
          on recent versions of Windows.
        io_service, strand,
                buffers, composed operations, timers, etc., should all work as normal.
              cancel() function is not supported for sockets.
                Asynchronous operations may only be cancelled by closing the socket.
              null_buffers are not supported.
              tcp::no_delay and socket_base::keep_alive
                options are supported.
              async_connect were not correctly propagated through
          to the completion handler (#8795).
        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 (#8933).
        async_wait on a signal that is already raised
          (#8738).
        async_write_at
          operations (#8669).
        HANDLE backend to treat ERROR_MORE_DATA
          as a non-fatal error when returned by GetOverlappedResult
          for a synchronous read (#8722).
        generic as a keyword. Added
          a workaround that renames the namespace to cpp_generic when
          those language extensions are in effect.
        async_result
          support in Boost 1.54. In particular, the buffered stream templates have
          been updated so that they adhere to current handler patterns (#9000,
          #9001).
        use_future support for Microsoft Visual Studio 2012.
        std::min in the Windows IOCP backend to avoid
          a dependency on the <algorithm> header (#8758).
        SSL_CTX_clear_options
          function (#9273).
        handler_type and async_result,
          that allow the customisation of the return type of an initiating function.
        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 Stackful
          Coroutines.
        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 C++
          2011 Support - Futures.
        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.
        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 Support
          for Other Protocols.
        ip::tcp::socket
          can be converted into a generic::stream_protocol::socket via
          move construction. For further information, see Support
          for Other Protocols.
        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 Support
          for Other Protocols.
        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.
              ssl::context
                objects.
              set_verify_depth() function to the ssl::context
                and ssl::stream<> classes.
              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.
              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).
              signal_set implementation.
        #warning directive #7939.
        epoll implementation.
        error_code with an invalid (i.e. NULL) error_category
          #8613.
        basic_waitable_timer's underlying implementation so
          that it can handle any time_point value without overflowing
          the intermediate duration objects.
        run() and poll() on the same io_service
          object #8354.
        ssl::rfc2818_verification class.
        boost/asio/detail/winsock_init.hpp
          for details.
        basic_socket::get_option's
          documentation (#7562).
        long rather than int for SSL_CTX
          options, to match OpenSSL (#7209).
        _snwprintf to address a compile error due to
          the changed swprintf signature in recent versions of MinGW
          (#7373).
        io_service threads due to running out of work (#7552).
        noexcept qualifier for error categories (#7797).
        accept
          as non-fatal (#7488).
        ip::tcp::iostream and C++11
          (#7162).
        #include <cctype>, needed for some versions
          of MinGW.
        gcc's atomic builtins on ARM CPUs, when
          available (#7140).
        io_service has been destroyed.
        epoll_create1()
          function but always fail with ENOSYS (#7012).
        buffered_write_stream (#6310).
        epoll_reactor backend to do lazy registration
          for EPOLLOUT events.
        epoll_reactor handling of out-of-band data, which
          was broken by an incomplete fix in the last release.
        OPENSSL_NO_ENGINE
          feature test #define (#6432).
        windows::object_handle so that it works with Windows
          compilers that support C++11 move semantics (such as g++).
        g++ 4.7 when compiling in C++11 mode
          (#6620).
        signal_set handlers were not being delivered
          when the io_service was constructed with a concurrency_hint
          of 1 (#6657).
        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.
        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.
        connect() can return EAGAIN in certain circumstances.
          Remapped this to another error so that it doesn't look like a non-blocking
          operation (#6048).
        buffered_write_stream (#6310).
        io_service
          is repeatedly run without anything to do (#6321).
        concurrency_hint is 1) to eliminate a lock/unlock
                pair.
              epoll_reactor speculative operations to
                be performed without holding the lock.
              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.
              boost::array or std::array)
                of exactly two buffers.
              async_read_until
          (#5688).
        signal()
          function from the global namespace (#5722).
        deadline_timer implementation so that it does
          not read the clock unless the timer heap is non-empty.
        null_buffers operations
          so that they obey the user's non-blocking setting (#5756).
        fd_set at runtime when
          using Windows.
        epoll_reactor initialisation
          (#6006).
        BOOST_ASIO_STRAND_IMPLEMENTATIONS
          to the desired number.
        BOOST_ASIO_ENABLE_SEQUENTIAL_STRAND_ALLOCATION
          flag which switches the allocation of strand implementations to use a round-robin
          approach rather than hashing.
        strand.post()
          is used.
        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 be registered with multiple signal_set
          objects, however the signal number must be used only with Asio. Addresses
          #2879.
        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).
        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.
        error() member function to socket iostreams, for
          retrieving the error code from the most recent system call.
        basic_deadline_timer::cancel_one() function. This
          function lets you cancel a single waiting handler on a timer. Handlers
          are cancelled in FIFO order.
        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.
        connect() and async_connect().
          These operations try each endpoint in a list until the socket is successfully
          connected, and are useful for creating TCP clients that work with both
          IPv4 and IPv6.
        buffer_size() function so that it works for buffer
          sequences in addition to individual buffers.
        buffer_copy() function that can be used to copy
          the raw bytes between individual buffers and buffer sequences.
        read(), read_at(),
          write() and write_at() that do not require a
          completion condition.
        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.
        BOOST_ASIO_ENABLE_OLD_SSL. Addresses #3702,
          #3958.
        boost/asio/ssl/impl/src.hpp in one
          source file in your program.
        is_loopback(), is_unspecified() and
          is_multicast() functions consistently available across the
          ip::address, ip::address_v4 and ip::address_v6
          classes (#3939).
        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.
        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.
        io_control() member function for socket acceptors
          (#3297).
        release() member function to posix descriptors. This
          function releases ownership of the underlying native descriptor to the
          caller. Addresses #3900.
        SOCK_SEQPACKET).
        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()).
        native_type
          typedefs in favour of native_handle_type, and the native()
          member functions in favour of native_handle().
        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. Addresses #3238,
          #4162.
        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. Addresses #3307.
        asio::buffer() overloads for std::array,
          when available.
        array, shared_ptr, weak_ptr and
          atomic when they are available, rather than the Boost equivalents.
        what() messages.
        shutdown_service() member functions to be private.
        ip::basic_endpoint<> objects (such
          as ip::tcp::endpoint and ip::udp::endpoint).
        assign() may have been dup()-ed,
          and so require explicit deregistration from the reactor (#4971).
        io_service().
          The get_io_service() member functions should be used instead.
        resolver_query and resolver_iterator
          from the ip::tcp, ip::udp and ip::icmp
          classes.
        buffers_iterator<> and ip::basic_resolver_iterator
          classes so that the value_type typedefs are non-const byte types.
        -Wshadow compiler option
          (#3905).
        FIONBIO constant to
          int, to suppress a compiler warning on some platforms (#5128).
        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 (#5418).
        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 (#5021).
        g++ due
          to the use of anonymous enums (#4883).
        EWOULDBLOCK are not correctly re-registered with
          kqueue.
        asio::streambuf to ensure that its internal pointers
          are updated correctly after the data has been modified using std::streambuf
          member functions.
        ip::address_v4::broadcast()
          is used on 64-bit platforms.
        deadline_timer
          may never fire if the io_service is running in a background
          thread (#4568).
        has_service<>
          from compiling (#4638).
        close()/closesocket() failures are correctly
          propagated (#4573).
        InitializeCriticalSectionAndSpinCount
          (#4574).
        pselect() on HP-UX, if it is available (#4578).
        deadline_timer objects
          with expiry times set more than 5 minutes in the future may never expire
          (#4745).
        resolver backend on BSD platforms so that an empty
          service name resolves to port number 0, as per the documentation
          (#4690).
        const_buffers_1 (#4746).
        Protocol and id to avoid clashing with
          Objective-C++ keywords (#4191).
        vector reallocation performance issue that can occur
          when there are many active deadline_timer objects (#4780).
        io_control() implementation on 64-bit Mac
          OS X and BSD platforms (#4782).
        accept()
          are incorrectly treated as successes (#4859).
        <boost/asio/impl/src.cpp>
          in favour of <boost/asio/impl/src.hpp> (#4560).
        #includes, e.g. if the program uses boost::array
          but does not explicitly include <boost/array.hpp>.)
        deadline_timer implementation to improve performance.
        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.
        #include <boost/asio/impl/src.cpp>
          to 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.
        BOOST_ASIO_DISABLE_FENCED_BLOCK to permit
          the disabling of memory fences around completion handlers, even if thread
          support is enabled.
        const types.
        null_buffers variant of
          async_send_to (#4170).
        unsigned char is used with isdigit in
          getaddrinfo emulation (#4201).
        operator+ overload in buffers_iterator
          (#4382).
        null_buffers operations on Windows.
        timerfd for dispatching timers on Linux, when
          available.
        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.
        #define NOMINMAX for all Windows compilers. Users can
          define BOOST_ASIO_NO_NOMINMAX to suppress this definition
          (#3901).
        error::eof result to the completion handler (#4023).
        io_control() member functions to always call
          ioctl on the underlying descriptor when modifying blocking
          mode (#3307).
        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.
        select().
        BOOST_ASIO_DISABLE_THREADS macro that allows Asio's
          threading support to be independently disabled.
        boost::addressof
          to get the address of handler objects, rather than applying operator&
          directly (#2977).
        OVERLAPPED structure to be valid until both the initiating
          function call has returned and the completion packet has been delivered.
        boost_ prefix to the extern "C"
          thread entry point function (#3809).
        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.
        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.
        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 (#2754).
        /dev/poll
          backend.
        _GLIBCXX_DEBUG is defined (#3098).
        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.)
        io_control() so that it adheres
          to the documented type requirements for IoControlCommand (#2820).
        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 (#2936).
        BOOST_ASIO_DISABLE_SERIAL_PORT
          is defined (#2917).
        windows::overlapped_ptr::complete() are
          correctly passed to the completion handler (#2614).
        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).
        HANDLEs such as
          named pipes (requires HANDLEs that work with I/O completion
          ports).
        HANDLEs such as files
          (requires HANDLEs that work with I/O completion ports).
        null_buffers type.
        read_until() and async_read_until()
          overloads that take a user-defined function object for locating message
          boundaries.
        BOOST_ASIO_ENABLE_TWO_LOCK_QUEUE)
          that may provide better io_service scalability across many
          processors.
        First release of Asio as part of Boost.