|  | Home | Libraries | People | FAQ | More | 
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.