├── .appveyor.yml ├── .cirrus.yml ├── .github └── workflows │ └── ci.yml ├── .gitignore └── asio ├── .gitignore ├── COPYING ├── INSTALL ├── LICENSE_1_0.txt ├── Makefile.am ├── README ├── asio.manifest ├── asio.pc.in ├── autogen.sh ├── boost_asio.manifest ├── boostify.pl ├── configure.ac ├── include ├── .gitignore ├── Makefile.am ├── asio.hpp └── asio │ ├── any_completion_executor.hpp │ ├── any_completion_handler.hpp │ ├── any_io_executor.hpp │ ├── append.hpp │ ├── as_tuple.hpp │ ├── associated_allocator.hpp │ ├── associated_cancellation_slot.hpp │ ├── associated_executor.hpp │ ├── associated_immediate_executor.hpp │ ├── associator.hpp │ ├── async_result.hpp │ ├── awaitable.hpp │ ├── basic_datagram_socket.hpp │ ├── basic_deadline_timer.hpp │ ├── basic_file.hpp │ ├── basic_io_object.hpp │ ├── basic_random_access_file.hpp │ ├── basic_raw_socket.hpp │ ├── basic_readable_pipe.hpp │ ├── basic_seq_packet_socket.hpp │ ├── basic_serial_port.hpp │ ├── basic_signal_set.hpp │ ├── basic_socket.hpp │ ├── basic_socket_acceptor.hpp │ ├── basic_socket_iostream.hpp │ ├── basic_socket_streambuf.hpp │ ├── basic_stream_file.hpp │ ├── basic_stream_socket.hpp │ ├── basic_streambuf.hpp │ ├── basic_streambuf_fwd.hpp │ ├── basic_waitable_timer.hpp │ ├── basic_writable_pipe.hpp │ ├── bind_allocator.hpp │ ├── bind_cancellation_slot.hpp │ ├── bind_executor.hpp │ ├── bind_immediate_executor.hpp │ ├── buffer.hpp │ ├── buffer_registration.hpp │ ├── buffered_read_stream.hpp │ ├── buffered_read_stream_fwd.hpp │ ├── buffered_stream.hpp │ ├── buffered_stream_fwd.hpp │ ├── buffered_write_stream.hpp │ ├── buffered_write_stream_fwd.hpp │ ├── buffers_iterator.hpp │ ├── cancel_after.hpp │ ├── cancel_at.hpp │ ├── cancellation_signal.hpp │ ├── cancellation_state.hpp │ ├── cancellation_type.hpp │ ├── co_composed.hpp │ ├── co_spawn.hpp │ ├── completion_condition.hpp │ ├── compose.hpp │ ├── composed.hpp │ ├── config.hpp │ ├── connect.hpp │ ├── connect_pipe.hpp │ ├── consign.hpp │ ├── coroutine.hpp │ ├── deadline_timer.hpp │ ├── default_completion_token.hpp │ ├── defer.hpp │ ├── deferred.hpp │ ├── detached.hpp │ ├── detail │ ├── array.hpp │ ├── array_fwd.hpp │ ├── assert.hpp │ ├── atomic_count.hpp │ ├── base_from_cancellation_state.hpp │ ├── base_from_completion_cond.hpp │ ├── bind_handler.hpp │ ├── blocking_executor_op.hpp │ ├── buffer_resize_guard.hpp │ ├── buffer_sequence_adapter.hpp │ ├── buffered_stream_storage.hpp │ ├── call_stack.hpp │ ├── chrono.hpp │ ├── chrono_time_traits.hpp │ ├── completion_handler.hpp │ ├── completion_message.hpp │ ├── completion_payload.hpp │ ├── completion_payload_handler.hpp │ ├── composed_work.hpp │ ├── concurrency_hint.hpp │ ├── conditionally_enabled_event.hpp │ ├── conditionally_enabled_mutex.hpp │ ├── config.hpp │ ├── consuming_buffers.hpp │ ├── cstddef.hpp │ ├── cstdint.hpp │ ├── date_time_fwd.hpp │ ├── deadline_timer_service.hpp │ ├── dependent_type.hpp │ ├── descriptor_ops.hpp │ ├── descriptor_read_op.hpp │ ├── descriptor_write_op.hpp │ ├── dev_poll_reactor.hpp │ ├── epoll_reactor.hpp │ ├── event.hpp │ ├── eventfd_select_interrupter.hpp │ ├── exception.hpp │ ├── executor_function.hpp │ ├── executor_op.hpp │ ├── fd_set_adapter.hpp │ ├── fenced_block.hpp │ ├── functional.hpp │ ├── future.hpp │ ├── global.hpp │ ├── handler_alloc_helpers.hpp │ ├── handler_cont_helpers.hpp │ ├── handler_tracking.hpp │ ├── handler_type_requirements.hpp │ ├── handler_work.hpp │ ├── hash_map.hpp │ ├── impl │ │ ├── buffer_sequence_adapter.ipp │ │ ├── descriptor_ops.ipp │ │ ├── dev_poll_reactor.hpp │ │ ├── dev_poll_reactor.ipp │ │ ├── epoll_reactor.hpp │ │ ├── epoll_reactor.ipp │ │ ├── eventfd_select_interrupter.ipp │ │ ├── handler_tracking.ipp │ │ ├── io_uring_descriptor_service.ipp │ │ ├── io_uring_file_service.ipp │ │ ├── io_uring_service.hpp │ │ ├── io_uring_service.ipp │ │ ├── io_uring_socket_service_base.ipp │ │ ├── kqueue_reactor.hpp │ │ ├── kqueue_reactor.ipp │ │ ├── null_event.ipp │ │ ├── pipe_select_interrupter.ipp │ │ ├── posix_event.ipp │ │ ├── posix_mutex.ipp │ │ ├── posix_serial_port_service.ipp │ │ ├── posix_thread.ipp │ │ ├── posix_tss_ptr.ipp │ │ ├── reactive_descriptor_service.ipp │ │ ├── reactive_socket_service_base.ipp │ │ ├── resolver_service_base.ipp │ │ ├── scheduler.ipp │ │ ├── select_reactor.hpp │ │ ├── select_reactor.ipp │ │ ├── service_registry.hpp │ │ ├── service_registry.ipp │ │ ├── signal_set_service.ipp │ │ ├── socket_ops.ipp │ │ ├── socket_select_interrupter.ipp │ │ ├── strand_executor_service.hpp │ │ ├── strand_executor_service.ipp │ │ ├── strand_service.hpp │ │ ├── strand_service.ipp │ │ ├── thread_context.ipp │ │ ├── throw_error.ipp │ │ ├── timer_queue_ptime.ipp │ │ ├── timer_queue_set.ipp │ │ ├── win_event.ipp │ │ ├── win_iocp_file_service.ipp │ │ ├── win_iocp_handle_service.ipp │ │ ├── win_iocp_io_context.hpp │ │ ├── win_iocp_io_context.ipp │ │ ├── win_iocp_serial_port_service.ipp │ │ ├── win_iocp_socket_service_base.ipp │ │ ├── win_mutex.ipp │ │ ├── win_object_handle_service.ipp │ │ ├── win_static_mutex.ipp │ │ ├── win_thread.ipp │ │ ├── win_tss_ptr.ipp │ │ ├── winrt_ssocket_service_base.ipp │ │ ├── winrt_timer_scheduler.hpp │ │ ├── winrt_timer_scheduler.ipp │ │ └── winsock_init.ipp │ ├── initiate_defer.hpp │ ├── initiate_dispatch.hpp │ ├── initiate_post.hpp │ ├── initiation_base.hpp │ ├── io_control.hpp │ ├── io_object_impl.hpp │ ├── io_uring_descriptor_read_at_op.hpp │ ├── io_uring_descriptor_read_op.hpp │ ├── io_uring_descriptor_service.hpp │ ├── io_uring_descriptor_write_at_op.hpp │ ├── io_uring_descriptor_write_op.hpp │ ├── io_uring_file_service.hpp │ ├── io_uring_null_buffers_op.hpp │ ├── io_uring_operation.hpp │ ├── io_uring_service.hpp │ ├── io_uring_socket_accept_op.hpp │ ├── io_uring_socket_connect_op.hpp │ ├── io_uring_socket_recv_op.hpp │ ├── io_uring_socket_recvfrom_op.hpp │ ├── io_uring_socket_recvmsg_op.hpp │ ├── io_uring_socket_send_op.hpp │ ├── io_uring_socket_sendto_op.hpp │ ├── io_uring_socket_service.hpp │ ├── io_uring_socket_service_base.hpp │ ├── io_uring_wait_op.hpp │ ├── is_buffer_sequence.hpp │ ├── is_executor.hpp │ ├── keyword_tss_ptr.hpp │ ├── kqueue_reactor.hpp │ ├── limits.hpp │ ├── local_free_on_block_exit.hpp │ ├── memory.hpp │ ├── mutex.hpp │ ├── non_const_lvalue.hpp │ ├── noncopyable.hpp │ ├── null_event.hpp │ ├── null_fenced_block.hpp │ ├── null_global.hpp │ ├── null_mutex.hpp │ ├── null_reactor.hpp │ ├── null_signal_blocker.hpp │ ├── null_socket_service.hpp │ ├── null_static_mutex.hpp │ ├── null_thread.hpp │ ├── null_tss_ptr.hpp │ ├── object_pool.hpp │ ├── old_win_sdk_compat.hpp │ ├── op_queue.hpp │ ├── operation.hpp │ ├── pipe_select_interrupter.hpp │ ├── pop_options.hpp │ ├── posix_event.hpp │ ├── posix_fd_set_adapter.hpp │ ├── posix_global.hpp │ ├── posix_mutex.hpp │ ├── posix_serial_port_service.hpp │ ├── posix_signal_blocker.hpp │ ├── posix_static_mutex.hpp │ ├── posix_thread.hpp │ ├── posix_tss_ptr.hpp │ ├── push_options.hpp │ ├── reactive_descriptor_service.hpp │ ├── reactive_null_buffers_op.hpp │ ├── reactive_socket_accept_op.hpp │ ├── reactive_socket_connect_op.hpp │ ├── reactive_socket_recv_op.hpp │ ├── reactive_socket_recvfrom_op.hpp │ ├── reactive_socket_recvmsg_op.hpp │ ├── reactive_socket_send_op.hpp │ ├── reactive_socket_sendto_op.hpp │ ├── reactive_socket_service.hpp │ ├── reactive_socket_service_base.hpp │ ├── reactive_wait_op.hpp │ ├── reactor.hpp │ ├── reactor_op.hpp │ ├── reactor_op_queue.hpp │ ├── recycling_allocator.hpp │ ├── regex_fwd.hpp │ ├── resolve_endpoint_op.hpp │ ├── resolve_op.hpp │ ├── resolve_query_op.hpp │ ├── resolver_service.hpp │ ├── resolver_service_base.hpp │ ├── scheduler.hpp │ ├── scheduler_operation.hpp │ ├── scheduler_task.hpp │ ├── scheduler_thread_info.hpp │ ├── scoped_lock.hpp │ ├── scoped_ptr.hpp │ ├── select_interrupter.hpp │ ├── select_reactor.hpp │ ├── service_registry.hpp │ ├── signal_blocker.hpp │ ├── signal_handler.hpp │ ├── signal_init.hpp │ ├── signal_op.hpp │ ├── signal_set_service.hpp │ ├── socket_holder.hpp │ ├── socket_ops.hpp │ ├── socket_option.hpp │ ├── socket_select_interrupter.hpp │ ├── socket_types.hpp │ ├── source_location.hpp │ ├── static_mutex.hpp │ ├── std_event.hpp │ ├── std_fenced_block.hpp │ ├── std_global.hpp │ ├── std_mutex.hpp │ ├── std_static_mutex.hpp │ ├── std_thread.hpp │ ├── strand_executor_service.hpp │ ├── strand_service.hpp │ ├── string_view.hpp │ ├── thread.hpp │ ├── thread_context.hpp │ ├── thread_group.hpp │ ├── thread_info_base.hpp │ ├── throw_error.hpp │ ├── throw_exception.hpp │ ├── timed_cancel_op.hpp │ ├── timer_queue.hpp │ ├── timer_queue_base.hpp │ ├── timer_queue_ptime.hpp │ ├── timer_queue_set.hpp │ ├── timer_scheduler.hpp │ ├── timer_scheduler_fwd.hpp │ ├── tss_ptr.hpp │ ├── type_traits.hpp │ ├── utility.hpp │ ├── wait_handler.hpp │ ├── wait_op.hpp │ ├── win_event.hpp │ ├── win_fd_set_adapter.hpp │ ├── win_global.hpp │ ├── win_iocp_file_service.hpp │ ├── win_iocp_handle_read_op.hpp │ ├── win_iocp_handle_service.hpp │ ├── win_iocp_handle_write_op.hpp │ ├── win_iocp_io_context.hpp │ ├── win_iocp_null_buffers_op.hpp │ ├── win_iocp_operation.hpp │ ├── win_iocp_overlapped_op.hpp │ ├── win_iocp_overlapped_ptr.hpp │ ├── win_iocp_serial_port_service.hpp │ ├── win_iocp_socket_accept_op.hpp │ ├── win_iocp_socket_connect_op.hpp │ ├── win_iocp_socket_recv_op.hpp │ ├── win_iocp_socket_recvfrom_op.hpp │ ├── win_iocp_socket_recvmsg_op.hpp │ ├── win_iocp_socket_send_op.hpp │ ├── win_iocp_socket_service.hpp │ ├── win_iocp_socket_service_base.hpp │ ├── win_iocp_thread_info.hpp │ ├── win_iocp_wait_op.hpp │ ├── win_mutex.hpp │ ├── win_object_handle_service.hpp │ ├── win_static_mutex.hpp │ ├── win_thread.hpp │ ├── win_tss_ptr.hpp │ ├── winapp_thread.hpp │ ├── wince_thread.hpp │ ├── winrt_async_manager.hpp │ ├── winrt_async_op.hpp │ ├── winrt_resolve_op.hpp │ ├── winrt_resolver_service.hpp │ ├── winrt_socket_connect_op.hpp │ ├── winrt_socket_recv_op.hpp │ ├── winrt_socket_send_op.hpp │ ├── winrt_ssocket_service.hpp │ ├── winrt_ssocket_service_base.hpp │ ├── winrt_timer_scheduler.hpp │ ├── winrt_utils.hpp │ ├── winsock_init.hpp │ ├── work_dispatcher.hpp │ └── wrapped_handler.hpp │ ├── dispatch.hpp │ ├── disposition.hpp │ ├── error.hpp │ ├── error_code.hpp │ ├── execution.hpp │ ├── execution │ ├── allocator.hpp │ ├── any_executor.hpp │ ├── bad_executor.hpp │ ├── blocking.hpp │ ├── blocking_adaptation.hpp │ ├── context.hpp │ ├── context_as.hpp │ ├── executor.hpp │ ├── impl │ │ └── bad_executor.ipp │ ├── invocable_archetype.hpp │ ├── mapping.hpp │ ├── occupancy.hpp │ ├── outstanding_work.hpp │ ├── prefer_only.hpp │ └── relationship.hpp │ ├── execution_context.hpp │ ├── executor.hpp │ ├── executor_work_guard.hpp │ ├── experimental │ ├── as_single.hpp │ ├── awaitable_operators.hpp │ ├── basic_channel.hpp │ ├── basic_concurrent_channel.hpp │ ├── cancellation_condition.hpp │ ├── channel.hpp │ ├── channel_error.hpp │ ├── channel_traits.hpp │ ├── co_composed.hpp │ ├── co_spawn.hpp │ ├── concurrent_channel.hpp │ ├── coro.hpp │ ├── coro_traits.hpp │ ├── detail │ │ ├── channel_operation.hpp │ │ ├── channel_receive_op.hpp │ │ ├── channel_send_functions.hpp │ │ ├── channel_send_op.hpp │ │ ├── channel_service.hpp │ │ ├── coro_completion_handler.hpp │ │ ├── coro_promise_allocator.hpp │ │ ├── has_signature.hpp │ │ ├── impl │ │ │ └── channel_service.hpp │ │ └── partial_promise.hpp │ ├── impl │ │ ├── as_single.hpp │ │ ├── channel_error.ipp │ │ ├── coro.hpp │ │ ├── parallel_group.hpp │ │ ├── promise.hpp │ │ ├── use_coro.hpp │ │ └── use_promise.hpp │ ├── parallel_group.hpp │ ├── promise.hpp │ ├── use_coro.hpp │ └── use_promise.hpp │ ├── file_base.hpp │ ├── generic │ ├── basic_endpoint.hpp │ ├── datagram_protocol.hpp │ ├── detail │ │ ├── endpoint.hpp │ │ └── impl │ │ │ └── endpoint.ipp │ ├── raw_protocol.hpp │ ├── seq_packet_protocol.hpp │ └── stream_protocol.hpp │ ├── handler_continuation_hook.hpp │ ├── high_resolution_timer.hpp │ ├── immediate.hpp │ ├── impl │ ├── any_completion_executor.ipp │ ├── any_io_executor.ipp │ ├── append.hpp │ ├── as_tuple.hpp │ ├── awaitable.hpp │ ├── buffered_read_stream.hpp │ ├── buffered_write_stream.hpp │ ├── cancel_after.hpp │ ├── cancel_at.hpp │ ├── cancellation_signal.ipp │ ├── co_spawn.hpp │ ├── config.hpp │ ├── config.ipp │ ├── connect.hpp │ ├── connect_pipe.hpp │ ├── connect_pipe.ipp │ ├── consign.hpp │ ├── deferred.hpp │ ├── detached.hpp │ ├── error.ipp │ ├── error_code.ipp │ ├── execution_context.hpp │ ├── execution_context.ipp │ ├── executor.hpp │ ├── executor.ipp │ ├── io_context.hpp │ ├── io_context.ipp │ ├── multiple_exceptions.ipp │ ├── prepend.hpp │ ├── read.hpp │ ├── read_at.hpp │ ├── read_until.hpp │ ├── redirect_error.hpp │ ├── serial_port_base.hpp │ ├── serial_port_base.ipp │ ├── spawn.hpp │ ├── src.hpp │ ├── system_context.hpp │ ├── system_context.ipp │ ├── system_executor.hpp │ ├── thread_pool.hpp │ ├── thread_pool.ipp │ ├── use_awaitable.hpp │ ├── use_future.hpp │ ├── write.hpp │ └── write_at.hpp │ ├── io_context.hpp │ ├── io_context_strand.hpp │ ├── ip │ ├── address.hpp │ ├── address_v4.hpp │ ├── address_v4_iterator.hpp │ ├── address_v4_range.hpp │ ├── address_v6.hpp │ ├── address_v6_iterator.hpp │ ├── address_v6_range.hpp │ ├── bad_address_cast.hpp │ ├── basic_endpoint.hpp │ ├── basic_resolver.hpp │ ├── basic_resolver_entry.hpp │ ├── basic_resolver_iterator.hpp │ ├── basic_resolver_query.hpp │ ├── basic_resolver_results.hpp │ ├── detail │ │ ├── endpoint.hpp │ │ ├── impl │ │ │ └── endpoint.ipp │ │ └── socket_option.hpp │ ├── host_name.hpp │ ├── icmp.hpp │ ├── impl │ │ ├── address.hpp │ │ ├── address.ipp │ │ ├── address_v4.hpp │ │ ├── address_v4.ipp │ │ ├── address_v6.hpp │ │ ├── address_v6.ipp │ │ ├── basic_endpoint.hpp │ │ ├── host_name.ipp │ │ ├── network_v4.hpp │ │ ├── network_v4.ipp │ │ ├── network_v6.hpp │ │ └── network_v6.ipp │ ├── multicast.hpp │ ├── network_v4.hpp │ ├── network_v6.hpp │ ├── resolver_base.hpp │ ├── resolver_query_base.hpp │ ├── tcp.hpp │ ├── udp.hpp │ ├── unicast.hpp │ └── v6_only.hpp │ ├── is_applicable_property.hpp │ ├── is_contiguous_iterator.hpp │ ├── is_executor.hpp │ ├── is_read_buffered.hpp │ ├── is_write_buffered.hpp │ ├── local │ ├── basic_endpoint.hpp │ ├── connect_pair.hpp │ ├── datagram_protocol.hpp │ ├── detail │ │ ├── endpoint.hpp │ │ └── impl │ │ │ └── endpoint.ipp │ ├── seq_packet_protocol.hpp │ └── stream_protocol.hpp │ ├── multiple_exceptions.hpp │ ├── packaged_task.hpp │ ├── placeholders.hpp │ ├── posix │ ├── basic_descriptor.hpp │ ├── basic_stream_descriptor.hpp │ ├── descriptor.hpp │ ├── descriptor_base.hpp │ └── stream_descriptor.hpp │ ├── post.hpp │ ├── prefer.hpp │ ├── prepend.hpp │ ├── query.hpp │ ├── random_access_file.hpp │ ├── read.hpp │ ├── read_at.hpp │ ├── read_until.hpp │ ├── readable_pipe.hpp │ ├── recycling_allocator.hpp │ ├── redirect_error.hpp │ ├── registered_buffer.hpp │ ├── require.hpp │ ├── require_concept.hpp │ ├── serial_port.hpp │ ├── serial_port_base.hpp │ ├── signal_set.hpp │ ├── signal_set_base.hpp │ ├── socket_base.hpp │ ├── spawn.hpp │ ├── ssl.hpp │ ├── ssl │ ├── context.hpp │ ├── context_base.hpp │ ├── detail │ │ ├── buffered_handshake_op.hpp │ │ ├── engine.hpp │ │ ├── handshake_op.hpp │ │ ├── impl │ │ │ ├── engine.ipp │ │ │ └── openssl_init.ipp │ │ ├── io.hpp │ │ ├── openssl_init.hpp │ │ ├── openssl_types.hpp │ │ ├── password_callback.hpp │ │ ├── read_op.hpp │ │ ├── shutdown_op.hpp │ │ ├── stream_core.hpp │ │ ├── verify_callback.hpp │ │ └── write_op.hpp │ ├── error.hpp │ ├── host_name_verification.hpp │ ├── impl │ │ ├── context.hpp │ │ ├── context.ipp │ │ ├── error.ipp │ │ ├── host_name_verification.ipp │ │ └── src.hpp │ ├── stream.hpp │ ├── stream_base.hpp │ ├── verify_context.hpp │ └── verify_mode.hpp │ ├── static_thread_pool.hpp │ ├── steady_timer.hpp │ ├── strand.hpp │ ├── stream_file.hpp │ ├── streambuf.hpp │ ├── system_context.hpp │ ├── system_error.hpp │ ├── system_executor.hpp │ ├── system_timer.hpp │ ├── this_coro.hpp │ ├── thread.hpp │ ├── thread_pool.hpp │ ├── time_traits.hpp │ ├── traits │ ├── equality_comparable.hpp │ ├── execute_member.hpp │ ├── prefer_free.hpp │ ├── prefer_member.hpp │ ├── query_free.hpp │ ├── query_member.hpp │ ├── query_static_constexpr_member.hpp │ ├── require_concept_free.hpp │ ├── require_concept_member.hpp │ ├── require_free.hpp │ ├── require_member.hpp │ ├── static_query.hpp │ ├── static_require.hpp │ └── static_require_concept.hpp │ ├── ts │ ├── buffer.hpp │ ├── executor.hpp │ ├── internet.hpp │ ├── io_context.hpp │ ├── net.hpp │ ├── netfwd.hpp │ ├── socket.hpp │ └── timer.hpp │ ├── unyield.hpp │ ├── use_awaitable.hpp │ ├── use_future.hpp │ ├── uses_executor.hpp │ ├── version.hpp │ ├── wait_traits.hpp │ ├── windows │ ├── basic_object_handle.hpp │ ├── basic_overlapped_handle.hpp │ ├── basic_random_access_handle.hpp │ ├── basic_stream_handle.hpp │ ├── object_handle.hpp │ ├── overlapped_handle.hpp │ ├── overlapped_ptr.hpp │ ├── random_access_handle.hpp │ └── stream_handle.hpp │ ├── writable_pipe.hpp │ ├── write.hpp │ ├── write_at.hpp │ └── yield.hpp ├── release.pl ├── src ├── .gitignore ├── Makefile.am ├── Makefile.mgw ├── Makefile.msc ├── asio.cpp ├── asio_ssl.cpp ├── doc │ ├── .gitignore │ ├── Jamfile.v2 │ ├── asio.png │ ├── asio.qbk │ ├── asioref.sty │ ├── asioref.xsl │ ├── boost_bind_dox.txt │ ├── doxy2qbk.pl │ ├── examples.qbk │ ├── history.qbk │ ├── index.xml │ ├── makepdf.pl │ ├── model_dox.txt │ ├── net_ts.qbk │ ├── noncopyable_dox.txt │ ├── overview.qbk │ ├── overview │ │ ├── allocation.qbk │ │ ├── async.qbk │ │ ├── async_op1.dot │ │ ├── async_op1.png │ │ ├── async_op2.dot │ │ ├── async_op2.png │ │ ├── basics.qbk │ │ ├── bsd_sockets.qbk │ │ ├── buffers.qbk │ │ ├── cancellation.qbk │ │ ├── channels.qbk │ │ ├── compose.qbk │ │ ├── configuration.qbk │ │ ├── coro.qbk │ │ ├── coroutine.qbk │ │ ├── cpp2011.qbk │ │ ├── cpp20_coroutines.qbk │ │ ├── deferred.qbk │ │ ├── files.qbk │ │ ├── futures.qbk │ │ ├── handler_tracking.qbk │ │ ├── immediate_completion.qbk │ │ ├── implementation.qbk │ │ ├── iostreams.qbk │ │ ├── line_based.qbk │ │ ├── model.qbk │ │ ├── model │ │ │ ├── allocators.qbk │ │ │ ├── associators.qbk │ │ │ ├── async_agent_chain.png │ │ │ ├── async_agent_model.png │ │ │ ├── async_agents.qbk │ │ │ ├── async_child_agent_chain.png │ │ │ ├── async_op_init_complete.png │ │ │ ├── async_op_model.png │ │ │ ├── async_op_phases.png │ │ │ ├── async_op_trivial_chain.png │ │ │ ├── async_ops.qbk │ │ │ ├── cancellation.qbk │ │ │ ├── child_agents.qbk │ │ │ ├── completion_token_model.png │ │ │ ├── completion_token_transform.png │ │ │ ├── completion_tokens.qbk │ │ │ ├── executors.qbk │ │ │ ├── higher_level_model.png │ │ │ ├── higher_levels.qbk │ │ │ └── library_elements.qbk │ │ ├── other_protocols.qbk │ │ ├── parallel_group.qbk │ │ ├── pipes.qbk │ │ ├── posix.qbk │ │ ├── proactor.dot │ │ ├── proactor.png │ │ ├── promises.qbk │ │ ├── protocols.qbk │ │ ├── rationale.qbk │ │ ├── reactor.qbk │ │ ├── serial_ports.qbk │ │ ├── signals.qbk │ │ ├── spawn.qbk │ │ ├── ssl.qbk │ │ ├── strands.qbk │ │ ├── streams.qbk │ │ ├── sync_op.dot │ │ ├── sync_op.png │ │ ├── threads.qbk │ │ ├── timers.qbk │ │ ├── token_adapters.qbk │ │ ├── type_erasure.qbk │ │ └── windows.qbk │ ├── platform_macros.pl │ ├── platform_macros.qbk │ ├── project-root.jam │ ├── quickref.xml │ ├── reference.dox │ ├── reference.qbk │ ├── reference.xsl │ ├── release_checklist.htm │ ├── requirements │ │ ├── AcceptHandler.qbk │ │ ├── AcceptToken.qbk │ │ ├── AcceptableProtocol.qbk │ │ ├── AsyncRandomAccessReadDevice.qbk │ │ ├── AsyncRandomAccessWriteDevice.qbk │ │ ├── AsyncReadStream.qbk │ │ ├── AsyncWriteStream.qbk │ │ ├── BufferedHandshakeHandler.qbk │ │ ├── BufferedHandshakeToken.qbk │ │ ├── CancellationHandler.qbk │ │ ├── CancellationSlot.qbk │ │ ├── CompletionCondition.qbk │ │ ├── ConnectCondition.qbk │ │ ├── ConnectHandler.qbk │ │ ├── ConnectToken.qbk │ │ ├── ConstBufferSequence.qbk │ │ ├── Disposition.qbk │ │ ├── DynamicBuffer.qbk │ │ ├── DynamicBuffer_v1.qbk │ │ ├── DynamicBuffer_v2.qbk │ │ ├── Endpoint.qbk │ │ ├── EndpointSequence.qbk │ │ ├── ExecutionContext.qbk │ │ ├── Executor.qbk │ │ ├── GettableSerialPortOption.qbk │ │ ├── GettableSocketOption.qbk │ │ ├── Handler.qbk │ │ ├── HandshakeHandler.qbk │ │ ├── HandshakeToken.qbk │ │ ├── InternetProtocol.qbk │ │ ├── IoControlCommand.qbk │ │ ├── IoObjectService.qbk │ │ ├── IteratorConnectHandler.qbk │ │ ├── IteratorConnectToken.qbk │ │ ├── MoveAcceptHandler.qbk │ │ ├── MoveAcceptToken.qbk │ │ ├── MutableBufferSequence.qbk │ │ ├── NullaryToken.qbk │ │ ├── ProtoAllocator.qbk │ │ ├── Protocol.qbk │ │ ├── RangeConnectHandler.qbk │ │ ├── RangeConnectToken.qbk │ │ ├── ReadHandler.qbk │ │ ├── ReadToken.qbk │ │ ├── ResolveHandler.qbk │ │ ├── ResolveToken.qbk │ │ ├── Service.qbk │ │ ├── SettableSerialPortOption.qbk │ │ ├── SettableSocketOption.qbk │ │ ├── ShutdownHandler.qbk │ │ ├── ShutdownToken.qbk │ │ ├── SignalHandler.qbk │ │ ├── SignalToken.qbk │ │ ├── SyncRandomAccessReadDevice.qbk │ │ ├── SyncRandomAccessWriteDevice.qbk │ │ ├── SyncReadStream.qbk │ │ ├── SyncWriteStream.qbk │ │ ├── TimeTraits.qbk │ │ ├── WaitHandler.qbk │ │ ├── WaitToken.qbk │ │ ├── WaitTraits.qbk │ │ ├── WriteHandler.qbk │ │ ├── WriteToken.qbk │ │ ├── asynchronous_operations.qbk │ │ ├── asynchronous_socket_operations.qbk │ │ ├── read_write_operations.qbk │ │ └── synchronous_socket_operations.qbk │ ├── requirements_dox.txt │ ├── std_exception_dox.txt │ ├── std_executors.qbk │ ├── tutorial.dox │ ├── tutorial.qbk │ ├── tutorial.xsl │ └── using.qbk ├── examples │ ├── cpp11 │ │ ├── Makefile.am │ │ ├── allocation │ │ │ ├── .gitignore │ │ │ └── server.cpp │ │ ├── buffers │ │ │ ├── .gitignore │ │ │ └── reference_counted.cpp │ │ ├── chat │ │ │ ├── .gitignore │ │ │ ├── chat_client.cpp │ │ │ ├── chat_message.hpp │ │ │ ├── chat_server.cpp │ │ │ └── posix_chat_client.cpp │ │ ├── deferred │ │ │ ├── .gitignore │ │ │ ├── deferred_1.cpp │ │ │ └── deferred_2.cpp │ │ ├── echo │ │ │ ├── .gitignore │ │ │ ├── async_tcp_echo_server.cpp │ │ │ ├── async_udp_echo_server.cpp │ │ │ ├── blocking_tcp_echo_client.cpp │ │ │ ├── blocking_tcp_echo_server.cpp │ │ │ ├── blocking_udp_echo_client.cpp │ │ │ └── blocking_udp_echo_server.cpp │ │ ├── executors │ │ │ ├── .gitignore │ │ │ ├── actor.cpp │ │ │ ├── bank_account_1.cpp │ │ │ ├── bank_account_2.cpp │ │ │ ├── fork_join.cpp │ │ │ ├── pipeline.cpp │ │ │ └── priority_scheduler.cpp │ │ ├── files │ │ │ ├── .gitignore │ │ │ ├── async_file_copy.cpp │ │ │ └── blocking_file_copy.cpp │ │ ├── fork │ │ │ ├── .gitignore │ │ │ ├── daemon.cpp │ │ │ └── process_per_connection.cpp │ │ ├── futures │ │ │ ├── .gitignore │ │ │ └── daytime_client.cpp │ │ ├── handler_tracking │ │ │ ├── .gitignore │ │ │ ├── async_tcp_echo_server.cpp │ │ │ └── custom_tracking.hpp │ │ ├── http │ │ │ ├── client │ │ │ │ ├── .gitignore │ │ │ │ ├── async_client.cpp │ │ │ │ └── sync_client.cpp │ │ │ ├── doc_root │ │ │ │ ├── data_1K.html │ │ │ │ ├── data_2K.html │ │ │ │ ├── data_4K.html │ │ │ │ └── data_8K.html │ │ │ ├── server │ │ │ │ ├── .gitignore │ │ │ │ ├── connection.cpp │ │ │ │ ├── connection.hpp │ │ │ │ ├── connection_manager.cpp │ │ │ │ ├── connection_manager.hpp │ │ │ │ ├── header.hpp │ │ │ │ ├── main.cpp │ │ │ │ ├── mime_types.cpp │ │ │ │ ├── mime_types.hpp │ │ │ │ ├── reply.cpp │ │ │ │ ├── reply.hpp │ │ │ │ ├── request.hpp │ │ │ │ ├── request_handler.cpp │ │ │ │ ├── request_handler.hpp │ │ │ │ ├── request_parser.cpp │ │ │ │ ├── request_parser.hpp │ │ │ │ ├── server.cpp │ │ │ │ └── server.hpp │ │ │ ├── server2 │ │ │ │ ├── .gitignore │ │ │ │ ├── connection.cpp │ │ │ │ ├── connection.hpp │ │ │ │ ├── header.hpp │ │ │ │ ├── io_context_pool.cpp │ │ │ │ ├── io_context_pool.hpp │ │ │ │ ├── main.cpp │ │ │ │ ├── mime_types.cpp │ │ │ │ ├── mime_types.hpp │ │ │ │ ├── reply.cpp │ │ │ │ ├── reply.hpp │ │ │ │ ├── request.hpp │ │ │ │ ├── request_handler.cpp │ │ │ │ ├── request_handler.hpp │ │ │ │ ├── request_parser.cpp │ │ │ │ ├── request_parser.hpp │ │ │ │ ├── server.cpp │ │ │ │ └── server.hpp │ │ │ ├── server3 │ │ │ │ ├── .gitignore │ │ │ │ ├── connection.cpp │ │ │ │ ├── connection.hpp │ │ │ │ ├── header.hpp │ │ │ │ ├── main.cpp │ │ │ │ ├── mime_types.cpp │ │ │ │ ├── mime_types.hpp │ │ │ │ ├── reply.cpp │ │ │ │ ├── reply.hpp │ │ │ │ ├── request.hpp │ │ │ │ ├── request_handler.cpp │ │ │ │ ├── request_handler.hpp │ │ │ │ ├── request_parser.cpp │ │ │ │ ├── request_parser.hpp │ │ │ │ ├── server.cpp │ │ │ │ └── server.hpp │ │ │ └── server4 │ │ │ │ ├── .gitignore │ │ │ │ ├── file_handler.cpp │ │ │ │ ├── file_handler.hpp │ │ │ │ ├── header.hpp │ │ │ │ ├── main.cpp │ │ │ │ ├── mime_types.cpp │ │ │ │ ├── mime_types.hpp │ │ │ │ ├── reply.cpp │ │ │ │ ├── reply.hpp │ │ │ │ ├── request.hpp │ │ │ │ ├── request_handler.cpp │ │ │ │ ├── request_handler.hpp │ │ │ │ ├── request_parser.cpp │ │ │ │ ├── request_parser.hpp │ │ │ │ ├── server.cpp │ │ │ │ └── server.hpp │ │ ├── icmp │ │ │ ├── .gitignore │ │ │ ├── icmp_header.hpp │ │ │ ├── ipv4_header.hpp │ │ │ └── ping.cpp │ │ ├── invocation │ │ │ ├── .gitignore │ │ │ └── prioritised_handlers.cpp │ │ ├── iostreams │ │ │ ├── .gitignore │ │ │ ├── daytime_client.cpp │ │ │ ├── daytime_server.cpp │ │ │ └── http_client.cpp │ │ ├── local │ │ │ ├── .gitignore │ │ │ ├── connect_pair.cpp │ │ │ ├── fd_passing_stream_client.cpp │ │ │ ├── fd_passing_stream_server.cpp │ │ │ ├── iostream_client.cpp │ │ │ ├── stream_client.cpp │ │ │ └── stream_server.cpp │ │ ├── multicast │ │ │ ├── .gitignore │ │ │ ├── receiver.cpp │ │ │ └── sender.cpp │ │ ├── nonblocking │ │ │ ├── .gitignore │ │ │ └── third_party_lib.cpp │ │ ├── operations │ │ │ ├── .gitignore │ │ │ ├── composed_1.cpp │ │ │ ├── composed_2.cpp │ │ │ ├── composed_3.cpp │ │ │ ├── composed_4.cpp │ │ │ ├── composed_5.cpp │ │ │ ├── composed_6.cpp │ │ │ ├── composed_7.cpp │ │ │ └── composed_8.cpp │ │ ├── parallel_group │ │ │ ├── .gitignore │ │ │ ├── ranged_wait_for_all.cpp │ │ │ ├── wait_for_all.cpp │ │ │ ├── wait_for_one.cpp │ │ │ ├── wait_for_one_error.cpp │ │ │ └── wait_for_one_success.cpp │ │ ├── porthopper │ │ │ ├── .gitignore │ │ │ ├── client.cpp │ │ │ ├── protocol.hpp │ │ │ └── server.cpp │ │ ├── serialization │ │ │ ├── .gitignore │ │ │ ├── client.cpp │ │ │ ├── connection.hpp │ │ │ ├── server.cpp │ │ │ └── stock.hpp │ │ ├── services │ │ │ ├── .gitignore │ │ │ ├── basic_logger.hpp │ │ │ ├── daytime_client.cpp │ │ │ ├── logger.hpp │ │ │ ├── logger_service.cpp │ │ │ └── logger_service.hpp │ │ ├── socks4 │ │ │ ├── .gitignore │ │ │ ├── socks4.hpp │ │ │ └── sync_client.cpp │ │ ├── spawn │ │ │ ├── .gitignore │ │ │ ├── echo_server.cpp │ │ │ └── parallel_grep.cpp │ │ ├── ssl │ │ │ ├── .gitignore │ │ │ ├── README │ │ │ ├── ca.pem │ │ │ ├── client.cpp │ │ │ ├── dh4096.pem │ │ │ ├── server.cpp │ │ │ └── server.pem │ │ ├── timeouts │ │ │ ├── .gitignore │ │ │ ├── async_tcp_client.cpp │ │ │ ├── blocking_tcp_client.cpp │ │ │ ├── blocking_token_tcp_client.cpp │ │ │ ├── blocking_udp_client.cpp │ │ │ └── server.cpp │ │ ├── timers │ │ │ ├── .gitignore │ │ │ └── time_t_timer.cpp │ │ ├── tutorial │ │ │ ├── daytime1 │ │ │ │ ├── .gitignore │ │ │ │ └── client.cpp │ │ │ ├── daytime2 │ │ │ │ ├── .gitignore │ │ │ │ └── server.cpp │ │ │ ├── daytime3 │ │ │ │ ├── .gitignore │ │ │ │ └── server.cpp │ │ │ ├── daytime4 │ │ │ │ ├── .gitignore │ │ │ │ └── client.cpp │ │ │ ├── daytime5 │ │ │ │ ├── .gitignore │ │ │ │ └── server.cpp │ │ │ ├── daytime6 │ │ │ │ ├── .gitignore │ │ │ │ └── server.cpp │ │ │ ├── daytime7 │ │ │ │ ├── .gitignore │ │ │ │ └── server.cpp │ │ │ ├── daytime_dox.txt │ │ │ ├── index_dox.txt │ │ │ ├── timer1 │ │ │ │ ├── .gitignore │ │ │ │ └── timer.cpp │ │ │ ├── timer2 │ │ │ │ ├── .gitignore │ │ │ │ └── timer.cpp │ │ │ ├── timer3 │ │ │ │ ├── .gitignore │ │ │ │ └── timer.cpp │ │ │ ├── timer4 │ │ │ │ ├── .gitignore │ │ │ │ └── timer.cpp │ │ │ ├── timer5 │ │ │ │ ├── .gitignore │ │ │ │ └── timer.cpp │ │ │ └── timer_dox.txt │ │ ├── type_erasure │ │ │ ├── .gitignore │ │ │ ├── line_reader.hpp │ │ │ ├── main.cpp │ │ │ ├── sleep.cpp │ │ │ ├── sleep.hpp │ │ │ ├── stdin_line_reader.cpp │ │ │ └── stdin_line_reader.hpp │ │ └── windows │ │ │ ├── .gitignore │ │ │ └── transmit_file.cpp │ ├── cpp14 │ │ ├── Makefile.am │ │ ├── deferred │ │ │ ├── .gitignore │ │ │ ├── deferred_1.cpp │ │ │ ├── deferred_2.cpp │ │ │ ├── deferred_3.cpp │ │ │ ├── deferred_4.cpp │ │ │ ├── deferred_5.cpp │ │ │ ├── deferred_6.cpp │ │ │ └── deferred_7.cpp │ │ ├── echo │ │ │ ├── .gitignore │ │ │ ├── async_tcp_echo_server.cpp │ │ │ ├── async_udp_echo_server.cpp │ │ │ ├── blocking_tcp_echo_client.cpp │ │ │ ├── blocking_tcp_echo_server.cpp │ │ │ ├── blocking_udp_echo_client.cpp │ │ │ └── blocking_udp_echo_server.cpp │ │ ├── executors │ │ │ ├── .gitignore │ │ │ ├── actor.cpp │ │ │ ├── async_1.cpp │ │ │ ├── async_2.cpp │ │ │ ├── bank_account_1.cpp │ │ │ ├── bank_account_2.cpp │ │ │ ├── fork_join.cpp │ │ │ ├── pipeline.cpp │ │ │ └── priority_scheduler.cpp │ │ ├── iostreams │ │ │ ├── .gitignore │ │ │ └── http_client.cpp │ │ ├── operations │ │ │ ├── .gitignore │ │ │ ├── c_callback_wrapper.cpp │ │ │ ├── callback_wrapper.cpp │ │ │ ├── composed_1.cpp │ │ │ ├── composed_2.cpp │ │ │ ├── composed_3.cpp │ │ │ ├── composed_4.cpp │ │ │ ├── composed_5.cpp │ │ │ ├── composed_6.cpp │ │ │ ├── composed_7.cpp │ │ │ └── composed_8.cpp │ │ └── parallel_group │ │ │ ├── .gitignore │ │ │ ├── parallel_sort.cpp │ │ │ ├── ranged_wait_for_all.cpp │ │ │ ├── wait_for_all.cpp │ │ │ ├── wait_for_one.cpp │ │ │ ├── wait_for_one_error.cpp │ │ │ └── wait_for_one_success.cpp │ ├── cpp17 │ │ ├── Makefile.am │ │ └── coroutines_ts │ │ │ ├── .gitignore │ │ │ ├── chat_server.cpp │ │ │ ├── echo_server.cpp │ │ │ ├── echo_server_with_as_single_default.cpp │ │ │ ├── echo_server_with_as_tuple_default.cpp │ │ │ ├── echo_server_with_default.cpp │ │ │ ├── range_based_for.cpp │ │ │ └── refactored_echo_server.cpp │ └── cpp20 │ │ ├── Makefile.am │ │ ├── channels │ │ ├── .gitignore │ │ ├── mutual_exclusion_1.cpp │ │ ├── mutual_exclusion_2.cpp │ │ └── throttling_proxy.cpp │ │ ├── coroutines │ │ ├── .gitignore │ │ ├── chat_server.cpp │ │ ├── echo_server.cpp │ │ ├── echo_server_with_as_single_default.cpp │ │ ├── echo_server_with_as_tuple_default.cpp │ │ ├── echo_server_with_default.cpp │ │ ├── echo_server_with_deferred.cpp │ │ ├── echo_server_with_deferred_default.cpp │ │ ├── refactored_echo_server.cpp │ │ └── timeout.cpp │ │ ├── invocation │ │ ├── .gitignore │ │ └── completion_executor.cpp │ │ ├── operations │ │ ├── .gitignore │ │ ├── c_callback_wrapper.cpp │ │ ├── callback_wrapper.cpp │ │ ├── composed_1.cpp │ │ ├── composed_2.cpp │ │ ├── composed_3.cpp │ │ ├── composed_4.cpp │ │ ├── composed_5.cpp │ │ ├── composed_6.cpp │ │ ├── composed_7.cpp │ │ └── composed_8.cpp │ │ └── type_erasure │ │ ├── .gitignore │ │ ├── line_reader.hpp │ │ ├── main.cpp │ │ ├── sleep.cpp │ │ ├── sleep.hpp │ │ ├── stdin_line_reader.cpp │ │ └── stdin_line_reader.hpp ├── tests │ ├── .gitignore │ ├── Makefile.am │ ├── latency │ │ ├── .gitignore │ │ ├── allocator.hpp │ │ ├── high_res_clock.hpp │ │ ├── tcp_client.cpp │ │ ├── tcp_server.cpp │ │ ├── udp_client.cpp │ │ └── udp_server.cpp │ ├── performance │ │ ├── .gitignore │ │ ├── client.cpp │ │ ├── handler_allocator.hpp │ │ └── server.cpp │ ├── properties │ │ ├── .gitignore │ │ ├── Makefile.am │ │ ├── Makefile.msc │ │ ├── cpp03 │ │ │ ├── can_prefer_free_prefer.cpp │ │ │ ├── can_prefer_free_require.cpp │ │ │ ├── can_prefer_member_prefer.cpp │ │ │ ├── can_prefer_member_require.cpp │ │ │ ├── can_prefer_not_applicable_free_prefer.cpp │ │ │ ├── can_prefer_not_applicable_free_require.cpp │ │ │ ├── can_prefer_not_applicable_member_prefer.cpp │ │ │ ├── can_prefer_not_applicable_member_require.cpp │ │ │ ├── can_prefer_not_applicable_static.cpp │ │ │ ├── can_prefer_not_applicable_unsupported.cpp │ │ │ ├── can_prefer_not_preferable_free_prefer.cpp │ │ │ ├── can_prefer_not_preferable_free_require.cpp │ │ │ ├── can_prefer_not_preferable_member_prefer.cpp │ │ │ ├── can_prefer_not_preferable_member_require.cpp │ │ │ ├── can_prefer_not_preferable_static.cpp │ │ │ ├── can_prefer_not_preferable_unsupported.cpp │ │ │ ├── can_prefer_static.cpp │ │ │ ├── can_prefer_unsupported.cpp │ │ │ ├── can_query_free.cpp │ │ │ ├── can_query_member.cpp │ │ │ ├── can_query_not_applicable_free.cpp │ │ │ ├── can_query_not_applicable_member.cpp │ │ │ ├── can_query_not_applicable_static.cpp │ │ │ ├── can_query_not_applicable_unsupported.cpp │ │ │ ├── can_query_static.cpp │ │ │ ├── can_query_unsupported.cpp │ │ │ ├── can_require_concept_free.cpp │ │ │ ├── can_require_concept_member.cpp │ │ │ ├── can_require_concept_not_applicable_free.cpp │ │ │ ├── can_require_concept_not_applicable_member.cpp │ │ │ ├── can_require_concept_not_applicable_static.cpp │ │ │ ├── can_require_concept_not_applicable_unsupported.cpp │ │ │ ├── can_require_concept_static.cpp │ │ │ ├── can_require_concept_unsupported.cpp │ │ │ ├── can_require_free.cpp │ │ │ ├── can_require_member.cpp │ │ │ ├── can_require_not_applicable_free.cpp │ │ │ ├── can_require_not_applicable_member.cpp │ │ │ ├── can_require_not_applicable_static.cpp │ │ │ ├── can_require_not_applicable_unsupported.cpp │ │ │ ├── can_require_static.cpp │ │ │ ├── can_require_unsupported.cpp │ │ │ ├── prefer_free_prefer.cpp │ │ │ ├── prefer_free_require.cpp │ │ │ ├── prefer_member_prefer.cpp │ │ │ ├── prefer_member_require.cpp │ │ │ ├── prefer_static.cpp │ │ │ ├── prefer_unsupported.cpp │ │ │ ├── query_free.cpp │ │ │ ├── query_member.cpp │ │ │ ├── query_static.cpp │ │ │ ├── require_concept_free.cpp │ │ │ ├── require_concept_member.cpp │ │ │ ├── require_concept_static.cpp │ │ │ ├── require_free.cpp │ │ │ ├── require_member.cpp │ │ │ └── require_static.cpp │ │ ├── cpp11 │ │ │ ├── can_prefer_free_prefer.cpp │ │ │ ├── can_prefer_free_require.cpp │ │ │ ├── can_prefer_member_prefer.cpp │ │ │ ├── can_prefer_member_require.cpp │ │ │ ├── can_prefer_not_applicable_free_prefer.cpp │ │ │ ├── can_prefer_not_applicable_free_require.cpp │ │ │ ├── can_prefer_not_applicable_member_prefer.cpp │ │ │ ├── can_prefer_not_applicable_member_require.cpp │ │ │ ├── can_prefer_not_applicable_static.cpp │ │ │ ├── can_prefer_not_applicable_unsupported.cpp │ │ │ ├── can_prefer_not_preferable_free_prefer.cpp │ │ │ ├── can_prefer_not_preferable_free_require.cpp │ │ │ ├── can_prefer_not_preferable_member_prefer.cpp │ │ │ ├── can_prefer_not_preferable_member_require.cpp │ │ │ ├── can_prefer_not_preferable_static.cpp │ │ │ ├── can_prefer_not_preferable_unsupported.cpp │ │ │ ├── can_prefer_static.cpp │ │ │ ├── can_prefer_unsupported.cpp │ │ │ ├── can_query_free.cpp │ │ │ ├── can_query_member.cpp │ │ │ ├── can_query_not_applicable_free.cpp │ │ │ ├── can_query_not_applicable_member.cpp │ │ │ ├── can_query_not_applicable_static.cpp │ │ │ ├── can_query_not_applicable_unsupported.cpp │ │ │ ├── can_query_static.cpp │ │ │ ├── can_query_unsupported.cpp │ │ │ ├── can_require_concept_free.cpp │ │ │ ├── can_require_concept_member.cpp │ │ │ ├── can_require_concept_not_applicable_free.cpp │ │ │ ├── can_require_concept_not_applicable_member.cpp │ │ │ ├── can_require_concept_not_applicable_static.cpp │ │ │ ├── can_require_concept_not_applicable_unsupported.cpp │ │ │ ├── can_require_concept_static.cpp │ │ │ ├── can_require_concept_unsupported.cpp │ │ │ ├── can_require_free.cpp │ │ │ ├── can_require_member.cpp │ │ │ ├── can_require_not_applicable_free.cpp │ │ │ ├── can_require_not_applicable_member.cpp │ │ │ ├── can_require_not_applicable_static.cpp │ │ │ ├── can_require_not_applicable_unsupported.cpp │ │ │ ├── can_require_static.cpp │ │ │ ├── can_require_unsupported.cpp │ │ │ ├── prefer_free_prefer.cpp │ │ │ ├── prefer_free_require.cpp │ │ │ ├── prefer_member_prefer.cpp │ │ │ ├── prefer_member_require.cpp │ │ │ ├── prefer_static.cpp │ │ │ ├── prefer_unsupported.cpp │ │ │ ├── query_free.cpp │ │ │ ├── query_member.cpp │ │ │ ├── query_static.cpp │ │ │ ├── require_concept_free.cpp │ │ │ ├── require_concept_member.cpp │ │ │ ├── require_concept_static.cpp │ │ │ ├── require_free.cpp │ │ │ ├── require_member.cpp │ │ │ └── require_static.cpp │ │ └── cpp14 │ │ │ ├── can_prefer_free_prefer.cpp │ │ │ ├── can_prefer_free_require.cpp │ │ │ ├── can_prefer_member_prefer.cpp │ │ │ ├── can_prefer_member_require.cpp │ │ │ ├── can_prefer_not_applicable_free_prefer.cpp │ │ │ ├── can_prefer_not_applicable_free_require.cpp │ │ │ ├── can_prefer_not_applicable_member_prefer.cpp │ │ │ ├── can_prefer_not_applicable_member_require.cpp │ │ │ ├── can_prefer_not_applicable_static.cpp │ │ │ ├── can_prefer_not_applicable_unsupported.cpp │ │ │ ├── can_prefer_not_preferable_free_prefer.cpp │ │ │ ├── can_prefer_not_preferable_free_require.cpp │ │ │ ├── can_prefer_not_preferable_member_prefer.cpp │ │ │ ├── can_prefer_not_preferable_member_require.cpp │ │ │ ├── can_prefer_not_preferable_static.cpp │ │ │ ├── can_prefer_not_preferable_unsupported.cpp │ │ │ ├── can_prefer_static.cpp │ │ │ ├── can_prefer_unsupported.cpp │ │ │ ├── can_query_free.cpp │ │ │ ├── can_query_member.cpp │ │ │ ├── can_query_not_applicable_free.cpp │ │ │ ├── can_query_not_applicable_member.cpp │ │ │ ├── can_query_not_applicable_static.cpp │ │ │ ├── can_query_not_applicable_unsupported.cpp │ │ │ ├── can_query_static.cpp │ │ │ ├── can_query_unsupported.cpp │ │ │ ├── can_require_concept_free.cpp │ │ │ ├── can_require_concept_member.cpp │ │ │ ├── can_require_concept_not_applicable_free.cpp │ │ │ ├── can_require_concept_not_applicable_member.cpp │ │ │ ├── can_require_concept_not_applicable_static.cpp │ │ │ ├── can_require_concept_not_applicable_unsupported.cpp │ │ │ ├── can_require_concept_static.cpp │ │ │ ├── can_require_concept_unsupported.cpp │ │ │ ├── can_require_free.cpp │ │ │ ├── can_require_member.cpp │ │ │ ├── can_require_not_applicable_free.cpp │ │ │ ├── can_require_not_applicable_member.cpp │ │ │ ├── can_require_not_applicable_static.cpp │ │ │ ├── can_require_not_applicable_unsupported.cpp │ │ │ ├── can_require_static.cpp │ │ │ ├── can_require_unsupported.cpp │ │ │ ├── prefer_free_prefer.cpp │ │ │ ├── prefer_free_require.cpp │ │ │ ├── prefer_member_prefer.cpp │ │ │ ├── prefer_member_require.cpp │ │ │ ├── prefer_static.cpp │ │ │ ├── prefer_unsupported.cpp │ │ │ ├── query_free.cpp │ │ │ ├── query_member.cpp │ │ │ ├── query_static.cpp │ │ │ ├── require_concept_free.cpp │ │ │ ├── require_concept_member.cpp │ │ │ ├── require_concept_static.cpp │ │ │ ├── require_free.cpp │ │ │ ├── require_member.cpp │ │ │ └── require_static.cpp │ └── unit │ │ ├── .gitignore │ │ ├── any_completion_executor.cpp │ │ ├── any_completion_handler.cpp │ │ ├── any_io_executor.cpp │ │ ├── append.cpp │ │ ├── archetypes │ │ ├── async_ops.hpp │ │ ├── async_result.hpp │ │ ├── gettable_socket_option.hpp │ │ ├── io_control_command.hpp │ │ └── settable_socket_option.hpp │ │ ├── as_tuple.cpp │ │ ├── associated_allocator.cpp │ │ ├── associated_cancellation_slot.cpp │ │ ├── associated_executor.cpp │ │ ├── associated_immediate_executor.cpp │ │ ├── associator.cpp │ │ ├── async_result.cpp │ │ ├── awaitable.cpp │ │ ├── basic_datagram_socket.cpp │ │ ├── basic_deadline_timer.cpp │ │ ├── basic_file.cpp │ │ ├── basic_random_access_file.cpp │ │ ├── basic_raw_socket.cpp │ │ ├── basic_readable_pipe.cpp │ │ ├── basic_seq_packet_socket.cpp │ │ ├── basic_serial_port.cpp │ │ ├── basic_signal_set.cpp │ │ ├── basic_socket.cpp │ │ ├── basic_socket_acceptor.cpp │ │ ├── basic_stream_file.cpp │ │ ├── basic_stream_socket.cpp │ │ ├── basic_streambuf.cpp │ │ ├── basic_waitable_timer.cpp │ │ ├── basic_writable_pipe.cpp │ │ ├── bind_allocator.cpp │ │ ├── bind_cancellation_slot.cpp │ │ ├── bind_executor.cpp │ │ ├── bind_immediate_executor.cpp │ │ ├── buffer.cpp │ │ ├── buffer_registration.cpp │ │ ├── buffered_read_stream.cpp │ │ ├── buffered_stream.cpp │ │ ├── buffered_write_stream.cpp │ │ ├── buffers_iterator.cpp │ │ ├── cancel_after.cpp │ │ ├── cancel_at.cpp │ │ ├── cancellation_signal.cpp │ │ ├── cancellation_state.cpp │ │ ├── cancellation_type.cpp │ │ ├── co_composed.cpp │ │ ├── co_spawn.cpp │ │ ├── completion_condition.cpp │ │ ├── compose.cpp │ │ ├── composed.cpp │ │ ├── config.cpp │ │ ├── connect.cpp │ │ ├── connect_pipe.cpp │ │ ├── consign.cpp │ │ ├── coroutine.cpp │ │ ├── deadline_timer.cpp │ │ ├── defer.cpp │ │ ├── deferred.cpp │ │ ├── detached.cpp │ │ ├── dispatch.cpp │ │ ├── disposition.cpp │ │ ├── error.cpp │ │ ├── execution │ │ ├── .gitignore │ │ ├── any_executor.cpp │ │ ├── blocking.cpp │ │ ├── blocking_adaptation.cpp │ │ ├── context_as.cpp │ │ ├── executor.cpp │ │ ├── invocable_archetype.cpp │ │ ├── mapping.cpp │ │ ├── outstanding_work.cpp │ │ ├── prefer_only.cpp │ │ └── relationship.cpp │ │ ├── execution_context.cpp │ │ ├── executor.cpp │ │ ├── executor_work_guard.cpp │ │ ├── experimental │ │ ├── .gitignore │ │ ├── awaitable_operators.cpp │ │ ├── basic_channel.cpp │ │ ├── basic_concurrent_channel.cpp │ │ ├── channel.cpp │ │ ├── channel_traits.cpp │ │ ├── co_composed.cpp │ │ ├── concurrent_channel.cpp │ │ ├── coro │ │ │ ├── .gitignore │ │ │ ├── allocator.cpp │ │ │ ├── cancel.cpp │ │ │ ├── co_spawn.cpp │ │ │ ├── exception.cpp │ │ │ ├── executor.cpp │ │ │ ├── partial.cpp │ │ │ ├── simple_test.cpp │ │ │ ├── stack_test.cpp │ │ │ └── use_coro.cpp │ │ ├── parallel_group.cpp │ │ └── promise.cpp │ │ ├── file_base.cpp │ │ ├── generic │ │ ├── .gitignore │ │ ├── basic_endpoint.cpp │ │ ├── datagram_protocol.cpp │ │ ├── raw_protocol.cpp │ │ ├── seq_packet_protocol.cpp │ │ └── stream_protocol.cpp │ │ ├── high_resolution_timer.cpp │ │ ├── immediate.cpp │ │ ├── io_context.cpp │ │ ├── io_context_strand.cpp │ │ ├── ip │ │ ├── .gitignore │ │ ├── address.cpp │ │ ├── address_v4.cpp │ │ ├── address_v4_iterator.cpp │ │ ├── address_v4_range.cpp │ │ ├── address_v6.cpp │ │ ├── address_v6_iterator.cpp │ │ ├── address_v6_range.cpp │ │ ├── basic_endpoint.cpp │ │ ├── basic_resolver.cpp │ │ ├── basic_resolver_entry.cpp │ │ ├── basic_resolver_iterator.cpp │ │ ├── basic_resolver_query.cpp │ │ ├── host_name.cpp │ │ ├── icmp.cpp │ │ ├── multicast.cpp │ │ ├── network_v4.cpp │ │ ├── network_v6.cpp │ │ ├── resolver_query_base.cpp │ │ ├── tcp.cpp │ │ ├── udp.cpp │ │ ├── unicast.cpp │ │ └── v6_only.cpp │ │ ├── is_read_buffered.cpp │ │ ├── is_write_buffered.cpp │ │ ├── local │ │ ├── .gitignore │ │ ├── basic_endpoint.cpp │ │ ├── connect_pair.cpp │ │ ├── datagram_protocol.cpp │ │ ├── seq_packet_protocol.cpp │ │ └── stream_protocol.cpp │ │ ├── packaged_task.cpp │ │ ├── placeholders.cpp │ │ ├── posix │ │ ├── .gitignore │ │ ├── basic_descriptor.cpp │ │ ├── basic_stream_descriptor.cpp │ │ ├── descriptor.cpp │ │ ├── descriptor_base.cpp │ │ └── stream_descriptor.cpp │ │ ├── post.cpp │ │ ├── prepend.cpp │ │ ├── random_access_file.cpp │ │ ├── read.cpp │ │ ├── read_at.cpp │ │ ├── read_until.cpp │ │ ├── readable_pipe.cpp │ │ ├── recycling_allocator.cpp │ │ ├── redirect_error.cpp │ │ ├── registered_buffer.cpp │ │ ├── serial_port.cpp │ │ ├── serial_port_base.cpp │ │ ├── signal_set.cpp │ │ ├── signal_set_base.cpp │ │ ├── socket_base.cpp │ │ ├── spawn.cpp │ │ ├── ssl │ │ ├── .gitignore │ │ ├── context.cpp │ │ ├── context_base.cpp │ │ ├── error.cpp │ │ ├── host_name_verification.cpp │ │ ├── stream.cpp │ │ └── stream_base.cpp │ │ ├── static_thread_pool.cpp │ │ ├── steady_timer.cpp │ │ ├── strand.cpp │ │ ├── stream_file.cpp │ │ ├── streambuf.cpp │ │ ├── system_context.cpp │ │ ├── system_executor.cpp │ │ ├── system_timer.cpp │ │ ├── this_coro.cpp │ │ ├── thread.cpp │ │ ├── thread_pool.cpp │ │ ├── time_traits.cpp │ │ ├── ts │ │ ├── .gitignore │ │ ├── buffer.cpp │ │ ├── executor.cpp │ │ ├── internet.cpp │ │ ├── io_context.cpp │ │ ├── net.cpp │ │ ├── netfwd.cpp │ │ ├── socket.cpp │ │ └── timer.cpp │ │ ├── unit_test.hpp │ │ ├── use_awaitable.cpp │ │ ├── use_future.cpp │ │ ├── uses_executor.cpp │ │ ├── wait_traits.cpp │ │ ├── windows │ │ ├── .gitignore │ │ ├── basic_object_handle.cpp │ │ ├── basic_overlapped_handle.cpp │ │ ├── basic_random_access_handle.cpp │ │ ├── basic_stream_handle.cpp │ │ ├── object_handle.cpp │ │ ├── overlapped_handle.cpp │ │ ├── overlapped_ptr.cpp │ │ ├── random_access_handle.cpp │ │ └── stream_handle.cpp │ │ ├── writable_pipe.cpp │ │ ├── write.cpp │ │ └── write_at.cpp └── tools │ ├── handlerlive.pl │ ├── handlertree.pl │ └── handlerviz.pl └── tsify.pl /.cirrus.yml: -------------------------------------------------------------------------------- 1 | freebsd_instance: 2 | image_family: freebsd-14-2 3 | cpu: 1 4 | 5 | env: 6 | CXXFLAGS: -std=c++14 -Wall -Wextra -O2 7 | 8 | task: 9 | install_script: 10 | - pkg install -y autoconf automake pkgconf 11 | build_script: 12 | - cd asio 13 | - ./autogen.sh 14 | - ./configure --with-boost=no 15 | - make 16 | - make check 17 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /*.cpp 2 | /*.hpp 3 | /boost 4 | -------------------------------------------------------------------------------- /asio/.gitignore: -------------------------------------------------------------------------------- 1 | Makefile 2 | Makefile.in 3 | aclocal.m4 4 | asio.pc 5 | autom4te.cache 6 | compile 7 | config.guess 8 | config.log 9 | config.status 10 | config.sub 11 | configure 12 | depcomp 13 | install-sh 14 | missing 15 | test-driver 16 | /doc 17 | /lib 18 | /boostified 19 | /tsified 20 | *.gz 21 | *.bz2 22 | *.zip 23 | /*.cpp 24 | /*.hpp 25 | -------------------------------------------------------------------------------- /asio/COPYING: -------------------------------------------------------------------------------- 1 | Copyright (c) 2003-2025 Christopher M. Kohlhoff (chris at kohlhoff dot com) 2 | 3 | Distributed under the Boost Software License, Version 1.0. (See accompanying 4 | file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | -------------------------------------------------------------------------------- /asio/INSTALL: -------------------------------------------------------------------------------- 1 | See doc/index.html for information on: 2 | - External dependencies 3 | - Using, building, and configuring Asio 4 | - Supported platforms 5 | - How to build the tests and examples 6 | -------------------------------------------------------------------------------- /asio/Makefile.am: -------------------------------------------------------------------------------- 1 | AUTOMAKE_OPTIONS = foreign dist-bzip2 dist-zip 2 | 3 | noarch_pkgconfig_DATA = asio.pc 4 | 5 | SUBDIRS = include src 6 | 7 | MAINTAINERCLEANFILES = \ 8 | $(srcdir)/aclocal.m4 \ 9 | $(srcdir)/configure \ 10 | $(srcdir)/config.guess \ 11 | $(srcdir)/config.sub \ 12 | $(srcdir)/depcomp \ 13 | $(srcdir)/install-sh \ 14 | $(srcdir)/missing \ 15 | $(srcdir)/mkinstalldirs \ 16 | $(srcdir)/Makefile.in \ 17 | asio-*.tar.gz 18 | 19 | EXTRA_DIST = \ 20 | LICENSE_1_0.txt \ 21 | doc 22 | -------------------------------------------------------------------------------- /asio/README: -------------------------------------------------------------------------------- 1 | asio version 1.34.2 2 | Released Friday, 11 April 2025. 3 | 4 | See doc/index.html for API documentation and a tutorial. 5 | -------------------------------------------------------------------------------- /asio/asio.pc.in: -------------------------------------------------------------------------------- 1 | prefix=@prefix@ 2 | exec_prefix=@exec_prefix@ 3 | includedir=@includedir@ 4 | 5 | Name: @PACKAGE_NAME@ 6 | Description: A cross-platform C++ library for network and low-level I/O programming that provides developers with a consistent asynchronous model using a modern C++ approach. 7 | Version: @PACKAGE_VERSION@ 8 | Cflags: -I${includedir} 9 | Lflags: 10 | Requires: 11 | Requires.private: 12 | -------------------------------------------------------------------------------- /asio/include/.gitignore: -------------------------------------------------------------------------------- 1 | Makefile 2 | Makefile.in 3 | -------------------------------------------------------------------------------- /asio/include/asio/associator.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // associator.hpp 3 | // ~~~~~~~~~~~~~~ 4 | // 5 | // Copyright (c) 2003-2025 Christopher M. Kohlhoff (chris at kohlhoff dot com) 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See accompanying 8 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 9 | // 10 | 11 | #ifndef ASIO_ASSOCIATOR_HPP 12 | #define ASIO_ASSOCIATOR_HPP 13 | 14 | #if defined(_MSC_VER) && (_MSC_VER >= 1200) 15 | # pragma once 16 | #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) 17 | 18 | #include "asio/detail/config.hpp" 19 | 20 | #include "asio/detail/push_options.hpp" 21 | 22 | namespace asio { 23 | 24 | /// Used to generically specialise associators for a type. 25 | template